tools/test/testfloat/testFunction.c

   1
   2 /*
   3 ===============================================================================
   4
   5 This C source file is part of TestFloat, Release 2a, a package of programs
   6 for testing the correctness of floating-point arithmetic complying to the
   7 IEC/IEEE Standard for Floating-Point.
   8
   9 Written by John R. Hauser.  More information is available through the Web
  10 page `http://HTTP.CS.Berkeley.EDU/~jhauser/arithmetic/TestFloat.html'.
  11
  12 THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE.  Although reasonable effort
  13 has been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT
  14 TIMES RESULT IN INCORRECT BEHAVIOR.  USE OF THIS SOFTWARE IS RESTRICTED TO
  15 PERSONS AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ANY
  16 AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE.
  17
  18 Derivative works are acceptable, even for commercial purposes, so long as
  19 (1) they include prominent notice that the work is derivative, and (2) they
  20 include prominent notice akin to these four paragraphs for those parts of
  21 this code that are retained.
  22
  23 ===============================================================================
  24 */
  25
  26 #include "milieu.h"
  27 #include "softfloat.h"
  28 #include "testCases.h"
  29 #include "testLoops.h"
  30 #include "systmodes.h"
  31 #include "systflags.h"
  32 #include "systfloat.h"
  33 #include "testFunction.h"
  34
  35 const functionT functions[ NUM_FUNCTIONS ] = {
  36     { 0, 0, 0, 0 },
  37     { "int32_to_float32",                1, FALSE, TRUE  },
  38     { "int32_to_float64",                1, FALSE, FALSE },
  39     { "int32_to_floatx80",               1, FALSE, FALSE },
  40     { "int32_to_float128",               1, FALSE, FALSE },
  41     { "int64_to_float32",                1, FALSE, TRUE  },
  42     { "int64_to_float64",                1, FALSE, TRUE  },
  43     { "int64_to_floatx80",               1, FALSE, FALSE },
  44     { "int64_to_float128",               1, FALSE, FALSE },
  45     { "float32_to_int32",                1, FALSE, TRUE  },
  46     { "float32_to_int32_round_to_zero",  1, FALSE, FALSE },
  47     { "float32_to_int64",                1, FALSE, TRUE  },
  48     { "float32_to_int64_round_to_zero",  1, FALSE, FALSE },
  49     { "float32_to_float64",              1, FALSE, FALSE },
  50     { "float32_to_floatx80",             1, FALSE, FALSE },
  51     { "float32_to_float128",             1, FALSE, FALSE },
  52     { "float32_round_to_int",            1, FALSE, TRUE  },
  53     { "float32_add",                     2, FALSE, TRUE  },
  54     { "float32_sub",                     2, FALSE, TRUE  },
  55     { "float32_mul",                     2, FALSE, TRUE  },
  56     { "float32_div",                     2, FALSE, TRUE  },
  57     { "float32_rem",                     2, FALSE, FALSE },
  58     { "float32_sqrt",                    1, FALSE, TRUE  },
  59     { "float32_eq",                      2, FALSE, FALSE },
  60     { "float32_le",                      2, FALSE, FALSE },
  61     { "float32_lt",                      2, FALSE, FALSE },
  62     { "float32_eq_signaling",            2, FALSE, FALSE },
  63     { "float32_le_quiet",                2, FALSE, FALSE },
  64     { "float32_lt_quiet",                2, FALSE, FALSE },
  65     { "float64_to_int32",                1, FALSE, TRUE  },
  66     { "float64_to_int32_round_to_zero",  1, FALSE, FALSE },
  67     { "float64_to_int64",                1, FALSE, TRUE  },
  68     { "float64_to_int64_round_to_zero",  1, FALSE, FALSE },
  69     { "float64_to_float32",              1, FALSE, TRUE  },
  70     { "float64_to_floatx80",             1, FALSE, FALSE },
  71     { "float64_to_float128",             1, FALSE, FALSE },
  72     { "float64_round_to_int",            1, FALSE, TRUE  },
  73     { "float64_add",                     2, FALSE, TRUE  },
  74     { "float64_sub",                     2, FALSE, TRUE  },
  75     { "float64_mul",                     2, FALSE, TRUE  },
  76     { "float64_div",                     2, FALSE, TRUE  },
  77     { "float64_rem",                     2, FALSE, FALSE },
  78     { "float64_sqrt",                    1, FALSE, TRUE  },
  79     { "float64_eq",                      2, FALSE, FALSE },
  80     { "float64_le",                      2, FALSE, FALSE },
  81     { "float64_lt",                      2, FALSE, FALSE },
  82     { "float64_eq_signaling",            2, FALSE, FALSE },
  83     { "float64_le_quiet",                2, FALSE, FALSE },
  84     { "float64_lt_quiet",                2, FALSE, FALSE },
  85     { "floatx80_to_int32",               1, FALSE, TRUE  },
  86     { "floatx80_to_int32_round_to_zero", 1, FALSE, FALSE },
  87     { "floatx80_to_int64",               1, FALSE, TRUE  },
  88     { "floatx80_to_int64_round_to_zero", 1, FALSE, FALSE },
  89     { "floatx80_to_float32",             1, FALSE, TRUE  },
  90     { "floatx80_to_float64",             1, FALSE, TRUE  },
  91     { "floatx80_to_float128",            1, FALSE, FALSE },
  92     { "floatx80_round_to_int",           1, FALSE, TRUE  },
  93     { "floatx80_add",                    2, TRUE,  TRUE  },
  94     { "floatx80_sub",                    2, TRUE,  TRUE  },
  95     { "floatx80_mul",                    2, TRUE,  TRUE  },
  96     { "floatx80_div",                    2, TRUE,  TRUE  },
  97     { "floatx80_rem",                    2, FALSE, FALSE },
  98     { "floatx80_sqrt",                   1, TRUE,  TRUE  },
  99     { "floatx80_eq",                     2, FALSE, FALSE },
 100     { "floatx80_le",                     2, FALSE, FALSE },
 101     { "floatx80_lt",                     2, FALSE, FALSE },
 102     { "floatx80_eq_signaling",           2, FALSE, FALSE },
 103     { "floatx80_le_quiet",               2, FALSE, FALSE },
 104     { "floatx80_lt_quiet",               2, FALSE, FALSE },
 105     { "float128_to_int32",               1, FALSE, TRUE  },
 106     { "float128_to_int32_round_to_zero", 1, FALSE, FALSE },
 107     { "float128_to_int64",               1, FALSE, TRUE  },
 108     { "float128_to_int64_round_to_zero", 1, FALSE, FALSE },
 109     { "float128_to_float32",             1, FALSE, TRUE  },
 110     { "float128_to_float64",             1, FALSE, TRUE  },
 111     { "float128_to_floatx80",            1, FALSE, TRUE  },
 112     { "float128_round_to_int",           1, FALSE, TRUE  },
 113     { "float128_add",                    2, FALSE, TRUE  },
 114     { "float128_sub",                    2, FALSE, TRUE  },
 115     { "float128_mul",                    2, FALSE, TRUE  },
 116     { "float128_div",                    2, FALSE, TRUE  },
 117     { "float128_rem",                    2, FALSE, FALSE },
 118     { "float128_sqrt",                   1, FALSE, TRUE  },
 119     { "float128_eq",                     2, FALSE, FALSE },
 120     { "float128_le",                     2, FALSE, FALSE },
 121     { "float128_lt",                     2, FALSE, FALSE },
 122     { "float128_eq_signaling",           2, FALSE, FALSE },
 123     { "float128_le_quiet",               2, FALSE, FALSE },
 124     { "float128_lt_quiet",               2, FALSE, FALSE },
 125 };
 126
 127 const flag functionExists[ NUM_FUNCTIONS ] = {
 128     0,
 129 #ifdef SYST_INT32_TO_FLOAT32
 130     1,
 131 #else
 132     0,
 133 #endif
 134 #ifdef SYST_INT32_TO_FLOAT64
 135     1,
 136 #else
 137     0,
 138 #endif
 139 #ifdef SYST_INT32_TO_FLOATX80
 140     1,
 141 #else
 142     0,
 143 #endif
 144 #ifdef SYST_INT32_TO_FLOAT128
 145     1,
 146 #else
 147     0,
 148 #endif
 149 #ifdef SYST_INT64_TO_FLOAT32
 150     1,
 151 #else
 152     0,
 153 #endif
 154 #ifdef SYST_INT64_TO_FLOAT64
 155     1,
 156 #else
 157     0,
 158 #endif
 159 #ifdef SYST_INT64_TO_FLOATX80
 160     1,
 161 #else
 162     0,
 163 #endif
 164 #ifdef SYST_INT64_TO_FLOAT128
 165     1,
 166 #else
 167     0,
 168 #endif
 169 #ifdef SYST_FLOAT32_TO_INT32
 170     1,
 171 #else
 172     0,
 173 #endif
 174 #ifdef SYST_FLOAT32_TO_INT32_ROUND_TO_ZERO
 175     1,
 176 #else
 177     0,
 178 #endif
 179 #ifdef SYST_FLOAT32_TO_INT64
 180     1,
 181 #else
 182     0,
 183 #endif
 184 #ifdef SYST_FLOAT32_TO_INT64_ROUND_TO_ZERO
 185     1,
 186 #else
 187     0,
 188 #endif
 189 #ifdef SYST_FLOAT32_TO_FLOAT64
 190     1,
 191 #else
 192     0,
 193 #endif
 194 #ifdef SYST_FLOAT32_TO_FLOATX80
 195     1,
 196 #else
 197     0,
 198 #endif
 199 #ifdef SYST_FLOAT32_TO_FLOAT128
 200     1,
 201 #else
 202     0,
 203 #endif
 204 #ifdef SYST_FLOAT32_ROUND_TO_INT
 205     1,
 206 #else
 207     0,
 208 #endif
 209 #ifdef SYST_FLOAT32_ADD
 210     1,
 211 #else
 212     0,
 213 #endif
 214 #ifdef SYST_FLOAT32_SUB
 215     1,
 216 #else
 217     0,
 218 #endif
 219 #ifdef SYST_FLOAT32_MUL
 220     1,
 221 #else
 222     0,
 223 #endif
 224 #ifdef SYST_FLOAT32_DIV
 225     1,
 226 #else
 227     0,
 228 #endif
 229 #ifdef SYST_FLOAT32_REM
 230     1,
 231 #else
 232     0,
 233 #endif
 234 #ifdef SYST_FLOAT32_SQRT
 235     1,
 236 #else
 237     0,
 238 #endif
 239 #ifdef SYST_FLOAT32_EQ
 240     1,
 241 #else
 242     0,
 243 #endif
 244 #ifdef SYST_FLOAT32_LE
 245     1,
 246 #else
 247     0,
 248 #endif
 249 #ifdef SYST_FLOAT32_LT
 250     1,
 251 #else
 252     0,
 253 #endif
 254 #ifdef SYST_FLOAT32_EQ_SIGNALING
 255     1,
 256 #else
 257     0,
 258 #endif
 259 #ifdef SYST_FLOAT32_LE_QUIET
 260     1,
 261 #else
 262     0,
 263 #endif
 264 #ifdef SYST_FLOAT32_LT_QUIET
 265     1,
 266 #else
 267     0,
 268 #endif
 269 #ifdef SYST_FLOAT64_TO_INT32
 270     1,
 271 #else
 272     0,
 273 #endif
 274 #ifdef SYST_FLOAT64_TO_INT32_ROUND_TO_ZERO
 275     1,
 276 #else
 277     0,
 278 #endif
 279 #ifdef SYST_FLOAT64_TO_INT64
 280     1,
 281 #else
 282     0,
 283 #endif
 284 #ifdef SYST_FLOAT64_TO_INT64_ROUND_TO_ZERO
 285     1,
 286 #else
 287     0,
 288 #endif
 289 #ifdef SYST_FLOAT64_TO_FLOAT32
 290     1,
 291 #else
 292     0,
 293 #endif
 294 #ifdef SYST_FLOAT64_TO_FLOATX80
 295     1,
 296 #else
 297     0,
 298 #endif
 299 #ifdef SYST_FLOAT64_TO_FLOAT128
 300     1,
 301 #else
 302     0,
 303 #endif
 304 #ifdef SYST_FLOAT64_ROUND_TO_INT
 305     1,
 306 #else
 307     0,
 308 #endif
 309 #ifdef SYST_FLOAT64_ADD
 310     1,
 311 #else
 312     0,
 313 #endif
 314 #ifdef SYST_FLOAT64_SUB
 315     1,
 316 #else
 317     0,
 318 #endif
 319 #ifdef SYST_FLOAT64_MUL
 320     1,
 321 #else
 322     0,
 323 #endif
 324 #ifdef SYST_FLOAT64_DIV
 325     1,
 326 #else
 327     0,
 328 #endif
 329 #ifdef SYST_FLOAT64_REM
 330     1,
 331 #else
 332     0,
 333 #endif
 334 #ifdef SYST_FLOAT64_SQRT
 335     1,
 336 #else
 337     0,
 338 #endif
 339 #ifdef SYST_FLOAT64_EQ
 340     1,
 341 #else
 342     0,
 343 #endif
 344 #ifdef SYST_FLOAT64_LE
 345     1,
 346 #else
 347     0,
 348 #endif
 349 #ifdef SYST_FLOAT64_LT
 350     1,
 351 #else
 352     0,
 353 #endif
 354 #ifdef SYST_FLOAT64_EQ_SIGNALING
 355     1,
 356 #else
 357     0,
 358 #endif
 359 #ifdef SYST_FLOAT64_LE_QUIET
 360     1,
 361 #else
 362     0,
 363 #endif
 364 #ifdef SYST_FLOAT64_LT_QUIET
 365     1,
 366 #else
 367     0,
 368 #endif
 369 #ifdef SYST_FLOATX80_TO_INT32
 370     1,
 371 #else
 372     0,
 373 #endif
 374 #ifdef SYST_FLOATX80_TO_INT32_ROUND_TO_ZERO
 375     1,
 376 #else
 377     0,
 378 #endif
 379 #ifdef SYST_FLOATX80_TO_INT64
 380     1,
 381 #else
 382     0,
 383 #endif
 384 #ifdef SYST_FLOATX80_TO_INT64_ROUND_TO_ZERO
 385     1,
 386 #else
 387     0,
 388 #endif
 389 #ifdef SYST_FLOATX80_TO_FLOAT32
 390     1,
 391 #else
 392     0,
 393 #endif
 394 #ifdef SYST_FLOATX80_TO_FLOAT64
 395     1,
 396 #else
 397     0,
 398 #endif
 399 #ifdef SYST_FLOATX80_TO_FLOAT128
 400     1,
 401 #else
 402     0,
 403 #endif
 404 #ifdef SYST_FLOATX80_ROUND_TO_INT
 405     1,
 406 #else
 407     0,
 408 #endif
 409 #ifdef SYST_FLOATX80_ADD
 410     1,
 411 #else
 412     0,
 413 #endif
 414 #ifdef SYST_FLOATX80_SUB
 415     1,
 416 #else
 417     0,
 418 #endif
 419 #ifdef SYST_FLOATX80_MUL
 420     1,
 421 #else
 422     0,
 423 #endif
 424 #ifdef SYST_FLOATX80_DIV
 425     1,
 426 #else
 427     0,
 428 #endif
 429 #ifdef SYST_FLOATX80_REM
 430     1,
 431 #else
 432     0,
 433 #endif
 434 #ifdef SYST_FLOATX80_SQRT
 435     1,
 436 #else
 437     0,
 438 #endif
 439 #ifdef SYST_FLOATX80_EQ
 440     1,
 441 #else
 442     0,
 443 #endif
 444 #ifdef SYST_FLOATX80_LE
 445     1,
 446 #else
 447     0,
 448 #endif
 449 #ifdef SYST_FLOATX80_LT
 450     1,
 451 #else
 452     0,
 453 #endif
 454 #ifdef SYST_FLOATX80_EQ_SIGNALING
 455     1,
 456 #else
 457     0,
 458 #endif
 459 #ifdef SYST_FLOATX80_LE_QUIET
 460     1,
 461 #else
 462     0,
 463 #endif
 464 #ifdef SYST_FLOATX80_LT_QUIET
 465     1,
 466 #else
 467     0,
 468 #endif
 469 #ifdef SYST_FLOAT128_TO_INT32
 470     1,
 471 #else
 472     0,
 473 #endif
 474 #ifdef SYST_FLOAT128_TO_INT32_ROUND_TO_ZERO
 475     1,
 476 #else
 477     0,
 478 #endif
 479 #ifdef SYST_FLOAT128_TO_INT64
 480     1,
 481 #else
 482     0,
 483 #endif
 484 #ifdef SYST_FLOAT128_TO_INT64_ROUND_TO_ZERO
 485     1,
 486 #else
 487     0,
 488 #endif
 489 #ifdef SYST_FLOAT128_TO_FLOAT32
 490     1,
 491 #else
 492     0,
 493 #endif
 494 #ifdef SYST_FLOAT128_TO_FLOAT64
 495     1,
 496 #else
 497     0,
 498 #endif
 499 #ifdef SYST_FLOAT128_TO_FLOATX80
 500     1,
 501 #else
 502     0,
 503 #endif
 504 #ifdef SYST_FLOAT128_ROUND_TO_INT
 505     1,
 506 #else
 507     0,
 508 #endif
 509 #ifdef SYST_FLOAT128_ADD
 510     1,
 511 #else
 512     0,
 513 #endif
 514 #ifdef SYST_FLOAT128_SUB
 515     1,
 516 #else
 517     0,
 518 #endif
 519 #ifdef SYST_FLOAT128_MUL
 520     1,
 521 #else
 522     0,
 523 #endif
 524 #ifdef SYST_FLOAT128_DIV
 525     1,
 526 #else
 527     0,
 528 #endif
 529 #ifdef SYST_FLOAT128_REM
 530     1,
 531 #else
 532     0,
 533 #endif
 534 #ifdef SYST_FLOAT128_SQRT
 535     1,
 536 #else
 537     0,
 538 #endif
 539 #ifdef SYST_FLOAT128_EQ
 540     1,
 541 #else
 542     0,
 543 #endif
 544 #ifdef SYST_FLOAT128_LE
 545     1,
 546 #else
 547     0,
 548 #endif
 549 #ifdef SYST_FLOAT128_LT
 550     1,
 551 #else
 552     0,
 553 #endif
 554 #ifdef SYST_FLOAT128_EQ_SIGNALING
 555     1,
 556 #else
 557     0,
 558 #endif
 559 #ifdef SYST_FLOAT128_LE_QUIET
 560     1,
 561 #else
 562     0,
 563 #endif
 564 #ifdef SYST_FLOAT128_LT_QUIET
 565     1,
 566 #else
 567     0,
 568 #endif
 569 };
 570
 571 static void
 572  testFunctionVariety(
 573      uint8 functionCode, int8 roundingPrecision, int8 roundingMode )
 574 {
 575     uint8 roundingCode;
 576
 577     functionName = functions[ functionCode ].name;
 578 #ifdef FLOATX80
 579     if ( roundingPrecision == 32 ) {
 580         roundingPrecisionName = "32";
 581     }
 582     else if ( roundingPrecision == 64 ) {
 583         roundingPrecisionName = "64";
 584     }
 585     else if ( roundingPrecision == 80 ) {
 586         roundingPrecisionName = "80";
 587     }
 588     else {
 589         roundingPrecision = 80;
 590         roundingPrecisionName = 0;
 591     }
 592     floatx80_rounding_precision = roundingPrecision;
 593     syst_float_set_rounding_precision( roundingPrecision );
 594 #endif
 595     switch ( roundingMode ) {
 596      case 0:
 597         roundingModeName = 0;
 598         roundingCode = float_round_nearest_even;
 599         break;
 600      case ROUND_NEAREST_EVEN:
 601         roundingModeName = "nearest_even";
 602         roundingCode = float_round_nearest_even;
 603         break;
 604      case ROUND_TO_ZERO:
 605         roundingModeName = "to_zero";
 606         roundingCode = float_round_to_zero;
 607         break;
 608      case ROUND_DOWN:
 609         roundingModeName = "down";
 610         roundingCode = float_round_down;
 611         break;
 612      case ROUND_UP:
 613         roundingModeName = "up";
 614         roundingCode = float_round_up;
 615         break;
 616     }
 617     float_rounding_mode = roundingCode;
 618     syst_float_set_rounding_mode( roundingCode );
 619     fputs( "Testing ", stderr );
 620     writeFunctionName( stderr );
 621     fputs( ".\n", stderr );
 622     switch ( functionCode ) {
 623 #ifdef SYST_INT32_TO_FLOAT32
 624      case INT32_TO_FLOAT32:
 625         test_a_int32_z_float32( int32_to_float32, syst_int32_to_float32 );
 626         break;
 627 #endif
 628 #ifdef SYST_INT32_TO_FLOAT64
 629      case INT32_TO_FLOAT64:
 630         test_a_int32_z_float64( int32_to_float64, syst_int32_to_float64 );
 631         break;
 632 #endif
 633 #ifdef SYST_INT32_TO_FLOATX80
 634      case INT32_TO_FLOATX80:
 635         test_a_int32_z_floatx80( int32_to_floatx80, syst_int32_to_floatx80 );
 636         break;
 637 #endif
 638 #ifdef SYST_INT32_TO_FLOAT128
 639      case INT32_TO_FLOAT128:
 640         test_a_int32_z_float128( int32_to_float128, syst_int32_to_float128 );
 641         break;
 642 #endif
 643 #ifdef SYST_INT64_TO_FLOAT32
 644      case INT64_TO_FLOAT32:
 645         test_a_int64_z_float32( int64_to_float32, syst_int64_to_float32 );
 646         break;
 647 #endif
 648 #ifdef SYST_INT64_TO_FLOAT64
 649      case INT64_TO_FLOAT64:
 650         test_a_int64_z_float64( int64_to_float64, syst_int64_to_float64 );
 651         break;
 652 #endif
 653 #ifdef SYST_INT64_TO_FLOATX80
 654      case INT64_TO_FLOATX80:
 655         test_a_int64_z_floatx80( int64_to_floatx80, syst_int64_to_floatx80 );
 656         break;
 657 #endif
 658 #ifdef SYST_INT64_TO_FLOAT128
 659      case INT64_TO_FLOAT128:
 660         test_a_int64_z_float128( int64_to_float128, syst_int64_to_float128 );
 661         break;
 662 #endif
 663 #ifdef SYST_FLOAT32_TO_INT32
 664      case FLOAT32_TO_INT32:
 665         test_a_float32_z_int32( float32_to_int32, syst_float32_to_int32 );
 666         break;
 667 #endif
 668 #ifdef SYST_FLOAT32_TO_INT32_ROUND_TO_ZERO
 669      case FLOAT32_TO_INT32_ROUND_TO_ZERO:
 670         test_a_float32_z_int32(
 671             float32_to_int32_round_to_zero,
 672             syst_float32_to_int32_round_to_zero
 673         );
 674         break;
 675 #endif
 676 #ifdef SYST_FLOAT32_TO_INT64
 677      case FLOAT32_TO_INT64:
 678         test_a_float32_z_int64( float32_to_int64, syst_float32_to_int64 );
 679         break;
 680 #endif
 681 #ifdef SYST_FLOAT32_TO_INT64_ROUND_TO_ZERO
 682      case FLOAT32_TO_INT64_ROUND_TO_ZERO:
 683         test_a_float32_z_int64(
 684             float32_to_int64_round_to_zero,
 685             syst_float32_to_int64_round_to_zero
 686         );
 687         break;
 688 #endif
 689 #ifdef SYST_FLOAT32_TO_FLOAT64
 690      case FLOAT32_TO_FLOAT64:
 691         test_a_float32_z_float64(
 692             float32_to_float64, syst_float32_to_float64 );
 693         break;
 694 #endif
 695 #ifdef SYST_FLOAT32_TO_FLOATX80
 696      case FLOAT32_TO_FLOATX80:
 697         test_a_float32_z_floatx80(
 698             float32_to_floatx80, syst_float32_to_floatx80 );
 699         break;
 700 #endif
 701 #ifdef SYST_FLOAT32_TO_FLOAT128
 702      case FLOAT32_TO_FLOAT128:
 703         test_a_float32_z_float128(
 704             float32_to_float128, syst_float32_to_float128 );
 705         break;
 706 #endif
 707 #ifdef SYST_FLOAT32_ROUND_TO_INT
 708      case FLOAT32_ROUND_TO_INT:
 709         test_az_float32( float32_round_to_int, syst_float32_round_to_int );
 710         break;
 711 #endif
 712 #ifdef SYST_FLOAT32_ADD
 713      case FLOAT32_ADD:
 714         test_abz_float32( float32_add, syst_float32_add );
 715         break;
 716 #endif
 717 #ifdef SYST_FLOAT32_SUB
 718      case FLOAT32_SUB:
 719         test_abz_float32( float32_sub, syst_float32_sub );
 720         break;
 721 #endif
 722 #ifdef SYST_FLOAT32_MUL
 723      case FLOAT32_MUL:
 724         test_abz_float32( float32_mul, syst_float32_mul );
 725         break;
 726 #endif
 727 #ifdef SYST_FLOAT32_DIV
 728      case FLOAT32_DIV:
 729         test_abz_float32( float32_div, syst_float32_div );
 730         break;
 731 #endif
 732 #ifdef SYST_FLOAT32_REM
 733      case FLOAT32_REM:
 734         test_abz_float32( float32_rem, syst_float32_rem );
 735         break;
 736 #endif
 737 #ifdef SYST_FLOAT32_SQRT
 738      case FLOAT32_SQRT:
 739         test_az_float32( float32_sqrt, syst_float32_sqrt );
 740         break;
 741 #endif
 742 #ifdef SYST_FLOAT32_EQ
 743      case FLOAT32_EQ:
 744         test_ab_float32_z_flag( float32_eq, syst_float32_eq );
 745         break;
 746 #endif
 747 #ifdef SYST_FLOAT32_LE
 748      case FLOAT32_LE:
 749         test_ab_float32_z_flag( float32_le, syst_float32_le );
 750         break;
 751 #endif
 752 #ifdef SYST_FLOAT32_LT
 753      case FLOAT32_LT:
 754         test_ab_float32_z_flag( float32_lt, syst_float32_lt );
 755         break;
 756 #endif
 757 #ifdef SYST_FLOAT32_EQ_SIGNALING
 758      case FLOAT32_EQ_SIGNALING:
 759         test_ab_float32_z_flag(
 760             float32_eq_signaling, syst_float32_eq_signaling );
 761         break;
 762 #endif
 763 #ifdef SYST_FLOAT32_LE_QUIET
 764      case FLOAT32_LE_QUIET:
 765         test_ab_float32_z_flag( float32_le_quiet, syst_float32_le_quiet );
 766         break;
 767 #endif
 768 #ifdef SYST_FLOAT32_LT_QUIET
 769      case FLOAT32_LT_QUIET:
 770         test_ab_float32_z_flag( float32_lt_quiet, syst_float32_lt_quiet );
 771         break;
 772 #endif
 773 #ifdef SYST_FLOAT64_TO_INT32
 774      case FLOAT64_TO_INT32:
 775         test_a_float64_z_int32( float64_to_int32, syst_float64_to_int32 );
 776         break;
 777 #endif
 778 #ifdef SYST_FLOAT64_TO_INT32_ROUND_TO_ZERO
 779      case FLOAT64_TO_INT32_ROUND_TO_ZERO:
 780         test_a_float64_z_int32(
 781             float64_to_int32_round_to_zero,
 782             syst_float64_to_int32_round_to_zero
 783         );
 784         break;
 785 #endif
 786 #ifdef SYST_FLOAT64_TO_INT64
 787      case FLOAT64_TO_INT64:
 788         test_a_float64_z_int64( float64_to_int64, syst_float64_to_int64 );
 789         break;
 790 #endif
 791 #ifdef SYST_FLOAT64_TO_INT64_ROUND_TO_ZERO
 792      case FLOAT64_TO_INT64_ROUND_TO_ZERO:
 793         test_a_float64_z_int64(
 794             float64_to_int64_round_to_zero,
 795             syst_float64_to_int64_round_to_zero
 796         );
 797         break;
 798 #endif
 799 #ifdef SYST_FLOAT64_TO_FLOAT32
 800      case FLOAT64_TO_FLOAT32:
 801         test_a_float64_z_float32(
 802             float64_to_float32, syst_float64_to_float32 );
 803         break;
 804 #endif
 805 #ifdef SYST_FLOAT64_TO_FLOATX80
 806      case FLOAT64_TO_FLOATX80:
 807         test_a_float64_z_floatx80(
 808             float64_to_floatx80, syst_float64_to_floatx80 );
 809         break;
 810 #endif
 811 #ifdef SYST_FLOAT64_TO_FLOAT128
 812      case FLOAT64_TO_FLOAT128:
 813         test_a_float64_z_float128(
 814             float64_to_float128, syst_float64_to_float128 );
 815         break;
 816 #endif
 817 #ifdef SYST_FLOAT64_ROUND_TO_INT
 818      case FLOAT64_ROUND_TO_INT:
 819         test_az_float64( float64_round_to_int, syst_float64_round_to_int );
 820         break;
 821 #endif
 822 #ifdef SYST_FLOAT64_ADD
 823      case FLOAT64_ADD:
 824         test_abz_float64( float64_add, syst_float64_add );
 825         break;
 826 #endif
 827 #ifdef SYST_FLOAT64_SUB
 828      case FLOAT64_SUB:
 829         test_abz_float64( float64_sub, syst_float64_sub );
 830         break;
 831 #endif
 832 #ifdef SYST_FLOAT64_MUL
 833      case FLOAT64_MUL:
 834         test_abz_float64( float64_mul, syst_float64_mul );
 835         break;
 836 #endif
 837 #ifdef SYST_FLOAT64_DIV
 838      case FLOAT64_DIV:
 839         test_abz_float64( float64_div, syst_float64_div );
 840         break;
 841 #endif
 842 #ifdef SYST_FLOAT64_REM
 843      case FLOAT64_REM:
 844         test_abz_float64( float64_rem, syst_float64_rem );
 845         break;
 846 #endif
 847 #ifdef SYST_FLOAT64_SQRT
 848      case FLOAT64_SQRT:
 849         test_az_float64( float64_sqrt, syst_float64_sqrt );
 850         break;
 851 #endif
 852 #ifdef SYST_FLOAT64_EQ
 853      case FLOAT64_EQ:
 854         test_ab_float64_z_flag( float64_eq, syst_float64_eq );
 855         break;
 856 #endif
 857 #ifdef SYST_FLOAT64_LE
 858      case FLOAT64_LE:
 859         test_ab_float64_z_flag( float64_le, syst_float64_le );
 860         break;
 861 #endif
 862 #ifdef SYST_FLOAT64_LT
 863      case FLOAT64_LT:
 864         test_ab_float64_z_flag( float64_lt, syst_float64_lt );
 865         break;
 866 #endif
 867 #ifdef SYST_FLOAT64_EQ_SIGNALING
 868      case FLOAT64_EQ_SIGNALING:
 869         test_ab_float64_z_flag(
 870             float64_eq_signaling, syst_float64_eq_signaling );
 871         break;
 872 #endif
 873 #ifdef SYST_FLOAT64_LE_QUIET
 874      case FLOAT64_LE_QUIET:
 875         test_ab_float64_z_flag( float64_le_quiet, syst_float64_le_quiet );
 876         break;
 877 #endif
 878 #ifdef SYST_FLOAT64_LT_QUIET
 879      case FLOAT64_LT_QUIET:
 880         test_ab_float64_z_flag( float64_lt_quiet, syst_float64_lt_quiet );
 881         break;
 882 #endif
 883 #ifdef SYST_FLOATX80_TO_INT32
 884      case FLOATX80_TO_INT32:
 885         test_a_floatx80_z_int32( floatx80_to_int32, syst_floatx80_to_int32 );
 886         break;
 887 #endif
 888 #ifdef SYST_FLOATX80_TO_INT32_ROUND_TO_ZERO
 889      case FLOATX80_TO_INT32_ROUND_TO_ZERO:
 890         test_a_floatx80_z_int32(
 891             floatx80_to_int32_round_to_zero,
 892             syst_floatx80_to_int32_round_to_zero
 893         );
 894         break;
 895 #endif
 896 #ifdef SYST_FLOATX80_TO_INT64
 897      case FLOATX80_TO_INT64:
 898         test_a_floatx80_z_int64( floatx80_to_int64, syst_floatx80_to_int64 );
 899         break;
 900 #endif
 901 #ifdef SYST_FLOATX80_TO_INT64_ROUND_TO_ZERO
 902      case FLOATX80_TO_INT64_ROUND_TO_ZERO:
 903         test_a_floatx80_z_int64(
 904             floatx80_to_int64_round_to_zero,
 905             syst_floatx80_to_int64_round_to_zero
 906         );
 907         break;
 908 #endif
 909 #ifdef SYST_FLOATX80_TO_FLOAT32
 910      case FLOATX80_TO_FLOAT32:
 911         test_a_floatx80_z_float32(
 912             floatx80_to_float32, syst_floatx80_to_float32 );
 913         break;
 914 #endif
 915 #ifdef SYST_FLOATX80_TO_FLOAT64
 916      case FLOATX80_TO_FLOAT64:
 917         test_a_floatx80_z_float64(
 918             floatx80_to_float64, syst_floatx80_to_float64 );
 919         break;
 920 #endif
 921 #ifdef SYST_FLOATX80_TO_FLOAT128
 922      case FLOATX80_TO_FLOAT128:
 923         test_a_floatx80_z_float128(
 924             floatx80_to_float128, syst_floatx80_to_float128 );
 925         break;
 926 #endif
 927 #ifdef SYST_FLOATX80_ROUND_TO_INT
 928      case FLOATX80_ROUND_TO_INT:
 929         test_az_floatx80( floatx80_round_to_int, syst_floatx80_round_to_int );
 930         break;
 931 #endif
 932 #ifdef SYST_FLOATX80_ADD
 933      case FLOATX80_ADD:
 934         test_abz_floatx80( floatx80_add, syst_floatx80_add );
 935         break;
 936 #endif
 937 #ifdef SYST_FLOATX80_SUB
 938      case FLOATX80_SUB:
 939         test_abz_floatx80( floatx80_sub, syst_floatx80_sub );
 940         break;
 941 #endif
 942 #ifdef SYST_FLOATX80_MUL
 943      case FLOATX80_MUL:
 944         test_abz_floatx80( floatx80_mul, syst_floatx80_mul );
 945         break;
 946 #endif
 947 #ifdef SYST_FLOATX80_DIV
 948      case FLOATX80_DIV:
 949         test_abz_floatx80( floatx80_div, syst_floatx80_div );
 950         break;
 951 #endif
 952 #ifdef SYST_FLOATX80_REM
 953      case FLOATX80_REM:
 954         test_abz_floatx80( floatx80_rem, syst_floatx80_rem );
 955         break;
 956 #endif
 957 #ifdef SYST_FLOATX80_SQRT
 958      case FLOATX80_SQRT:
 959         test_az_floatx80( floatx80_sqrt, syst_floatx80_sqrt );
 960         break;
 961 #endif
 962 #ifdef SYST_FLOATX80_EQ
 963      case FLOATX80_EQ:
 964         test_ab_floatx80_z_flag( floatx80_eq, syst_floatx80_eq );
 965         break;
 966 #endif
 967 #ifdef SYST_FLOATX80_LE
 968      case FLOATX80_LE:
 969         test_ab_floatx80_z_flag( floatx80_le, syst_floatx80_le );
 970         break;
 971 #endif
 972 #ifdef SYST_FLOATX80_LT
 973      case FLOATX80_LT:
 974         test_ab_floatx80_z_flag( floatx80_lt, syst_floatx80_lt );
 975         break;
 976 #endif
 977 #ifdef SYST_FLOATX80_EQ_SIGNALING
 978      case FLOATX80_EQ_SIGNALING:
 979         test_ab_floatx80_z_flag(
 980             floatx80_eq_signaling, syst_floatx80_eq_signaling );
 981         break;
 982 #endif
 983 #ifdef SYST_FLOATX80_LE_QUIET
 984      case FLOATX80_LE_QUIET:
 985         test_ab_floatx80_z_flag( floatx80_le_quiet, syst_floatx80_le_quiet );
 986         break;
 987 #endif
 988 #ifdef SYST_FLOATX80_LT_QUIET
 989      case FLOATX80_LT_QUIET:
 990         test_ab_floatx80_z_flag( floatx80_lt_quiet, syst_floatx80_lt_quiet );
 991         break;
 992 #endif
 993 #ifdef SYST_FLOAT128_TO_INT32
 994      case FLOAT128_TO_INT32:
 995         test_a_float128_z_int32( float128_to_int32, syst_float128_to_int32 );
 996         break;
 997 #endif
 998 #ifdef SYST_FLOAT128_TO_INT32_ROUND_TO_ZERO
 999      case FLOAT128_TO_INT32_ROUND_TO_ZERO:
1000         test_a_float128_z_int32(
1001             float128_to_int32_round_to_zero,
1002             syst_float128_to_int32_round_to_zero
1003         );
1004         break;
1005 #endif
1006 #ifdef SYST_FLOAT128_TO_INT64
1007      case FLOAT128_TO_INT64:
1008         test_a_float128_z_int64( float128_to_int64, syst_float128_to_int64 );
1009         break;
1010 #endif
1011 #ifdef SYST_FLOAT128_TO_INT64_ROUND_TO_ZERO
1012      case FLOAT128_TO_INT64_ROUND_TO_ZERO:
1013         test_a_float128_z_int64(
1014             float128_to_int64_round_to_zero,
1015             syst_float128_to_int64_round_to_zero
1016         );
1017         break;
1018 #endif
1019 #ifdef SYST_FLOAT128_TO_FLOAT32
1020      case FLOAT128_TO_FLOAT32:
1021         test_a_float128_z_float32(
1022             float128_to_float32, syst_float128_to_float32 );
1023         break;
1024 #endif
1025 #ifdef SYST_FLOAT128_TO_FLOAT64
1026      case FLOAT128_TO_FLOAT64:
1027         test_a_float128_z_float64(
1028             float128_to_float64, syst_float128_to_float64 );
1029         break;
1030 #endif
1031 #ifdef SYST_FLOAT128_TO_FLOATX80
1032      case FLOAT128_TO_FLOATX80:
1033         test_a_float128_z_floatx80(
1034             float128_to_floatx80, syst_float128_to_floatx80 );
1035         break;
1036 #endif
1037 #ifdef SYST_FLOAT128_ROUND_TO_INT
1038      case FLOAT128_ROUND_TO_INT:
1039         test_az_float128( float128_round_to_int, syst_float128_round_to_int );
1040         break;
1041 #endif
1042 #ifdef SYST_FLOAT128_ADD
1043      case FLOAT128_ADD:
1044         test_abz_float128( float128_add, syst_float128_add );
1045         break;
1046 #endif
1047 #ifdef SYST_FLOAT128_SUB
1048      case FLOAT128_SUB:
1049         test_abz_float128( float128_sub, syst_float128_sub );
1050         break;
1051 #endif
1052 #ifdef SYST_FLOAT128_MUL
1053      case FLOAT128_MUL:
1054         test_abz_float128( float128_mul, syst_float128_mul );
1055         break;
1056 #endif
1057 #ifdef SYST_FLOAT128_DIV
1058      case FLOAT128_DIV:
1059         test_abz_float128( float128_div, syst_float128_div );
1060         break;
1061 #endif
1062 #ifdef SYST_FLOAT128_REM
1063      case FLOAT128_REM:
1064         test_abz_float128( float128_rem, syst_float128_rem );
1065         break;
1066 #endif
1067 #ifdef SYST_FLOAT128_SQRT
1068      case FLOAT128_SQRT:
1069         test_az_float128( float128_sqrt, syst_float128_sqrt );
1070         break;
1071 #endif
1072 #ifdef SYST_FLOAT128_EQ
1073      case FLOAT128_EQ:
1074         test_ab_float128_z_flag( float128_eq, syst_float128_eq );
1075         break;
1076 #endif
1077 #ifdef SYST_FLOAT128_LE
1078      case FLOAT128_LE:
1079         test_ab_float128_z_flag( float128_le, syst_float128_le );
1080         break;
1081 #endif
1082 #ifdef SYST_FLOAT128_LT
1083      case FLOAT128_LT:
1084         test_ab_float128_z_flag( float128_lt, syst_float128_lt );
1085         break;
1086 #endif
1087 #ifdef SYST_FLOAT128_EQ_SIGNALING
1088      case FLOAT128_EQ_SIGNALING:
1089         test_ab_float128_z_flag(
1090             float128_eq_signaling, syst_float128_eq_signaling );
1091         break;
1092 #endif
1093 #ifdef SYST_FLOAT128_LE_QUIET
1094      case FLOAT128_LE_QUIET:
1095         test_ab_float128_z_flag( float128_le_quiet, syst_float128_le_quiet );
1096         break;
1097 #endif
1098 #ifdef SYST_FLOAT128_LT_QUIET
1099      case FLOAT128_LT_QUIET:
1100         test_ab_float128_z_flag( float128_lt_quiet, syst_float128_lt_quiet );
1101         break;
1102 #endif
1103     }
1104     if ( ( errorStop && anyErrors ) || stop ) exitWithStatus();
1105
1106 }
1107
1108 void
1109  testFunction(
1110      uint8 functionCode, int8 roundingPrecisionIn, int8 roundingModeIn )
1111 {
1112     int8 roundingPrecision, roundingMode;
1113
1114     roundingPrecision = 32;
1115     for (;;) {
1116         if ( ! functions[ functionCode ].roundingPrecision ) {
1117             roundingPrecision = 0;
1118         }
1119         else if ( roundingPrecisionIn ) {
1120             roundingPrecision = roundingPrecisionIn;
1121         }
1122         for ( roundingMode = 1;
1123               roundingMode < NUM_ROUNDINGMODES;
1124               ++roundingMode
1125             ) {
1126             if ( ! functions[ functionCode ].roundingMode ) {
1127                 roundingMode = 0;
1128             }
1129             else if ( roundingModeIn ) {
1130                 roundingMode = roundingModeIn;
1131             }
1132             testFunctionVariety(
1133                 functionCode, roundingPrecision, roundingMode );
1134             if ( roundingModeIn || ! roundingMode ) break;
1135         }
1136         if ( roundingPrecisionIn || ! roundingPrecision ) break;
1137         if ( roundingPrecision == 80 ) {
1138             break;
1139         }
1140         else if ( roundingPrecision == 64 ) {
1141             roundingPrecision = 80;
1142         }
1143         else if ( roundingPrecision == 32 ) {
1144             roundingPrecision = 64;
1145         }
1146     }
1147
1148 }
1149