示例#1
0
static void
 testFunctionVariety(
     uint8 functionCode, int8 roundingPrecision, int8 roundingMode )
{
    uint8 roundingCode;

    functionName = functions[ functionCode ].name;
#ifdef FLOATX80
    if ( roundingPrecision == 32 ) {
        roundingPrecisionName = "32";
    }
    else if ( roundingPrecision == 64 ) {
        roundingPrecisionName = "64";
    }
    else if ( roundingPrecision == 80 ) {
        roundingPrecisionName = "80";
    }
    else {
        roundingPrecision = 80;
        roundingPrecisionName = 0;
    }
    floatx80_rounding_precision = roundingPrecision;
    syst_float_set_rounding_precision( roundingPrecision );
#endif
    switch ( roundingMode ) {
     case ROUND_NEAREST_EVEN:
        roundingModeName = "nearest_even";
        roundingCode = float_round_nearest_even;
        break;
     case ROUND_TO_ZERO:
        roundingModeName = "to_zero";
        roundingCode = float_round_to_zero;
        break;
     case ROUND_DOWN:
        roundingModeName = "down";
        roundingCode = float_round_down;
        break;
     case ROUND_UP:
        roundingModeName = "up";
        roundingCode = float_round_up;
        break;
    default:
      roundingModeName = 0;
      roundingCode = float_round_nearest_even;
      break;
    }
    float_rounding_mode = roundingCode;
    syst_float_set_rounding_mode( roundingCode );
    printf( "Testing "/*, stderr*/ );
    writeFunctionName( /*stderr*/ );
    printf( ".\n" /*, stderr*/ );
    switch ( functionCode ) {
#ifdef SYST_INT32_TO_FLOAT32
     case INT32_TO_FLOAT32:
        test_a_int32_z_float32( int32_to_float32, syst_int32_to_float32 );
        break;
#endif
#ifdef SYST_INT32_TO_FLOAT64
     case INT32_TO_FLOAT64:
        test_a_int32_z_float64( int32_to_float64, syst_int32_to_float64 );
        break;
#endif
#ifdef SYST_INT32_TO_FLOATX80
     case INT32_TO_FLOATX80:
        test_a_int32_z_floatx80( int32_to_floatx80, syst_int32_to_floatx80 );
        break;
#endif
#ifdef SYST_INT32_TO_FLOAT128
     case INT32_TO_FLOAT128:
        test_a_int32_z_float128( int32_to_float128, syst_int32_to_float128 );
        break;
#endif
#ifdef SYST_INT64_TO_FLOAT32
     case INT64_TO_FLOAT32:
        test_a_int64_z_float32( int64_to_float32, syst_int64_to_float32 );
        break;
#endif
#ifdef SYST_INT64_TO_FLOAT64
     case INT64_TO_FLOAT64:
        test_a_int64_z_float64( int64_to_float64, syst_int64_to_float64 );
        break;
#endif
#ifdef SYST_INT64_TO_FLOATX80
     case INT64_TO_FLOATX80:
        test_a_int64_z_floatx80( int64_to_floatx80, syst_int64_to_floatx80 );
        break;
#endif
#ifdef SYST_INT64_TO_FLOAT128
     case INT64_TO_FLOAT128:
        test_a_int64_z_float128( int64_to_float128, syst_int64_to_float128 );
        break;
#endif
#ifdef SYST_FLOAT32_TO_INT32
     case FLOAT32_TO_INT32:
        test_a_float32_z_int32( float32_to_int32, syst_float32_to_int32 );
        break;
#endif
#ifdef SYST_FLOAT32_TO_INT32_ROUND_TO_ZERO
     case FLOAT32_TO_INT32_ROUND_TO_ZERO:
       syst_float_set_rounding_mode(float_round_to_zero);
        test_a_float32_z_int32(
            float32_to_int32_round_to_zero,
            syst_float32_to_int32_round_to_zero
        );
        break;
#endif
#ifdef SYST_FLOAT32_TO_INT64
     case FLOAT32_TO_INT64:
        test_a_float32_z_int64( float32_to_int64, syst_float32_to_int64 );
        break;
#endif
#ifdef SYST_FLOAT32_TO_INT64_ROUND_TO_ZERO
     case FLOAT32_TO_INT64_ROUND_TO_ZERO:
        test_a_float32_z_int64(
            float32_to_int64_round_to_zero,
            syst_float32_to_int64_round_to_zero
        );
        break;
#endif
#ifdef SYST_FLOAT32_TO_FLOAT64
     case FLOAT32_TO_FLOAT64:
        test_a_float32_z_float64(
            float32_to_float64, syst_float32_to_float64 );
        break;
#endif
#ifdef SYST_FLOAT32_TO_FLOATX80
     case FLOAT32_TO_FLOATX80:
        test_a_float32_z_floatx80(
            float32_to_floatx80, syst_float32_to_floatx80 );
        break;
#endif
#ifdef SYST_FLOAT32_TO_FLOAT128
     case FLOAT32_TO_FLOAT128:
        test_a_float32_z_float128(
            float32_to_float128, syst_float32_to_float128 );
        break;
#endif
#ifdef SYST_FLOAT32_ROUND_TO_INT
     case FLOAT32_ROUND_TO_INT:
        test_az_float32( float32_round_to_int, syst_float32_round_to_int );
        break;
#endif
#ifdef SYST_FLOAT32_ADD
     case FLOAT32_ADD:
        test_abz_float32( float32_add, syst_float32_add );
        break;
#endif
#ifdef SYST_FLOAT32_SUB
     case FLOAT32_SUB:
        test_abz_float32( float32_sub, syst_float32_sub );
        break;
#endif
#ifdef SYST_FLOAT32_MUL
     case FLOAT32_MUL:
        test_abz_float32( float32_mul, syst_float32_mul );
        break;
#endif
#ifdef SYST_FLOAT32_DIV
     case FLOAT32_DIV:
        test_abz_float32( float32_div, syst_float32_div );
        break;
#endif
#ifdef SYST_FLOAT32_REM
     case FLOAT32_REM:
        test_abz_float32( float32_rem, syst_float32_rem );
        break;
#endif
#ifdef SYST_FLOAT32_SQRT
     case FLOAT32_SQRT:
        test_az_float32( float32_sqrt, syst_float32_sqrt );
        break;
#endif
#ifdef SYST_FLOAT32_EQ
     case FLOAT32_EQ:
        test_ab_float32_z_flag( float32_eq, syst_float32_eq );
        break;
#endif
#ifdef SYST_FLOAT32_LE
     case FLOAT32_LE:
        test_ab_float32_z_flag( float32_le, syst_float32_le );
        break;
#endif
#ifdef SYST_FLOAT32_LT
     case FLOAT32_LT:
        test_ab_float32_z_flag( float32_lt, syst_float32_lt );
        break;
#endif
#ifdef SYST_FLOAT32_EQ_SIGNALING
     case FLOAT32_EQ_SIGNALING:
        test_ab_float32_z_flag(
            float32_eq_signaling, syst_float32_eq_signaling );
        break;
#endif
#ifdef SYST_FLOAT32_LE_QUIET
     case FLOAT32_LE_QUIET:
        test_ab_float32_z_flag( float32_le_quiet, syst_float32_le_quiet );
        break;
#endif
#ifdef SYST_FLOAT32_LT_QUIET
     case FLOAT32_LT_QUIET:
        test_ab_float32_z_flag( float32_lt_quiet, syst_float32_lt_quiet );
        break;
#endif
#ifdef SYST_FLOAT64_TO_INT32
     case FLOAT64_TO_INT32:
        test_a_float64_z_int32( float64_to_int32, syst_float64_to_int32 );
        break;
#endif
#ifdef SYST_FLOAT64_TO_INT32_ROUND_TO_ZERO
     case FLOAT64_TO_INT32_ROUND_TO_ZERO:
        test_a_float64_z_int32(
            float64_to_int32_round_to_zero,
            syst_float64_to_int32_round_to_zero
        );
        break;
#endif
#ifdef SYST_FLOAT64_TO_INT64
     case FLOAT64_TO_INT64:
        test_a_float64_z_int64( float64_to_int64, syst_float64_to_int64 );
        break;
#endif
#ifdef SYST_FLOAT64_TO_INT64_ROUND_TO_ZERO
     case FLOAT64_TO_INT64_ROUND_TO_ZERO:
        test_a_float64_z_int64(
            float64_to_int64_round_to_zero,
            syst_float64_to_int64_round_to_zero
        );
        break;
#endif
#ifdef SYST_FLOAT64_TO_FLOAT32
     case FLOAT64_TO_FLOAT32:
        test_a_float64_z_float32(
            float64_to_float32, syst_float64_to_float32 );
        break;
#endif
#ifdef SYST_FLOAT64_TO_FLOATX80
     case FLOAT64_TO_FLOATX80:
        test_a_float64_z_floatx80(
            float64_to_floatx80, syst_float64_to_floatx80 );
        break;
#endif
#ifdef SYST_FLOAT64_TO_FLOAT128
     case FLOAT64_TO_FLOAT128:
        test_a_float64_z_float128(
            float64_to_float128, syst_float64_to_float128 );
        break;
#endif
#ifdef SYST_FLOAT64_ROUND_TO_INT
     case FLOAT64_ROUND_TO_INT:
        test_az_float64( float64_round_to_int, syst_float64_round_to_int );
        break;
#endif
#ifdef SYST_FLOAT64_ADD
     case FLOAT64_ADD:
        test_abz_float64( float64_add, syst_float64_add );
        break;
#endif
#ifdef SYST_FLOAT64_SUB
     case FLOAT64_SUB:
        test_abz_float64( float64_sub, syst_float64_sub );
        break;
#endif
#ifdef SYST_FLOAT64_MUL
     case FLOAT64_MUL:
        test_abz_float64( float64_mul, syst_float64_mul );
        break;
#endif
#ifdef SYST_FLOAT64_DIV
     case FLOAT64_DIV:
        test_abz_float64( float64_div, syst_float64_div );
        break;
#endif
#ifdef SYST_FLOAT64_REM
     case FLOAT64_REM:
        test_abz_float64( float64_rem, syst_float64_rem );
        break;
#endif
#ifdef SYST_FLOAT64_SQRT
     case FLOAT64_SQRT:
        test_az_float64( float64_sqrt, syst_float64_sqrt );
        break;
#endif
#ifdef SYST_FLOAT64_EQ
     case FLOAT64_EQ:
        test_ab_float64_z_flag( float64_eq, syst_float64_eq );
        break;
#endif
#ifdef SYST_FLOAT64_LE
     case FLOAT64_LE:
        test_ab_float64_z_flag( float64_le, syst_float64_le );
        break;
#endif
#ifdef SYST_FLOAT64_LT
     case FLOAT64_LT:
        test_ab_float64_z_flag( float64_lt, syst_float64_lt );
        break;
#endif
#ifdef SYST_FLOAT64_EQ_SIGNALING
     case FLOAT64_EQ_SIGNALING:
        test_ab_float64_z_flag(
            float64_eq_signaling, syst_float64_eq_signaling );
        break;
#endif
#ifdef SYST_FLOAT64_LE_QUIET
     case FLOAT64_LE_QUIET:
        test_ab_float64_z_flag( float64_le_quiet, syst_float64_le_quiet );
        break;
#endif
#ifdef SYST_FLOAT64_LT_QUIET
     case FLOAT64_LT_QUIET:
        test_ab_float64_z_flag( float64_lt_quiet, syst_float64_lt_quiet );
        break;
#endif
#ifdef SYST_FLOATX80_TO_INT32
     case FLOATX80_TO_INT32:
        test_a_floatx80_z_int32( floatx80_to_int32, syst_floatx80_to_int32 );
        break;
#endif
#ifdef SYST_FLOATX80_TO_INT32_ROUND_TO_ZERO
     case FLOATX80_TO_INT32_ROUND_TO_ZERO:
        test_a_floatx80_z_int32(
            floatx80_to_int32_round_to_zero,
            syst_floatx80_to_int32_round_to_zero
        );
        break;
#endif
#ifdef SYST_FLOATX80_TO_INT64
     case FLOATX80_TO_INT64:
        test_a_floatx80_z_int64( floatx80_to_int64, syst_floatx80_to_int64 );
        break;
#endif
#ifdef SYST_FLOATX80_TO_INT64_ROUND_TO_ZERO
     case FLOATX80_TO_INT64_ROUND_TO_ZERO:
        test_a_floatx80_z_int64(
            floatx80_to_int64_round_to_zero,
            syst_floatx80_to_int64_round_to_zero
        );
        break;
#endif
#ifdef SYST_FLOATX80_TO_FLOAT32
     case FLOATX80_TO_FLOAT32:
        test_a_floatx80_z_float32(
            floatx80_to_float32, syst_floatx80_to_float32 );
        break;
#endif
#ifdef SYST_FLOATX80_TO_FLOAT64
     case FLOATX80_TO_FLOAT64:
        test_a_floatx80_z_float64(
            floatx80_to_float64, syst_floatx80_to_float64 );
        break;
#endif
#ifdef SYST_FLOATX80_TO_FLOAT128
     case FLOATX80_TO_FLOAT128:
        test_a_floatx80_z_float128(
            floatx80_to_float128, syst_floatx80_to_float128 );
        break;
#endif
#ifdef SYST_FLOATX80_ROUND_TO_INT
     case FLOATX80_ROUND_TO_INT:
        test_az_floatx80( floatx80_round_to_int, syst_floatx80_round_to_int );
        break;
#endif
#ifdef SYST_FLOATX80_ADD
     case FLOATX80_ADD:
        test_abz_floatx80( floatx80_add, syst_floatx80_add );
        break;
#endif
#ifdef SYST_FLOATX80_SUB
     case FLOATX80_SUB:
        test_abz_floatx80( floatx80_sub, syst_floatx80_sub );
        break;
#endif
#ifdef SYST_FLOATX80_MUL
     case FLOATX80_MUL:
        test_abz_floatx80( floatx80_mul, syst_floatx80_mul );
        break;
#endif
#ifdef SYST_FLOATX80_DIV
     case FLOATX80_DIV:
        test_abz_floatx80( floatx80_div, syst_floatx80_div );
        break;
#endif
#ifdef SYST_FLOATX80_REM
     case FLOATX80_REM:
        test_abz_floatx80( floatx80_rem, syst_floatx80_rem );
        break;
#endif
#ifdef SYST_FLOATX80_SQRT
     case FLOATX80_SQRT:
        test_az_floatx80( floatx80_sqrt, syst_floatx80_sqrt );
        break;
#endif
#ifdef SYST_FLOATX80_EQ
     case FLOATX80_EQ:
        test_ab_floatx80_z_flag( floatx80_eq, syst_floatx80_eq );
        break;
#endif
#ifdef SYST_FLOATX80_LE
     case FLOATX80_LE:
        test_ab_floatx80_z_flag( floatx80_le, syst_floatx80_le );
        break;
#endif
#ifdef SYST_FLOATX80_LT
     case FLOATX80_LT:
        test_ab_floatx80_z_flag( floatx80_lt, syst_floatx80_lt );
        break;
#endif
#ifdef SYST_FLOATX80_EQ_SIGNALING
     case FLOATX80_EQ_SIGNALING:
        test_ab_floatx80_z_flag(
            floatx80_eq_signaling, syst_floatx80_eq_signaling );
        break;
#endif
#ifdef SYST_FLOATX80_LE_QUIET
     case FLOATX80_LE_QUIET:
        test_ab_floatx80_z_flag( floatx80_le_quiet, syst_floatx80_le_quiet );
        break;
#endif
#ifdef SYST_FLOATX80_LT_QUIET
     case FLOATX80_LT_QUIET:
        test_ab_floatx80_z_flag( floatx80_lt_quiet, syst_floatx80_lt_quiet );
        break;
#endif
#ifdef SYST_FLOAT128_TO_INT32
     case FLOAT128_TO_INT32:
        test_a_float128_z_int32( float128_to_int32, syst_float128_to_int32 );
        break;
#endif
#ifdef SYST_FLOAT128_TO_INT32_ROUND_TO_ZERO
     case FLOAT128_TO_INT32_ROUND_TO_ZERO:
        test_a_float128_z_int32(
            float128_to_int32_round_to_zero,
            syst_float128_to_int32_round_to_zero
        );
        break;
#endif
#ifdef SYST_FLOAT128_TO_INT64
     case FLOAT128_TO_INT64:
        test_a_float128_z_int64( float128_to_int64, syst_float128_to_int64 );
        break;
#endif
#ifdef SYST_FLOAT128_TO_INT64_ROUND_TO_ZERO
     case FLOAT128_TO_INT64_ROUND_TO_ZERO:
        test_a_float128_z_int64(
            float128_to_int64_round_to_zero,
            syst_float128_to_int64_round_to_zero
        );
        break;
#endif
#ifdef SYST_FLOAT128_TO_FLOAT32
     case FLOAT128_TO_FLOAT32:
        test_a_float128_z_float32(
            float128_to_float32, syst_float128_to_float32 );
        break;
#endif
#ifdef SYST_FLOAT128_TO_FLOAT64
     case FLOAT128_TO_FLOAT64:
        test_a_float128_z_float64(
            float128_to_float64, syst_float128_to_float64 );
        break;
#endif
#ifdef SYST_FLOAT128_TO_FLOATX80
     case FLOAT128_TO_FLOATX80:
        test_a_float128_z_floatx80(
            float128_to_floatx80, syst_float128_to_floatx80 );
        break;
#endif
#ifdef SYST_FLOAT128_ROUND_TO_INT
     case FLOAT128_ROUND_TO_INT:
        test_az_float128( float128_round_to_int, syst_float128_round_to_int );
        break;
#endif
#ifdef SYST_FLOAT128_ADD
     case FLOAT128_ADD:
        test_abz_float128( float128_add, syst_float128_add );
        break;
#endif
#ifdef SYST_FLOAT128_SUB
     case FLOAT128_SUB:
        test_abz_float128( float128_sub, syst_float128_sub );
        break;
#endif
#ifdef SYST_FLOAT128_MUL
     case FLOAT128_MUL:
        test_abz_float128( float128_mul, syst_float128_mul );
        break;
#endif
#ifdef SYST_FLOAT128_DIV
     case FLOAT128_DIV:
        test_abz_float128( float128_div, syst_float128_div );
        break;
#endif
#ifdef SYST_FLOAT128_REM
     case FLOAT128_REM:
        test_abz_float128( float128_rem, syst_float128_rem );
        break;
#endif
#ifdef SYST_FLOAT128_SQRT
     case FLOAT128_SQRT:
        test_az_float128( float128_sqrt, syst_float128_sqrt );
        break;
#endif
#ifdef SYST_FLOAT128_EQ
     case FLOAT128_EQ:
        test_ab_float128_z_flag( float128_eq, syst_float128_eq );
        break;
#endif
#ifdef SYST_FLOAT128_LE
     case FLOAT128_LE:
        test_ab_float128_z_flag( float128_le, syst_float128_le );
        break;
#endif
#ifdef SYST_FLOAT128_LT
     case FLOAT128_LT:
        test_ab_float128_z_flag( float128_lt, syst_float128_lt );
        break;
#endif
#ifdef SYST_FLOAT128_EQ_SIGNALING
     case FLOAT128_EQ_SIGNALING:
        test_ab_float128_z_flag(
            float128_eq_signaling, syst_float128_eq_signaling );
        break;
#endif
#ifdef SYST_FLOAT128_LE_QUIET
     case FLOAT128_LE_QUIET:
        test_ab_float128_z_flag( float128_le_quiet, syst_float128_le_quiet );
        break;
#endif
#ifdef SYST_FLOAT128_LT_QUIET
     case FLOAT128_LT_QUIET:
        test_ab_float128_z_flag( float128_lt_quiet, syst_float128_lt_quiet );
        break;
#endif
    }
    if ( ( errorStop && anyErrors ) || stop ) exitWithStatus();

}
示例#2
0
static void
 testFunctionVariety(
     uint8 functionCode,
     int8 roundingPrecision,
     int8 roundingMode,
     int8 tininessMode
 )
{
    uint8 roundingCode;
    int8 tininessCode;

    functionName = functions[ functionCode ].name;
    if ( roundingPrecision == 32 ) {
        roundingPrecisionName = "32";
    }
    else if ( roundingPrecision == 64 ) {
        roundingPrecisionName = "64";
    }
    else if ( roundingPrecision == 80 ) {
        roundingPrecisionName = "80";
    }
    else {
        roundingPrecisionName = 0;
    }
#ifdef FLOATX80
    floatx80_rounding_precision = roundingPrecision;
    slow_floatx80_rounding_precision = roundingPrecision;
#endif
    switch ( roundingMode ) {
     case 0:
        roundingModeName = 0;
        roundingCode = float_round_nearest_even;
        break;
     case ROUND_NEAREST_EVEN:
        roundingModeName = "nearest_even";
        roundingCode = float_round_nearest_even;
        break;
     case ROUND_TO_ZERO:
        roundingModeName = "to_zero";
        roundingCode = float_round_to_zero;
        break;
     case ROUND_DOWN:
        roundingModeName = "down";
        roundingCode = float_round_down;
        break;
     case ROUND_UP:
        roundingModeName = "up";
        roundingCode = float_round_up;
        break;
    }
    float_rounding_mode = roundingCode;
    slow_float_rounding_mode = roundingCode;
    switch ( tininessMode ) {
     case 0:
        tininessModeName = 0;
        tininessCode = float_tininess_after_rounding;
        break;
     case TININESS_BEFORE_ROUNDING:
        tininessModeName = "before";
        tininessCode = float_tininess_before_rounding;
        break;
     case TININESS_AFTER_ROUNDING:
        tininessModeName = "after";
        tininessCode = float_tininess_after_rounding;
        break;
    }
    float_detect_tininess = tininessCode;
    slow_float_detect_tininess = tininessCode;
    fputs( "Testing ", stderr );
    writeFunctionName( stderr );
    fputs( ".\n", stderr );
    switch ( functionCode ) {
     case INT32_TO_FLOAT32:
        test_a_int32_z_float32( slow_int32_to_float32, int32_to_float32 );
        break;
     case INT32_TO_FLOAT64:
        test_a_int32_z_float64( slow_int32_to_float64, int32_to_float64 );
        break;
#ifdef FLOATX80
     case INT32_TO_FLOATX80:
        test_a_int32_z_floatx80( slow_int32_to_floatx80, int32_to_floatx80 );
        break;
#endif
#ifdef FLOAT128
     case INT32_TO_FLOAT128:
        test_a_int32_z_float128( slow_int32_to_float128, int32_to_float128 );
        break;
#endif
#ifdef BITS64
     case INT64_TO_FLOAT32:
        test_a_int64_z_float32( slow_int64_to_float32, int64_to_float32 );
        break;
     case INT64_TO_FLOAT64:
        test_a_int64_z_float64( slow_int64_to_float64, int64_to_float64 );
        break;
#ifdef FLOATX80
     case INT64_TO_FLOATX80:
        test_a_int64_z_floatx80( slow_int64_to_floatx80, int64_to_floatx80 );
        break;
#endif
#ifdef FLOAT128
     case INT64_TO_FLOAT128:
        test_a_int64_z_float128( slow_int64_to_float128, int64_to_float128 );
        break;
#endif
#endif
     case FLOAT32_TO_INT32:
        test_a_float32_z_int32( slow_float32_to_int32, float32_to_int32 );
        break;
     case FLOAT32_TO_INT32_ROUND_TO_ZERO:
        test_a_float32_z_int32(
            slow_float32_to_int32_round_to_zero,
            float32_to_int32_round_to_zero
        );
        break;
#ifdef BITS64
     case FLOAT32_TO_INT64:
        test_a_float32_z_int64( slow_float32_to_int64, float32_to_int64 );
        break;
     case FLOAT32_TO_INT64_ROUND_TO_ZERO:
        test_a_float32_z_int64(
            slow_float32_to_int64_round_to_zero,
            float32_to_int64_round_to_zero
        );
        break;
#endif
     case FLOAT32_TO_FLOAT64:
        test_a_float32_z_float64(
            slow_float32_to_float64, float32_to_float64 );
        break;
#ifdef FLOATX80
     case FLOAT32_TO_FLOATX80:
        test_a_float32_z_floatx80(
            slow_float32_to_floatx80, float32_to_floatx80 );
        break;
#endif
#ifdef FLOAT128
     case FLOAT32_TO_FLOAT128:
        test_a_float32_z_float128(
            slow_float32_to_float128, float32_to_float128 );
        break;
#endif
     case FLOAT32_ROUND_TO_INT:
        test_az_float32( slow_float32_round_to_int, float32_round_to_int );
        break;
     case FLOAT32_ADD:
        test_abz_float32( slow_float32_add, float32_add );
        break;
     case FLOAT32_SUB:
        test_abz_float32( slow_float32_sub, float32_sub );
        break;
     case FLOAT32_MUL:
        test_abz_float32( slow_float32_mul, float32_mul );
        break;
     case FLOAT32_DIV:
        test_abz_float32( slow_float32_div, float32_div );
        break;
     case FLOAT32_REM:
        test_abz_float32( slow_float32_rem, float32_rem );
        break;
     case FLOAT32_SQRT:
        test_az_float32( slow_float32_sqrt, float32_sqrt );
        break;
     case FLOAT32_EQ:
        test_ab_float32_z_flag( slow_float32_eq, float32_eq );
        break;
     case FLOAT32_LE:
        test_ab_float32_z_flag( slow_float32_le, float32_le );
        break;
     case FLOAT32_LT:
        test_ab_float32_z_flag( slow_float32_lt, float32_lt );
        break;
     case FLOAT32_EQ_SIGNALING:
        test_ab_float32_z_flag(
            slow_float32_eq_signaling, float32_eq_signaling );
        break;
     case FLOAT32_LE_QUIET:
        test_ab_float32_z_flag( slow_float32_le_quiet, float32_le_quiet );
        break;
     case FLOAT32_LT_QUIET:
        test_ab_float32_z_flag( slow_float32_lt_quiet, float32_lt_quiet );
        break;
     case FLOAT64_TO_INT32:
        test_a_float64_z_int32( slow_float64_to_int32, float64_to_int32 );
        break;
     case FLOAT64_TO_INT32_ROUND_TO_ZERO:
        test_a_float64_z_int32(
            slow_float64_to_int32_round_to_zero,
            float64_to_int32_round_to_zero
        );
        break;
#ifdef BITS64
     case FLOAT64_TO_INT64:
        test_a_float64_z_int64( slow_float64_to_int64, float64_to_int64 );
        break;
     case FLOAT64_TO_INT64_ROUND_TO_ZERO:
        test_a_float64_z_int64(
            slow_float64_to_int64_round_to_zero,
            float64_to_int64_round_to_zero
        );
        break;
#endif
     case FLOAT64_TO_FLOAT32:
        test_a_float64_z_float32(
            slow_float64_to_float32, float64_to_float32 );
        break;
#ifdef FLOATX80
     case FLOAT64_TO_FLOATX80:
        test_a_float64_z_floatx80(
            slow_float64_to_floatx80, float64_to_floatx80 );
        break;
#endif
#ifdef FLOAT128
     case FLOAT64_TO_FLOAT128:
        test_a_float64_z_float128(
            slow_float64_to_float128, float64_to_float128 );
        break;
#endif
     case FLOAT64_ROUND_TO_INT:
        test_az_float64( slow_float64_round_to_int, float64_round_to_int );
        break;
     case FLOAT64_ADD:
        test_abz_float64( slow_float64_add, float64_add );
        break;
     case FLOAT64_SUB:
        test_abz_float64( slow_float64_sub, float64_sub );
        break;
     case FLOAT64_MUL:
        test_abz_float64( slow_float64_mul, float64_mul );
        break;
     case FLOAT64_DIV:
        test_abz_float64( slow_float64_div, float64_div );
        break;
     case FLOAT64_REM:
        test_abz_float64( slow_float64_rem, float64_rem );
        break;
     case FLOAT64_SQRT:
        test_az_float64( slow_float64_sqrt, float64_sqrt );
        break;
     case FLOAT64_EQ:
        test_ab_float64_z_flag( slow_float64_eq, float64_eq );
        break;
     case FLOAT64_LE:
        test_ab_float64_z_flag( slow_float64_le, float64_le );
        break;
     case FLOAT64_LT:
        test_ab_float64_z_flag( slow_float64_lt, float64_lt );
        break;
     case FLOAT64_EQ_SIGNALING:
        test_ab_float64_z_flag(
            slow_float64_eq_signaling, float64_eq_signaling );
        break;
     case FLOAT64_LE_QUIET:
        test_ab_float64_z_flag( slow_float64_le_quiet, float64_le_quiet );
        break;
     case FLOAT64_LT_QUIET:
        test_ab_float64_z_flag( slow_float64_lt_quiet, float64_lt_quiet );
        break;
#ifdef FLOATX80
     case FLOATX80_TO_INT32:
        test_a_floatx80_z_int32( slow_floatx80_to_int32, floatx80_to_int32 );
        break;
     case FLOATX80_TO_INT32_ROUND_TO_ZERO:
        test_a_floatx80_z_int32(
            slow_floatx80_to_int32_round_to_zero,
            floatx80_to_int32_round_to_zero
        );
        break;
#ifdef BITS64
     case FLOATX80_TO_INT64:
        test_a_floatx80_z_int64( slow_floatx80_to_int64, floatx80_to_int64 );
        break;
     case FLOATX80_TO_INT64_ROUND_TO_ZERO:
        test_a_floatx80_z_int64(
            slow_floatx80_to_int64_round_to_zero,
            floatx80_to_int64_round_to_zero
        );
        break;
#endif
     case FLOATX80_TO_FLOAT32:
        test_a_floatx80_z_float32(
            slow_floatx80_to_float32, floatx80_to_float32 );
        break;
     case FLOATX80_TO_FLOAT64:
        test_a_floatx80_z_float64(
            slow_floatx80_to_float64, floatx80_to_float64 );
        break;
#ifdef FLOAT128
     case FLOATX80_TO_FLOAT128:
        test_a_floatx80_z_float128(
            slow_floatx80_to_float128, floatx80_to_float128 );
        break;
#endif
     case FLOATX80_ROUND_TO_INT:
        test_az_floatx80( slow_floatx80_round_to_int, floatx80_round_to_int );
        break;
     case FLOATX80_ADD:
        test_abz_floatx80( slow_floatx80_add, floatx80_add );
        break;
     case FLOATX80_SUB:
        test_abz_floatx80( slow_floatx80_sub, floatx80_sub );
        break;
     case FLOATX80_MUL:
        test_abz_floatx80( slow_floatx80_mul, floatx80_mul );
        break;
     case FLOATX80_DIV:
        test_abz_floatx80( slow_floatx80_div, floatx80_div );
        break;
     case FLOATX80_REM:
        test_abz_floatx80( slow_floatx80_rem, floatx80_rem );
        break;
     case FLOATX80_SQRT:
        test_az_floatx80( slow_floatx80_sqrt, floatx80_sqrt );
        break;
     case FLOATX80_EQ:
        test_ab_floatx80_z_flag( slow_floatx80_eq, floatx80_eq );
        break;
     case FLOATX80_LE:
        test_ab_floatx80_z_flag( slow_floatx80_le, floatx80_le );
        break;
     case FLOATX80_LT:
        test_ab_floatx80_z_flag( slow_floatx80_lt, floatx80_lt );
        break;
     case FLOATX80_EQ_SIGNALING:
        test_ab_floatx80_z_flag(
            slow_floatx80_eq_signaling, floatx80_eq_signaling );
        break;
     case FLOATX80_LE_QUIET:
        test_ab_floatx80_z_flag( slow_floatx80_le_quiet, floatx80_le_quiet );
        break;
     case FLOATX80_LT_QUIET:
        test_ab_floatx80_z_flag( slow_floatx80_lt_quiet, floatx80_lt_quiet );
        break;
#endif
#ifdef FLOAT128
     case FLOAT128_TO_INT32:
        test_a_float128_z_int32( slow_float128_to_int32, float128_to_int32 );
        break;
     case FLOAT128_TO_INT32_ROUND_TO_ZERO:
        test_a_float128_z_int32(
            slow_float128_to_int32_round_to_zero,
            float128_to_int32_round_to_zero
        );
        break;
#ifdef BITS64
     case FLOAT128_TO_INT64:
        test_a_float128_z_int64( slow_float128_to_int64, float128_to_int64 );
        break;
     case FLOAT128_TO_INT64_ROUND_TO_ZERO:
        test_a_float128_z_int64(
            slow_float128_to_int64_round_to_zero,
            float128_to_int64_round_to_zero
        );
        break;
#endif
     case FLOAT128_TO_FLOAT32:
        test_a_float128_z_float32(
            slow_float128_to_float32, float128_to_float32 );
        break;
     case FLOAT128_TO_FLOAT64:
        test_a_float128_z_float64(
            slow_float128_to_float64, float128_to_float64 );
        break;
#ifdef FLOATX80
     case FLOAT128_TO_FLOATX80:
        test_a_float128_z_floatx80(
            slow_float128_to_floatx80, float128_to_floatx80 );
        break;
#endif
     case FLOAT128_ROUND_TO_INT:
        test_az_float128( slow_float128_round_to_int, float128_round_to_int );
        break;
     case FLOAT128_ADD:
        test_abz_float128( slow_float128_add, float128_add );
        break;
     case FLOAT128_SUB:
        test_abz_float128( slow_float128_sub, float128_sub );
        break;
     case FLOAT128_MUL:
        test_abz_float128( slow_float128_mul, float128_mul );
        break;
     case FLOAT128_DIV:
        test_abz_float128( slow_float128_div, float128_div );
        break;
     case FLOAT128_REM:
        test_abz_float128( slow_float128_rem, float128_rem );
        break;
     case FLOAT128_SQRT:
        test_az_float128( slow_float128_sqrt, float128_sqrt );
        break;
     case FLOAT128_EQ:
        test_ab_float128_z_flag( slow_float128_eq, float128_eq );
        break;
     case FLOAT128_LE:
        test_ab_float128_z_flag( slow_float128_le, float128_le );
        break;
     case FLOAT128_LT:
        test_ab_float128_z_flag( slow_float128_lt, float128_lt );
        break;
     case FLOAT128_EQ_SIGNALING:
        test_ab_float128_z_flag(
            slow_float128_eq_signaling, float128_eq_signaling );
        break;
     case FLOAT128_LE_QUIET:
        test_ab_float128_z_flag( slow_float128_le_quiet, float128_le_quiet );
        break;
     case FLOAT128_LT_QUIET:
        test_ab_float128_z_flag( slow_float128_lt_quiet, float128_lt_quiet );
        break;
#endif
    }
    if ( ( errorStop && anyErrors ) || stop ) exitWithStatus();

}