e_exp10l.s

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

       mov GR_BM8 = 0xffff-8
}
{.mlx
       nop.m 0
       // GR_EMIN = (-2^14-62)*2^{8}
       movl GR_EMIN = 0xca807c00 ;;
}

{.mmb
       // FR_CONST1 = 2^{-8}
       setf.exp FR_CONST1 = GR_BM8
       // load log2(10)*2^8
       ldfe FR_LOG10 = [ GR_ADDR0 ], 16
 (p12) br.cond.spnt SPECIAL_EXP10 ;;
}

{.mmf
       setf.s FR_UF_TEST = GR_EMIN
       // load overflow threshold
       ldfe FR_OF_TEST = [ GR_ADDR0 ], 16
       // normalize x
       fma.s0 f8 = f8, f1, f0 ;;
}

{.mmi
       // load C_1
       ldfe FR_COEFF1 = [ GR_ADDR0 ], 16 ;;
       // load C_2
       ldfe FR_COEFF2 = [ GR_ADDR0 ], 16
       nop.i 0 ;;
}

{.mmf
       // GR_D_ADDR = pointer to D table
       add GR_D_ADDR = 2048-64+96+32, GR_ADDR0
       // load C_3, C_4
       ldfpd FR_COEFF3, FR_COEFF4 = [ GR_ADDR0 ], 16
       // y = x*log2(10)*2^8
       fma.s1 FR_XL10 = f8, FR_LOG10, f0 ;;
}

{.mfi
       // load C_5, C_6
       ldfpd FR_COEFF5, FR_COEFF6 = [ GR_ADDR0 ], 16
       // get int(x)
       fcvt.fx.trunc.s1 FR_XINT = f8
       nop.i 0
}
{.mfi
       nop.m 0
       // FR_LOG10 = log2(10)
       fma.s1 FR_L10 = FR_LOG10, FR_CONST1, f0
       nop.i 0 ;;
}

{.mfi
       // load log2(10)_low
       ldfe FR_L10_LOW = [ GR_ADDR0 ], 16
       // y0 = x*log2(10) = x*log2(10)_hi
       fma.s1 FR_LOG10 = f8, FR_L10, f0
       mov GR_EMIN = 0xffff-63
}
{.mfi
       mov GR_32_BIAS = 0xffff + 5
       // (K+f)*2^8 = round_to_int(y)
       fcvt.fx.s1 FR_KF0 = FR_XL10
       mov GR_4_BIAS = 0xffff + 2;;
}

{.mfi
       // load smallest normal limit
       ldfe FR_SNORM_LIMIT = [ GR_ADDR0 ], 16
       // x>overflow threshold ?
       fcmp.gt.s1 p12, p7 = f8, FR_OF_TEST
       nop.i 0 ;;
}

{.mfi
       setf.exp FR_32 = GR_32_BIAS
       // x<underflow threshold ?
  (p7) fcmp.lt.s1 p12, p7 = FR_XL10, FR_UF_TEST
       nop.i 0 ;;
}

{.mfi
       setf.exp FR_4 = GR_4_BIAS
       fcvt.xf FR_XINTF = FR_XINT
       nop.i 0
}
{.mfi
       nop.m 0
       // FR_L10 = log2(10)_h*x-RN(log2(10)_h*x)
       fms.s1 FR_L10 = f8, FR_L10, FR_LOG10
       nop.i 0 ;;
}

{.mfi
       getf.sig GR_BM8 = FR_KF0
       fcvt.xf FR_KF0 = FR_KF0
       mov GR_CONST2 = 255 ;;
}

{.mfi
       // GR_CONST2 = f
       and GR_CONST2 = GR_CONST2, GR_BM8
       // FR_L10_LOW = e = log2(10)_l*x+(log2(10)_h*x-RN(log2(10)_h*x))
       fma.s1 FR_L10_LOW = FR_L10_LOW, f8, FR_L10
       // GR_BM8 = K
       shr GR_BM8 = GR_BM8, 8 ;;
}

{.mmi
       // address of D
       shladd GR_D_ADDR = GR_CONST2, 2, GR_D_ADDR
       // K+ = bias-63
       add GR_BM8 = GR_BM8, GR_EMIN
       // address of T
       shladd GR_ADDR0 = GR_CONST2, 3, GR_ADDR0 ;;
}

{.mfb
       // load D
       ldfs FR_OF_TEST = [ GR_D_ADDR ]
       // is input an integer ?
       fcmp.eq.s1 p13, p14 = f8, FR_XINTF
 (p12) br.cond.spnt OUT_RANGE_EXP10 ;;
}

{.mmf
       // load T
       ldf8 FR_UF_TEST = [ GR_ADDR0 ]
       // FR_XL10 = 2^{K-63}
       setf.exp FR_XL10 = GR_BM8
       // r = x*log2(10)_hi-2^{-10}* [ (K+f)*2^{10} ]
       fnma.s1 FR_KF0 = FR_KF0, FR_CONST1, FR_LOG10 ;;
}

{.mfi
       nop.m 0
       // get 28.0
       fms.s1 FR_28 = FR_32, f1, FR_4
       nop.i 0
}
{.mfi
       nop.m 0
       // E = 1+C_1*e
       fma.s1 FR_L10 = FR_L10_LOW, FR_COEFF1, f1
       nop.i 0 ;;
}

{.mfi
       nop.m 0
       // P12 = C_1+C_2*r
       fma.s1 FR_COEFF2 = FR_COEFF2, FR_KF0, FR_COEFF1
       nop.i 0
}
{.mfi
       nop.m 0
       // P34 = C_3+C_4*r
       fma.s1 FR_COEFF4 = FR_COEFF4, FR_KF0, FR_COEFF3
       nop.i 0 ;;
}

{.mfi
       nop.m 0
       // P56 = C_5+C_6*r
       fma.s1 FR_COEFF5 = FR_COEFF6, FR_KF0, FR_COEFF5
       nop.i 0
}
{.mfi
       nop.m 0
       // GR_ADDR0 = r*r
       fma.s1 FR_COEFF3 = FR_KF0, FR_KF0, f0
       nop.i 0 ;;
}

{.mfi
       nop.m 0
       // if input is integer, is it positive ?
 (p13) fcmp.ge.s1 p13, p14 = f8, f0
       nop.i 0
}
{.mfi
       nop.m 0
       // r' = r*E
       fma.s1 FR_KF0 = FR_KF0, FR_L10, f0
       nop.i 0 ;;
}

{.mfi
       nop.m 0
       // D' = D+C_1*e
       fma.s1 FR_OF_TEST = FR_L10_LOW, FR_COEFF1, FR_OF_TEST
       nop.i 0 ;;
}

{.mfi
       nop.m 0
       // test if x >= smallest normal limit
       fcmp.ge.s1 p11, p0 = f8, FR_SNORM_LIMIT
       nop.i 0 ;;
}

{.mfi
       nop.m 0
       // P36 = P34+r2*P56
       fma.s1 FR_COEFF4 = FR_COEFF5, FR_COEFF3, FR_COEFF4
       nop.i 0
}
{.mfi
       nop.m 0
       // GR_D_ADDR = r'*r2
       fma.s1 FR_COEFF3 = FR_COEFF3, FR_KF0, f0
       nop.i 0 ;;
}

{.mfi
       nop.m 0
       // is input below 28.0 ?
 (p13) fcmp.lt.s1 p13, p14 = f8, FR_28
       nop.i 0
}
{.mfi
       nop.m 0
       // P' = P12*r'+D'
       fma.s1 FR_COEFF2 = FR_COEFF2, FR_KF0, FR_OF_TEST
       nop.i 0 ;;
}

{.mfi
       nop.m 0
       // P = P'+r3*P36
       fma.s1 FR_COEFF3 = FR_COEFF3, FR_COEFF4, FR_COEFF2
       nop.i 0
}
{.mfi
       nop.m 0
       // T = 2^{K-63}*T
       fma.s1 FR_UF_TEST = FR_UF_TEST, FR_XL10, f0
       nop.i 0 ;;
}

.pred.rel "mutex",p13,p14
{.mfi
       nop.m 0
 (p13) fma.s1 f8 = FR_COEFF3, FR_UF_TEST, FR_UF_TEST
       nop.i 0
}
{.mfb
       nop.m 0
       // result = T+T*P
 (p14) fma.s0 f8 = FR_COEFF3, FR_UF_TEST, FR_UF_TEST
       // return
 (p11) br.ret.sptk b0 ;;                  // return, if result normal
}

// Here if result in denormal range (and not zero)
{.mib
       nop.m 0
       mov GR_Parameter_TAG= 264
       br.cond.sptk __libm_error_region           // Branch to error handling
}
;;

SPECIAL_EXP10:

{.mfi
       nop.m 0
       // x = -Infinity ?
       fclass.m p6, p0 = f8, 0x22
       nop.i 0 ;;
}

{.mfi
       nop.m 0
       // x = +Infinity ?
       fclass.m p7, p0 = f8, 0x21
       nop.i 0 ;;
}

{.mfi
       nop.m 0
       // x = +/-Zero ?
       fclass.m p8, p0 = f8, 0x7
       nop.i 0
}
{.mfb
       nop.m 0
       // exp10(-Infinity) = 0
  (p6) mov f8 = f0
  (p6) br.ret.spnt b0 ;;
}

{.mfb
       nop.m 0
       // exp10(+Infinity) = +Infinity
       nop.f 0
  (p7) br.ret.spnt b0 ;;
}

{.mfb
       nop.m 0
       // exp10(+/-0) = 1
  (p8) mov f8 = f1
  (p8) br.ret.spnt b0 ;;
}

{.mfb
       nop.m 0
       // Remaining cases: NaNs
       fma.s0 f8 = f8, f1, f0
       br.ret.sptk b0 ;;
}


OUT_RANGE_EXP10:

// underflow: p6 = 1
// overflow: p8 = 1

.pred.rel "mutex",p6,p8
{.mmi
  (p8) mov GR_CONST1 = 0x1fffe
  (p6) mov GR_CONST1 = 1
       nop.i 0
}
;;

{.mii
       setf.exp FR_KF0 = GR_CONST1
  (p8) mov GR_Parameter_TAG = 165
  (p6) mov GR_Parameter_TAG = 264
}
;;

{.mfb
       nop.m 999
       fma.s0 f8 = FR_KF0, FR_KF0, f0             // Create overflow/underflow
       br.cond.sptk __libm_error_region           // Branch to error handling
}
;;

GLOBAL_IEEE754_END(exp10l)
weak_alias (exp10l, pow10l)


LOCAL_LIBM_ENTRY(__libm_error_region)
.prologue
{.mfi
       add GR_Parameter_Y = -32, sp // Parameter 2 value
       nop.f 0
.save ar.pfs, GR_SAVE_PFS
       mov GR_SAVE_PFS = ar.pfs // Save ar.pfs
}

{.mfi
.fframe 64
       add sp = -64, sp // Create new stack
       nop.f 0
       mov GR_SAVE_GP = gp ;; // Save gp
}

{.mmi
       stfe [ GR_Parameter_Y ] = FR_Y, 16 // STORE Parameter 2 on stack
       add GR_Parameter_X = 16, sp // Parameter 1 address
.save b0, GR_SAVE_B0
       mov GR_SAVE_B0 = b0 ;; // Save b0
}

.body
{.mib
       stfe [ GR_Parameter_X ] = FR_X // STORE Parameter 1 on stack
       add GR_Parameter_RESULT = 0, GR_Parameter_Y // Parameter 3 address
       nop.b 0
}
{.mib
       stfe [ GR_Parameter_Y ] = FR_RESULT // STORE Parameter 3 on stack
       add GR_Parameter_Y = -16, GR_Parameter_Y
       br.call.sptk b0 = __libm_error_support# ;; // Call error handling function
}

{.mmi
       add GR_Parameter_RESULT = 48, sp
       nop.m 0
       nop.i 0 ;;
}

{.mmi
       ldfe f8 = [ GR_Parameter_RESULT ] // Get return result off stack
.restore sp
       add sp = 64, sp // Restore stack pointer
       mov b0 = GR_SAVE_B0 ;; // Restore return address
}

{.mib
       mov gp = GR_SAVE_GP // Restore gp
       mov ar.pfs = GR_SAVE_PFS // Restore ar.pfs
       br.ret.sptk b0 ;; // Return
}


LOCAL_LIBM_END(__libm_error_region)
.type __libm_error_support#, @function
.global __libm_error_support#