lib/msun/tests/fenv_test.c

   1 /*-
   2  * Copyright (c) 2004 David Schultz <das@FreeBSD.org>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26
  27 /*
  28  * Test the correctness and C99-compliance of various fenv.h features.
  29  */
  30
  31 #include <sys/cdefs.h>
  32 __FBSDID("$FreeBSD$");
  33
  34 #include <sys/types.h>
  35 #include <sys/wait.h>
  36 #include <assert.h>
  37 #include <err.h>
  38 #include <fenv.h>
  39 #include <float.h>
  40 #include <math.h>
  41 #include <signal.h>
  42 #include <stdio.h>
  43 #include <string.h>
  44 #include <unistd.h>
  45
  46 /*
  47  * Implementations are permitted to define additional exception flags
  48  * not specified in the standard, so it is not necessarily true that
  49  * FE_ALL_EXCEPT == ALL_STD_EXCEPT.
  50  */
  51 #define ALL_STD_EXCEPT  (FE_DIVBYZERO | FE_INEXACT | FE_INVALID | \
  52                          FE_OVERFLOW | FE_UNDERFLOW)
  53
  54 #define NEXCEPTS        (sizeof(std_excepts) / sizeof(std_excepts[0]))
  55
  56 static const int std_excepts[] = {
  57         FE_INVALID,
  58         FE_DIVBYZERO,
  59         FE_OVERFLOW,
  60         FE_UNDERFLOW,
  61         FE_INEXACT,
  62 };
  63
  64 /* init_exceptsets() initializes this to the power set of std_excepts[] */
  65 static int std_except_sets[1 << NEXCEPTS];
  66
  67 #pragma STDC FENV_ACCESS ON
  68
  69 /*
  70  * Initialize std_except_sets[] to the power set of std_excepts[]
  71  */
  72 static void
  73 init_exceptsets(void)
  74 {
  75         unsigned i, j, sr;
  76
  77         for (i = 0; i < 1 << NEXCEPTS; i++) {
  78                 for (sr = i, j = 0; sr != 0; sr >>= 1, j++)
  79                         std_except_sets[i] |= std_excepts[j] & ((~sr & 1) - 1);
  80         }
  81 }
  82
  83 /*
  84  * Raise a floating-point exception without relying on the standard
  85  * library routines, which we are trying to test.
  86  *
  87  * XXX We can't raise an {over,under}flow without also raising an
  88  * inexact exception.
  89  */
  90 static void
  91 raiseexcept(int excepts)
  92 {
  93         volatile double d;
  94
  95         /*
  96          * With a compiler that supports the FENV_ACCESS pragma
  97          * properly, simple expressions like '0.0 / 0.0' should
  98          * be sufficient to generate traps.  Unfortunately, we
  99          * need to bring a volatile variable into the equation
 100          * to prevent incorrect optimizations.
 101          */
 102         if (excepts & FE_INVALID) {
 103                 d = 0.0;
 104                 d = 0.0 / d;
 105         }
 106         if (excepts & FE_DIVBYZERO) {
 107                 d = 0.0;
 108                 d = 1.0 / d;
 109         }
 110         if (excepts & FE_OVERFLOW) {
 111                 d = DBL_MAX;
 112                 d *= 2.0;
 113         }
 114         if (excepts & FE_UNDERFLOW) {
 115                 d = DBL_MIN;
 116                 d /= DBL_MAX;
 117         }
 118         if (excepts & FE_INEXACT) {
 119                 d = DBL_MIN;
 120                 d += 1.0;
 121         }
 122
 123         /*
 124          * On the x86 (and some other architectures?) the FPU and
 125          * integer units are decoupled.  We need to execute an FWAIT
 126          * or a floating-point instruction to get synchronous exceptions.
 127          */
 128         d = 1.0;
 129         d += 1.0;
 130 }
 131
 132 /*
 133  * Determine the current rounding mode without relying on the fenv
 134  * routines.  This function may raise an inexact exception.
 135  */
 136 static int
 137 getround(void)
 138 {
 139         volatile double d;
 140
 141         /*
 142          * This test works just as well with 0.0 - 0.0, except on ia64
 143          * where 0.0 - 0.0 gives the wrong sign when rounding downwards.
 144          */
 145         d = 1.0;
 146         d -= 1.0;
 147         if (copysign(1.0, d) < 0.0)
 148                 return (FE_DOWNWARD);
 149
 150         d = 1.0;
 151         if (d + (DBL_EPSILON * 3.0 / 4.0) == 1.0)
 152                 return (FE_TOWARDZERO);
 153         if (d + (DBL_EPSILON * 1.0 / 4.0) > 1.0)
 154                 return (FE_UPWARD);
 155
 156         return (FE_TONEAREST);
 157 }
 158
 159 static void
 160 trap_handler(int sig)
 161 {
 162
 163         assert(sig == SIGFPE);
 164         _exit(0);
 165 }
 166
 167 /*
 168  * This tests checks the default FP environment, so it must be first.
 169  * The memcmp() test below may be too much to ask for, since there
 170  * could be multiple machine-specific default environments.
 171  */
 172 static void
 173 test_dfl_env(void)
 174 {
 175 #ifndef NO_STRICT_DFL_ENV
 176         fenv_t env;
 177
 178         fegetenv(&env);
 179
 180 #ifdef __amd64__
 181         /*
 182          * Compare the fields that the AMD [1] and Intel [2] specs say will be
 183          * set once fnstenv returns.
 184          *
 185          * Not all amd64 capable processors implement the fnstenv instruction
 186          * by zero'ing out the env.__x87.__other field (example: AMD Opteron
 187          * 6308). The AMD64/x64 specs aren't explicit on what the
 188          * env.__x87.__other field will contain after fnstenv is executed, so
 189          * the values in env.__x87.__other could be filled with arbitrary
 190          * data depending on how the CPU implements fnstenv.
 191          *
 192          * 1. http://support.amd.com/TechDocs/26569_APM_v5.pdf
 193          * 2. http://www.intel.com/Assets/en_US/PDF/manual/253666.pdf
 194          */
 195         assert(memcmp(&env.__mxcsr, &FE_DFL_ENV->__mxcsr,
 196             sizeof(env.__mxcsr)) == 0);
 197         assert(memcmp(&env.__x87.__control, &FE_DFL_ENV->__x87.__control,
 198             sizeof(env.__x87.__control)) == 0);
 199         assert(memcmp(&env.__x87.__status, &FE_DFL_ENV->__x87.__status,
 200             sizeof(env.__x87.__status)) == 0);
 201         assert(memcmp(&env.__x87.__tag, &FE_DFL_ENV->__x87.__tag,
 202             sizeof(env.__x87.__tag)) == 0);
 203 #else
 204         assert(memcmp(&env, FE_DFL_ENV, sizeof(env)) == 0);
 205 #endif
 206
 207 #endif
 208         assert(fetestexcept(FE_ALL_EXCEPT) == 0);
 209 }
 210
 211 /*
 212  * Test fetestexcept() and feclearexcept().
 213  */
 214 static void
 215 test_fetestclearexcept(void)
 216 {
 217         int excepts, i;
 218
 219         for (i = 0; i < 1 << NEXCEPTS; i++)
 220                 assert(fetestexcept(std_except_sets[i]) == 0);
 221         for (i = 0; i < 1 << NEXCEPTS; i++) {
 222                 excepts = std_except_sets[i];
 223
 224                 /* FE_ALL_EXCEPT might be special-cased, as on i386. */
 225                 raiseexcept(excepts);
 226                 assert(fetestexcept(excepts) == excepts);
 227                 assert(feclearexcept(FE_ALL_EXCEPT) == 0);
 228                 assert(fetestexcept(FE_ALL_EXCEPT) == 0);
 229
 230                 raiseexcept(excepts);
 231                 assert(fetestexcept(excepts) == excepts);
 232                 if ((excepts & (FE_UNDERFLOW | FE_OVERFLOW)) != 0) {
 233                         excepts |= FE_INEXACT;
 234                         assert((fetestexcept(ALL_STD_EXCEPT) | FE_INEXACT) ==
 235                             excepts);
 236                 } else {
 237                         assert(fetestexcept(ALL_STD_EXCEPT) == excepts);
 238                 }
 239                 assert(feclearexcept(excepts) == 0);
 240                 assert(fetestexcept(ALL_STD_EXCEPT) == 0);
 241         }
 242 }
 243
 244 /*
 245  * Test fegetexceptflag() and fesetexceptflag().
 246  *
 247  * Prerequisites: fetestexcept(), feclearexcept()
 248  */
 249 static void
 250 test_fegsetexceptflag(void)
 251 {
 252         fexcept_t flag;
 253         int excepts, i;
 254
 255         assert(fetestexcept(FE_ALL_EXCEPT) == 0);
 256         for (i = 0; i < 1 << NEXCEPTS; i++) {
 257                 excepts = std_except_sets[i];
 258
 259                 assert(fegetexceptflag(&flag, excepts) == 0);
 260                 raiseexcept(ALL_STD_EXCEPT);
 261                 assert(fesetexceptflag(&flag, excepts) == 0);
 262                 assert(fetestexcept(ALL_STD_EXCEPT) ==
 263                     (ALL_STD_EXCEPT ^ excepts));
 264
 265                 assert(fegetexceptflag(&flag, FE_ALL_EXCEPT) == 0);
 266                 assert(feclearexcept(FE_ALL_EXCEPT) == 0);
 267                 assert(fesetexceptflag(&flag, excepts) == 0);
 268                 assert(fetestexcept(ALL_STD_EXCEPT) == 0);
 269                 assert(fesetexceptflag(&flag, ALL_STD_EXCEPT ^ excepts) == 0);
 270                 assert(fetestexcept(ALL_STD_EXCEPT) ==
 271                     (ALL_STD_EXCEPT ^ excepts));
 272
 273                 assert(feclearexcept(FE_ALL_EXCEPT) == 0);
 274         }
 275 }
 276
 277 /*
 278  * Test feraiseexcept().
 279  *
 280  * Prerequisites: fetestexcept(), feclearexcept()
 281  */
 282 static void
 283 test_feraiseexcept(void)
 284 {
 285         int excepts, i;
 286
 287         for (i = 0; i < 1 << NEXCEPTS; i++) {
 288                 excepts = std_except_sets[i];
 289
 290                 assert(fetestexcept(FE_ALL_EXCEPT) == 0);
 291                 assert(feraiseexcept(excepts) == 0);
 292                 if ((excepts & (FE_UNDERFLOW | FE_OVERFLOW)) != 0) {
 293                         excepts |= FE_INEXACT;
 294                         assert((fetestexcept(ALL_STD_EXCEPT) | FE_INEXACT) ==
 295                             excepts);
 296                 } else {
 297                         assert(fetestexcept(ALL_STD_EXCEPT) == excepts);
 298                 }
 299                 assert(feclearexcept(FE_ALL_EXCEPT) == 0);
 300         }
 301         assert(feraiseexcept(FE_INVALID | FE_DIVBYZERO) == 0);
 302         assert(fetestexcept(ALL_STD_EXCEPT) == (FE_INVALID | FE_DIVBYZERO));
 303         assert(feraiseexcept(FE_OVERFLOW | FE_UNDERFLOW | FE_INEXACT) == 0);
 304         assert(fetestexcept(ALL_STD_EXCEPT) == ALL_STD_EXCEPT);
 305         assert(feclearexcept(FE_ALL_EXCEPT) == 0);
 306 }
 307
 308 /*
 309  * Test fegetround() and fesetround().
 310  */
 311 static void
 312 test_fegsetround(void)
 313 {
 314
 315         assert(fegetround() == FE_TONEAREST);
 316         assert(getround() == FE_TONEAREST);
 317         assert(FLT_ROUNDS == 1);
 318
 319         assert(fesetround(FE_DOWNWARD) == 0);
 320         assert(fegetround() == FE_DOWNWARD);
 321         assert(getround() == FE_DOWNWARD);
 322         assert(FLT_ROUNDS == 3);
 323
 324         assert(fesetround(FE_UPWARD) == 0);
 325         assert(getround() == FE_UPWARD);
 326         assert(fegetround() == FE_UPWARD);
 327         assert(FLT_ROUNDS == 2);
 328
 329         assert(fesetround(FE_TOWARDZERO) == 0);
 330         assert(getround() == FE_TOWARDZERO);
 331         assert(fegetround() == FE_TOWARDZERO);
 332         assert(FLT_ROUNDS == 0);
 333
 334         assert(fesetround(FE_TONEAREST) == 0);
 335         assert(getround() == FE_TONEAREST);
 336         assert(FLT_ROUNDS == 1);
 337
 338         assert(feclearexcept(FE_ALL_EXCEPT) == 0);
 339 }
 340
 341 /*
 342  * Test fegetenv() and fesetenv().
 343  *
 344  * Prerequisites: fetestexcept(), feclearexcept(), fegetround(), fesetround()
 345  */
 346 static void
 347 test_fegsetenv(void)
 348 {
 349         fenv_t env1, env2;
 350         int excepts, i;
 351
 352         for (i = 0; i < 1 << NEXCEPTS; i++) {
 353                 excepts = std_except_sets[i];
 354
 355                 assert(fetestexcept(FE_ALL_EXCEPT) == 0);
 356                 assert(fegetround() == FE_TONEAREST);
 357                 assert(fegetenv(&env1) == 0);
 358
 359                 /*
 360                  * fe[gs]etenv() should be able to save and restore
 361                  * exception flags without the spurious inexact
 362                  * exceptions that afflict raiseexcept().
 363                  */
 364                 raiseexcept(excepts);
 365                 if ((excepts & (FE_UNDERFLOW | FE_OVERFLOW)) != 0 &&
 366                     (excepts & FE_INEXACT) == 0)
 367                         assert(feclearexcept(FE_INEXACT) == 0);
 368
 369                 fesetround(FE_DOWNWARD);
 370                 assert(fegetenv(&env2) == 0);
 371                 assert(fesetenv(&env1) == 0);
 372                 assert(fetestexcept(FE_ALL_EXCEPT) == 0);
 373                 assert(fegetround() == FE_TONEAREST);
 374
 375                 assert(fesetenv(&env2) == 0);
 376                 assert(fetestexcept(FE_ALL_EXCEPT) == excepts);
 377                 assert(fegetround() == FE_DOWNWARD);
 378                 assert(fesetenv(&env1) == 0);
 379                 assert(fetestexcept(FE_ALL_EXCEPT) == 0);
 380                 assert(fegetround() == FE_TONEAREST);
 381         }
 382 }
 383
 384 /*
 385  * Test fegetexcept(), fedisableexcept(), and feenableexcept().
 386  *
 387  * Prerequisites: fetestexcept(), feraiseexcept()
 388  */
 389 static void
 390 test_masking(void)
 391 {
 392         struct sigaction act;
 393         int except, pass, raise, status;
 394         unsigned i;
 395
 396         assert((fegetexcept() & ALL_STD_EXCEPT) == 0);
 397         assert((feenableexcept(FE_INVALID|FE_OVERFLOW) & ALL_STD_EXCEPT) == 0);
 398         assert((feenableexcept(FE_UNDERFLOW) & ALL_STD_EXCEPT) ==
 399             (FE_INVALID | FE_OVERFLOW));
 400         assert((fedisableexcept(FE_OVERFLOW) & ALL_STD_EXCEPT) ==
 401             (FE_INVALID | FE_OVERFLOW | FE_UNDERFLOW));
 402         assert((fegetexcept() & ALL_STD_EXCEPT) == (FE_INVALID | FE_UNDERFLOW));
 403         assert((fedisableexcept(FE_ALL_EXCEPT) & ALL_STD_EXCEPT) ==
 404             (FE_INVALID | FE_UNDERFLOW));
 405         assert((fegetexcept() & ALL_STD_EXCEPT) == 0);
 406
 407         sigemptyset(&act.sa_mask);
 408         act.sa_flags = 0;
 409         act.sa_handler = trap_handler;
 410         for (pass = 0; pass < 2; pass++) {
 411                 for (i = 0; i < NEXCEPTS; i++) {
 412                         except = std_excepts[i];
 413                         /* over/underflow may also raise inexact */
 414                         if (except == FE_INEXACT)
 415                                 raise = FE_DIVBYZERO | FE_INVALID;
 416                         else
 417                                 raise = ALL_STD_EXCEPT ^ except;
 418
 419                         /*
 420                          * We need to fork a child process because
 421                          * there isn't a portable way to recover from
 422                          * a floating-point exception.
 423                          */
 424                         switch(fork()) {
 425                         case 0:         /* child */
 426                                 assert((fegetexcept() & ALL_STD_EXCEPT) == 0);
 427                                 assert((feenableexcept(except)
 428                                            & ALL_STD_EXCEPT) == 0);
 429                                 assert(fegetexcept() == except);
 430                                 raiseexcept(raise);
 431                                 assert(feraiseexcept(raise) == 0);
 432                                 assert(fetestexcept(ALL_STD_EXCEPT) == raise);
 433
 434                                 assert(sigaction(SIGFPE, &act, NULL) == 0);
 435                                 switch (pass) {
 436                                 case 0:
 437                                         raiseexcept(except);
 438                                 case 1:
 439                                         feraiseexcept(except);
 440                                 default:
 441                                         assert(0);
 442                                 }
 443                                 assert(0);
 444                         default:        /* parent */
 445                                 assert(wait(&status) > 0);
 446                                 /*
 447                                  * Avoid assert() here so that it's possible
 448                                  * to examine a failed child's core dump.
 449                                  */
 450                                 if (!WIFEXITED(status))
 451                                         errx(1, "child aborted\n");
 452                                 assert(WEXITSTATUS(status) == 0);
 453                                 break;
 454                         case -1:        /* error */
 455                                 assert(0);
 456                         }
 457                 }
 458         }
 459         assert(fetestexcept(FE_ALL_EXCEPT) == 0);
 460 }
 461
 462 /*
 463  * Test feholdexcept() and feupdateenv().
 464  *
 465  * Prerequisites: fetestexcept(), fegetround(), fesetround(),
 466  *      fedisableexcept(), feenableexcept()
 467  */
 468 static void
 469 test_feholdupdate(void)
 470 {
 471         fenv_t env;
 472
 473         struct sigaction act;
 474         int except, pass, status, raise;
 475         unsigned i;
 476
 477         sigemptyset(&act.sa_mask);
 478         act.sa_flags = 0;
 479         act.sa_handler = trap_handler;
 480         for (pass = 0; pass < 2; pass++) {
 481                 for (i = 0; i < NEXCEPTS; i++) {
 482                         except = std_excepts[i];
 483                         /* over/underflow may also raise inexact */
 484                         if (except == FE_INEXACT)
 485                                 raise = FE_DIVBYZERO | FE_INVALID;
 486                         else
 487                                 raise = ALL_STD_EXCEPT ^ except;
 488
 489                         /*
 490                          * We need to fork a child process because
 491                          * there isn't a portable way to recover from
 492                          * a floating-point exception.
 493                          */
 494                         switch(fork()) {
 495                         case 0:         /* child */
 496                                 /*
 497                                  * We don't want to cause a fatal exception in
 498                                  * the child until the second pass, so we can
 499                                  * check other properties of feupdateenv().
 500                                  */
 501                                 if (pass == 1)
 502                                         assert((feenableexcept(except) &
 503                                                    ALL_STD_EXCEPT) == 0);
 504                                 raiseexcept(raise);
 505                                 assert(fesetround(FE_DOWNWARD) == 0);
 506                                 assert(feholdexcept(&env) == 0);
 507                                 assert(fetestexcept(FE_ALL_EXCEPT) == 0);
 508                                 raiseexcept(except);
 509                                 assert(fesetround(FE_UPWARD) == 0);
 510
 511                                 if (pass == 1)
 512                                         assert(sigaction(SIGFPE, &act, NULL) ==
 513                                             0);
 514                                 assert(feupdateenv(&env) == 0);
 515                                 assert(fegetround() == FE_DOWNWARD);
 516                                 assert(fetestexcept(ALL_STD_EXCEPT) ==
 517                                     (except | raise));
 518
 519                                 assert(pass == 0);
 520                                 _exit(0);
 521                         default:        /* parent */
 522                                 assert(wait(&status) > 0);
 523                                 /*
 524                                  * Avoid assert() here so that it's possible
 525                                  * to examine a failed child's core dump.
 526                                  */
 527                                 if (!WIFEXITED(status))
 528                                         errx(1, "child aborted\n");
 529                                 assert(WEXITSTATUS(status) == 0);
 530                                 break;
 531                         case -1:        /* error */
 532                                 assert(0);
 533                         }
 534                 }
 535         }
 536         assert(fetestexcept(FE_ALL_EXCEPT) == 0);
 537 }
 538
 539 int
 540 main(void)
 541 {
 542
 543         printf("1..8\n");
 544         init_exceptsets();
 545         test_dfl_env();
 546         printf("ok 1 - fenv\n");
 547         test_fetestclearexcept();
 548         printf("ok 2 - fenv\n");
 549         test_fegsetexceptflag();
 550         printf("ok 3 - fenv\n");
 551         test_feraiseexcept();
 552         printf("ok 4 - fenv\n");
 553         test_fegsetround();
 554         printf("ok 5 - fenv\n");
 555         test_fegsetenv();
 556         printf("ok 6 - fenv\n");
 557         test_masking();
 558         printf("ok 7 - fenv\n");
 559         test_feholdupdate();
 560         printf("ok 8 - fenv\n");
 561
 562         return (0);
 563 }