From 60f0e64b3c13cf717fd49d327dbbca88568ca647 Mon Sep 17 00:00:00 2001 From: Ulrich Drepper Date: Sat, 19 Aug 2000 16:58:09 +0000 Subject: Update. * malloc/mtrace.pl (usage): Inform about --help. 2000-08-19 Wolfram Gloger * malloc/malloc.c (new_heap): try harder to get an aligned chunk of size HEAP_MAX_SIZE. 2000-08-19 Andreas Jaeger * shlib-versions: Remove libnss_db, libdb and libdb1. 2000-08-19 Jakub Jelinek * sysdeps/unix/sysv/linux/alpha/readdir.c: Move... * sysdeps/unix/sysv/linux/ia64/readdir.c: ...here and * sysdeps/unix/sysv/linux/sparc/sparc64/readdir.c: ...here. * sysdeps/unix/sysv/linux/alpha/readdir_r.c: Move... * sysdeps/unix/sysv/linux/ia64/readdir_r.c: ...here and * sysdeps/unix/sysv/linux/sparc/sparc64/readdir_r.c: ...here. * sysdeps/unix/sysv/linux/alpha/readdir64.c: Remove. * sysdeps/unix/sysv/linux/alpha/readdir64_r.c: Remove. * sysdeps/unix/sysv/linux/alpha/getdents64.c: Remove. * sysdeps/unix/sysv/linux/alpha/getdents.c: Only use for non-LFS getdents. * sysdeps/unix/sysv/linux/readdir64.c: Remove versioning. * sysdeps/unix/sysv/linux/readdir64_r.c: Likewise. 2000-08-18 Jakub Jelinek * include/glob.h (__glob64): Add prototype. * sysdeps/generic/glob.c: If GLOB_ONLY_P is defined, only define glob and glob_in_dir. * sysdeps/unix/sysv/linux/i386/Versions: Add glob64@@GLIBC_2.2. * sysdeps/unix/sysv/linux/arm/Versions: Likewise. * sysdeps/unix/sysv/linux/powerpc/Versions: Likewise. * sysdeps/unix/sysv/linux/sparc/sparc32/Versions: Likewise. * sysdeps/unix/sysv/linux/i386/glob64.c: New file. * sysdeps/unix/sysv/linux/arm/glob64.c: New file. * sysdeps/unix/sysv/linux/powerpc/glob64.c: New file. * sysdeps/unix/sysv/linux/sparc/sparc32/glob64.c: New file. 2000-08-18 Jakub Jelinek * malloc/Makefile (memusage): libmemusage.so is installed in slibdir. 2000-08-17 Andreas Jaeger * math/test-fenv.c (fe_single_test): New function. (fe_env_tests): Use fe_single_test. (feenable_test): New tests for feenable/fedisable and fegetexcpetions. (feexcp_mask_test): New function. (feexcp_nomask_test): New function. 2000-08-19 Richard Henderson * sysdeps/alpha/fpu/fenv_libc.h: New file. * sysdeps/alpha/fpu/fclrexcpt.c: Use it. * sysdeps/alpha/fpu/fegetenv.c: Likewise. * sysdeps/alpha/fpu/fesetround.c: Likewise. * sysdeps/alpha/fpu/fegetround.c: Likewise. * sysdeps/alpha/fpu/fgetexcptflg.c: Likewise. * sysdeps/alpha/fpu/fraiseexcpt.c: Likewise. * sysdeps/alpha/fpu/ftestexcept.c: Likewise. * sysdeps/alpha/fpu/fedisblxcpt.c: Likewise. Use the smaller mask. * sysdeps/alpha/fpu/feenablxcpt.c: Likewise. * sysdeps/alpha/fpu/fegetexcept.c: Likewise. * sysdeps/alpha/fpu/feholdexcpt.c: Retain the SWCR_MAP bits. * sysdeps/alpha/fpu/fesetenv.c: Likewise. * sysdeps/alpha/fpu/feupdateenv.c: Likewise. * sysdeps/alpha/fpu/fsetexcptflg.c: Likewise. * sysdeps/alpha/fpu/bits/fenv.h (FE_DENORMAL): New. (FE_MAP_DMZ, FE_MAP_UMZ, FE_NONIEEE_ENV): New. 2000-08-19 Andreas Jaeger --- math/test-fenv.c | 268 ++++++++++++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 255 insertions(+), 13 deletions(-) (limited to 'math/test-fenv.c') diff --git a/math/test-fenv.c b/math/test-fenv.c index b87f68763e..03e4877761 100644 --- a/math/test-fenv.c +++ b/math/test-fenv.c @@ -1,6 +1,6 @@ -/* Copyright (C) 1997, 1998 Free Software Foundation, Inc. +/* Copyright (C) 1997, 1998, 2000 Free Software Foundation, Inc. This file is part of the GNU C Library. - Contributed by Andreas Jaeger and + Contributed by Andreas Jaeger and Ulrich Drepper , 1997. The GNU C Library is free software; you can redistribute it and/or @@ -343,31 +343,273 @@ feenv_mask_test (const char *flag_name, int fe_exc) } } +/* Test that program aborts with no masked interrupts */ +static void +feexcp_nomask_test (const char *flag_name, int fe_exc) +{ + int status; + pid_t pid; + printf ("Test: after fedisable (%s) processes will abort\n"); + printf (" when feraiseexcept (%s) is called.\n", flag_name, flag_name); + pid = fork (); + if (pid == 0) + { +#ifdef RLIMIT_CORE + /* Try to avoid dumping core. */ + struct rlimit core_limit; + core_limit.rlim_cur = 0; + core_limit.rlim_max = 0; + setrlimit (RLIMIT_CORE, &core_limit); +#endif + fedisableexcept (FE_ALL_EXCEPT); + feenableexcept (fe_exc); + feraiseexcept (fe_exc); + exit (2); + } + else if (pid < 0) + { + if (errno != ENOSYS) + { + printf (" Fail: Could not fork.\n"); + ++count_errors; + } + else + printf (" `fork' not implemented, test ignored.\n"); + } + else { + if (waitpid (pid, &status, 0) != pid) + { + printf (" Fail: waitpid call failed.\n"); + ++count_errors; + } + else if (WIFSIGNALED (status) && WTERMSIG (status) == SIGFPE) + printf (" Pass: Process received SIGFPE.\n"); + else + { + printf (" Fail: Process didn't receive signal and exited with status %d.\n", + status); + ++count_errors; + } + } +} + +/* Test that program doesn't abort with exception. */ static void -feenv_tests (void) +feexcp_mask_test (const char *flag_name, int fe_exc) { + int status; + pid_t pid; + printf ("Test: after fedisable (%s) processes will not abort\n"); + printf (" when feraiseexcept (%s) is called.\n", flag_name, flag_name); + pid = fork (); + if (pid == 0) + { +#ifdef RLIMIT_CORE + /* Try to avoid dumping core. */ + struct rlimit core_limit; + core_limit.rlim_cur = 0; + core_limit.rlim_max = 0; + setrlimit (RLIMIT_CORE, &core_limit); +#endif + feenableexcept (FE_ALL_EXCEPT); + fedisableexcept (fe_exc); + feraiseexcept (fe_exc); + exit (2); + } + else if (pid < 0) + { + if (errno != ENOSYS) + { + printf (" Fail: Could not fork.\n"); + ++count_errors; + } + else + printf (" `fork' not implemented, test ignored.\n"); + } + else { + if (waitpid (pid, &status, 0) != pid) + { + printf (" Fail: waitpid call failed.\n"); + ++count_errors; + } + else if (WIFEXITED (status) && WEXITSTATUS (status) == 2) + printf (" Pass: Process exited normally.\n"); + else + { + printf (" Fail: Process exited abnormally with status %d.\n", + status); + ++count_errors; + } + } +} + + +/* Tests for feenableexcept/fedisableexcept/fegetexcept. */ +static void +feenable_test (const char *flag_name, int fe_exc) +{ + int excepts; + + + printf ("Tests for feenableexcepts etc. with flag %s\n", flag_name); + + /* First disable all exceptions. */ + if (fedisableexcept (FE_ALL_EXCEPT) == -1) + { + printf ("Test: fedisableexcept (FE_ALL_EXCEPT) failed\n"); + ++count_errors; + /* If this fails, the other tests don't make sense. */ + return; + } + excepts = fegetexcept (); + if (excepts != 0) + { + printf ("Test: fegetexcept (%s) failed, return should be 0, is %d\n", + flag_name, excepts); + ++count_errors; + } + + excepts = feenableexcept (fe_exc); + if (excepts == -1) + { + printf ("Test: feenableexcept (%s) failed\n", flag_name); + ++count_errors; + return; + } + if (excepts != 0) + { + printf ("Test: feenableexcept (%s) failed, return should be 0, is %x\n", + flag_name, excepts); + ++count_errors; + } + + excepts = fegetexcept (); + if (excepts != fe_exc) + { + printf ("Test: fegetexcept (%s) failed, return should be 0x%x, is 0x%x\n", + flag_name, fe_exc, excepts); + ++count_errors; + } + + /* And now disable the exception again. */ + excepts = fedisableexcept (fe_exc); + if (excepts == -1) + { + printf ("Test: fedisableexcept (%s) failed\n", flag_name); + ++count_errors; + return; + } + if (excepts != fe_exc) + { + printf ("Test: fedisableexcept (%s) failed, return should be 0x%x, is 0x%x\n", + flag_name, fe_exc, excepts); + ++count_errors; + } + + excepts = fegetexcept (); + if (excepts != 0) + { + printf ("Test: fegetexcept (%s) failed, return should be 0, is 0x%x\n", + flag_name, excepts); + ++count_errors; + } + + /* Now the other way round: Enable all exceptions and disable just this one. */ + if (feenableexcept (FE_ALL_EXCEPT) == -1) + { + printf ("Test: feenableexcept (FE_ALL_EXCEPT) failed\n"); + ++count_errors; + /* If this fails, the other tests don't make sense. */ + return; + } + + excepts = fegetexcept (); + if (excepts != FE_ALL_EXCEPT) + { + printf ("Test: fegetexcept (%s) failed, return should be 0x%x, is 0x%x\n", + flag_name, FE_ALL_EXCEPT, excepts); + ++count_errors; + } + + excepts = fedisableexcept (fe_exc); + if (excepts == -1) + { + printf ("Test: fedisableexcept (%s) failed\n", flag_name); + ++count_errors; + return; + } + if (excepts != FE_ALL_EXCEPT) + { + printf ("Test: fedisableexcept (%s) failed, return should be 0, is 0x%x\n", + flag_name, excepts); + ++count_errors; + } + + excepts = fegetexcept (); + if (excepts != (FE_ALL_EXCEPT & ~fe_exc)) + { + printf ("Test: fegetexcept (%s) failed, return should be 0x%x, is 0x%x\n", + flag_name, (FE_ALL_EXCEPT & ~fe_exc), excepts); + ++count_errors; + } + + /* And now enable the exception again. */ + excepts = feenableexcept (fe_exc); + if (excepts == -1) + { + printf ("Test: feenableexcept (%s) failed\n", flag_name); + ++count_errors; + return; + } + if (excepts != (FE_ALL_EXCEPT & ~fe_exc)) + { + printf ("Test: feenableexcept (%s) failed, return should be 0, is 0x%x\n", + flag_name, excepts); + ++count_errors; + } + + excepts = fegetexcept (); + if (excepts != FE_ALL_EXCEPT) + { + printf ("Test: fegetexcept (%s) failed, return should be 0x%x, is 0x%x\n", + flag_name, FE_ALL_EXCEPT, excepts); + ++count_errors; + } + feexcp_nomask_test (flag_name, fe_exc); + feexcp_mask_test (flag_name, fe_exc); + +} + + +static void +fe_single_test (const char *flag_name, int fe_exc) +{ + feenv_nomask_test (flag_name, fe_exc); + feenv_mask_test (flag_name, fe_exc); + feenable_test (flag_name, fe_exc); +} + + +static void +feenv_tests (void) +{ #ifdef FE_DIVBYZERO - feenv_nomask_test ("FE_DIVBYZERO", FE_DIVBYZERO); - feenv_mask_test ("FE_DIVBYZERO", FE_DIVBYZERO); + fe_single_test ("FE_DIVBYZERO", FE_DIVBYZERO); #endif #ifdef FE_INVALID - feenv_nomask_test ("FE_INVALID", FE_INVALID); - feenv_mask_test ("FE_INVALID", FE_INVALID); + fe_single_test ("FE_INVALID", FE_INVALID); #endif #ifdef FE_INEXACT - feenv_nomask_test ("FE_INEXACT", FE_INEXACT); - feenv_mask_test ("FE_INEXACT", FE_INEXACT); + fe_single_test ("FE_INEXACT", FE_INEXACT); #endif #ifdef FE_UNDERFLOW - feenv_nomask_test ("FE_UNDERFLOW", FE_UNDERFLOW); - feenv_mask_test ("FE_UNDERFLOW", FE_UNDERFLOW); + fe_single_test ("FE_UNDERFLOW", FE_UNDERFLOW); #endif #ifdef FE_OVERFLOW - feenv_nomask_test ("FE_OVERFLOW", FE_OVERFLOW); - feenv_mask_test ("FE_OVERFLOW", FE_OVERFLOW); + fe_single_test ("FE_OVERFLOW", FE_OVERFLOW); #endif fesetenv (FE_DFL_ENV); } -- cgit v1.2.3