s_expm1.s

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

      nop.f           0
      nop.i           0
}
;;

{ .mfi
      ldfe            fQ5 = [rAD_Q1], 16       // Load coeff for small path
      nop.f           0
      nop.i           0
}
{ .mib
      ldfe            fQ4 = [rAD_Q2], 16       // Load coeff for small path
(p7)  cmp.gt.unc      p6, p7 = -60, rExp_x     // Test |x| < 2^(-60)
(p7)  br.cond.spnt    EXPM1_SMALL              // Branch if 2^-60 <= |x| < 2^-2
}
;;

// W = X * Inv_log2_by_128
// By adding 1.10...0*2^63 we shift and get round_int(W) in significand.
// We actually add 1.10...0*2^56 to X * Inv_log2 to do the same thing.

{ .mfi
      ldfe            fLn2_by_128_hi  = [rAD_TB1],32
      fma.s1          fW_2TO56_RSH  = fNormX, fINV_LN2_2TO63, fRSHF_2TO56
      nop.i           0
}
{ .mfb
      ldfe            fLn2_by_128_lo  = [rAD_Ln2_lo]
(p6)  fma.d.s0        f8 = f8, f8, f8 // If x < 2^-60, result=x+x*x
(p6)  br.ret.spnt     b0              // Exit if x < 2^-60
}
;;

// Divide arguments into the following categories:
//  Certain minus one       p11 - -inf < x <= MAX_DBL_MINUS_1_ARG
//  Possible Overflow       p14 - MAX_DBL_NORM_ARG < x < MIN_DBL_OFLOW_ARG
//  Certain Overflow        p15 - MIN_DBL_OFLOW_ARG <= x < +inf
//
// If the input is really a double arg, then there will never be "Possible
// Overflow" arguments.
//

// After that last load, rAD_TB1 points to the beginning of table 1

{ .mfi
      nop.m           0
      fcmp.ge.s1      p15,p14 = fNormX,fMIN_DBL_OFLOW_ARG
      nop.i           0
}
;;

{ .mfi
      add             rAD_P = 0x80, rAD_TB2
      fcmp.le.s1      p11,p0 = fNormX,fMAX_DBL_MINUS_1_ARG
      nop.i           0
}
;;

{ .mfb
      ldfpd           fP5, fP4  = [rAD_P] ,16
(p14) fcmp.gt.unc.s1  p14,p0 = fNormX,fMAX_DBL_NORM_ARG
(p15) br.cond.spnt    EXPM1_CERTAIN_OVERFLOW
}
;;

// Nfloat = round_int(W)
// The signficand of fW_2TO56_RSH contains the rounded integer part of W,
// as a twos complement number in the lower bits (that is, it may be negative).
// That twos complement number (called N) is put into rN.

// Since fW_2TO56_RSH is scaled by 2^56, it must be multiplied by 2^-56
// before the shift constant 1.10000 * 2^63 is subtracted to yield fNfloat.
// Thus, fNfloat contains the floating point version of N

{ .mfb
      ldfpd           fP3, fP2  = [rAD_P]
      fms.s1          fNfloat = fW_2TO56_RSH, f2TOM56, fRSHF
(p11) br.cond.spnt    EXPM1_CERTAIN_MINUS_ONE
}
;;

{ .mfi
      getf.sig        rN = fW_2TO56_RSH
      nop.f           0
      nop.i           0
}
;;

// rIndex_1 has index_1
// rIndex_2_16 has index_2 * 16
// rBiased_M has M
// rIndex_1_16 has index_1 * 16

// r = x - Nfloat * ln2_by_128_hi
// f = 1 - Nfloat * ln2_by_128_lo
{ .mfi
      and             rIndex_1 = 0x0f, rN
      fnma.s1         fR   = fNfloat, fLn2_by_128_hi, fNormX
      shr             rM = rN,  0x7
}
{ .mfi
      and             rIndex_2_16 = 0x70, rN
      fnma.s1         fF   = fNfloat, fLn2_by_128_lo, f1
      nop.i           0
}
;;

// rAD_T1 has address of T1
// rAD_T2 has address if T2

{ .mmi
      add             rBiased_M = rExp_bias, rM
      add             rAD_T2 = rAD_TB2, rIndex_2_16
      shladd          rAD_T1 = rIndex_1, 4, rAD_TB1
}
;;

// Create Scale = 2^M
// Load T1 and T2
{ .mmi
      setf.exp        f2M = rBiased_M
      ldfe            fT2  = [rAD_T2]
      nop.i           0
}
;;

{ .mfi
      ldfe            fT1  = [rAD_T1]
      fmpy.s0         fTmp = fLn2_by_128_lo, fLn2_by_128_lo // Force inexact
      nop.i           0
}
;;

{ .mfi
      nop.m           0
      fma.s1          fP54 = fR, fP5, fP4
      nop.i           0
}
{ .mfi
      nop.m           0
      fma.s1          fP32 = fR, fP3, fP2
      nop.i           0
}
;;

{ .mfi
      nop.m           0
      fma.s1          fRsq = fR, fR, f0
      nop.i           0
}
;;

{ .mfi
      nop.m           0
      fma.s1          fP5432  = fRsq, fP54, fP32
      nop.i           0
}
;;

{ .mfi
      nop.m           0
      fma.s1          fS2  = fF,fT2,f0
      nop.i           0
}
{ .mfi
      nop.m           0
      fma.s1          fS1  = f2M,fT1,f0
      nop.i           0
}
;;

{ .mfi
      nop.m           0
      fma.s1          fP = fRsq, fP5432, fR
      nop.i           0
}
;;

{ .mfi
      nop.m           0
      fms.s1          fSm1 = fS1,fS2,f1    // S - 1.0
      nop.i           0
}
{ .mfb
      nop.m           0
      fma.s1          fS   = fS1,fS2,f0
(p14) br.cond.spnt    EXPM1_POSSIBLE_OVERFLOW
}
;;

{ .mfb
      nop.m           0
      fma.d.s0        f8 = fS, fP, fSm1
      br.ret.sptk     b0                // Normal path exit
}
;;

// Here if 2^-60 <= |x| <2^-2
// Compute 13th order polynomial
EXPM1_SMALL:
{ .mmf
      ldfe            fQ3 = [rAD_Q1], 16
      ldfe            fQ2 = [rAD_Q2], 16
      fma.s1          fX4 = fXsq, fXsq, f0
}
;;

{ .mfi
      nop.m           0
      fma.s1          fQDC = fQD, fNormX, fQC
      nop.i           0
}
{ .mfi
      nop.m           0
      fma.s1          fQBA = fQB, fNormX, fQA
      nop.i           0
}
;;

{ .mfi
      nop.m           0
      fma.s1          fQ98 = fQ9, fNormX, fQ8
      nop.i           0
}
{ .mfi
      nop.m           0
      fma.s1          fQ76= fQ7, fNormX, fQ6
      nop.i           0
}
;;

{ .mfi
      nop.m           0
      fma.s1          fQ54 = fQ5, fNormX, fQ4
      nop.i           0
}
;;

{ .mfi
      nop.m           0
      fma.s1          fX6 = fX4, fXsq, f0
      nop.i           0
}
{ .mfi
      nop.m           0
      fma.s1          fQ32= fQ3, fNormX, fQ2
      nop.i           0
}
;;

{ .mfi
      nop.m           0
      fma.s1          fQDCBA = fQDC, fXsq, fQBA
      nop.i           0
}
{ .mfi
      nop.m           0
      fma.s1          fQ7654 = fQ76, fXsq, fQ54
      nop.i           0
}
;;

{ .mfi
      nop.m           0
      fma.s1          fQDCBA98 = fQDCBA, fXsq, fQ98
      nop.i           0
}
{ .mfi
      nop.m           0
      fma.s1          fQ765432 = fQ7654, fXsq, fQ32
      nop.i           0
}
;;

{ .mfi
      nop.m           0
      fma.s1          fQDCBA98765432 = fQDCBA98, fX6, fQ765432
      nop.i           0
}
;;

{ .mfb
      nop.m           0
      fma.d.s0        f8 = fQDCBA98765432, fXsq, fNormX
      br.ret.sptk     b0                   // Exit small branch
}
;;


EXPM1_POSSIBLE_OVERFLOW:

// Here if fMAX_DBL_NORM_ARG < x < fMIN_DBL_OFLOW_ARG
// This cannot happen if input is a double, only if input higher precision.
// Overflow is a possibility, not a certainty.

// Recompute result using status field 2 with user's rounding mode,
// and wre set.  If result is larger than largest double, then we have
// overflow

{ .mfi
      mov             rGt_ln  = 0x103ff // Exponent for largest dbl + 1 ulp
      fsetc.s2        0x7F,0x42         // Get user's round mode, set wre
      nop.i           0
}
;;

{ .mfi
      setf.exp        fGt_pln = rGt_ln  // Create largest double + 1 ulp
      fma.d.s2        fWre_urm_f8 = fS, fP, fSm1  // Result with wre set
      nop.i           0
}
;;

{ .mfi
      nop.m           0
      fsetc.s2        0x7F,0x40                   // Turn off wre in sf2
      nop.i           0
}
;;

{ .mfi
      nop.m           0
      fcmp.ge.s1      p6, p0 =  fWre_urm_f8, fGt_pln // Test for overflow
      nop.i           0
}
;;

{ .mfb
      nop.m           0
      nop.f           0
(p6)  br.cond.spnt    EXPM1_CERTAIN_OVERFLOW // Branch if overflow
}
;;

{ .mfb
      nop.m           0
      fma.d.s0        f8 = fS, fP, fSm1
      br.ret.sptk     b0                     // Exit if really no overflow
}
;;

EXPM1_CERTAIN_OVERFLOW:
{ .mmi
      sub             rTmp = rExp_mask, r0, 1
;;
      setf.exp        fTmp = rTmp
      nop.i           0
}
;;

{ .mfi
      alloc           r32=ar.pfs,1,4,4,0
      fmerge.s        FR_X = f8,f8
      nop.i           0
}
{ .mfb
      mov             GR_Parameter_TAG = 41
      fma.d.s0        FR_RESULT = fTmp, fTmp, f0    // Set I,O and +INF result
      br.cond.sptk    __libm_error_region
}
;;

// Here if x unorm
EXPM1_UNORM:
{ .mfb
      getf.exp        rSignexp_x = fNormX    // Must recompute if x unorm
      fcmp.eq.s0      p6, p0 = f8, f0        // Set D flag
      br.cond.sptk    EXPM1_COMMON
}
;;

// here if result will be -1 and inexact, x <= -48.0
EXPM1_CERTAIN_MINUS_ONE:
{ .mmi
      mov             rTmp = 1
;;
      setf.exp        fTmp = rTmp
      nop.i           0
}
;;

{ .mfb
      nop.m           0
      fms.d.s0        FR_RESULT = fTmp, fTmp, f1 // Set I, rounded -1+eps result
      br.ret.sptk     b0
}
;;

GLOBAL_IEEE754_END(expm1)


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
        stfd [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
        stfd [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
        stfd [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
        ldfd  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#