data4 0x23F924D3 // 201data4 0x2381B92F // 202data4 0x243A0FBE // 203data4 0x24712D72 // 204data4 0x24594E2F // 205data4 0x220CD12A // 206data4 0x23D87FB0 // 207data4 0x2338288A // 208data4 0x242BB2CC // 209data4 0x220F6265 // 210data4 0x23BB7FE3 // 211data4 0x2301C0A2 // 212data4 0x246709AB // 213data4 0x23A619E2 // 214data4 0x24030E3B // 215data4 0x233C36CC // 216data4 0x241AAB77 // 217data4 0x243D41A3 // 218data4 0x23834A60 // 219data4 0x236AC7BF // 220data4 0x23B6D597 // 221data4 0x210E9474 // 222data4 0x242156E6 // 223data4 0x243A1D68 // 224data4 0x2472187C // 225data4 0x23834E86 // 226data4 0x23CA0807 // 227data4 0x24745887 // 228data4 0x23E2B0E1 // 229data4 0x2421EB67 // 230data4 0x23DCC64E // 231data4 0x22DF71D1 // 232data4 0x238D5ECA // 233data4 0x23CDE86F // 234data4 0x24131F45 // 235data4 0x240FE4E2 // 236data4 0x2317731A // 237data4 0x24015C76 // 238data4 0x2301A4E8 // 239data4 0x23E52A6D // 240data4 0x247D8A0D // 241data4 0x23DFEEBA // 242data4 0x22139FEC // 243data4 0x2454A112 // 244data4 0x23C21E28 // 245data4 0x2460D813 // 246data4 0x24258924 // 247data4 0x2425680F // 248data4 0x24194D1E // 249data4 0x24242C2F // 250data4 0x243DDE5E // 251data4 0x23DEB388 // 252data4 0x23E0E6EB // 253data4 0x24393E74 // 254data4 0x241B1863 // 255LOCAL_OBJECT_END(log10_data)// Code//==============================================================// log   has p13 true, p14 false// log10 has p14 true, p13 false.section .textGLOBAL_IEEE754_ENTRY(log10){ .mfi      getf.exp      GR_Exp = f8 // if x is unorm then must recompute      frcpa.s1      FR_RcpX,p0 = f1,f8      mov           GR_05 = 0xFFFE // biased exponent of A2=0.5}{ .mlx      addl          GR_ad_1 = @ltoff(log10_data),gp      movl          GR_A3 = 0x3fd5555555555557 // double precision memory                                               // representation of A3};;{ .mfi      getf.sig      GR_Sig = f8 // get significand to calculate index      fclass.m      p8,p0 = f8,9 // is x positive unorm?      mov           GR_xorg = 0x3fefe // double precision memory msb of 255/256}{ .mib      ld8           GR_ad_1 = [GR_ad_1]      cmp.eq        p14,p13 = r0,r0 // set p14 to 1 for log10      br.cond.sptk  log_log10_common};;GLOBAL_IEEE754_END(log10)GLOBAL_IEEE754_ENTRY(log){ .mfi      getf.exp      GR_Exp = f8 // if x is unorm then must recompute      frcpa.s1      FR_RcpX,p0 = f1,f8      mov           GR_05 = 0xfffe}{ .mlx      addl          GR_ad_1 = @ltoff(log_data),gp      movl          GR_A3 = 0x3fd5555555555557 // double precision memory                                               // representation of A3};;{ .mfi      getf.sig      GR_Sig = f8 // get significand to calculate index      fclass.m      p8,p0 = f8,9 // is x positive unorm?      mov           GR_xorg = 0x3fefe // double precision memory msb of 255/256}{ .mfi      ld8           GR_ad_1 = [GR_ad_1]      nop.f         0      cmp.eq        p13,p14 = r0,r0 // set p13 to 1 for log};;log_log10_common:{ .mfi      getf.d        GR_x = f8 // double precision memory representation of x      fclass.m      p9,p0 = f8,0x1E1 // is x NaN, NaT or +Inf?      dep.z         GR_dx = 3, 44, 2 // Create 0x0000300000000000                                     // Difference between double precision                                     // memory representations of 257/256 and                                     // 255/256}{ .mfi      setf.exp      FR_A2 = GR_05 // create A2      fnorm.s1      FR_NormX = f8      mov           GR_bias = 0xffff};;  { .mfi      setf.d        FR_A3 = GR_A3 // create A3      fcmp.eq.s1    p12,p0 = f1,f8 // is x equal to 1.0?      dep.z         GR_xorg = GR_xorg, 44, 19 // 0x3fefe00000000000                                               // double precision memory                                              // representation of 255/256}{ .mib      add           GR_ad_2 = 0x30,GR_ad_1 // address of A5,A4      add           GR_ad_3 = 0x840,GR_ad_1 // address of ln(1/frcpa) lo parts(p8)  br.cond.spnt  log_positive_unorms};;log_core:{ .mfi      ldfpd         FR_A7,FR_A6 = [GR_ad_1],16      fclass.m      p10,p0 = f8,0x3A // is x < 0?      sub           GR_Nm1 = GR_Exp,GR_05 // unbiased_exponent_of_x - 1}{ .mfi      ldfpd         FR_A5,FR_A4 = [GR_ad_2],16(p9)  fma.d.s0      f8 = f8,f1,f0 // set V-flag      sub           GR_N = GR_Exp,GR_bias // unbiased_exponent_of_x};;{ .mfi      setf.sig      FR_N = GR_N // copy unbiased exponent of x to significand      fms.s1        FR_r = FR_RcpX,f8,f1 // range reduction for |x-1|>=1/256      extr.u        GR_Ind = GR_Sig,55,8 // get bits from 55 to 62 as index}{ .mib      sub           GR_x = GR_x, GR_xorg // get diff between x and 255/256      cmp.gtu       p6, p7 = 2, GR_Nm1 // p6 true if 0.5 <= x < 2(p9)  br.ret.spnt   b0 // exit for NaN, NaT and +Inf};;{ .mfi      ldfpd         FR_Ln2hi,FR_Ln2lo = [GR_ad_1],16      fclass.m      p11,p0 = f8,0x07 // is x = 0?      shladd        GR_ad_3 = GR_Ind,2,GR_ad_3 // address of Tlo}{ .mib      shladd        GR_ad_2 = GR_Ind,3,GR_ad_2 // address of Thi(p6)  cmp.leu       p6, p7 = GR_x, GR_dx       // 255/256 <= x <= 257/256(p10) br.cond.spnt  log_negatives // jump if x is negative};;// p6 is true if |x-1| < 1/256// p7 is true if |x-1| >= 1/256{ .mfi      ldfd          FR_Thi = [GR_ad_2](p6)  fms.s1        FR_r = f8,f1,f1 // range reduction for |x-1|<1/256      nop.i         0};;{ .mmi(p7)  ldfs          FR_Tlo = [GR_ad_3]      nop.m         0      nop.i         0}{ .mfb      nop.m         0(p12) fma.d.s0      f8 = f0,f0,f0(p12) br.ret.spnt   b0 // exit for +1.0};;.pred.rel "mutex",p6,p7{ .mfi(p6)  mov           GR_NearOne = 1      fms.s1        FR_A32 = FR_A3,FR_r,FR_A2 // A3*r-A2(p7)  mov           GR_NearOne = 0}{ .mfb      ldfe          FR_InvLn10 = [GR_ad_1],16      fma.s1        FR_r2 = FR_r,FR_r,f0 // r^2(p11) br.cond.spnt  log_zeroes // jump if x is zero};;{ .mfi      nop.m         0      fma.s1        FR_A6 = FR_A7,FR_r,FR_A6 // A7*r+A6      nop.i         0}{ .mfi(p7)  cmp.eq.unc    p9,p0 = r0,r0  // set p9 if |x-1| > 1/256      fma.s1        FR_A4 = FR_A5,FR_r,FR_A4 // A5*r+A4(p14) cmp.eq.unc    p8,p0 = 1,GR_NearOne // set p8 to 1 if it's log10                                         // and argument near 1.0};;{ .mfi(p6)  getf.exp      GR_rexp = FR_r  // Get signexp of x-1(p7)  fcvt.xf       FR_N = FR_N(p8)  cmp.eq        p9,p6 = r0,r0        // Also set p9 and clear p6 if log10                                          // and arg near 1};;{ .mfi      nop.m         0      fma.s1        FR_r4 = FR_r2,FR_r2,f0 // r^4      nop.i         0}{ .mfi      nop.m         0(p8)  fma.s1        FR_NxLn2pT = f0,f0,f0  // Clear NxLn2pT if log10 near 1      nop.i         0};;{ .mfi      nop.m         0      // (A3*r+A2)*r^2+r      fma.s1        FR_A321 = FR_A32,FR_r2,FR_r      mov           GR_mask = 0x1ffff}{ .mfi      nop.m         0      // (A7*r+A6)*r^2+(A5*r+A4)      fma.s1        FR_A4 = FR_A6,FR_r2,FR_A4      nop.i         0};;{ .mfi(p6)  and           GR_rexp = GR_rexp, GR_mask      // N*Ln2hi+Thi(p7)  fma.s1        FR_NxLn2hipThi = FR_N,FR_Ln2hi,FR_Thi      nop.i         0}{ .mfi      nop.m         0      // N*Ln2lo+Tlo(p7)  fma.s1        FR_NxLn2lopTlo = FR_N,FR_Ln2lo,FR_Tlo      nop.i         0};;{ .mfi(p6)  sub           GR_rexp = GR_rexp, GR_bias // unbiased exponent of x-1(p9)  fma.s1        f8 = FR_A4,FR_r4,FR_A321 // P(r) if |x-1| >= 1/256 or                                             // log10 and |x-1| < 1/256      nop.i         0}{ .mfi      nop.m         0      // (N*Ln2hi+Thi) + (N*Ln2lo+Tlo)(p7)  fma.s1        FR_NxLn2pT = FR_NxLn2hipThi,f1,FR_NxLn2lopTlo      nop.i         0};;{ .mfi(p6)  cmp.gt.unc    p10, p6 = -40, GR_rexp // Test |x-1| < 2^-40      nop.f         0      nop.i         0};;{ .mfi      nop.m         0(p10) fma.d.s0      f8 = FR_A32,FR_r2,FR_r // log(x) if |x-1| < 2^-40      nop.i         0};;.pred.rel "mutex",p6,p9{ .mfi      nop.m         0(p6)  fma.d.s0      f8 = FR_A4,FR_r4,FR_A321 // log(x) if 2^-40 <= |x-1| < 1/256      nop.i         0}{ .mfb      nop.m         0(p9)  fma.d.s0      f8 = f8,FR_InvLn10,FR_NxLn2pT // result if |x-1| >= 1/256                                                  // or log10 and |x-1| < 1/256      br.ret.sptk   b0};;.align 32log_positive_unorms:{ .mmf      getf.exp      GR_Exp = FR_NormX // recompute biased exponent      getf.d        GR_x = FR_NormX   // recompute double precision x      fcmp.eq.s1    p12,p0 = f1,FR_NormX // is x equal to 1.0?};;{ .mfb      getf.sig      GR_Sig = FR_NormX // recompute significand      fcmp.eq.s0    p15, p0 = f8, f0  // set denormal flag      br.cond.sptk  log_core};;.align 32log_zeroes:{ .mfi      nop.m         0      fmerge.s      FR_X = f8,f8 // keep input argument for subsequent                                 // call of __libm_error_support#      nop.i         0}{ .mfi      nop.m         0      fms.s1        FR_tmp = f0,f0,f1 // -1.0      nop.i         0};;.pred.rel "mutex",p13,p14{ .mfi(p13) mov           GR_TAG = 2 // set libm error in case of log      frcpa.s0      f8,p0 = FR_tmp,f0 // log(+/-0) should be equal to -INF.                                      // We can get it using frcpa because it                                      // sets result to the IEEE-754 mandated                                      // quotient of FR_tmp/f0.                                      // As far as FR_tmp is -1 it'll be -INF      nop.i         0}{ .mib(p14) mov           GR_TAG = 8 // set libm error in case of log10      nop.i         0      br.cond.sptk  log_libm_err};;.align 32log_negatives:{ .mfi      nop.m         0      fmerge.s      FR_X = f8,f8      nop.i         0};;.pred.rel "mutex",p13,p14{ .mfi(p13) mov           GR_TAG = 3 // set libm error in case of log      frcpa.s0      f8,p0 = f0,f0 // log(negatives) should be equal to NaN.                                  // We can get it using frcpa because it                                  // sets result to the IEEE-754 mandated                                  // quotient of f0/f0 i.e. NaN.(p14) mov           GR_TAG = 9 // set libm error in case of log10};;.align 32log_libm_err:{ .mmi      alloc         r32 = ar.pfs,1,4,4,0      mov           GR_Parameter_TAG = GR_TAG      nop.i         0};;GLOBAL_IEEE754_END(log)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#