data8 0x3FD21F6253C48D01 // 235data8 0x3FD22CBBE51D60AA // 236data8 0x3FD240CE4C975444 // 237data8 0x3FD24E37F8ECDAE8 // 238data8 0x3FD25BA8215AF7FC // 239data8 0x3FD2691ECC29F042 // 240data8 0x3FD2769BFFAB2E00 // 241data8 0x3FD2841FC23952C9 // 242data8 0x3FD291AA1A384978 // 243data8 0x3FD29F3B0E15584B // 244data8 0x3FD2B3A0EE479DF7 // 245data8 0x3FD2C142842C09E6 // 246data8 0x3FD2CEEACCB7BD6D // 247data8 0x3FD2DC99CE82FF21 // 248data8 0x3FD2EA4F902FD7DA // 249data8 0x3FD2F80C186A25FD // 250data8 0x3FD305CF6DE7B0F7 // 251data8 0x3FD3139997683CE7 // 252data8 0x3FD3216A9BB59E7C // 253data8 0x3FD32F4281A3CEFF // 254data8 0x3FD33D2150110092 // 255LOCAL_OBJECT_END(log10f_data)// Code//==============================================================.section .text// logf   has p13 true, p14 false// log10f has p14 true, p13 falseGLOBAL_IEEE754_ENTRY(log10f){ .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_T = @ltoff(log10f_data),gp      movl          GR_A3 = 0x3FD5555555555555 // double precision memory                                               // representation of A3};;{ .mfi      getf.sig      GR_Sig = f8 // if x is unorm then must recompute      fclass.m      p8,p0 = f8,9 // is x positive unorm?      sub           GR_025 = GR_05,r0,1 // biased exponent of A4=0.25}{ .mlx      ld8           GR_ad_T = [GR_ad_T]      movl          GR_Ln2 = 0x3FD34413509F79FF // double precision memory                                                // representation of                                                // log(2)/ln(10)};;{ .mfi      setf.d        FR_A3 = GR_A3 // create A3      fcmp.eq.s1    p14,p13 = f0,f0 // set p14 to 1 for log10f      dep.z         GR_xorg = GR_05,55,8 // 0x7F00000000000000 integer number                                         // bits of that are                                         // GR_xorg[63]   = last bit of biased                                         //            exponent of 255/256                                         // GR_xorg[62-0] = bits from 62 to 0                                         //            of significand of 255/256}{ .mib      setf.exp      FR_A2 = GR_05 // create A2      sub           GR_de = GR_Exp,GR_05 // biased_exponent_of_x - 0xFFFE                                         // needed to comparion with 0.5 and 2.0      br.cond.sptk  logf_log10f_common};;GLOBAL_IEEE754_END(log10f)GLOBAL_IEEE754_ENTRY(logf){ .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_T = @ltoff(logf_data),gp      movl          GR_A3 = 0x3FD5555555555555 // double precision memory                                               // representation of A3};;{ .mfi      getf.sig      GR_Sig = f8 // if x is unorm then must recompute      fclass.m      p8,p0 = f8,9 // is x positive unorm?      dep.z         GR_xorg = GR_05,55,8 // 0x7F00000000000000 integer number                                         // bits of that are                                         // GR_xorg[63]   = last bit of biased                                         //            exponent of 255/256                                         // GR_xorg[62-0] = bits from 62 to 0                                         //            of significand of 255/256}{ .mfi      ld8           GR_ad_T = [GR_ad_T]      nop.f         0      sub           GR_025 = GR_05,r0,1 // biased exponent of A4=0.25};;{ .mfi      setf.d        FR_A3 = GR_A3 // create A3      fcmp.eq.s1    p13,p14 = f0,f0 // p13 - true for logf      sub           GR_de = GR_Exp,GR_05 // biased_exponent_of_x - 0xFFFE                                         // needed to comparion with 0.5 and 2.0}{ .mlx      setf.exp      FR_A2 = GR_05 // create A2      movl          GR_Ln2 = 0x3FE62E42FEFA39EF // double precision memory                                                // representation of log(2)};;logf_log10f_common:{ .mfi      setf.exp      FR_A4 = GR_025 // create A4=0.25      fclass.m      p9,p0 = f8,0x3A // is x < 0 (including negateve unnormals)?      dep           GR_x = GR_Exp,GR_Sig,63,1 // produce integer that bits are                                              // GR_x[63] = GR_Exp[0]                                              // GR_x[62-0] = GR_Sig[62-0]}{ .mib      sub           GR_N = GR_Exp,GR_05,1 // unbiased exponent of x      cmp.gtu       p6,p7 = 2,GR_de // is 0.5 <= x < 2.0?(p8)  br.cond.spnt  logf_positive_unorm};;logf_core:{ .mfi      setf.sig      FR_N = GR_N // copy unbiased exponent of x to the                                // significand field of FR_N      fclass.m      p10,p0 = f8,0x1E1 // is x NaN, NaT or +Inf?      dep.z         GR_dx = GR_05,54,3 // 0x0180000000000000 - difference                                       // between our integer representations                                       // of 257/256 and 255/256}{ .mfi      nop.m         0      nop.f         0      sub           GR_x = GR_x,GR_xorg // difference between representations                                        // of x and 255/256};;{ .mfi      ldfd          FR_InvLn10 = [GR_ad_T],8      fcmp.eq.s1    p11,p0 = f8,f1 // is x equal to 1.0?      extr.u        GR_Ind = GR_Sig,55,8 // get bits from 55 to 62 as index}{ .mib      setf.d        FR_Ln2 = GR_Ln2 // create log(2) or log10(2)(p6)  cmp.gtu       p6,p7 = GR_dx,GR_x // set p6 if 255/256 <= x < 257/256(p9)  br.cond.spnt  logf_negatives // jump if input argument is negative number};;// p6 is true if |x-1| < 1/256// p7 is true if |x-1| >= 1/256.pred.rel "mutex",p6,p7{ .mfi      shladd        GR_ad_T = GR_Ind,3,GR_ad_T // calculate address of T(p7)  fms.s1        FR_r = FR_RcpX,f8,f1 // range reduction for |x-1|>=1/256      extr.u        GR_Exp = GR_Exp,0,17 // exponent without sign}{ .mfb      nop.m         0(p6)  fms.s1        FR_r = f8,f1,f1 // range reduction for |x-1|<1/256(p10) br.cond.spnt  logf_nan_nat_pinf // exit for NaN, NaT or +Inf};;{ .mfb      ldfd          FR_T = [GR_ad_T] // load T(p11) fma.s.s0      f8 = f0,f0,f0(p11) br.ret.spnt   b0 // exit for x = 1.0};;{ .mib      nop.m         0      cmp.eq        p12,p0 = r0,GR_Exp // is x +/-0? (here it's quite enough                                       // only to compare exponent with 0                                       // because all unnormals already                                       // have been filtered)(p12) br.cond.spnt  logf_zeroes        // Branch if input argument is +/-0};;{ .mfi      nop.m         0      fnma.s1       FR_A2 = FR_A2,FR_r,f1 // A2*r+1      nop.i         0}{ .mfi      nop.m         0      fma.s1        FR_r2 = FR_r,FR_r,f0  // r^2      nop.i         0};;{ .mfi      nop.m         0      fcvt.xf       FR_N = FR_N // convert integer N in significand of FR_N                                // to floating-point representation      nop.i         0}{ .mfi      nop.m         0      fnma.s1       FR_A3 = FR_A4,FR_r,FR_A3 // A4*r+A3      nop.i         0};;{ .mfi      nop.m         0      fma.s1        FR_r = FR_r,FR_InvLn10,f0 // For log10f we have r/log(10)      nop.i         0}{ .mfi      nop.m         0      nop.f         0      nop.i         0};;{ .mfi      nop.m         0      fma.s1        FR_A2 = FR_A3,FR_r2,FR_A2 // (A4*r+A3)*r^2+(A2*r+1)      nop.i         0}{ .mfi      nop.m         0      fma.s1        FR_NxLn2pT = FR_N,FR_Ln2,FR_T // N*Ln2+T      nop.i         0};;.pred.rel "mutex",p6,p7{ .mfi      nop.m         0(p7)  fma.s.s0      f8 = FR_A2,FR_r,FR_NxLn2pT // result for |x-1|>=1/256      nop.i         0}{ .mfb      nop.m         0(p6)  fma.s.s0      f8 = FR_A2,FR_r,f0 // result for |x-1|<1/256      br.ret.sptk   b0};;.align 32logf_positive_unorm:{ .mfi      nop.m         0(p8)  fma.s0        f8 = f8,f1,f0 // Normalize & set D-flag      nop.i         0};;{ .mfi      getf.exp      GR_Exp = f8    // recompute biased exponent      nop.f         0      cmp.ne        p6,p7 = r0,r0  // p6 <- 0, p7 <- 1 because                                   // in case of unorm we are out                                   // interval [255/256; 257/256]};;{ .mfi      getf.sig      GR_Sig = f8 // recompute significand      nop.f         0      nop.i         0};;{ .mib      sub           GR_N = GR_Exp,GR_05,1 // unbiased exponent N      nop.i         0      br.cond.sptk  logf_core // return into main path};;.align 32logf_nan_nat_pinf:{ .mfi      nop.m         0      fma.s.s0      f8 = f8,f1,f0 // set V-flag      nop.i         0}{ .mfb      nop.m         0      nop.f         0      br.ret.sptk   b0 // exit for NaN, NaT or +Inf};;.align 32logf_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(p13) mov           GR_TAG = 4 // set libm error in case of logf      fms.s1        FR_tmp = f0,f0,f1 // -1.0      nop.i         0};;{ .mfi      nop.m         0      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 = 10 // set libm error in case of log10f      nop.i         0      br.cond.sptk  logf_libm_err};;.align 32logf_negatives:{ .mfi(p13) mov           GR_TAG = 5 // set libm error in case of logf      fmerge.s      FR_X = f8,f8 // keep input argument for subsequent                                 // call of __libm_error_support#      nop.i         0};;{ .mfi(p14) mov           GR_TAG = 11 // set libm error in case of log10f      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.      nop.i         0};;.align 32logf_libm_err:{ .mmi      alloc         r32 = ar.pfs,1,4,4,0      mov           GR_Parameter_TAG = GR_TAG      nop.i         0};;GLOBAL_IEEE754_END(logf)// Stack operations when calling error support.//       (1)               (2)                          (3) (call)              (4)//   sp   -> +          psp -> +                     psp -> +                   sp -> +//           |                 |                            |                         |//           |                 | <- GR_Y               R3 ->| <- GR_RESULT            | -> f8//           |                 |                            |                         |//           | <-GR_Y      Y2->|                       Y2 ->| <- GR_Y                 |//           |                 |                            |                         |//           |                 | <- GR_X               X1 ->|                         |//           |                 |                            |                         |//  sp-64 -> +          sp ->  +                     sp ->  +                         +//    save ar.pfs          save b0                                               restore gp//    save gp                                                                    restore ar.pfsLOCAL_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      stfs [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      stfs [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      stfs [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      nop.m 0      nop.m 0      add   GR_Parameter_RESULT = 48,sp};;{ .mmi      ldfs  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#