e_pow.s

glibc 2.9,最新版的C语言库函数

{ .mfi
          nop.m 999
          fma.s1 POW_q                  = POW_Z3sq, POW_q, POW_Z3
          nop.i 999
}
;;

// p8 TRUE ==> |Y(G + r)| >= 10

// double
//     -2^10  -2^9             2^9   2^10
// -----+-----+----+ ... +-----+-----+-----
//  p8  |             p9             |  p8
//      |     |       p10      |     |

// Form signexp of constants to indicate overflow
{ .mfi
          mov         pow_GR_big_pos    = 0x103ff
          fma.s1 POW_ssq                = POW_s, POW_s, f0
          cmp.le p8,p9                  = 10, pow_GR_true_exp_Y_Gpr
}
{ .mfi
          mov         pow_GR_big_neg    = 0x303ff
          fma.s1 POW_v4                 = POW_s, POW_Q3, POW_Q2
          andcm pow_GR_sign_Y_Gpr       = pow_GR_signexp_Y_Gpr, pow_GR_17ones
}
;;

// Form big positive and negative constants to test for possible overflow
{ .mfi
          setf.exp POW_big_pos          = pow_GR_big_pos
          fma.s1 POW_v2                 = POW_s, POW_Q1, POW_Q0_half
(p9)      cmp.le.unc p0,p10             = 9, pow_GR_true_exp_Y_Gpr
}
{ .mfb
          setf.exp POW_big_neg          = pow_GR_big_neg
          fma.s1 POW_1ps                = f1,f1,POW_s
(p8)      br.cond.spnt POW_OVER_UNDER_X_NOT_INF
}
;;

// f123 = f12*(e123+1) = f12*e123+f12
{ .mfi
          nop.m 999
          fma.s1 POW_f123               = POW_e123,POW_f12,POW_f12
          nop.i 999
}
;;

{ .mfi
          nop.m 999
          fma.s1 POW_T1T2               = POW_T1, POW_T2, f0
          nop.i 999
}
{ .mfi
          nop.m 999
          fma.s1 POW_v3                 = POW_ssq, POW_Q4, POW_v4
          cmp.ne p12,p13 = pow_GR_xneg_yodd, r0
}
;;

{ .mfi
          nop.m 999
          fma.s1 POW_v21ps              = POW_ssq, POW_v2, POW_1ps
          nop.i 999
}
{ .mfi
          nop.m 999
          fma.s1 POW_s4                 = POW_ssq, POW_ssq, f0
          nop.i 999
}
;;

{ .mfi
          nop.m 999
(p12)     fnma.s1 POW_A                 =  POW_2M, POW_f123, f0
          nop.i 999
}
{ .mfi
          nop.m 999
(p13)     fma.s1 POW_A                  =  POW_2M, POW_f123, f0
          cmp.eq p14,p11 = r0,r0   // Initialize p14 on, p11 off
}
;;

{ .mfi
          nop.m 999
          fmerge.s POW_abs_q = f0, POW_q // Form |q| so can test its size
          nop.i 999
}
;;

{ .mfi
(p10)     cmp.eq p0,p14 = r0,r0    // Turn off p14 if no overflow
          fma.s1 POW_es                 = POW_s4,  POW_v3, POW_v21ps
          nop.i 999
}
{ .mfi
          nop.m 999
          fma.s1 POW_A                  = POW_A, POW_T1T2, f0
          nop.i 999
}
;;

{ .mfi
// Test for |q| < 2^-63.  If so then reverse last two steps of the result
// to avoid monotonicity problems for results near 1.0 in round up/down/zero.
// p11 will be set if need to reverse the order, p14 if not.
          nop.m 999
(p10)     fcmp.lt.s0 p11,p14 = POW_abs_q, POW_2toM63 // Test |q| <2^-63
          nop.i 999
}
;;

.pred.rel "mutex",p11,p14
{ .mfi
          nop.m 999
(p14)     fma.s1 POW_A                  = POW_A, POW_es, f0
          nop.i 999
}
{ .mfi
          nop.m 999
(p11)     fma.s1 POW_A                  = POW_A, POW_q, POW_A
          nop.i 999
}
;;

// Dummy op to set inexact if |q| < 2^-63
{ .mfi
          nop.m 999
(p11)     fma.d.s0 POW_tmp              = POW_A, POW_q, POW_A
          nop.i 999
}
;;

{ .mfi
          nop.m 999
(p14)     fma.d.s0 f8                   = POW_A, POW_q, POW_A
          nop.i 999
}
{ .mfb
          nop.m 999
(p11)     fma.d.s0 f8                   = POW_A, POW_es, f0
(p10)     br.ret.sptk     b0            // Exit main branch if no over/underflow
}
;;

// POSSIBLE_OVER_UNDER
// p6 = TRUE ==> Y_Gpr negative
// Result is already computed.  We just need to know if over/underflow occurred.

{ .mfb
        cmp.eq p0,p6                    = pow_GR_sign_Y_Gpr, r0
        nop.f 999
(p6)    br.cond.spnt POW_POSSIBLE_UNDER
}
;;

// POSSIBLE_OVER
// We got an answer.
// overflow is a possibility, not a certainty


// We define an overflow when the answer with
//    WRE set
//    user-defined rounding mode

// double
// Largest double is 7FE (biased double)
//                   7FE - 3FF + FFFF = 103FE
// Create + largest_double_plus_ulp
// Create - largest_double_plus_ulp
// Calculate answer with WRE set.

// single
// Largest single is FE (biased double)
//                   FE - 7F + FFFF = 1007E
// Create + largest_single_plus_ulp
// Create - largest_single_plus_ulp
// Calculate answer with WRE set.

// Cases when answer is ldn+1  are as follows:
//  ldn                   ldn+1
// --+----------|----------+------------
//              |
//    +inf          +inf      -inf
//                  RN         RN
//                             RZ

// Put in s2 (td set, wre set)
{ .mfi
        nop.m 999
        fsetc.s2 0x7F,0x42
        nop.i 999
}
;;

{ .mfi
        nop.m 999
        fma.d.s2 POW_wre_urm_f8         = POW_A, POW_q, POW_A
        nop.i 999
}
;;

// Return s2 to default
{ .mfi
        nop.m 999
        fsetc.s2 0x7F,0x40
        nop.i 999
}
;;

// p7 = TRUE ==> yes, we have an overflow
{ .mfi
        nop.m 999
        fcmp.ge.s1 p7, p8               =  POW_wre_urm_f8, POW_big_pos
        nop.i 999
}
;;

{ .mfi
        nop.m 999
(p8)    fcmp.le.s1 p7, p0               =  POW_wre_urm_f8, POW_big_neg
        nop.i 999
}
;;

{ .mbb
(p7)   mov pow_GR_tag                   = 24
(p7)   br.cond.spnt __libm_error_region // Branch if overflow
       br.ret.sptk     b0               // Exit if did not overflow
}
;;

// Here if |y*log(x)| < 2^(-11)
// pow(x,y) ~ exp(d) ~ 1 + d + 0.5*d^2 + Q1*d^3 + Q2*d^4, where d = y*log(x)
.align 32
POW_NEAR_ONE:

{ .mfi
          nop.m 999
          fma.s1 POW_d2                 = POW_d, POW_d, f0
          nop.i 999
}
;;

{ .mfi
          nop.m 999
          fma.s1 POW_poly_d_hi          = POW_d, POW_Q0_half, f1
          nop.i 999
}
{ .mfi
          nop.m 999
          fma.s1 POW_poly_d_lo          = POW_d, POW_Q2, POW_Q1
          nop.i 999
}
;;

{ .mfi
          nop.m 999
          fma.s1 POW_poly_d             = POW_d2, POW_poly_d_lo, POW_poly_d_hi
          nop.i 999
}
;;

{ .mfb
          nop.m 999
          fma.d.s0 f8                   = POW_d, POW_poly_d, f1
          br.ret.sptk b0 // exit function for arguments |y*log(x)| < 2^(-11)
}
;;

POW_POSSIBLE_UNDER:
// We got an answer. input was < -2^9 but > -2^10 (double)
// We got an answer. input was < -2^6 but > -2^7  (float)
// underflow is a possibility, not a certainty

// We define an underflow when the answer with
//    ftz set
// is zero (tiny numbers become zero)
// Notice (from below) that if we have an unlimited exponent range,
// then there is an extra machine number E between the largest denormal and
// the smallest normal.
// So if with unbounded exponent we round to E or below, then we are
// tiny and underflow has occurred.
// But notice that you can be in a situation where we are tiny, namely
// rounded to E, but when the exponent is bounded we round to smallest
// normal. So the answer can be the smallest normal with underflow.
//                           E
// -----+--------------------+--------------------+-----
//      |                    |                    |
//   1.1...10 2^-3fff    1.1...11 2^-3fff    1.0...00 2^-3ffe
//   0.1...11 2^-3ffe                                   (biased, 1)
//    largest dn                               smallest normal

// Put in s2 (td set, ftz set)
{ .mfi
        nop.m 999
        fsetc.s2 0x7F,0x41
        nop.i 999
}
;;

{ .mfi
        nop.m 999
        fma.d.s2 POW_ftz_urm_f8         = POW_A, POW_q, POW_A
        nop.i 999
}
;;

// Return s2 to default
{ .mfi
        nop.m 999
        fsetc.s2 0x7F,0x40
        nop.i 999
}
;;

// p7 = TRUE ==> yes, we have an underflow
{ .mfi
        nop.m 999
        fcmp.eq.s1 p7, p0               =  POW_ftz_urm_f8, f0
        nop.i 999
}
;;

{ .mbb
(p7)    mov pow_GR_tag                  = 25
(p7)    br.cond.spnt __libm_error_region // Branch if underflow
        br.ret.sptk     b0               // Exit if did not underflow
}
;;

POW_X_DENORM:
// Here if x unorm. Use the NORM_X for getf instructions, and then back
// to normal path
{ .mfi
        getf.exp      pow_GR_signexp_X  = POW_NORM_X
        nop.f 999
        nop.i 999
}
;;

{ .mmi
        getf.sig      pow_GR_sig_X      = POW_NORM_X
;;
        and           pow_GR_exp_X      = pow_GR_signexp_X, pow_GR_17ones
        nop.i 999
}
;;

{ .mib
        sub       pow_G