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