e_powl.s

Glibc 2.3.2源代码(解压后有100多M)

}
//
//     S0 user supplied status
//     S2 user supplied status + WRE + TD  (Overflows)
//     S3 user supplied status + FZ + TD   (Underflows)
//
//
//     If (Safe) is true, then
//        Compute result using user supplied status field.
//        No overflow or underflow here, but perhaps inexact.
//        Return
//     Else
//       Determine if overflow or underflow  was raised.
//       Fetch +/- overflow threshold for IEEE single, double,
//       double extended
//
{ .mfi
(p0)   setf.exp FR_Big = GR_T1_ptr
(p0)   fsetc.s2 0x7F,0x40
	nop.i 999 ;;
}
{ .mfi
	nop.m 999
(p0)   fclass.m.unc   p11, p0 =  FR_Result_small, 0x00F
	nop.i 999 ;;
}
{ .mfi
	nop.m 999
(p0)   fmerge.ns FR_NBig = FR_Big, FR_Big
	nop.i 999
}
{ .mfi
	nop.m 999
//
//     Create largest double exponent + 1.
//     Create smallest double exponent - 1.
//     Identify denormals
//
(p0)   fcmp.ge.unc.s1 p8, p0 = FR_Result_big , FR_Big
	nop.i 999 ;;
}
{ .mii
	nop.m 999
	nop.i 999 ;;
//
//     fcmp:   resultS2 <= - overflow threshold  
//     fclass: resultS3 is denorm/unorm/0       
//
(p8)   mov   GR_Parameter_TAG = 18 ;;
}
{ .mfb
	nop.m 999
//
//     fcmp:   resultS2 >= + overflow threshold  
//
(p0)   fcmp.le.unc.s1 p9, p0 = FR_Result_big, FR_NBig
(p8)   br.cond.spnt __libm_error_region ;;
}
{ .mii
	nop.m 999
	nop.i 999 ;;
(p9)   mov   GR_Parameter_TAG = 18
}
{ .mib
	nop.m 999
	nop.i 999
(p9)   br.cond.spnt __libm_error_region ;;
}
//
//     Report that pow overflowed - either +Inf, or -Inf
//
{ .mmb
(p11)  mov   GR_Parameter_TAG = 19
	nop.m 999
(p11)  br.cond.spnt __libm_error_region ;;
}
{ .mib
	nop.m 999
	nop.i 999
//
//     Report that pow underflowed
//
(p0)   br.cond.sptk L(POWL_64_RETURN) ;;
}


L(POWL_64_SQUARE):
// Here if x not zero and y=2.
// Must call __libm_error_support for overflow or underflow
//
//     S0 user supplied status
//     S2 user supplied status + WRE + TD  (Overflows)
//     S3 user supplied status + FZ + TD   (Underflows)
//
{ .mfi
	nop.m 999
(p0)   fma.s0 FR_Result = FR_Input_X, FR_Input_X, f0
	nop.i 999
}
{ .mfi
	nop.m 999
(p0)   fsetc.s3 0x7F,0x01
	nop.i 999
}
{ .mlx
	nop.m 999
(p0)   movl GR_T1_ptr = 0x00000000013FFF ;;
}
{ .mfi
	nop.m 999
(p0)   fma.s3 FR_Result_small = FR_Input_X, FR_Input_X, f0
	nop.i 999
}
{ .mfi
	nop.m 999
(p0)   fsetc.s3 0x7F,0x40
	nop.i 999 ;;
}
{ .mfi
	nop.m 999
//
//     Return if no danger of over of underflow.
//
(p0)   fsetc.s2 0x7F,0x42
	nop.i 999;;
}
{ .mfi
	nop.m 999
(p0)   fma.s2 FR_Result_big = FR_Input_X, FR_Input_X, f0
	nop.i 999 ;;
}
//
//     S0 user supplied status
//     S2 user supplied status + WRE + TD  (Overflows)
//     S3 user supplied status + FZ + TD   (Underflows)
//
//
//     If (Safe) is true, then
//        Compute result using user supplied status field.
//        No overflow or underflow here, but perhaps inexact.
//        Return
//     Else
//       Determine if overflow or underflow  was raised.
//       Fetch +/- overflow threshold for IEEE single, double,
//       double extended
//
{ .mfi
(p0)   setf.exp FR_Big = GR_T1_ptr
(p0)   fsetc.s2 0x7F,0x40
	nop.i 999 ;;
}
{ .mfi
	nop.m 999
(p0)   fclass.m.unc   p11, p0 =  FR_Result_small, 0x00F
	nop.i 999 ;;
}
{ .mfi
	nop.m 999
(p0)   fmerge.ns FR_NBig = FR_Big, FR_Big
	nop.i 999
}
{ .mfi
	nop.m 999
//
//     Create largest double exponent + 1.
//     Create smallest double exponent - 1.
//     Identify denormals
//
(p0)   fcmp.ge.unc.s1 p8, p0 = FR_Result_big , FR_Big
	nop.i 999 ;;
}
{ .mii
	nop.m 999
	nop.i 999 ;;
//
//     fcmp:   resultS2 <= - overflow threshold  
//     fclass: resultS3 is denorm/unorm/0       
//
(p8)   mov   GR_Parameter_TAG = 18 ;;
}
{ .mfb
	nop.m 999
//
//     fcmp:   resultS2 >= + overflow threshold  
//
(p0)   fcmp.le.unc.s1 p9, p0 = FR_Result_big, FR_NBig
(p8)   br.cond.spnt __libm_error_region ;;
}
{ .mii
	nop.m 999
	nop.i 999 ;;
(p9)   mov   GR_Parameter_TAG = 18
}
{ .mib
	nop.m 999
	nop.i 999
(p9)   br.cond.spnt __libm_error_region ;;
}
//
//     Report that pow overflowed - either +Inf, or -Inf
//
{ .mmb
(p11)  mov   GR_Parameter_TAG = 19
	nop.m 999
(p11)  br.cond.spnt __libm_error_region ;;
}
{ .mib
	nop.m 999
	nop.i 999
//
//     Report that pow underflowed
//
(p0)   br.cond.sptk L(POWL_64_RETURN) ;;
}




L(POWL_64_SPECIAL): 
{ .mfi
	nop.m 999
(p0)   fcmp.eq.s1 p15, p0 =  FR_Input_X, f1  // Is x=+1
	nop.i 999 ;;
}
{ .mfi
	nop.m 999
(p0)   fclass.m.unc p14, p0 =  FR_Input_Y, 0x023 
	nop.i 999 ;;
}

{ .mfi
	nop.m 999
(p15)   fcmp.eq.unc.s0 p6,p0 = FR_Input_Y, f0 // If x=1, flag invalid if y=SNaN
	nop.i 999 
}
{ .mfb
	nop.m 999
(p15)   fmpy.s0 FR_Result = f1,f1        // If x=1, result=1
(p15)   br.cond.spnt L(POWL_64_RETURN) ;;   // Exit if x=1
}

{ .mfi
	nop.m 999
(p0)   fclass.m.unc p13, p0 =  FR_Input_X, 0x023 
	nop.i 999 ;;
}
{ .mfi
	nop.m 999
(p0)   fclass.m.unc p8, p0 =  FR_Input_X, 0x143 
	nop.i 999
}
{ .mfi
	nop.m 999
(p0)   fclass.m.unc p9, p0 =  FR_Input_Y, 0x143 
	nop.i 999 ;;
}
{ .mfi
	nop.m 999
(p0)   fclass.m.unc p10, p0 =  FR_Input_X, 0x083 
	nop.i 999
}
{ .mfi
	nop.m 999
(p0)   fclass.m.unc p11, p0 =  FR_Input_Y, 0x083 
	nop.i 999 ;;
}
{ .mfi
	nop.m 999
(p0)   fclass.m.unc p6, p0 =  FR_Input_Y, 0x007 
	nop.i 999
}
{ .mfi
	nop.m 999
(p0)   fcmp.eq.unc.s1 p7, p0 =  FR_Input_Y, f1 
	nop.i 999 ;;
}
{ .mfi
	nop.m 999
//
//     set p13 if x +/- Inf 
//     set p14 if y +/- Inf 
//     set p8  if x  Natval or +/-SNaN  
//     set p9  if y  Natval or +/-SNaN  
//     set p10 if x QNaN
//     set p11 if y QNaNs
//     set p6  if y is +/-0 
//     set p7  if y is 1
//
(p8)   fmpy.s0 FR_Result = FR_Input_Y, FR_Input_X 
(p6)   cmp.ne p8,p0 = r0,r0 ;;  // Don't exit if x=snan, y=0 ==> result=+1
}
{ .mfb
	nop.m 999
(p9)   fmpy.s0 FR_Result = FR_Input_Y, FR_Input_X 
(p8)   br.cond.spnt L(POWL_64_RETURN) ;; 
}
{ .mfb
	nop.m 999
(p10)  fmpy.s0 FR_Result = FR_Input_X, f0 
(p9)   br.cond.spnt L(POWL_64_RETURN) ;; 
}
{ .mfi
	nop.m 999
//
//     Produce result for SNaN and NatVals and return
//
(p6)   fclass.m.unc p15, p0 =  FR_Input_X,0x007 
	nop.i 999
}
{ .mfi
	nop.m 999
//
//     If Y +/- 0, set p15 if x +/- 0
//
(p6)   fclass.m.unc p8, p0 =  FR_Input_X,0x0C3 
	nop.i 999 ;;
}

{ .mfi
	nop.m 999
(p6)   fcmp.eq.s0 p9,p0 = FR_Input_X, f0 // If y=0, flag if x denormal
	nop.i 999
}
{ .mfi
	nop.m 999
(p6)   fadd.s0 FR_Result = f1, f0
	nop.i 999 ;;
}
{ .mfi
	nop.m 999
// 
//     Set p8 if y = +/-0 and X is a QNaN/SNaN
//     If y = +/-0, let result = 1.0
// 
(p7)   fmpy.s0 FR_Result = FR_Input_X,f1
//
//     If y == 1, result = x * 1 
//
(p15)  mov GR_Parameter_TAG = 20 
}
{ .mib
	nop.m 999
	nop.i 999
(p15)  br.cond.spnt __libm_error_region ;;
}
{ .mib
	nop.m 999
//
//     If x and y are both zero, result = 1.0 and call error
//     support. 
//
(p8)   mov GR_Parameter_TAG = 23 
(p8)   br.cond.spnt __libm_error_region ;;
}
{ .mib
	nop.m 999
	nop.i 999
//
//     If y = +/-0 and x is a QNaN, result = 1.0 and call error
//     support. 
//
(p6)   br.cond.spnt L(POWL_64_RETURN) ;; 
}

// If x=0, y=-inf, go to the X_IS_ZERO path
{ .mfb
	nop.m 999
(p14)  fcmp.eq.unc.s1 p0,p14 = FR_Input_X,f0 
(p7)   br.cond.spnt L(POWL_64_RETURN) ;; 
}

{ .mfi
	nop.m 999
//
//     Produce all results for x**0 and x**1 
//     Let all the result x ** 0 == 1 and return
//     Let all x ** 1 == x and return
//
(p10)  fmpy.s0 FR_Result = FR_Input_Y,FR_Input_X
	nop.i 999 ;;
}
{ .mfb
	nop.m 999
(p11)  fmpy.s0 FR_Result = FR_Input_Y,FR_Input_X
(p10)  br.cond.spnt L(POWL_64_RETURN) ;;
}
{ .mib
	nop.m 999
	nop.i 999
(p11)  br.cond.spnt L(POWL_64_RETURN) ;;
}
{ .mib
	nop.m 999
	nop.i 999
//
//     Return result for x or y QNaN input with QNaN result 
//
(p14)  br.cond.spnt L(POWL_64_Y_IS_INF) ;;
}
{ .mib
	nop.m 999
	nop.i 999
(p13)  br.cond.spnt L(POWL_64_X_IS_INF) ;;
}
L(POWL_64_X_IS_ZERO): 
{ .mmb
(p0)   getf.sig GR_signif_y = FR_Input_Y 
(p0)   getf.exp GR_BIASed_exp_y = FR_Input_Y
	nop.b 999 ;;
}
{ .mlx
	nop.m 999
(p0)   movl GR_Mask = 0x1FFFF
}
{ .mlx
	nop.m 999
(p0)   movl GR_y_sign = 0x20000 ;;
}
//
//     Get BIASed exp and significand of y
//
{ .mfi
(p0)   and GR_exp_y = GR_Mask,GR_BIASed_exp_y
	nop.f 999
(p0)   and GR_y_sign = GR_y_sign,GR_BIASed_exp_y
}
{ .mlx
	nop.m 999
(p0)   movl GR_BIAS = 0xFFFF ;;
}
{ .mfi
(p0)   cmp.lt.unc  p9, p8 = GR_exp_y,GR_BIAS
	nop.f 999
//
//     Maybe y is < 1 already, so
//     can never be an integer.
//     Remove sign bit from exponent.
//
(p0)   sub GR_exp_y = GR_exp_y,GR_BIAS ;;
}
{ .mii
	nop.m 999
	nop.i 999 ;;
//
//     Remove exponent BIAS
//
(p8)   shl GR_exp_y=  GR_signif_y,GR_exp_y ;;
}
{ .mfi
(p9)   or  GR_exp_y=  0xF,GR_signif_y
	nop.f 999
	nop.i 999 ;;
}
{ .mii
	nop.m 999
//
//     Shift significand of y looking for nonzero bits
//     For y > 1, shift signif_y exp_y bits to the left
//     For y < 1, turn on 4 low order bits of significand of y 
//     so that the fraction will always be non-zero
//
(p0)   shl GR_signif_y=  GR_exp_y,1 ;;
(p0)   extr.u GR_low_order_bit = GR_exp_y,63,1
}
//
//     Integer part of y  shifted off.
//     Get y's low even or odd bit - y might not be an int.
//
{ .mii
(p0)   cmp.eq.unc  p13,p0  =  GR_signif_y, r0
(p0)   cmp.eq.unc  p8,p9 =  GR_y_sign, r0 ;;
//
//     Is y an int?
//     Is y positive
//
(p13)  cmp.ne.unc  p13,p0 =  GR_low_order_bit, r0 ;;
}
//
//     Is y and int and odd?
//
{ .mfb
(p13)  cmp.eq.unc  p13,p14 =  GR_y_sign, r0
(p8)   fcmp.eq.s0 p12,p0 = FR_Input_Y, f0 // If x=0 and y>0 flag if y denormal
	nop.b 999 ;;
}
{ .mfb
	nop.m 999
//
//     Is y and int and odd and positive?
//
(p13)  mov FR_Result = FR_Input_X 
(p13)  br.cond.sptk L(POWL_64_RETURN) ;;
}
{ .mfi
	nop.m 999
//
//     Return +/-0 when x=+/-0 and y is and odd pos. int
//
(p14)  frcpa.s0 FR_Result, p10 = f1, FR_Input_X
(p14)  mov GR_Parameter_TAG = 21
}
{ .mib
	nop.m 999
	nop.i 999
(p14)  br.cond.spnt __libm_error_region ;;
}

{ .mfb
	nop.m 999
//
//     Return +/-0 when x=+/-Inf and y is and odd neg int
//     and raise dz exception
//
(p8)   mov FR_Result = f0
(p8)   br.cond.sptk L(POWL_64_RETURN) ;;
}
{ .mfi
	nop.m 999
//
//     Return +0 when x=+/-0 and y > 0  and not odd.
//
(p9)   frcpa.s0 FR_Result, p10 = f1,f0
(p9)   mov GR_Parameter_TAG = 21
}
{ .mib
	nop.m 999
	nop.i 999
(p9)   br.cond.sptk __libm_error_region ;;
}
L(POWL_64_X_IS_INF): 
{ .mfi
(p0)   getf.exp GR_exp_y = FR_Input_Y
(p0)   fclass.m.unc p13, p0 =  FR_Input_X,0x022 
(p0)   mov GR_Mask = 0x1FFFF ;;
}

{ .mfi
(p0)   getf.sig GR_signif_y = FR_Input_Y
(p0)   fcmp.eq.s0 p9,p0 = FR_Input_Y, f0 // Flag if y denormal
       nop.i 999 ;;
}

//
//     Get exp and significand of y
//     Create exponent mask and sign mask
//
{ .mlx
(p0)   and GR_low_order_bit = GR_Mask,GR_exp_y
(p0)   movl GR_BIAS = 0xFFFF
}
{ .mmi
	nop.m 999 ;;
//
//     Remove sign bit from exponent.
//
(p0)   cmp.lt.unc  p9, p8 = GR_low_order_bit,GR_BIAS
//
//     Maybe y is < 1 already, so 
//     isn't an int.
//
(p0)   sub GR_low_order_bit = GR_low_order_bit,GR_BIAS
}
{ .mlx
	nop.m 999
(p0)   movl GR_sign_mask = 0x20000 ;;
}
{ .mfi
(p0)   and GR_sign_mask = GR_sign_mask,GR_exp_y
//
//     Return +Inf when x=+/-0 and y < 0 and not odd and raise
//     divide-by-zero exception.
//
(p0)   fclass.m.unc p11, p0 =  FR_Input_X,0x021 
	nop.i 999 ;;
}
{ .mmi
	nop.m 999 ;;
//
//     Is shift off integer part of y.
//     Get y's even or odd bit - y might not be an int.
//
(p11)  cmp.eq.unc  p11,p12 = GR_sign_mask, r0
//
//     Remove exponent BIAS
//
(p8)   shl GR_exp_y = GR_signif_y,GR_low_order_bit ;;
}
{ .mfi
(p9)   or  GR_exp_y = 0xF,GR_signif_y
//
//     Is y positive or negative when x is +Inf?
//     Is y and int when x = -Inf 
//
(p11)  mov FR_Result = FR_Input_X 
	nop.i 999 ;;
}
{ .mfi
	nop.m 999
(p12)  mov FR_Result = f0
	nop.i 999 ;;
}
{ .mii
	nop.