math/test-misc.c

   1 /* Miscellaneous tests which don't fit anywhere else.
   2    Copyright (C) 2000, 2001, 2004, 2005, 2007 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, write to the Free
  17    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  18    02111-1307 USA.  */
  19
  20 #include <fenv.h>
  21 #include <float.h>
  22 #include <ieee754.h>
  23 #include <math.h>
  24 #include <stdio.h>
  25 #include <string.h>
  26
  27
  28 int
  29 main (void)
  30 {
  31   int result = 0;
  32
  33 #ifndef NO_LONG_DOUBLE
  34   {
  35     long double x = 0x100000001ll + (long double) 0.5;
  36     long double q;
  37     long double r;
  38
  39     r = modfl (x, &q);
  40     if (q != (long double) 0x100000001ll || r != 0.5)
  41       {
  42         printf ("modfl (%Lg, ...) failed\n", x);
  43         result = 1;
  44       }
  45   }
  46
  47   {
  48     long double x;
  49     long double m;
  50     long double r;
  51     int e;
  52     int i;
  53
  54 # if LDBL_MANT_DIG == 64
  55     m = 0xf.fffffffffffffffp-4L;
  56 # elif LDBL_MANT_DIG == 106
  57     /* This has to match the mantissa of LDBL_MAX which actually does have a
  58        missing bit in the middle.  */
  59     m = 0x1.fffffffffffff7ffffffffffff8p-1L;
  60 # elif LDBL_MANT_DIG == 113
  61     m = 0x1.ffffffffffffffffffffffffffffp-1L;
  62 # else
  63 #  error "Please adjust"
  64 # endif
  65
  66     for (i = LDBL_MAX_EXP, x = LDBL_MAX; i >= LDBL_MIN_EXP; --i, x /= 2.0L)
  67       {
  68         printf ("2^%d: ", i);
  69
  70         r = frexpl (x, &e);
  71         if (r != m)
  72           {
  73             printf ("mantissa incorrect: %.20La\n", r);
  74             result = 1;
  75             continue;
  76           }
  77         if (e != i)
  78           {
  79             printf ("exponent wrong %d (%.20Lg)\n", e, x);
  80             result = 1;
  81             continue;
  82           }
  83         puts ("ok");
  84       }
  85
  86     for (i = LDBL_MIN_EXP, x = LDBL_MIN; i >= LDBL_MIN_EXP - LDBL_MANT_DIG + 1;
  87          --i, x /= 2.0L)
  88       {
  89         printf ("2^%d: ", i);
  90
  91         r = frexpl (x, &e);
  92         if (r != 0.5L)
  93           {
  94             printf ("mantissa incorrect: %.20La\n", r);
  95             result = 1;
  96             continue;
  97           }
  98         if (e != i)
  99           {
 100             printf ("exponent wrong %d (%.20Lg)\n", e, x);
 101             result = 1;
 102             continue;
 103           }
 104         puts ("ok");
 105       }
 106
 107   }
 108
 109 # if 0
 110   {
 111     int e;
 112     long double r = frexpl (LDBL_MIN * LDBL_EPSILON, &e);
 113
 114     if (r != 0.5)
 115       {
 116         printf ("frexpl (LDBL_MIN * LDBL_EPSILON, ...): mantissa wrong: %Lg\n",
 117                 r);
 118         result = 1;
 119       }
 120     else if (e != -16444)
 121       {
 122         printf ("frexpl (LDBL_MIN * LDBL_EPSILON, ...): exponent wrong: %d\n",
 123                 e);
 124         result = 1;
 125       }
 126   }
 127 # endif
 128 #endif
 129
 130   {
 131     double x = 0x100000001ll + (double) 0.5;
 132     double q;
 133     double r;
 134
 135     r = modf (x, &q);
 136     if (q != (double) 0x100000001ll || r != 0.5)
 137       {
 138         printf ("modf (%g, ...) failed\n", x);
 139         result = 1;
 140       }
 141   }
 142
 143   {
 144     union ieee754_float v1;
 145     union ieee754_float v2;
 146     float f;
 147
 148     v1.f = f = FLT_MIN;
 149     if (fpclassify (f) != FP_NORMAL)
 150       {
 151         printf ("fpclassify (FLT_MIN) failed: %d\n", fpclassify (f));
 152         result = 1;
 153       }
 154     f = nextafterf (f, FLT_MIN / 2.0f);
 155     if (fpclassify (f) != FP_SUBNORMAL)
 156       {
 157         printf ("fpclassify (FLT_MIN-epsilon) failed: %d\n", fpclassify (f));
 158         result = 1;
 159       }
 160     v2.f = f = nextafterf (f, FLT_MIN);
 161     if (fpclassify (f) != FP_NORMAL)
 162       {
 163         printf ("fpclassify (FLT_MIN-epsilon+epsilon) failed: %d\n",
 164                 fpclassify (f));
 165         result = 1;
 166       }
 167
 168     if (v1.ieee.mantissa != v2.ieee.mantissa)
 169       {
 170         printf ("FLT_MIN: mantissa differs: %8x vs %8x\n",
 171                 v1.ieee.mantissa, v2.ieee.mantissa);
 172         result = 1;
 173       }
 174     if (v1.ieee.exponent != v2.ieee.exponent)
 175       {
 176         printf ("FLT_MIN: exponent differs: %4x vs %4x\n",
 177                 v1.ieee.exponent, v2.ieee.exponent);
 178         result = 1;
 179       }
 180     if (v1.ieee.negative != v2.ieee.negative)
 181       {
 182         printf ("FLT_MIN: negative differs: %d vs %d\n",
 183                 v1.ieee.negative, v2.ieee.negative);
 184         result = 1;
 185       }
 186
 187     v1.f = f = -FLT_MIN;
 188     if (fpclassify (f) != FP_NORMAL)
 189       {
 190         printf ("fpclassify (-FLT_MIN) failed: %d\n", fpclassify (f));
 191         result = 1;
 192       }
 193     f = nextafterf (f, -FLT_MIN / 2.0f);
 194     if (fpclassify (f) != FP_SUBNORMAL)
 195       {
 196         printf ("fpclassify (-FLT_MIN-epsilon) failed: %d\n", fpclassify (f));
 197         result = 1;
 198       }
 199     v2.f = f = nextafterf (f, -FLT_MIN);
 200     if (fpclassify (f) != FP_NORMAL)
 201       {
 202         printf ("fpclassify (-FLT_MIN-epsilon+epsilon) failed: %d\n",
 203                 fpclassify (f));
 204         result = 1;
 205       }
 206
 207     if (v1.ieee.mantissa != v2.ieee.mantissa)
 208       {
 209         printf ("-FLT_MIN: mantissa differs: %8x vs %8x\n",
 210                 v1.ieee.mantissa, v2.ieee.mantissa);
 211         result = 1;
 212       }
 213     if (v1.ieee.exponent != v2.ieee.exponent)
 214       {
 215         printf ("-FLT_MIN: exponent differs: %4x vs %4x\n",
 216                 v1.ieee.exponent, v2.ieee.exponent);
 217         result = 1;
 218       }
 219     if (v1.ieee.negative != v2.ieee.negative)
 220       {
 221         printf ("-FLT_MIN: negative differs: %d vs %d\n",
 222                 v1.ieee.negative, v2.ieee.negative);
 223         result = 1;
 224       }
 225
 226     f = FLT_MAX;
 227     if (fpclassify (f) != FP_NORMAL)
 228       {
 229         printf ("fpclassify (FLT_MAX) failed: %d\n", fpclassify (f));
 230         result = 1;
 231       }
 232     f = nextafterf (f, INFINITY);
 233     if (fpclassify (f) != FP_INFINITE)
 234       {
 235         printf ("fpclassify (FLT_MAX+epsilon) failed: %d\n", fpclassify (f));
 236         result = 1;
 237       }
 238
 239     f = -FLT_MAX;
 240     if (fpclassify (f) != FP_NORMAL)
 241       {
 242         printf ("fpclassify (-FLT_MAX) failed: %d\n", fpclassify (f));
 243         result = 1;
 244       }
 245     f = nextafterf (f, -INFINITY);
 246     if (fpclassify (f) != FP_INFINITE)
 247       {
 248         printf ("fpclassify (-FLT_MAX-epsilon) failed: %d\n", fpclassify (f));
 249         result = 1;
 250       }
 251
 252     v1.f = f = 0.0625;
 253     f = nextafterf (f, 0.0);
 254     v2.f = f = nextafterf (f, 1.0);
 255
 256     if (v1.ieee.mantissa != v2.ieee.mantissa)
 257       {
 258         printf ("0.0625f down: mantissa differs: %8x vs %8x\n",
 259                 v1.ieee.mantissa, v2.ieee.mantissa);
 260         result = 1;
 261       }
 262     if (v1.ieee.exponent != v2.ieee.exponent)
 263       {
 264         printf ("0.0625f down: exponent differs: %4x vs %4x\n",
 265                 v1.ieee.exponent, v2.ieee.exponent);
 266         result = 1;
 267       }
 268     if (v1.ieee.negative != v2.ieee.negative)
 269       {
 270         printf ("0.0625f down: negative differs: %d vs %d\n",
 271                 v1.ieee.negative, v2.ieee.negative);
 272         result = 1;
 273       }
 274
 275     v1.f = f = 0.0625;
 276     f = nextafterf (f, 1.0);
 277     v2.f = f = nextafterf (f, 0.0);
 278
 279     if (v1.ieee.mantissa != v2.ieee.mantissa)
 280       {
 281         printf ("0.0625f up: mantissa differs: %8x vs %8x\n",
 282                 v1.ieee.mantissa, v2.ieee.mantissa);
 283         result = 1;
 284       }
 285     if (v1.ieee.exponent != v2.ieee.exponent)
 286       {
 287         printf ("0.0625f up: exponent differs: %4x vs %4x\n",
 288                 v1.ieee.exponent, v2.ieee.exponent);
 289         result = 1;
 290       }
 291     if (v1.ieee.negative != v2.ieee.negative)
 292       {
 293         printf ("0.0625f up: negative differs: %d vs %d\n",
 294                 v1.ieee.negative, v2.ieee.negative);
 295         result = 1;
 296       }
 297
 298     v1.f = f = -0.0625;
 299     f = nextafterf (f, 0.0);
 300     v2.f = f = nextafterf (f, -1.0);
 301
 302     if (v1.ieee.mantissa != v2.ieee.mantissa)
 303       {
 304         printf ("-0.0625f up: mantissa differs: %8x vs %8x\n",
 305                 v1.ieee.mantissa, v2.ieee.mantissa);
 306         result = 1;
 307       }
 308     if (v1.ieee.exponent != v2.ieee.exponent)
 309       {
 310         printf ("-0.0625f up: exponent differs: %4x vs %4x\n",
 311                 v1.ieee.exponent, v2.ieee.exponent);
 312         result = 1;
 313       }
 314     if (v1.ieee.negative != v2.ieee.negative)
 315       {
 316         printf ("-0.0625f up: negative differs: %d vs %d\n",
 317                 v1.ieee.negative, v2.ieee.negative);
 318         result = 1;
 319       }
 320
 321     v1.f = f = -0.0625;
 322     f = nextafterf (f, -1.0);
 323     v2.f = f = nextafterf (f, 0.0);
 324
 325     if (v1.ieee.mantissa != v2.ieee.mantissa)
 326       {
 327         printf ("-0.0625f down: mantissa differs: %8x vs %8x\n",
 328                 v1.ieee.mantissa, v2.ieee.mantissa);
 329         result = 1;
 330       }
 331     if (v1.ieee.exponent != v2.ieee.exponent)
 332       {
 333         printf ("-0.0625f down: exponent differs: %4x vs %4x\n",
 334                 v1.ieee.exponent, v2.ieee.exponent);
 335         result = 1;
 336       }
 337     if (v1.ieee.negative != v2.ieee.negative)
 338       {
 339         printf ("-0.0625f down: negative differs: %d vs %d\n",
 340                 v1.ieee.negative, v2.ieee.negative);
 341         result = 1;
 342       }
 343
 344     v1.f = f = 0.0f;
 345     f = nextafterf (f, 1.0);
 346     v2.f = nextafterf (f, -1.0);
 347
 348     if (v1.ieee.mantissa != v2.ieee.mantissa)
 349       {
 350         printf ("0.0f up: mantissa differs: %8x vs %8x\n",
 351                 v1.ieee.mantissa, v2.ieee.mantissa);
 352         result = 1;
 353       }
 354     if (v1.ieee.exponent != v2.ieee.exponent)
 355       {
 356         printf ("0.0f up: exponent differs: %4x vs %4x\n",
 357                 v1.ieee.exponent, v2.ieee.exponent);
 358         result = 1;
 359       }
 360     if (0 != v2.ieee.negative)
 361       {
 362         printf ("0.0f up: negative differs: 0 vs %d\n",
 363                 v2.ieee.negative);
 364         result = 1;
 365       }
 366
 367     v1.f = f = 0.0f;
 368     f = nextafterf (f, -1.0);
 369     v2.f = nextafterf (f, 1.0);
 370
 371     if (v1.ieee.mantissa != v2.ieee.mantissa)
 372       {
 373         printf ("0.0f down: mantissa differs: %8x vs %8x\n",
 374                 v1.ieee.mantissa, v2.ieee.mantissa);
 375         result = 1;
 376       }
 377     if (v1.ieee.exponent != v2.ieee.exponent)
 378       {
 379         printf ("0.0f down: exponent differs: %4x vs %4x\n",
 380                 v1.ieee.exponent, v2.ieee.exponent);
 381         result = 1;
 382       }
 383     if (1 != v2.ieee.negative)
 384       {
 385         printf ("0.0f down: negative differs: 1 vs %d\n",
 386                 v2.ieee.negative);
 387         result = 1;
 388       }
 389
 390     if (nextafterf (0.0f, INFINITY) != nextafterf (0.0f, 1.0f)
 391         || nextafterf (-0.0f, INFINITY) != nextafterf (-0.0f, 1.0f)
 392         || nextafterf (0.0f, -INFINITY) != nextafterf (0.0f, -1.0f)
 393         || nextafterf (-0.0f, -INFINITY) != nextafterf (-0.0f, -1.0f))
 394       {
 395         printf ("nextafterf (+-0, +-Inf) != nextafterf (+-0, +-1)\n");
 396         result = 1;
 397       }
 398
 399     if (nexttowardf (0.0f, INFINITY) != nexttowardf (0.0f, 1.0f)
 400         || nexttowardf (-0.0f, INFINITY) != nexttowardf (-0.0f, 1.0f)
 401         || nexttowardf (0.0f, -INFINITY) != nexttowardf (0.0f, -1.0f)
 402         || nexttowardf (-0.0f, -INFINITY) != nexttowardf (-0.0f, -1.0f))
 403       {
 404         printf ("nexttowardf (+-0, +-Inf) != nexttowardf (+-0, +-1)\n");
 405         result = 1;
 406       }
 407   }
 408
 409   {
 410     union ieee754_double v1;
 411     union ieee754_double v2;
 412     double d;
 413
 414     v1.d = d = DBL_MIN;
 415     if (fpclassify (d) != FP_NORMAL)
 416       {
 417         printf ("fpclassify (DBL_MIN) failed: %d\n", fpclassify (d));
 418         result = 1;
 419       }
 420     d = nextafter (d, DBL_MIN / 2.0);
 421     if (fpclassify (d) != FP_SUBNORMAL)
 422       {
 423         printf ("fpclassify (DBL_MIN-epsilon) failed: %d\n", fpclassify (d));
 424         result = 1;
 425       }
 426     v2.d = d = nextafter (d, DBL_MIN);
 427     if (fpclassify (d) != FP_NORMAL)
 428       {
 429         printf ("fpclassify (DBL_MIN-epsilon+epsilon) failed: %d\n",
 430                 fpclassify (d));
 431         result = 1;
 432       }
 433
 434     if (v1.ieee.mantissa0 != v2.ieee.mantissa0)
 435       {
 436         printf ("DBL_MIN: mantissa0 differs: %8x vs %8x\n",
 437                 v1.ieee.mantissa0, v2.ieee.mantissa0);
 438         result = 1;
 439       }
 440     if (v1.ieee.mantissa1 != v2.ieee.mantissa1)
 441       {
 442         printf ("DBL_MIN: mantissa1 differs: %8x vs %8x\n",
 443                 v1.ieee.mantissa1, v2.ieee.mantissa1);
 444         result = 1;
 445       }
 446     if (v1.ieee.exponent != v2.ieee.exponent)
 447       {
 448         printf ("DBL_MIN: exponent differs: %4x vs %4x\n",
 449                 v1.ieee.exponent, v2.ieee.exponent);
 450         result = 1;
 451       }
 452     if (v1.ieee.negative != v2.ieee.negative)
 453       {
 454         printf ("DBL_MIN: negative differs: %d vs %d\n",
 455                 v1.ieee.negative, v2.ieee.negative);
 456         result = 1;
 457       }
 458
 459     v1.d = d = -DBL_MIN;
 460     if (fpclassify (d) != FP_NORMAL)
 461       {
 462         printf ("fpclassify (-DBL_MIN) failed: %d\n", fpclassify (d));
 463         result = 1;
 464       }
 465     d = nextafter (d, -DBL_MIN / 2.0);
 466     if (fpclassify (d) != FP_SUBNORMAL)
 467       {
 468         printf ("fpclassify (-DBL_MIN-epsilon) failed: %d\n", fpclassify (d));
 469         result = 1;
 470       }
 471     v2.d = d = nextafter (d, -DBL_MIN);
 472     if (fpclassify (d) != FP_NORMAL)
 473       {
 474         printf ("fpclassify (-DBL_MIN-epsilon+epsilon) failed: %d\n",
 475                 fpclassify (d));
 476         result = 1;
 477       }
 478
 479     if (v1.ieee.mantissa0 != v2.ieee.mantissa0)
 480       {
 481         printf ("-DBL_MIN: mantissa0 differs: %8x vs %8x\n",
 482                 v1.ieee.mantissa0, v2.ieee.mantissa0);
 483         result = 1;
 484       }
 485     if (v1.ieee.mantissa1 != v2.ieee.mantissa1)
 486       {
 487         printf ("-DBL_MIN: mantissa1 differs: %8x vs %8x\n",
 488                 v1.ieee.mantissa1, v2.ieee.mantissa1);
 489         result = 1;
 490       }
 491     if (v1.ieee.exponent != v2.ieee.exponent)
 492       {
 493         printf ("-DBL_MIN: exponent differs: %4x vs %4x\n",
 494                 v1.ieee.exponent, v2.ieee.exponent);
 495         result = 1;
 496       }
 497     if (v1.ieee.negative != v2.ieee.negative)
 498       {
 499         printf ("-DBL_MIN: negative differs: %d vs %d\n",
 500                 v1.ieee.negative, v2.ieee.negative);
 501         result = 1;
 502       }
 503
 504     d = DBL_MAX;
 505     if (fpclassify (d) != FP_NORMAL)
 506       {
 507         printf ("fpclassify (DBL_MAX) failed: %d\n", fpclassify (d));
 508         result = 1;
 509       }
 510     d = nextafter (d, INFINITY);
 511     if (fpclassify (d) != FP_INFINITE)
 512       {
 513         printf ("fpclassify (DBL_MAX+epsilon) failed: %d\n", fpclassify (d));
 514         result = 1;
 515       }
 516
 517     d = -DBL_MAX;
 518     if (fpclassify (d) != FP_NORMAL)
 519       {
 520         printf ("fpclassify (-DBL_MAX) failed: %d\n", fpclassify (d));
 521         result = 1;
 522       }
 523     d = nextafter (d, -INFINITY);
 524     if (fpclassify (d) != FP_INFINITE)
 525       {
 526         printf ("fpclassify (-DBL_MAX-epsilon) failed: %d\n", fpclassify (d));
 527         result = 1;
 528       }
 529
 530     v1.d = d = 0.0625;
 531     d = nextafter (d, 0.0);
 532     v2.d = d = nextafter (d, 1.0);
 533
 534     if (v1.ieee.mantissa0 != v2.ieee.mantissa0)
 535       {
 536         printf ("0.0625 down: mantissa0 differs: %8x vs %8x\n",
 537                 v1.ieee.mantissa0, v2.ieee.mantissa0);
 538         result = 1;
 539       }
 540     if (v1.ieee.mantissa1 != v2.ieee.mantissa1)
 541       {
 542         printf ("0.0625 down: mantissa1 differs: %8x vs %8x\n",
 543                 v1.ieee.mantissa1, v2.ieee.mantissa1);
 544         result = 1;
 545       }
 546     if (v1.ieee.exponent != v2.ieee.exponent)
 547       {
 548         printf ("0.0625 down: exponent differs: %4x vs %4x\n",
 549                 v1.ieee.exponent, v2.ieee.exponent);
 550         result = 1;
 551       }
 552     if (v1.ieee.negative != v2.ieee.negative)
 553       {
 554         printf ("0.0625 down: negative differs: %d vs %d\n",
 555                 v1.ieee.negative, v2.ieee.negative);
 556         result = 1;
 557       }
 558
 559     v1.d = d = 0.0625;
 560     d = nextafter (d, 1.0);
 561     v2.d = d = nextafter (d, 0.0);
 562
 563     if (v1.ieee.mantissa0 != v2.ieee.mantissa0)
 564       {
 565         printf ("0.0625 up: mantissa0 differs: %8x vs %8x\n",
 566                 v1.ieee.mantissa0, v2.ieee.mantissa0);
 567         result = 1;
 568       }
 569     if (v1.ieee.mantissa1 != v2.ieee.mantissa1)
 570       {
 571         printf ("0.0625 up: mantissa1 differs: %8x vs %8x\n",
 572                 v1.ieee.mantissa1, v2.ieee.mantissa1);
 573         result = 1;
 574       }
 575     if (v1.ieee.exponent != v2.ieee.exponent)
 576       {
 577         printf ("0.0625 up: exponent differs: %4x vs %4x\n",
 578                 v1.ieee.exponent, v2.ieee.exponent);
 579         result = 1;
 580       }
 581     if (v1.ieee.negative != v2.ieee.negative)
 582       {
 583         printf ("0.0625 up: negative differs: %d vs %d\n",
 584                 v1.ieee.negative, v2.ieee.negative);
 585         result = 1;
 586       }
 587
 588     v1.d = d = -0.0625;
 589     d = nextafter (d, 0.0);
 590     v2.d = d = nextafter (d, -1.0);
 591
 592     if (v1.ieee.mantissa0 != v2.ieee.mantissa0)
 593       {
 594         printf ("-0.0625 up: mantissa0 differs: %8x vs %8x\n",
 595                 v1.ieee.mantissa0, v2.ieee.mantissa0);
 596         result = 1;
 597       }
 598     if (v1.ieee.mantissa1 != v2.ieee.mantissa1)
 599       {
 600         printf ("-0.0625 up: mantissa1 differs: %8x vs %8x\n",
 601                 v1.ieee.mantissa1, v2.ieee.mantissa1);
 602         result = 1;
 603       }
 604     if (v1.ieee.exponent != v2.ieee.exponent)
 605       {
 606         printf ("-0.0625 up: exponent differs: %4x vs %4x\n",
 607                 v1.ieee.exponent, v2.ieee.exponent);
 608         result = 1;
 609       }
 610     if (v1.ieee.negative != v2.ieee.negative)
 611       {
 612         printf ("-0.0625 up: negative differs: %d vs %d\n",
 613                 v1.ieee.negative, v2.ieee.negative);
 614         result = 1;
 615       }
 616
 617     v1.d = d = -0.0625;
 618     d = nextafter (d, -1.0);
 619     v2.d = d = nextafter (d, 0.0);
 620
 621     if (v1.ieee.mantissa0 != v2.ieee.mantissa0)
 622       {
 623         printf ("-0.0625 down: mantissa0 differs: %8x vs %8x\n",
 624                 v1.ieee.mantissa0, v2.ieee.mantissa0);
 625         result = 1;
 626       }
 627     if (v1.ieee.mantissa1 != v2.ieee.mantissa1)
 628       {
 629         printf ("-0.0625 down: mantissa1 differs: %8x vs %8x\n",
 630                 v1.ieee.mantissa1, v2.ieee.mantissa1);
 631         result = 1;
 632       }
 633     if (v1.ieee.exponent != v2.ieee.exponent)
 634       {
 635         printf ("-0.0625 down: exponent differs: %4x vs %4x\n",
 636                 v1.ieee.exponent, v2.ieee.exponent);
 637         result = 1;
 638       }
 639     if (v1.ieee.negative != v2.ieee.negative)
 640       {
 641         printf ("-0.0625 down: negative differs: %d vs %d\n",
 642                 v1.ieee.negative, v2.ieee.negative);
 643         result = 1;
 644       }
 645
 646     v1.d = d = 0.0;
 647     d = nextafter (d, 1.0);
 648     v2.d = nextafter (d, -1.0);
 649
 650     if (v1.ieee.mantissa0 != v2.ieee.mantissa0)
 651       {
 652         printf ("0.0 up: mantissa0 differs: %8x vs %8x\n",
 653                 v1.ieee.mantissa0, v2.ieee.mantissa0);
 654         result = 1;
 655       }
 656     if (v1.ieee.mantissa1 != v2.ieee.mantissa1)
 657       {
 658         printf ("0.0 up: mantissa1 differs: %8x vs %8x\n",
 659                 v1.ieee.mantissa1, v2.ieee.mantissa1);
 660         result = 1;
 661       }
 662     if (v1.ieee.exponent != v2.ieee.exponent)
 663       {
 664         printf ("0.0 up: exponent differs: %4x vs %4x\n",
 665                 v1.ieee.exponent, v2.ieee.exponent);
 666         result = 1;
 667       }
 668     if (0 != v2.ieee.negative)
 669       {
 670         printf ("0.0 up: negative differs: 0 vs %d\n",
 671                 v2.ieee.negative);
 672         result = 1;
 673       }
 674
 675     v1.d = d = 0.0;
 676     d = nextafter (d, -1.0);
 677     v2.d = nextafter (d, 1.0);
 678
 679     if (v1.ieee.mantissa0 != v2.ieee.mantissa0)
 680       {
 681         printf ("0.0 down: mantissa0 differs: %8x vs %8x\n",
 682                 v1.ieee.mantissa0, v2.ieee.mantissa0);
 683         result = 1;
 684       }
 685     if (v1.ieee.mantissa1 != v2.ieee.mantissa1)
 686       {
 687         printf ("0.0 down: mantissa1 differs: %8x vs %8x\n",
 688                 v1.ieee.mantissa1, v2.ieee.mantissa1);
 689         result = 1;
 690       }
 691     if (v1.ieee.exponent != v2.ieee.exponent)
 692       {
 693         printf ("0.0 down: exponent differs: %4x vs %4x\n",
 694                 v1.ieee.exponent, v2.ieee.exponent);
 695         result = 1;
 696       }
 697     if (1 != v2.ieee.negative)
 698       {
 699         printf ("0.0 down: negative differs: 1 vs %d\n",
 700                 v2.ieee.negative);
 701         result = 1;
 702       }
 703
 704     if (nextafter (0.0, INFINITY) != nextafter (0.0, 1.0)
 705         || nextafter (-0.0, INFINITY) != nextafter (-0.0, 1.0)
 706         || nextafter (0.0, -INFINITY) != nextafter (0.0, -1.0)
 707         || nextafter (-0.0, -INFINITY) != nextafter (-0.0, -1.0))
 708       {
 709         printf ("nextafter (+-0, +-Inf) != nextafter (+-0, +-1)\n");
 710         result = 1;
 711       }
 712
 713     if (nexttoward (0.0, INFINITY) != nexttoward (0.0, 1.0)
 714         || nexttoward (-0.0, INFINITY) != nexttoward (-0.0, 1.0)
 715         || nexttoward (0.0, -INFINITY) != nexttoward (0.0, -1.0)
 716         || nexttoward (-0.0, -INFINITY) != nexttoward (-0.0, -1.0))
 717       {
 718         printf ("nexttoward (+-0, +-Inf) != nexttoward (+-0, +-1)\n");
 719         result = 1;
 720       }
 721   }
 722
 723 #ifndef NO_LONG_DOUBLE
 724   {
 725     union ieee854_long_double v1;
 726     union ieee854_long_double v2;
 727     long double ld;
 728
 729     v1.d = ld = LDBL_MIN;
 730     if (fpclassify (ld) != FP_NORMAL)
 731       {
 732         printf ("fpclassify (LDBL_MIN) failed: %d\n", fpclassify (ld));
 733         result = 1;
 734       }
 735     ld = nextafterl (ld, LDBL_MIN / 2.0);
 736     if (fpclassify (ld) != FP_SUBNORMAL)
 737       {
 738         printf ("fpclassify (LDBL_MIN-epsilon) failed: %d (%La)\n",
 739                 fpclassify (ld), ld);
 740         result = 1;
 741       }
 742     v2.d = ld = nextafterl (ld, LDBL_MIN);
 743     if (fpclassify (ld) != FP_NORMAL)
 744       {
 745         printf ("fpclassify (LDBL_MIN-epsilon+epsilon) failed: %d (%La)\n",
 746                 fpclassify (ld), ld);
 747         result = 1;
 748       }
 749
 750     if (v1.ieee.mantissa0 != v2.ieee.mantissa0)
 751       {
 752         printf ("LDBL_MIN: mantissa0 differs: %8x vs %8x\n",
 753                 v1.ieee.mantissa0, v2.ieee.mantissa0);
 754         result = 1;
 755       }
 756     if (v1.ieee.mantissa1 != v2.ieee.mantissa1)
 757       {
 758         printf ("LDBL_MIN: mantissa1 differs: %8x vs %8x\n",
 759                 v1.ieee.mantissa1, v2.ieee.mantissa1);
 760         result = 1;
 761       }
 762     if (v1.ieee.exponent != v2.ieee.exponent)
 763       {
 764         printf ("LDBL_MIN: exponent differs: %4x vs %4x\n",
 765                 v1.ieee.exponent, v2.ieee.exponent);
 766         result = 1;
 767       }
 768     if (v1.ieee.negative != v2.ieee.negative)
 769       {
 770         printf ("LDBL_MIN: negative differs: %d vs %d\n",
 771                 v1.ieee.negative, v2.ieee.negative);
 772         result = 1;
 773       }
 774
 775     v1.d = ld = -LDBL_MIN;
 776     if (fpclassify (ld) != FP_NORMAL)
 777       {
 778         printf ("fpclassify (-LDBL_MIN) failed: %d\n", fpclassify (ld));
 779         result = 1;
 780       }
 781     ld = nextafterl (ld, -LDBL_MIN / 2.0);
 782     if (fpclassify (ld) != FP_SUBNORMAL)
 783       {
 784         printf ("fpclassify (-LDBL_MIN-epsilon) failed: %d (%La)\n",
 785                 fpclassify (ld), ld);
 786         result = 1;
 787       }
 788     v2.d = ld = nextafterl (ld, -LDBL_MIN);
 789     if (fpclassify (ld) != FP_NORMAL)
 790       {
 791         printf ("fpclassify (-LDBL_MIN-epsilon+epsilon) failed: %d (%La)\n",
 792                 fpclassify (ld), ld);
 793         result = 1;
 794       }
 795
 796     if (v1.ieee.mantissa0 != v2.ieee.mantissa0)
 797       {
 798         printf ("-LDBL_MIN: mantissa0 differs: %8x vs %8x\n",
 799                 v1.ieee.mantissa0, v2.ieee.mantissa0);
 800         result = 1;
 801       }
 802     if (v1.ieee.mantissa1 != v2.ieee.mantissa1)
 803       {
 804         printf ("-LDBL_MIN: mantissa1 differs: %8x vs %8x\n",
 805                 v1.ieee.mantissa1, v2.ieee.mantissa1);
 806         result = 1;
 807       }
 808     if (v1.ieee.exponent != v2.ieee.exponent)
 809       {
 810         printf ("-LDBL_MIN: exponent differs: %4x vs %4x\n",
 811                 v1.ieee.exponent, v2.ieee.exponent);
 812         result = 1;
 813       }
 814     if (v1.ieee.negative != v2.ieee.negative)
 815       {
 816         printf ("-LDBL_MIN: negative differs: %d vs %d\n",
 817                 v1.ieee.negative, v2.ieee.negative);
 818         result = 1;
 819       }
 820
 821     ld = LDBL_MAX;
 822     if (fpclassify (ld) != FP_NORMAL)
 823       {
 824         printf ("fpclassify (LDBL_MAX) failed: %d\n", fpclassify (ld));
 825         result = 1;
 826       }
 827     ld = nextafterl (ld, INFINITY);
 828     if (fpclassify (ld) != FP_INFINITE)
 829       {
 830         printf ("fpclassify (LDBL_MAX+epsilon) failed: %d\n", fpclassify (ld));
 831         result = 1;
 832       }
 833
 834     ld = -LDBL_MAX;
 835     if (fpclassify (ld) != FP_NORMAL)
 836       {
 837         printf ("fpclassify (-LDBL_MAX) failed: %d\n", fpclassify (ld));
 838         result = 1;
 839       }
 840     ld = nextafterl (ld, -INFINITY);
 841     if (fpclassify (ld) != FP_INFINITE)
 842       {
 843         printf ("fpclassify (-LDBL_MAX-epsilon) failed: %d\n",
 844                 fpclassify (ld));
 845         result = 1;
 846       }
 847
 848     v1.d = ld = 0.0625;
 849     ld = nextafterl (ld, 0.0);
 850     v2.d = ld = nextafterl (ld, 1.0);
 851
 852     if (v1.ieee.mantissa0 != v2.ieee.mantissa0)
 853       {
 854         printf ("0.0625L down: mantissa0 differs: %8x vs %8x\n",
 855                 v1.ieee.mantissa0, v2.ieee.mantissa0);
 856         result = 1;
 857       }
 858     if (v1.ieee.mantissa1 != v2.ieee.mantissa1)
 859       {
 860         printf ("0.0625L down: mantissa1 differs: %8x vs %8x\n",
 861                 v1.ieee.mantissa1, v2.ieee.mantissa1);
 862         result = 1;
 863       }
 864     if (v1.ieee.exponent != v2.ieee.exponent)
 865       {
 866         printf ("0.0625L down: exponent differs: %4x vs %4x\n",
 867                 v1.ieee.exponent, v2.ieee.exponent);
 868         result = 1;
 869       }
 870     if (v1.ieee.negative != v2.ieee.negative)
 871       {
 872         printf ("0.0625L down: negative differs: %d vs %d\n",
 873                 v1.ieee.negative, v2.ieee.negative);
 874         result = 1;
 875       }
 876
 877     v1.d = ld = 0.0625;
 878     ld = nextafterl (ld, 1.0);
 879     v2.d = ld = nextafterl (ld, 0.0);
 880
 881     if (v1.ieee.mantissa0 != v2.ieee.mantissa0)
 882       {
 883         printf ("0.0625L up: mantissa0 differs: %8x vs %8x\n",
 884                 v1.ieee.mantissa0, v2.ieee.mantissa0);
 885         result = 1;
 886       }
 887     if (v1.ieee.mantissa1 != v2.ieee.mantissa1)
 888       {
 889         printf ("0.0625L up: mantissa1 differs: %8x vs %8x\n",
 890                 v1.ieee.mantissa1, v2.ieee.mantissa1);
 891         result = 1;
 892       }
 893     if (v1.ieee.exponent != v2.ieee.exponent)
 894       {
 895         printf ("0.0625L up: exponent differs: %4x vs %4x\n",
 896                 v1.ieee.exponent, v2.ieee.exponent);
 897         result = 1;
 898       }
 899     if (v1.ieee.negative != v2.ieee.negative)
 900       {
 901         printf ("0.0625L up: negative differs: %d vs %d\n",
 902                 v1.ieee.negative, v2.ieee.negative);
 903         result = 1;
 904       }
 905
 906     v1.d = ld = -0.0625;
 907     ld = nextafterl (ld, 0.0);
 908     v2.d = ld = nextafterl (ld, -1.0);
 909
 910     if (v1.ieee.mantissa0 != v2.ieee.mantissa0)
 911       {
 912         printf ("-0.0625L up: mantissa0 differs: %8x vs %8x\n",
 913                 v1.ieee.mantissa0, v2.ieee.mantissa0);
 914         result = 1;
 915       }
 916     if (v1.ieee.mantissa1 != v2.ieee.mantissa1)
 917       {
 918         printf ("-0.0625L up: mantissa1 differs: %8x vs %8x\n",
 919                 v1.ieee.mantissa1, v2.ieee.mantissa1);
 920         result = 1;
 921       }
 922     if (v1.ieee.exponent != v2.ieee.exponent)
 923       {
 924         printf ("-0.0625L up: exponent differs: %4x vs %4x\n",
 925                 v1.ieee.exponent, v2.ieee.exponent);
 926         result = 1;
 927       }
 928     if (v1.ieee.negative != v2.ieee.negative)
 929       {
 930         printf ("-0.0625L up: negative differs: %d vs %d\n",
 931                 v1.ieee.negative, v2.ieee.negative);
 932         result = 1;
 933       }
 934
 935     v1.d = ld = -0.0625;
 936     ld = nextafterl (ld, -1.0);
 937     v2.d = ld = nextafterl (ld, 0.0);
 938
 939     if (v1.ieee.mantissa0 != v2.ieee.mantissa0)
 940       {
 941         printf ("-0.0625L down: mantissa0 differs: %8x vs %8x\n",
 942                 v1.ieee.mantissa0, v2.ieee.mantissa0);
 943         result = 1;
 944       }
 945     if (v1.ieee.mantissa1 != v2.ieee.mantissa1)
 946       {
 947         printf ("-0.0625L down: mantissa1 differs: %8x vs %8x\n",
 948                 v1.ieee.mantissa1, v2.ieee.mantissa1);
 949         result = 1;
 950       }
 951     if (v1.ieee.exponent != v2.ieee.exponent)
 952       {
 953         printf ("-0.0625L down: exponent differs: %4x vs %4x\n",
 954                 v1.ieee.exponent, v2.ieee.exponent);
 955         result = 1;
 956       }
 957     if (v1.ieee.negative != v2.ieee.negative)
 958       {
 959         printf ("-0.0625L down: negative differs: %d vs %d\n",
 960                 v1.ieee.negative, v2.ieee.negative);
 961         result = 1;
 962       }
 963
 964     v1.d = ld = 0.0;
 965     ld = nextafterl (ld, 1.0);
 966     v2.d = nextafterl (ld, -1.0);
 967
 968     if (v1.ieee.mantissa0 != v2.ieee.mantissa0)
 969       {
 970         printf ("0.0L up: mantissa0 differs: %8x vs %8x\n",
 971                 v1.ieee.mantissa0, v2.ieee.mantissa0);
 972         result = 1;
 973       }
 974     if (v1.ieee.mantissa1 != v2.ieee.mantissa1)
 975       {
 976         printf ("0.0L up: mantissa1 differs: %8x vs %8x\n",
 977                 v1.ieee.mantissa1, v2.ieee.mantissa1);
 978         result = 1;
 979       }
 980     if (v1.ieee.exponent != v2.ieee.exponent)
 981       {
 982         printf ("0.0L up: exponent differs: %4x vs %4x\n",
 983                 v1.ieee.exponent, v2.ieee.exponent);
 984         result = 1;
 985       }
 986     if (0 != v2.ieee.negative)
 987       {
 988         printf ("0.0L up: negative differs: 0 vs %d\n",
 989                 v2.ieee.negative);
 990         result = 1;
 991       }
 992
 993     v1.d = ld = 0.0;
 994     ld = nextafterl (ld, -1.0);
 995     v2.d = nextafterl (ld, 1.0);
 996
 997     if (v1.ieee.mantissa0 != v2.ieee.mantissa0)
 998       {
 999         printf ("0.0L down: mantissa0 differs: %8x vs %8x\n",
1000                 v1.ieee.mantissa0, v2.ieee.mantissa0);
1001         result = 1;
1002       }
1003     if (v1.ieee.mantissa1 != v2.ieee.mantissa1)
1004       {
1005         printf ("0.0L down: mantissa1 differs: %8x vs %8x\n",
1006                 v1.ieee.mantissa1, v2.ieee.mantissa1);
1007         result = 1;
1008       }
1009     if (v1.ieee.exponent != v2.ieee.exponent)
1010       {
1011         printf ("0.0L down: exponent differs: %4x vs %4x\n",
1012                 v1.ieee.exponent, v2.ieee.exponent);
1013         result = 1;
1014       }
1015     if (1 != v2.ieee.negative)
1016       {
1017         printf ("0.0L down: negative differs: 1 vs %d\n",
1018                 v2.ieee.negative);
1019         result = 1;
1020       }
1021
1022     if (nextafterl (0.0, INFINITY) != nextafterl (0.0, 1.0)
1023         || nextafterl (-0.0, INFINITY) != nextafterl (-0.0, 1.0)
1024         || nextafterl (0.0, -INFINITY) != nextafterl (0.0, -1.0)
1025         || nextafterl (-0.0, -INFINITY) != nextafterl (-0.0, -1.0))
1026       {
1027         printf ("nextafterl (+-0, +-Inf) != nextafterl (+-0, +-1)\n");
1028         result = 1;
1029       }
1030
1031     if (nexttowardl (0.0L, INFINITY) != nexttowardl (0.0L, 1.0L)
1032         || nexttowardl (-0.0L, INFINITY) != nexttowardl (-0.0L, 1.0L)
1033         || nexttowardl (0.0L, -INFINITY) != nexttowardl (0.0L, -1.0L)
1034         || nexttowardl (-0.0L, -INFINITY) != nexttowardl (-0.0L, -1.0L))
1035       {
1036         printf ("nexttowardl (+-0, +-Inf) != nexttowardl (+-0, +-1)\n");
1037         result = 1;
1038       }
1039   }
1040 #endif
1041
1042   if (! isnormal (FLT_MIN))
1043     {
1044       puts ("isnormal (FLT_MIN) failed");
1045       result = 1;
1046     }
1047   if (! isnormal (DBL_MIN))
1048     {
1049       puts ("isnormal (DBL_MIN) failed");
1050       result = 1;
1051     }
1052 #ifndef NO_LONG_DOUBLE
1053   if (! isnormal (LDBL_MIN))
1054     {
1055       puts ("isnormal (LDBL_MIN) failed");
1056       result = 1;
1057     }
1058 #endif
1059
1060 #ifdef __i386__
1061   /* This is a test for the strange long doubles in x86 FPUs.  */
1062   {
1063     union
1064     {
1065       char b[10];
1066       long double d;
1067     } u =
1068       { .b = { 0, 0, 0, 0, 0, 0, 0, 0x80, 0, 0 } };
1069
1070     if (fpclassify (u.d) != FP_NORMAL)
1071       {
1072         printf ("fpclassify (0x00008000000000000000) failed: %d (%Lg)\n",
1073                 fpclassify (u.d), u.d);
1074         result = 1;
1075       }
1076   }
1077
1078   /* Special NaNs in x86 long double.  Test for scalbl.  */
1079   {
1080     union
1081     {
1082       char b[10];
1083       long double d;
1084     } u =
1085       { .b = { 0, 1, 0, 0, 0, 0, 0, 0xc0, 0xff, 0x7f } };
1086     long double r;
1087
1088     r = scalbl (u.d, 0.0);
1089     if (!isnan (r))
1090       {
1091         puts ("scalbl(NaN, 0) does not return NaN");
1092         result = 1;
1093       }
1094     else if (memcmp (&r, &u.d, sizeof (double)) != 0)
1095       {
1096         puts ("scalbl(NaN, 0) does not return the same NaN");
1097         result = 1;
1098       }
1099   }
1100 #endif
1101
1102 #ifndef NO_LONG_DOUBLE
1103   {
1104     long double r;
1105
1106     feclearexcept (FE_ALL_EXCEPT);
1107     r = scalbl (LDBL_MIN, 2147483647);
1108     if (! isinf (r))
1109       {
1110         puts ("scalbl (LDBL_MIN, 2147483647) does not return Inf");
1111         result = 1;
1112       }
1113     else if (signbit (r) != 0)
1114       {
1115         puts ("scalbl (LDBL_MIN, 2147483647) returns -Inf");
1116         result = 1;
1117       }
1118     else if (fetestexcept (FE_UNDERFLOW))
1119       {
1120         puts ("scalbl(NaN, 0) raises underflow exception");
1121         result = 1;
1122       }
1123
1124     feclearexcept (FE_ALL_EXCEPT);
1125     r = scalbl (LDBL_MAX, -2147483647);
1126     if (r != 0.0)
1127       {
1128         puts ("scalbl (LDBL_MAX, -2147483647) does not return 0");
1129         result = 1;
1130       }
1131     else if (signbit (r) != 0)
1132       {
1133         puts ("scalbl (LDBL_MAX, -2147483647) returns -Inf");
1134         result = 1;
1135       }
1136     else if (fetestexcept (FE_OVERFLOW))
1137       {
1138         puts ("scalbl(NaN, 0) raises overflow exception");
1139         result = 1;
1140       }
1141   }
1142 #endif
1143
1144   /* The tests here are very similar to tests earlier in this file,
1145      the important difference is just that there are no intervening
1146      union variables that cause some GCC versions to hide possible
1147      bugs in nextafter* implementation.  */
1148   if (nextafterf (nextafterf (FLT_MIN, FLT_MIN / 2.0), FLT_MIN) != FLT_MIN)
1149     {
1150       puts ("nextafterf FLT_MIN test failed");
1151       result = 1;
1152     }
1153   if (nextafterf (nextafterf (-FLT_MIN, -FLT_MIN / 2.0), -FLT_MIN)
1154       != -FLT_MIN)
1155     {
1156       puts ("nextafterf -FLT_MIN test failed");
1157       result = 1;
1158     }
1159   if (nextafter (nextafter (DBL_MIN, DBL_MIN / 2.0), DBL_MIN) != DBL_MIN)
1160     {
1161       puts ("nextafter DBL_MIN test failed");
1162       result = 1;
1163     }
1164   if (nextafter (nextafter (-DBL_MIN, -DBL_MIN / 2.0), -DBL_MIN) != -DBL_MIN)
1165     {
1166       puts ("nextafter -DBL_MIN test failed");
1167       result = 1;
1168     }
1169 #ifndef NO_LONG_DOUBLE
1170   if (nextafterl (nextafterl (LDBL_MIN, LDBL_MIN / 2.0), LDBL_MIN)
1171       != LDBL_MIN)
1172     {
1173       puts ("nextafterl LDBL_MIN test failed");
1174       result = 1;
1175     }
1176   if (nextafterl (nextafterl (-LDBL_MIN, -LDBL_MIN / 2.0), -LDBL_MIN)
1177       != -LDBL_MIN)
1178     {
1179       puts ("nextafterl -LDBL_MIN test failed");
1180       result = 1;
1181     }
1182 #endif
1183
1184   volatile float f1 = FLT_MAX;
1185   volatile float f2 = FLT_MAX / 2;
1186   (void) &f1;
1187   (void) &f2;
1188   feclearexcept (FE_ALL_EXCEPT);
1189   f2 += f1;
1190   int fe = fetestexcept (FE_ALL_EXCEPT);
1191   if (fe != (FE_OVERFLOW | FE_INEXACT))
1192     {
1193       printf ("float overflow test failed: %x\n", fe);
1194       result = 1;
1195     }
1196
1197   volatile double d1 = DBL_MAX;
1198   volatile double d2 = DBL_MAX / 2;
1199   (void) &d1;
1200   (void) &d2;
1201   feclearexcept (FE_ALL_EXCEPT);
1202   d2 += d1;
1203   fe = fetestexcept (FE_ALL_EXCEPT);
1204   if (fe != (FE_OVERFLOW | FE_INEXACT))
1205     {
1206       printf ("double overflow test failed: %x\n", fe);
1207       result = 1;
1208     }
1209
1210 #ifndef NO_LONG_DOUBLE
1211   volatile long double ld1 = LDBL_MAX;
1212   volatile long double ld2 = LDBL_MAX / 2;
1213   (void) &ld1;
1214   (void) &ld2;
1215   feclearexcept (FE_ALL_EXCEPT);
1216   ld2 += ld1;
1217   fe = fetestexcept (FE_ALL_EXCEPT);
1218   if (fe != (FE_OVERFLOW | FE_INEXACT))
1219     {
1220       printf ("long double overflow test failed: %x\n", fe);
1221       result = 1;
1222     }
1223 #endif
1224
1225 #if !defined NO_LONG_DOUBLE && LDBL_MANT_DIG == 113
1226   volatile long double ld3 = 0x1.0000000000010000000100000001p+1;
1227   volatile long double ld4 = 0x1.0000000000000000000000000001p+1;
1228   (void) &ld3;
1229   (void) &ld4;
1230   ld3 -= ld4;
1231   if (ld3 != 0x1.0p-47)
1232     {
1233       printf ("long double subtraction test failed %.28La\n", ld3);
1234       result = 1;
1235     }
1236 #endif
1237
1238 /* Skip testing IBM long double format, for 2 reasons:
1239    1) it only supports FE_TONEAREST
1240    2) nextafter (0.0, 1.0) == nextafterl (0.0L, 1.0L), so
1241       nextafter (0.0, 1.0) / 16.0L will be 0.0L.  */
1242 #if !defined NO_LONG_DOUBLE && LDBL_MANT_DIG >= DBL_MANT_DIG + 4 \
1243     && LDBL_MANT_DIG != 106
1244   int oldmode = fegetround ();
1245   int j;
1246   for (j = 0; j < 4; j++)
1247     {
1248       int mode;
1249       int i;
1250       int k = 0;
1251       const char *mstr;
1252       switch (j)
1253         {
1254 #ifdef FE_TONEAREST
1255         case 0:
1256           mode = FE_TONEAREST;
1257           mstr = "nearest";
1258           k = 8;
1259           break;
1260 #endif
1261 #ifdef FE_DOWNWARD
1262         case 1:
1263           mode = FE_DOWNWARD;
1264           mstr = "-inf";
1265           break;
1266 #endif
1267 #ifdef FE_UPWARD
1268         case 2:
1269           mode = FE_UPWARD;
1270           mstr = "+inf";
1271           k = 15;
1272           break;
1273 #endif
1274 #ifdef FE_TOWARDZERO
1275         case 3:
1276           mode = FE_TOWARDZERO;
1277           mstr = "0";
1278           break;
1279 #endif
1280         default:
1281           continue;
1282         }
1283
1284       volatile long double ld5 = nextafter (0.0, 1.0) / 16.0L;
1285       volatile double d5;
1286       (void) &ld5;
1287       for (i = 0; i <= 32; i++)
1288         {
1289           if (fesetround (mode))
1290             {
1291               printf ("failed to set rounding mode to %s\n", mstr);
1292               result = 1;
1293               break;
1294             }
1295           d5 = ld5 * i;
1296           (void) &d5;
1297           fesetround (oldmode);
1298           if (d5 != ((j == 0 && i == 8) ? 0 : (i + k) / 16)
1299                     * nextafter (0.0, 1.0))
1300             {
1301               printf ("%La incorrectly rounded to %s as %a\n",
1302                       ld5 * i, mstr, d5);
1303               result = 1;
1304             }
1305         }
1306     }
1307
1308   volatile long double ld7 = nextafterl (0.0L, 1.0L);
1309   volatile double d7;
1310   (void) &ld7;
1311   fesetround (FE_UPWARD);
1312   d7 = ld7;
1313   (void) &d7;
1314   fesetround (oldmode);
1315
1316   if (d7 != nextafter (0.0, 1.0))
1317     {
1318       printf ("%La incorrectly rounded upward to %a\n", ld7, d7);
1319       result = 1;
1320     }
1321 #endif
1322
1323   return result;
1324 }