e_fmodl.s

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

.file "fmodl.s"


// Copyright (c) 2000 - 2004, Intel Corporation
// All rights reserved.
//
// Contributed 2000 by the Intel Numerics Group, Intel Corporation
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// * Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// * The name of Intel Corporation may not be used to endorse or promote
// products derived from this software without specific prior written
// permission.

// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL INTEL OR ITS
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Intel Corporation is the author of this code, and requests that all
// problem reports or change requests be submitted to it directly at
// http://www.intel.com/software/products/opensource/libraries/num.htm.
//
// History
//====================================================================
// 02/02/00 Initial version
// 03/02/00 New Algorithm
// 04/04/00 Unwind support added
// 08/15/00 Bundle added after call to __libm_error_support to properly
// set [ the previously overwritten ] GR_Parameter_RESULT.
// 11/28/00 Set FR_Y to f9
// 03/11/02 Fixed flags for fmodl(qnan, zero)
// 05/20/02 Cleaned up namespace and sf0 syntax
// 02/10/03 Reordered header:.section,.global,.proc,.align
// 04/28/03 Fix: fmod(sNaN, 0) no longer sets errno
// 11/23/04 Reformatted routine and improved speed
//
// API
//====================================================================
// long double fmodl(long double, long double);
//
// Overview of operation
//====================================================================
// fmod(a, b)= a-i*b,
// where i is an integer such that, if b!= 0,
// |i|<|a/b| and |a/b-i|<1
//
// Algorithm
//====================================================================
// a). if |a|<|b|, return a
// b). get quotient and reciprocal overestimates accurate to
// 33 bits (q2, y2)
// c). if the exponent difference (exponent(a)-exponent(b))
// is less than 32, truncate quotient to integer and
// finish in one iteration
// d). if exponent(a)-exponent(b)>= 32 (q2>= 2^32)
// round quotient estimate to single precision (k= RN(q2)),
// calculate partial remainder (a'= a-k*b),
// get quotient estimate (a'*y2), and repeat from c).
//
// Registers used
//====================================================================

GR_SMALLBIASEXP     = r2
GR_2P32             = r3
GR_SMALLBIASEXP     = r20
GR_ROUNDCONST       = r21
GR_SIG_B            = r22
GR_ARPFS            = r23
GR_TMP1             = r24
GR_TMP2             = r25
GR_TMP3             = r26

GR_SAVE_B0          = r33
GR_SAVE_PFS         = r34
GR_SAVE_GP          = r35
GR_SAVE_SP          = r36

GR_Parameter_X      = r37
GR_Parameter_Y      = r38
GR_Parameter_RESULT = r39
GR_Parameter_TAG    = r40

FR_X                = f10
FR_Y                = f9
FR_RESULT           = f8

FR_ABS_A            = f6
FR_ABS_B            = f7
FR_Y_INV            = f10
FR_SMALLBIAS        = f11
FR_E0               = f12
FR_Q                = f13
FR_E1               = f14
FR_2P32             = f15
FR_TMPX             = f32
FR_TMPY             = f33
FR_ROUNDCONST       = f34
FR_QINT             = f35
FR_QRND24           = f36
FR_NORM_B           = f37
FR_TMP              = f38
FR_TMP2             = f39
FR_DFLAG            = f40
FR_Y_INV0           = f41
FR_Y_INV1           = f42
FR_Q0               = f43
FR_Q1               = f44
FR_QINT_Z           = f45
FR_QREM             = f46
FR_B_SGN_A          = f47

.section .text
GLOBAL_IEEE754_ENTRY(fmodl)

// inputs in f8, f9
// result in f8

{ .mfi
       getf.sig GR_SIG_B = f9
       // FR_ABS_A = |a|
       fmerge.s FR_ABS_A = f0, f8
       mov GR_SMALLBIASEXP = 0x0ffdd
}
{ .mfi
       nop.m 0
       // FR_ABS_B = |b|
       fmerge.s FR_ABS_B = f0, f9
       nop.i 0
}
;;

{ .mfi
       setf.exp FR_SMALLBIAS = GR_SMALLBIASEXP
       // (1) y0
       frcpa.s1 FR_Y_INV0, p6 = FR_ABS_A, FR_ABS_B
       nop.i 0
}
;;

{ .mlx
       nop.m 0
       movl GR_ROUNDCONST = 0x33a00000
}
;;

// eliminate special cases
{ .mmi
       nop.m 0
       nop.m 0
       // y pseudo-zero ?
       cmp.eq p7, p10 = GR_SIG_B, r0
}
;;

// set p7 if b +/-NAN, +/-inf, +/-0
{ .mfi
       nop.m 0
 (p10) fclass.m p7, p10 = f9, 0xe7
       nop.i 0
}
;;

{ .mfi
       mov GR_2P32 = 0x1001f
       // (2) q0 = a*y0
 (p6)  fma.s1 FR_Q0 = FR_ABS_A, FR_Y_INV0, f0
       nop.i 0
}
{ .mfi
       nop.m 0
       // (3) e0 = 1 - b * y0
 (p6)  fnma.s1 FR_E0 = FR_ABS_B, FR_Y_INV0, f1
       nop.i 0
}
;;

// set p9 if a +/-NAN, +/-inf
{ .mfi
       nop.m 0
       fclass.m.unc p9, p11 = f8, 0xe3
       nop.i 0
}
       // |a| < |b|? Return a, p8=1
{ .mfi
       nop.m 0
 (p10) fcmp.lt.unc.s1 p8, p0 = FR_ABS_A, FR_ABS_B
       nop.i 0
}
;;

// set p7 if b +/-NAN, +/-inf, +/-0
{ .mfi
       nop.m 0
       // pseudo-NaN ?
 (p10) fclass.nm p7, p0 = f9, 0xff
       nop.i 0
}
;;

// set p9 if a is +/-NaN, +/-Inf
{ .mfi
       nop.m 0
 (p11) fclass.nm p9, p0 = f8, 0xff
       nop.i 0
}
{ .mfi
       nop.m 0
       // b denormal ? set D flag (if |a|<|b|)
 (p8)  fnma.s0 FR_DFLAG = f9, f1, f9
       nop.i 0
}
;;

{ .mfi
       // FR_2P32 = 2^32
       setf.exp FR_2P32 = GR_2P32
       // (4) q1 = q0+e0*q0
 (p6)  fma.s1 FR_Q1 = FR_E0, FR_Q0, FR_Q0
       nop.i 0
}
{ .mfi
       nop.m 0
       // (5) e1 = e0 * e0 + 2^-34
 (p6)  fma.s1 FR_E1 = FR_E0, FR_E0, FR_SMALLBIAS
       nop.i 0
}
;;

{ .mfi
       nop.m 0
       // normalize a (if |a|<|b|)
 (p8)  fma.s0 f8 = f8, f1, f0
       nop.i 0
}
{ .bbb
 (p9) br.cond.spnt FMOD_A_NAN_INF
 (p7) br.cond.spnt FMOD_B_NAN_INF_ZERO
       // if |a|<|b|, return
 (p8) br.ret.spnt b0
}
;;


{ .mfi
       nop.m 0
       // (6) y1 = y0 + e0 * y0
 (p6)  fma.s1 FR_Y_INV1 = FR_E0, FR_Y_INV0, FR_Y_INV0
       nop.i 0
}
;;

{ .mfi
       nop.m 0
       // a denormal ? set D flag
       // b denormal ? set D flag
       fcmp.eq.s0 p12,p0 = FR_ABS_A, FR_ABS_B
       nop.i 0
}
{ .mfi
       // set FR_ROUNDCONST = 1.25*2^{-24}
       setf.s FR_ROUNDCONST = GR_ROUNDCONST
       // (7) q2 = q1+e1*q1
 (p6)  fma.s1 FR_Q = FR_Q1, FR_E1, FR_Q1
       nop.i 0
}
;;

{ .mfi
       nop.m 0
       fmerge.s FR_B_SGN_A = f8, f9
       nop.i 0
}
{ .mfi
       nop.m 0
       // (8) y2 = y1 + e1 * y1
 (p6)  fma.s1 FR_Y_INV = FR_E1, FR_Y_INV1, FR_Y_INV1
       // set p6 = 0, p10 = 0
       cmp.ne.and p6, p10 = r0, r0
}
;;

//   will compute integer quotient bits (24 bits per iteration)
.align 32
loop64:
{ .mfi
       nop.m 0
       // compare q2, 2^32
       fcmp.lt.unc.s1 p8, p7 = FR_Q, FR_2P32
       nop.i 0
}
{ .mfi
       nop.m 0
       // will truncate quotient to integer, if exponent<32 (in advance)
       fcvt.fx.trunc.s1 FR_QINT = FR_Q
       nop.i 0
}
;;

{ .mfi
       nop.m 0
       // if exponent>32 round quotient to single precision (perform in advance)
       fma.s.s1 FR_QRND24 = FR_Q, f1, f0
       nop.i 0
}
;;

{ .mfi
       nop.m 0
       // set FR_ROUNDCONST = sgn(a)
 (p8)  fmerge.s FR_ROUNDCONST = f8, f1
       nop.i 0
}
{ .mfi
       nop.m 0
       // normalize truncated quotient
 (p8)  fcvt.xf FR_QRND24 = FR_QINT
       nop.i 0
}
;;

{ .mfi
       nop.m 0
       // calculate remainder (assuming FR_QRND24 = RZ(Q))
 (p7)  fnma.s1 FR_E1 = FR_QRND24, FR_ABS_B, FR_ABS_A
       nop.i 0
}
{ .mfi
       nop.m 0
       // also if exponent>32, round quotient to single precision
       // and subtract 1 ulp: q = q-q*(1.25*2^{-24})
 (p7)  fnma.s.s1 FR_QINT_Z = FR_QRND24, FR_ROUNDCONST, FR_QRND24
       nop.i 0
}
;;

{ .mfi
       nop.m 0
       // (p8) calculate remainder (82-bit format)
 (p8)  fnma.s1 FR_QREM = FR_QRND24, FR_ABS_B, FR_ABS_A
       nop.i 0
}
{ .mfi
       nop.m 0
       // (p7) calculate remainder (assuming FR_QINT_Z = RZ(Q))
 (p7)  fnma.s1 FR_ABS_A = FR_QINT_Z, FR_ABS_B, FR_ABS_A
       nop.i 0
}
;;

{ .mfi
       nop.m 0
       // Final iteration (p8): is FR_ABS_A the correct remainder 
       // (quotient was not overestimated) ?
 (p8)  fcmp.lt.unc.s1 p6, p10 = FR_QREM, f0
       nop.i 0
}
;;

{ .mfi
       nop.m 0
       // get new quotient estimation: a'*y2
 (p7)  fma.s1 FR_Q = FR_E1, FR_Y_INV, f0
       nop.i 0
}
{ .mfb
       nop.m 0
       // was FR_Q = RZ(Q) ? (then new remainder FR_E1> = 0)
 (p7)  fcmp.lt.unc.s1 p7, p9 = FR_E1, f0
       nop.b 0
}
;;

.pred.rel "mutex", p6, p10
{ .mfb
       nop.m 0
       // add b to estimated remainder (to cover the case when the quotient was
       // overestimated)
       // also set correct sign by using 
       // FR_B_SGN_A = |b|*sgn(a), FR_ROUNDCONST = sgn(a)
 (p6)  fma.s0 f8 = FR_QREM, FR_ROUNDCONST, FR_B_SGN_A
       nop.b 0
}
{ .mfb
       nop.m 0
       // set correct sign of result before returning: FR_ROUNDCONST = sgn(a)
 (p10) fma.s0 f8 = FR_QREM, FR_ROUNDCONST, f0
 (p8)  br.ret.sptk b0
}
;;

{ .mfi
       nop.m 0
       // if f13! = RZ(Q), get alternative quotient estimation: a''*y2
 (p7)  fma.s1 FR_Q = FR_ABS_A, FR_Y_INV, f0
       nop.i 0
}
{ .mfb
       nop.m 0
       // if FR_E1 was RZ(Q), set remainder to FR_E1
 (p9)  fma.s1 FR_ABS_A = FR_E1, f1, f0
       br.cond.sptk loop64
}
;;

FMOD_A_NAN_INF:

// b zero ?
{ .mfi
       nop.m 0
       fclass.m p10, p0 = f8, 0xc3 // Test a = nan
       nop.i 0
}
{ .mfi
       nop.m 0
       fma.s1 FR_NORM_B = f9, f1, f0
       nop.i 0
}
;;

{ .mfi
       nop.m 0
       fma.s0 f8 = f8, f1, f0
       nop.i 0
}
{ .mfi
       nop.m 0
 (p10) fclass.m p10, p0 = f9, 0x07 // Test x = nan, and y = zero
       nop.i 0
}
;;

{ .mfb
       nop.m 0
       fcmp.eq.unc.s1 p11, p0 = FR_NORM_B, f0
 (p10) br.ret.spnt b0 // Exit with result = a if a = nan and b = zero
}
;;

{ .mib
       nop.m 0
       nop.i 0
       // if Y zero
 (p11) br.cond.spnt FMOD_B_ZERO
}
;;

// a= infinity? Return QNAN indefinite
{ .mfi
       // set p7 t0 0
       cmp.ne p7, p0 = r0, r0
       fclass.m.unc p8, p9 = f8, 0x23
       nop.i 0
}
;;

// b NaN ?
{ .mfi
       nop.m 0
 (p8)  fclass.m p9, p8 = f9, 0xc3
       nop.i 0
}
;;

// b not pseudo-zero ? (GR_SIG_B holds significand)
{ .mii
       nop.m 0
 (p8)  cmp.ne p7, p0 = GR_SIG_B, r0
       nop.i 0
}
;;

{ .mfi
       nop.m 0
 (p8)  frcpa.s0 f8, p0 = f8, f8
       nop.i 0
}
{ .mfi
       nop.m 0
       // also set Denormal flag if necessary
 (p7)  fnma.s0 f9 = f9, f1, f9
       nop.i 0
}
;;

{ .mfb
       nop.m 0
 (p8)  fma.s0 f8 = f8, f1, f0
       nop.b 0
}
;;

{ .mfb
       nop.m 0
 (p9)  frcpa.s0 f8, p7 = f8, f9
       br.ret.sptk b0
}
;;

FMOD_B_NAN_INF_ZERO:
// b INF
{ .mfi
       nop.m 0
       fclass.m.unc p7, p0 = f9, 0x23
       nop.i 0
}
;;

{ .mfb
       nop.m 0
 (p7)  fma.s0 f8 = f8, f1, f0
 (p7)  br.ret.spnt b0
}
;;

// b NAN?
{ .mfi
       nop.m 0
       fclass.m.unc p9, p10 = f9, 0xc3
       nop.i 0
}
;;

{ .mfi
       nop.m 0
 (p10) fclass.nm p9, p0 = f9, 0xff
       nop.i 0
}
;;

{ .mfb
       nop.m 0
 (p9)  fma.s0 f8 = f9, f1, f0
 (p9)  br.ret.spnt b0
}
;;

FMOD_B_ZERO:
// Y zero? Must be zero at this point
// because it is the only choice left.
// Return QNAN indefinite

{ .mfi
       nop.m 0
       // set Invalid
       frcpa.s0 FR_TMP, p0 = f0, f0
       nop.i 0
}
;;

// a NAN?
{ .mfi
       nop.m 0
       fclass.m.unc p9, p10 = f8, 0xc3
       nop.i 0
}
;;

{ .mfi
       alloc GR_ARPFS = ar.pfs, 1, 4, 4, 0
 (p10) fclass.nm p9, p10 = f8, 0xff
       nop.i 0
}
;;

{ .mfi
       nop.m 0
 (p9)  frcpa.s0 FR_TMP2, p7 = f8, f0
       nop.i 0
}
;;

{ .mfi
       nop.m 0
 (p10) frcpa.s0 FR_TMP2, p7 = f9, f9
       mov GR_Parameter_TAG = 120
}
;;

{ .mfi
       nop.m 0
       fmerge.s FR_X = f8, f8
       nop.i 0
}
{ .mfb
       nop.m 0
       fma.s0 f8 = FR_TMP2, f1, f0
       br.sptk __libm_error_region
}
;;

GLOBAL_IEEE754_END(fmodl)

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 // Save 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
       nop.b 0                      // Parameter 3 address
}
{ .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
       nop.m 0
       nop.m 0
       add GR_Parameter_RESULT = 48, sp
}
;;

{ .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#