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 static void init_exceptsets(void);
  68
  69 static void test_dfl_env(void);
  70 static void test_fegsetenv(void);
  71 static void test_fegsetexceptflag(void);
  72 static void test_masking(void);
  73 static void test_fegsetround(void);
  74 static void test_feholdupdate(void);
  75 static void test_feraiseexcept(void);
  76 static void test_fetestclearexcept(void);
  77
  78 static int getround(void);
  79 static void raiseexcept(int excepts);
  80 static void trap_handler(int sig);
  81
  82 #pragma STDC FENV_ACCESS ON
  83
  84 int
  85 main(int argc, char *argv[])
  86 {
  87
  88         printf("1..8\n");
  89         init_exceptsets();
  90         test_dfl_env();
  91         printf("ok 1 - fenv\n");
  92         test_fetestclearexcept();
  93         printf("ok 2 - fenv\n");
  94         test_fegsetexceptflag();
  95         printf("ok 3 - fenv\n");
  96         test_feraiseexcept();
  97         printf("ok 4 - fenv\n");
  98         test_fegsetround();
  99         printf("ok 5 - fenv\n");
 100         test_fegsetenv();
 101         printf("ok 6 - fenv\n");
 102         test_masking();
 103         printf("ok 7 - fenv\n");
 104         test_feholdupdate();
 105         printf("ok 8 - fenv\n");
 106
 107         return (0);
 108 }
 109
 110 /*
 111  * Initialize std_except_sets[] to the power set of std_excepts[]
 112  */
 113 void
 114 init_exceptsets(void)
 115 {
 116         int i, j, sr;
 117
 118         for (i = 0; i < 1 << NEXCEPTS; i++) {
 119                 for (sr = i, j = 0; sr != 0; sr >>= 1, j++)
 120                         std_except_sets[i] |= std_excepts[j] & ((~sr & 1) - 1);
 121         }
 122 }
 123
 124 /*
 125  * This tests checks the default FP environment, so it must be first.
 126  * The memcmp() test below may be too much to ask for, since there
 127  * could be multiple machine-specific default environments.
 128  */
 129 static void
 130 test_dfl_env(void)
 131 {
 132 #ifndef NO_STRICT_DFL_ENV
 133         fenv_t env;
 134
 135         fegetenv(&env);
 136
 137 #ifdef __amd64__
 138         /*
 139          * Compare the fields that the AMD [1] and Intel [2] specs say will be
 140          * set once fnstenv returns.
 141          *
 142          * Not all amd64 capable processors implement the fnstenv instruction
 143          * by zero'ing out the env.__x87.__other field (example: AMD Opteron
 144          * 6308). The AMD64/x64 specs aren't explicit on what the
 145          * env.__x87.__other field will contain after fnstenv is executed, so
 146          * the values in env.__x87.__other could be filled with arbitrary
 147          * data depending on how the CPU implements fnstenv.
 148          *
 149          * 1. http://support.amd.com/TechDocs/26569_APM_v5.pdf
 150          * 2. http://www.intel.com/Assets/en_US/PDF/manual/253666.pdf
 151          */
 152         assert(memcmp(&env.__mxcsr, &FE_DFL_ENV->__mxcsr,
 153             sizeof(env.__mxcsr)) == 0);
 154         assert(memcmp(&env.__x87.__control, &FE_DFL_ENV->__x87.__control,
 155             sizeof(env.__x87.__control)) == 0);
 156         assert(memcmp(&env.__x87.__status, &FE_DFL_ENV->__x87.__status,
 157             sizeof(env.__x87.__status)) == 0);
 158         assert(memcmp(&env.__x87.__tag, &FE_DFL_ENV->__x87.__tag,
 159             sizeof(env.__x87.__tag)) == 0);
 160 #else
 161         assert(memcmp(&env, FE_DFL_ENV, sizeof(env)) == 0);
 162 #endif
 163
 164 #endif
 165         assert(fetestexcept(FE_ALL_EXCEPT) == 0);
 166 }
 167
 168 /*
 169  * Test fetestexcept() and feclearexcept().
 170  */
 171 static void
 172 test_fetestclearexcept(void)
 173 {
 174         int excepts, i;
 175
 176         for (i = 0; i < 1 << NEXCEPTS; i++)
 177                 assert(fetestexcept(std_except_sets[i]) == 0);
 178         for (i = 0; i < 1 << NEXCEPTS; i++) {
 179                 excepts = std_except_sets[i];
 180
 181                 /* FE_ALL_EXCEPT might be special-cased, as on i386. */
 182                 raiseexcept(excepts);
 183                 assert(fetestexcept(excepts) == excepts);
 184                 assert(feclearexcept(FE_ALL_EXCEPT) == 0);
 185                 assert(fetestexcept(FE_ALL_EXCEPT) == 0);
 186
 187                 raiseexcept(excepts);
 188                 assert(fetestexcept(excepts) == excepts);
 189                 if ((excepts & (FE_UNDERFLOW | FE_OVERFLOW)) != 0) {
 190                         excepts |= FE_INEXACT;
 191                         assert((fetestexcept(ALL_STD_EXCEPT) | FE_INEXACT) ==
 192                             excepts);
 193                 } else {
 194                         assert(fetestexcept(ALL_STD_EXCEPT) == excepts);
 195                 }
 196                 assert(feclearexcept(excepts) == 0);
 197                 assert(fetestexcept(ALL_STD_EXCEPT) == 0);
 198         }
 199 }
 200
 201 /*
 202  * Test fegetexceptflag() and fesetexceptflag().
 203  *
 204  * Prerequisites: fetestexcept(), feclearexcept()
 205  */
 206 static void
 207 test_fegsetexceptflag(void)
 208 {
 209         fexcept_t flag;
 210         int excepts, i;
 211
 212         assert(fetestexcept(FE_ALL_EXCEPT) == 0);
 213         for (i = 0; i < 1 << NEXCEPTS; i++) {
 214                 excepts = std_except_sets[i];
 215
 216                 assert(fegetexceptflag(&flag, excepts) == 0);
 217                 raiseexcept(ALL_STD_EXCEPT);
 218                 assert(fesetexceptflag(&flag, excepts) == 0);
 219                 assert(fetestexcept(ALL_STD_EXCEPT) ==
 220                     (ALL_STD_EXCEPT ^ excepts));
 221
 222                 assert(fegetexceptflag(&flag, FE_ALL_EXCEPT) == 0);
 223                 assert(feclearexcept(FE_ALL_EXCEPT) == 0);
 224                 assert(fesetexceptflag(&flag, excepts) == 0);
 225                 assert(fetestexcept(ALL_STD_EXCEPT) == 0);
 226                 assert(fesetexceptflag(&flag, ALL_STD_EXCEPT ^ excepts) == 0);
 227                 assert(fetestexcept(ALL_STD_EXCEPT) ==
 228                     (ALL_STD_EXCEPT ^ excepts));
 229
 230                 assert(feclearexcept(FE_ALL_EXCEPT) == 0);
 231         }
 232 }
 233
 234 /*
 235  * Test feraiseexcept().
 236  *
 237  * Prerequisites: fetestexcept(), feclearexcept()
 238  */
 239 static void
 240 test_feraiseexcept(void)
 241 {
 242         int excepts, i;
 243
 244         for (i = 0; i < 1 << NEXCEPTS; i++) {
 245                 excepts = std_except_sets[i];
 246
 247                 assert(fetestexcept(FE_ALL_EXCEPT) == 0);
 248                 assert(feraiseexcept(excepts) == 0);
 249                 if ((excepts & (FE_UNDERFLOW | FE_OVERFLOW)) != 0) {
 250                         excepts |= FE_INEXACT;
 251                         assert((fetestexcept(ALL_STD_EXCEPT) | FE_INEXACT) ==
 252                             excepts);
 253                 } else {
 254                         assert(fetestexcept(ALL_STD_EXCEPT) == excepts);
 255                 }
 256                 assert(feclearexcept(FE_ALL_EXCEPT) == 0);
 257         }
 258         assert(feraiseexcept(FE_INVALID | FE_DIVBYZERO) == 0);
 259         assert(fetestexcept(ALL_STD_EXCEPT) == (FE_INVALID | FE_DIVBYZERO));
 260         assert(feraiseexcept(FE_OVERFLOW | FE_UNDERFLOW | FE_INEXACT) == 0);
 261         assert(fetestexcept(ALL_STD_EXCEPT) == ALL_STD_EXCEPT);
 262         assert(feclearexcept(FE_ALL_EXCEPT) == 0);
 263 }
 264
 265 /*
 266  * Test fegetround() and fesetround().
 267  */
 268 static void
 269 test_fegsetround(void)
 270 {
 271
 272         assert(fegetround() == FE_TONEAREST);
 273         assert(getround() == FE_TONEAREST);
 274         assert(FLT_ROUNDS == 1);
 275
 276         assert(fesetround(FE_DOWNWARD) == 0);
 277         assert(fegetround() == FE_DOWNWARD);
 278         assert(getround() == FE_DOWNWARD);
 279         assert(FLT_ROUNDS == 3);
 280
 281         assert(fesetround(FE_UPWARD) == 0);
 282         assert(getround() == FE_UPWARD);
 283         assert(fegetround() == FE_UPWARD);
 284         assert(FLT_ROUNDS == 2);
 285
 286         assert(fesetround(FE_TOWARDZERO) == 0);
 287         assert(getround() == FE_TOWARDZERO);
 288         assert(fegetround() == FE_TOWARDZERO);
 289         assert(FLT_ROUNDS == 0);
 290
 291         assert(fesetround(FE_TONEAREST) == 0);
 292         assert(getround() == FE_TONEAREST);
 293         assert(FLT_ROUNDS == 1);
 294
 295         assert(feclearexcept(FE_ALL_EXCEPT) == 0);
 296 }
 297
 298 /*
 299  * Test fegetenv() and fesetenv().
 300  *
 301  * Prerequisites: fetestexcept(), feclearexcept(), fegetround(), fesetround()
 302  */
 303 static void
 304 test_fegsetenv(void)
 305 {
 306         fenv_t env1, env2;
 307         int excepts, i;
 308
 309         for (i = 0; i < 1 << NEXCEPTS; i++) {
 310                 excepts = std_except_sets[i];
 311
 312                 assert(fetestexcept(FE_ALL_EXCEPT) == 0);
 313                 assert(fegetround() == FE_TONEAREST);
 314                 assert(fegetenv(&env1) == 0);
 315
 316                 /*
 317                  * fe[gs]etenv() should be able to save and restore
 318                  * exception flags without the spurious inexact
 319                  * exceptions that afflict raiseexcept().
 320                  */
 321                 raiseexcept(excepts);
 322                 if ((excepts & (FE_UNDERFLOW | FE_OVERFLOW)) != 0 &&
 323                     (excepts & FE_INEXACT) == 0)
 324                         assert(feclearexcept(FE_INEXACT) == 0);
 325
 326                 fesetround(FE_DOWNWARD);
 327                 assert(fegetenv(&env2) == 0);
 328                 assert(fesetenv(&env1) == 0);
 329                 assert(fetestexcept(FE_ALL_EXCEPT) == 0);
 330                 assert(fegetround() == FE_TONEAREST);
 331
 332                 assert(fesetenv(&env2) == 0);
 333                 assert(fetestexcept(FE_ALL_EXCEPT) == excepts);
 334                 assert(fegetround() == FE_DOWNWARD);
 335                 assert(fesetenv(&env1) == 0);
 336                 assert(fetestexcept(FE_ALL_EXCEPT) == 0);
 337                 assert(fegetround() == FE_TONEAREST);
 338         }
 339 }
 340
 341 /*
 342  * Test fegetexcept(), fedisableexcept(), and feenableexcept().
 343  *
 344  * Prerequisites: fetestexcept(), feraiseexcept()
 345  */
 346 static void
 347 test_masking(void)
 348 {
 349         struct sigaction act;
 350         int except, i, pass, raise, status;
 351
 352         assert((fegetexcept() & ALL_STD_EXCEPT) == 0);
 353         assert((feenableexcept(FE_INVALID|FE_OVERFLOW) & ALL_STD_EXCEPT) == 0);
 354         assert((feenableexcept(FE_UNDERFLOW) & ALL_STD_EXCEPT) ==
 355             (FE_INVALID | FE_OVERFLOW));
 356         assert((fedisableexcept(FE_OVERFLOW) & ALL_STD_EXCEPT) ==
 357             (FE_INVALID | FE_OVERFLOW | FE_UNDERFLOW));
 358         assert((fegetexcept() & ALL_STD_EXCEPT) == (FE_INVALID | FE_UNDERFLOW));
 359         assert((fedisableexcept(FE_ALL_EXCEPT) & ALL_STD_EXCEPT) ==
 360             (FE_INVALID | FE_UNDERFLOW));
 361         assert((fegetexcept() & ALL_STD_EXCEPT) == 0);
 362
 363         sigemptyset(&act.sa_mask);
 364         act.sa_flags = 0;
 365         act.sa_handler = trap_handler;
 366         for (pass = 0; pass < 2; pass++) {
 367                 for (i = 0; i < NEXCEPTS; i++) {
 368                         except = std_excepts[i];
 369                         /* over/underflow may also raise inexact */
 370                         if (except == FE_INEXACT)
 371                                 raise = FE_DIVBYZERO | FE_INVALID;
 372                         else
 373                                 raise = ALL_STD_EXCEPT ^ except;
 374
 375                         /*
 376                          * We need to fork a child process because
 377                          * there isn't a portable way to recover from
 378                          * a floating-point exception.
 379                          */
 380                         switch(fork()) {
 381                         case 0:         /* child */
 382                                 assert((fegetexcept() & ALL_STD_EXCEPT) == 0);
 383                                 assert((feenableexcept(except)
 384                                            & ALL_STD_EXCEPT) == 0);
 385                                 assert(fegetexcept() == except);
 386                                 raiseexcept(raise);
 387                                 assert(feraiseexcept(raise) == 0);
 388                                 assert(fetestexcept(ALL_STD_EXCEPT) == raise);
 389
 390                                 assert(sigaction(SIGFPE, &act, NULL) == 0);
 391                                 switch (pass) {
 392                                 case 0:
 393                                         raiseexcept(except);
 394                                 case 1:
 395                                         feraiseexcept(except);
 396                                 default:
 397                                         assert(0);
 398                                 }
 399                                 assert(0);
 400                         default:        /* parent */
 401                                 assert(wait(&status) > 0);
 402                                 /*
 403                                  * Avoid assert() here so that it's possible
 404                                  * to examine a failed child's core dump.
 405                                  */
 406                                 if (!WIFEXITED(status))
 407                                         errx(1, "child aborted\n");
 408                                 assert(WEXITSTATUS(status) == 0);
 409                                 break;
 410                         case -1:        /* error */
 411                                 assert(0);
 412                         }
 413                 }
 414         }
 415         assert(fetestexcept(FE_ALL_EXCEPT) == 0);
 416 }
 417
 418 /*
 419  * Test feholdexcept() and feupdateenv().
 420  *
 421  * Prerequisites: fetestexcept(), fegetround(), fesetround(),
 422  *      fedisableexcept(), feenableexcept()
 423  */
 424 static void
 425 test_feholdupdate(void)
 426 {
 427         fenv_t env;
 428
 429         struct sigaction act;
 430         int except, i, pass, status, raise;
 431
 432         sigemptyset(&act.sa_mask);
 433         act.sa_flags = 0;
 434         act.sa_handler = trap_handler;
 435         for (pass = 0; pass < 2; pass++) {
 436                 for (i = 0; i < NEXCEPTS; i++) {
 437                         except = std_excepts[i];
 438                         /* over/underflow may also raise inexact */
 439                         if (except == FE_INEXACT)
 440                                 raise = FE_DIVBYZERO | FE_INVALID;
 441                         else
 442                                 raise = ALL_STD_EXCEPT ^ except;
 443
 444                         /*
 445                          * We need to fork a child process because
 446                          * there isn't a portable way to recover from
 447                          * a floating-point exception.
 448                          */
 449                         switch(fork()) {
 450                         case 0:         /* child */
 451                                 /*
 452                                  * We don't want to cause a fatal exception in
 453                                  * the child until the second pass, so we can
 454                                  * check other properties of feupdateenv().
 455                                  */
 456                                 if (pass == 1)
 457                                         assert((feenableexcept(except) &
 458                                                    ALL_STD_EXCEPT) == 0);
 459                                 raiseexcept(raise);
 460                                 assert(fesetround(FE_DOWNWARD) == 0);
 461                                 assert(feholdexcept(&env) == 0);
 462                                 assert(fetestexcept(FE_ALL_EXCEPT) == 0);
 463                                 raiseexcept(except);
 464                                 assert(fesetround(FE_UPWARD) == 0);
 465
 466                                 if (pass == 1)
 467                                         assert(sigaction(SIGFPE, &act, NULL) ==
 468                                             0);
 469                                 assert(feupdateenv(&env) == 0);
 470                                 assert(fegetround() == FE_DOWNWARD);
 471                                 assert(fetestexcept(ALL_STD_EXCEPT) ==
 472                                     (except | raise));
 473
 474                                 assert(pass == 0);
 475                                 _exit(0);
 476                         default:        /* parent */
 477                                 assert(wait(&status) > 0);
 478                                 /*
 479                                  * Avoid assert() here so that it's possible
 480                                  * to examine a failed child's core dump.
 481                                  */
 482                                 if (!WIFEXITED(status))
 483                                         errx(1, "child aborted\n");
 484                                 assert(WEXITSTATUS(status) == 0);
 485                                 break;
 486                         case -1:        /* error */
 487                                 assert(0);
 488                         }
 489                 }
 490         }
 491         assert(fetestexcept(FE_ALL_EXCEPT) == 0);
 492 }
 493
 494 /*
 495  * Raise a floating-point exception without relying on the standard
 496  * library routines, which we are trying to test.
 497  *
 498  * XXX We can't raise an {over,under}flow without also raising an
 499  * inexact exception.
 500  */
 501 static void
 502 raiseexcept(int excepts)
 503 {
 504         volatile double d;
 505
 506         /*
 507          * With a compiler that supports the FENV_ACCESS pragma
 508          * properly, simple expressions like '0.0 / 0.0' should
 509          * be sufficient to generate traps.  Unfortunately, we
 510          * need to bring a volatile variable into the equation
 511          * to prevent incorrect optimizations.
 512          */
 513         if (excepts & FE_INVALID) {
 514                 d = 0.0;
 515                 d = 0.0 / d;
 516         }
 517         if (excepts & FE_DIVBYZERO) {
 518                 d = 0.0;
 519                 d = 1.0 / d;
 520         }
 521         if (excepts & FE_OVERFLOW) {
 522                 d = DBL_MAX;
 523                 d *= 2.0;
 524         }
 525         if (excepts & FE_UNDERFLOW) {
 526                 d = DBL_MIN;
 527                 d /= DBL_MAX;
 528         }
 529         if (excepts & FE_INEXACT) {
 530                 d = DBL_MIN;
 531                 d += 1.0;
 532         }
 533
 534         /*
 535          * On the x86 (and some other architectures?) the FPU and
 536          * integer units are decoupled.  We need to execute an FWAIT
 537          * or a floating-point instruction to get synchronous exceptions.
 538          */
 539         d = 1.0;
 540         d += 1.0;
 541 }
 542
 543 /*
 544  * Determine the current rounding mode without relying on the fenv
 545  * routines.  This function may raise an inexact exception.
 546  */
 547 static int
 548 getround(void)
 549 {
 550         volatile double d;
 551
 552         /*
 553          * This test works just as well with 0.0 - 0.0, except on ia64
 554          * where 0.0 - 0.0 gives the wrong sign when rounding downwards.
 555          */
 556         d = 1.0;
 557         d -= 1.0;
 558         if (copysign(1.0, d) < 0.0)
 559                 return (FE_DOWNWARD);
 560
 561         d = 1.0;
 562         if (d + (DBL_EPSILON * 3.0 / 4.0) == 1.0)
 563                 return (FE_TOWARDZERO);
 564         if (d + (DBL_EPSILON * 1.0 / 4.0) > 1.0)
 565                 return (FE_UPWARD);
 566
 567         return (FE_TONEAREST);
 568 }
 569
 570 static void
 571 trap_handler(int sig)
 572 {
 573
 574         assert(sig == SIGFPE);
 575         _exit(0);
 576 }