arm/insts/fplib.cc

709     int biased_exp; // non-negative exponent value for result
710     uint16_t int_mant; // mantissa for result, less than (2 << FP16_MANT_BITS)
793     int biased_exp; // non-negative exponent value for result
794     uint32_t int_mant; // mantissa for result, less than (2 << FP32_MANT_BITS)
870     int biased_exp; // non-negative exponent value for result
871     uint64_t int_mant; // mantissa for result, less than (2 << FP64_MANT_BITS)
1258         // Sign of exact zero result depends on rounding mode
1318         // Sign of exact zero result depends on rounding mode
1378         // Sign of exact zero result depends on rounding mode
1573         // Sign of exact zero result depends on rounding mode
1658         // Sign of exact zero result depends on rounding mode
1750         // Sign of exact zero result depends on rounding mode
2382     uint16_t result = fp16_add(op1, op2, 0, modeConv(fpscr), &flags);
2384     return result;
2392     uint32_t result = fp32_add(op1, op2, 0, modeConv(fpscr), &flags);
2394     return result;
2402     uint64_t result = fp64_add(op1, op2, 0, modeConv(fpscr), &flags);
2404     return result;
2413     int sgn1, exp1, sgn2, exp2, result;
2420         result = 3;
2426             result = 6;
2428             result = sgn1 ? 8 : 2;
2430             result = sgn1 ^ (exp1 < exp2) ? 8 : 2;
2432             result = sgn1 ^ (mnt1 < mnt2) ? 8 : 2;
2438     return result;
2447     int sgn1, exp1, sgn2, exp2, result;
2454         result = 3;
2460             result = 6;
2462             result = sgn1 ? 8 : 2;
2464             result = sgn1 ^ (exp1 < exp2) ? 8 : 2;
2466             result = sgn1 ^ (mnt1 < mnt2) ? 8 : 2;
2472     return result;
2481     int sgn1, exp1, sgn2, exp2, result;
2488         result = 3;
2494             result = 6;
2496             result = sgn1 ? 8 : 2;
2498             result = sgn1 ^ (exp1 < exp2) ? 8 : 2;
2500             result = sgn1 ^ (mnt1 < mnt2) ? 8 : 2;
2506     return result;
2619     uint16_t result;
2628             result = fp16_zero(sgn);
2630             result = fp16_defaultNaN();
2632             result = fp16_FPConvertNaN_32(op);
2639             result = ((uint16_t)sgn << (FP16_BITS - 1) |
2643             result = fp16_infinity(sgn);
2646         result = fp16_zero(sgn);
2648         result =
2657     return result;
2668     uint16_t result;
2677             result = fp16_zero(sgn);
2679             result = fp16_defaultNaN();
2681             result = fp16_FPConvertNaN_64(op);
2688             result = ((uint16_t)sgn << (FP16_BITS - 1) |
2692             result = fp16_infinity(sgn);
2695         result = fp16_zero(sgn);
2697         result =
2706     return result;
2717     uint32_t result;
2724             result = fp32_defaultNaN();
2726             result = fp32_FPConvertNaN_16(op);
2732         result = fp32_infinity(sgn);
2734         result = fp32_zero(sgn);
2737         result = fp32_pack(sgn, (exp - FP16_EXP_BIAS +
2744     return result;
2755     uint32_t result;
2762             result = fp32_defaultNaN();
2764             result = fp32_FPConvertNaN_64(op);
2770         result = fp32_infinity(sgn);
2772         result = fp32_zero(sgn);
2774         result =
2783     return result;
2794     uint64_t result;
2801             result = fp64_defaultNaN();
2803             result = fp64_FPConvertNaN_16(op);
2809         result = fp64_infinity(sgn);
2811         result = fp64_zero(sgn);
2814         result = fp64_pack(sgn, (exp - FP16_EXP_BIAS +
2821     return result;
2832     uint64_t result;
2839             result = fp64_defaultNaN();
2841             result = fp64_FPConvertNaN_32(op);
2847         result = fp64_infinity(sgn);
2849         result = fp64_zero(sgn);
2852         result = fp64_pack(sgn, (exp - FP32_EXP_BIAS +
2859     return result;
2867     uint16_t result = fp16_muladd(addend, op1, op2, 0, modeConv(fpscr), &flags);
2869     return result;
2877     uint32_t result = fp32_muladd(addend, op1, op2, 0, modeConv(fpscr), &flags);
2879     return result;
2887     uint64_t result = fp64_muladd(addend, op1, op2, 0, modeConv(fpscr), &flags);
2889     return result;
2897     uint16_t result = fp16_div(op1, op2, modeConv(fpscr), &flags);
2899     return result;
2907     uint32_t result = fp32_div(op1, op2, modeConv(fpscr), &flags);
2909     return result;
2917     uint64_t result = fp64_div(op1, op2, modeConv(fpscr), &flags);
2919     return result;
3173     uint16_t mnt1, mnt2, x, result;
3179         result = x;
3181         result = ((sgn1 != sgn2 ? sgn2 : sgn1 ^ (op1 > op2)) ?
3186     return result;
3196     uint32_t mnt1, mnt2, x, result;
3202         result = x;
3204         result = ((sgn1 != sgn2 ? sgn2 : sgn1 ^ (op1 > op2)) ?
3209     return result;
3219     uint64_t mnt1, mnt2, x, result;
3225         result = x;
3227         result = ((sgn1 != sgn2 ? sgn2 : sgn1 ^ (op1 > op2)) ?
3232     return result;
3266     uint16_t mnt1, mnt2, x, result;
3272         result = x;
3274         result = ((sgn1 != sgn2 ? sgn1 : sgn1 ^ (op1 < op2)) ?
3279     return result;
3289     uint32_t mnt1, mnt2, x, result;
3295         result = x;
3297         result = ((sgn1 != sgn2 ? sgn1 : sgn1 ^ (op1 < op2)) ?
3302     return result;
3312     uint64_t mnt1, mnt2, x, result;
3318         result = x;
3320         result = ((sgn1 != sgn2 ? sgn1 : sgn1 ^ (op1 < op2)) ?
3325     return result;
3357     uint16_t result = fp16_mul(op1, op2, modeConv(fpscr), &flags);
3359     return result;
3367     uint32_t result = fp32_mul(op1, op2, modeConv(fpscr), &flags);
3369     return result;
3377     uint64_t result = fp64_mul(op1, op2, modeConv(fpscr), &flags);
3379     return result;
3389     uint16_t mnt1, mnt2, result;
3394     result = fp16_process_NaNs(op1, op2, mode, &flags);
3395     if (!result) {
3398             result = fp16_FPTwo(sgn1 ^ sgn2);
3400             result = fp16_infinity(sgn1 ^ sgn2);
3402             result = fp16_zero(sgn1 ^ sgn2);
3404             result = fp16_mul(op1, op2, mode, &flags);
3410     return result;
3420     uint32_t mnt1, mnt2, result;
3425     result = fp32_process_NaNs(op1, op2, mode, &flags);
3426     if (!result) {
3429             result = fp32_FPTwo(sgn1 ^ sgn2);
3431             result = fp32_infinity(sgn1 ^ sgn2);
3433             result = fp32_zero(sgn1 ^ sgn2);
3435             result = fp32_mul(op1, op2, mode, &flags);
3441     return result;
3451     uint64_t mnt1, mnt2, result;
3456     result = fp64_process_NaNs(op1, op2, mode, &flags);
3457     if (!result) {
3460             result = fp64_FPTwo(sgn1 ^ sgn2);
3462             result = fp64_infinity(sgn1 ^ sgn2);
3464             result = fp64_zero(sgn1 ^ sgn2);
3466             result = fp64_mul(op1, op2, mode, &flags);
3472     return result;
3522     uint16_t mnt, result;
3527         result = fp16_process_NaN(op, mode, &flags);
3529         result = fp16_infinity(sgn);
3532         result = fp16_defaultNaN();
3535         result = fp16_zero(0);
3541         result = fp16_pack(0, (3 * FP16_EXP_BIAS - exp - 1) >> 1,
3547     return result;
3557     uint32_t mnt, result;
3562         result = fp32_process_NaN(op, mode, &flags);
3564         result = fp32_infinity(sgn);
3567         result = fp32_defaultNaN();
3570         result = fp32_zero(0);
3576         result = fp32_pack(0, (3 * FP32_EXP_BIAS - exp - 1) >> 1,
3582     return result;
3592     uint64_t mnt, result;
3597         result = fp64_process_NaN(op, mode, &flags);
3599         result = fp64_infinity(sgn);
3602         result = fp64_defaultNaN();
3605         result = fp32_zero(0);
3611         result = fp64_pack(0, (3 * FP64_EXP_BIAS - exp - 1) >> 1,
3617     return result;
3627     uint16_t mnt1, mnt2, result;
3633     result = fp16_process_NaNs(op1, op2, mode, &flags);
3634     if (!result) {
3637             result = fp16_FPOnePointFive(0);
3639             result = fp16_infinity(sgn1 ^ sgn2);
3641             result = fp16_muladd(fp16_FPThree(0), op1, op2, -1, mode, &flags);
3647     return result;
3657     uint32_t mnt1, mnt2, result;
3663     result = fp32_process_NaNs(op1, op2, mode, &flags);
3664     if (!result) {
3667             result = fp32_FPOnePointFive(0);
3669             result = fp32_infinity(sgn1 ^ sgn2);
3671             result = fp32_muladd(fp32_FPThree(0), op1, op2, -1, mode, &flags);
3677     return result;
3687     uint64_t mnt1, mnt2, result;
3693     result = fp64_process_NaNs(op1, op2, mode, &flags);
3694     if (!result) {
3697             result = fp64_FPOnePointFive(0);
3699             result = fp64_infinity(sgn1 ^ sgn2);
3701             result = fp64_muladd(fp64_FPThree(0), op1, op2, -1, mode, &flags);
3707     return result;
3717     uint16_t mnt, result;
3722         result = fp16_process_NaN(op, mode, &flags);
3724         result = fp16_zero(sgn);
3726         result = fp16_infinity(sgn);
3746         result = overflow_to_inf ? fp16_infinity(sgn) : fp16_max_normal(sgn);
3749         result = fp16_zero(sgn);
3764         result = fp16_pack(sgn, result_exp, fraction);
3769     return result;
3779     uint32_t mnt, result;
3784         result = fp32_process_NaN(op, mode, &flags);
3786         result = fp32_zero(sgn);
3788         result = fp32_infinity(sgn);
3808         result = overflow_to_inf ? fp32_infinity(sgn) : fp32_max_normal(sgn);
3811         result = fp32_zero(sgn);
3826         result = fp32_pack(sgn, result_exp, fraction);
3831     return result;
3841     uint64_t mnt, result;
3846         result = fp64_process_NaN(op, mode, &flags);
3848         result = fp64_zero(sgn);
3850         result = fp64_infinity(sgn);
3870         result = overflow_to_inf ? fp64_infinity(sgn) : fp64_max_normal(sgn);
3873         result = fp64_zero(sgn);
3888         result = fp64_pack(sgn, result_exp, fraction);
3893     return result;
3903     uint16_t mnt1, mnt2, result;
3909     result = fp16_process_NaNs(op1, op2, mode, &flags);
3910     if (!result) {
3913             result = fp16_FPTwo(0);
3915             result = fp16_infinity(sgn1 ^ sgn2);
3917             result = fp16_muladd(fp16_FPTwo(0), op1, op2, 0, mode, &flags);
3923     return result;
3933     uint32_t mnt1, mnt2, result;
3939     result = fp32_process_NaNs(op1, op2, mode, &flags);
3940     if (!result) {
3943             result = fp32_FPTwo(0);
3945             result = fp32_infinity(sgn1 ^ sgn2);
3947             result = fp32_muladd(fp32_FPTwo(0), op1, op2, 0, mode, &flags);
3953     return result;
3963     uint64_t mnt1, mnt2, result;
3969     result = fp64_process_NaNs(op1, op2, mode, &flags);
3970     if (!result) {
3973             result = fp64_FPTwo(0);
3975             result = fp64_infinity(sgn1 ^ sgn2);
3977             result = fp64_muladd(fp64_FPTwo(0), op1, op2, 0, mode, &flags);
3983     return result;
3993     uint16_t mnt, result;
3998         result = fp16_process_NaN(op, mode, &flags);
4002             result = fp16_pack(sgn, FP16_EXP_INF - 1, 0);
4004             result = fp16_pack(sgn, exp ^ FP16_EXP_INF, 0);
4010     return result;
4020     uint32_t mnt, result;
4025         result = fp32_process_NaN(op, mode, &flags);
4029             result = fp32_pack(sgn, FP32_EXP_INF - 1, 0);
4031             result = fp32_pack(sgn, exp ^ FP32_EXP_INF, 0);
4037     return result;
4047     uint64_t mnt, result;
4052         result = fp64_process_NaN(op, mode, &flags);
4056             result = fp64_pack(sgn, FP64_EXP_INF - 1, 0);
4058             result = fp64_pack(sgn, exp ^ FP64_EXP_INF, 0);
4064     return result;
4075     uint16_t mnt, result;
4082         result = fp16_process_NaN(op, mode, &flags);
4084         result = fp16_infinity(sgn);
4086         result = fp16_zero(sgn);
4089         result = op;
4116             result = fp16_zero(sgn);
4120             result = fp16_pack(sgn, exp + FP16_EXP_BITS, mnt >> FP16_EXP_BITS);
4129     return result;
4140     uint32_t mnt, result;
4147         result = fp32_process_NaN(op, mode, &flags);
4149         result = fp32_infinity(sgn);
4151         result = fp32_zero(sgn);
4154         result = op;
4181             result = fp32_zero(sgn);
4185             result = fp32_pack(sgn, exp + FP32_EXP_BITS, mnt >> FP32_EXP_BITS);
4194     return result;
4205     uint64_t mnt, result;
4212         result = fp64_process_NaN(op, mode, &flags);
4214         result = fp64_infinity(sgn);
4216         result = fp64_zero(sgn);
4219         result = op;
4246             result = fp64_zero(sgn);
4250             result = fp64_pack(sgn, exp + FP64_EXP_BITS, mnt >> FP64_EXP_BITS);
4259     return result;
4267     uint16_t result = fp16_scale(op1, (int16_t)op2, modeConv(fpscr), &flags);
4269     return result;
4277     uint32_t result = fp32_scale(op1, (int32_t)op2, modeConv(fpscr), &flags);
4279     return result;
4287     uint64_t result = fp64_scale(op1, (int64_t)op2, modeConv(fpscr), &flags);
4289     return result;
4297     uint16_t result = fp16_sqrt(op, modeConv(fpscr), &flags);
4299     return result;
4307     uint32_t result = fp32_sqrt(op, modeConv(fpscr), &flags);
4309     return result;
4317     uint64_t result = fp64_sqrt(op, modeConv(fpscr), &flags);
4319     return result;
4327     uint16_t result = fp16_add(op1, op2, 1, modeConv(fpscr), &flags);
4329     return result;
4337     uint32_t result = fp32_add(op1, op2, 1, modeConv(fpscr), &flags);
4339     return result;
4347     uint64_t result = fp64_add(op1, op2, 1, modeConv(fpscr), &flags);
4349     return result;
4379     uint16_t result =
4383     return result;
4413     uint32_t result =
4417     return result;
4447     uint64_t result =
4451     return result;
4463     uint16_t result = fp16_mul(op1, op1, mode, &flags);
4466     fp16_unpack(&sgn, &exp, &mnt, result, mode, &flags);
4468         result = (result & ~(1ULL << (FP16_BITS - 1))) |
4471     return result;
4483     uint32_t result = fp32_mul(op1, op1, mode, &flags);
4486     fp32_unpack(&sgn, &exp, &mnt, result, mode, &flags);
4488         result = (result & ~(1ULL << (FP32_BITS - 1))) | op2 << (FP32_BITS - 1);
4490     return result;
4502     uint64_t result = fp64_mul(op1, op1, mode, &flags);
4505     fp64_unpack(&sgn, &exp, &mnt, result, mode, &flags);
4507         result = (result & ~(1ULL << (FP64_BITS - 1))) | op2 << (FP64_BITS - 1);
4509     return result;
4629     uint16_t mnt, result;
4637         result = 0;
4641         result =
4649     return result;
4660     uint32_t result;
4668         result = 0;
4673         result =
4681     return result;
4690     uint32_t mnt, result;
4698         result = 0;
4702         result =
4710     return result;
4720     uint32_t result;
4728         result = 0;
4732         result = FPToFixed_32(sgn, exp + fbits, mnt, u, rounding, &flags);
4737     return result;
4748     uint64_t result;
4756         result = 0;
4761         result =
4769     return result;
4779     uint64_t result;
4787         result = 0;
4791         result =
4799     return result;
4808     uint64_t mnt, result;
4816         result = 0;
4820         result = FPToFixed_64(sgn, exp + fbits, mnt, u, rounding, &flags);
4825     return result;