diff options
Diffstat (limited to 'sysdeps/ia64/fpu/e_scalb.S')
| -rw-r--r-- | sysdeps/ia64/fpu/e_scalb.S | 669 |
1 files changed, 317 insertions, 352 deletions
diff --git a/sysdeps/ia64/fpu/e_scalb.S b/sysdeps/ia64/fpu/e_scalb.S index 3d48aab189..7f5b5796de 100644 --- a/sysdeps/ia64/fpu/e_scalb.S +++ b/sysdeps/ia64/fpu/e_scalb.S @@ -1,10 +1,10 @@ .file "scalb.s" - -// Copyright (c) 2000 - 2003, Intel Corporation +// Copyright (C) 2000, 2001, Intel Corporation // All rights reserved. -// -// Contributed 2000 by the Intel Numerics Group, Intel Corporation +// +// Contributed 2/2/2000 by John Harrison, Ted Kubaska, Bob Norin, Shane Story, +// and Ping Tak Peter Tang of the Computational Software Lab, Intel Corporation. // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are @@ -20,83 +20,61 @@ // * 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 +// +// 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 +// 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 +// 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. -// +// 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. +// problem reports or change requests be submitted to it directly at +// http://developer.intel.com/opensource. // // History //============================================================== -// 02/02/00 Initial version -// 01/26/01 Scalb completely reworked and now standalone version -// 05/20/02 Cleaned up namespace and sf0 syntax -// 02/10/03 Reordered header: .section, .global, .proc, .align -// 08/06/03 Improved performance +// 2/02/00 Initial version +// 1/26/01 Scalb completely reworked and now standalone version // // API //============================================================== -// double = scalb (double x, double n) +// double = scalb (double x, double n) // input floating point f8 and floating point f9 // output floating point f8 // -// int_type = 0 if int is 32 bits -// int_type = 1 if int is 64 bits -// // Returns x* 2**n using an fma and detects overflow -// and underflow. +// and underflow. // // -// Strategy: -// Compute biased exponent of result exp_Result = N + exp_X -// Break into ranges: -// exp_Result > 0x103fe -> Certain overflow -// exp_Result = 0x103fe -> Possible overflow -// 0x0fc01 <= exp_Result < 0x103fe -> No over/underflow (main path) -// 0x0fc01 - 52 <= exp_Result < 0x0fc01 -> Possible underflow -// exp_Result < 0x0fc01 - 52 -> Certain underflow -FR_Big = f6 -FR_NBig = f7 +#include "libm_support.h" + FR_Floating_X = f8 FR_Result = f8 FR_Floating_N = f9 FR_Result2 = f9 -FR_Result3 = f10 -FR_Norm_X = f11 -FR_Two_N = f12 +FR_Norm_N = f10 +FR_Result3 = f11 +FR_Norm_X = f12 FR_N_float_int = f13 -FR_Norm_N = f14 +FR_Two_N = f14 +FR_Two_to_Big = f15 +FR_Big = f6 +FR_NBig = f7 -GR_neg_ov_limit= r14 -GR_big_exp = r14 GR_N_Biased = r15 GR_Big = r16 -GR_exp_Result = r18 -GR_pos_ov_limit= r19 -GR_exp_sure_ou = r19 +GR_NBig = r17 +GR_Scratch = r18 +GR_Scratch1 = r19 GR_Bias = r20 GR_N_as_int = r21 -GR_signexp_X = r22 -GR_exp_X = r23 -GR_exp_mask = r24 -GR_max_exp = r25 -GR_min_exp = r26 -GR_min_den_exp = r27 -GR_Scratch = r28 -GR_signexp_N = r29 -GR_exp_N = r30 GR_SAVE_B0 = r32 GR_SAVE_GP = r33 @@ -106,447 +84,433 @@ GR_Parameter_Y = r36 GR_Parameter_RESULT = r37 GR_Tag = r38 +.align 32 +.global scalb + .section .text -GLOBAL_IEEE754_ENTRY(scalb) +.proc scalb +.align 32 + +scalb: +#ifdef _LIBC +.global __ieee754_scalb +.type __ieee754_scalb,@function +__ieee754_scalb: +#endif // // Is x NAN, INF, ZERO, +-? -// Build the exponent Bias // { .mfi - getf.exp GR_signexp_N = FR_Floating_N // Get signexp of n - fclass.m p6,p0 = FR_Floating_X, 0xe7 // @snan | @qnan | @inf | @zero - mov GR_Bias = 0x0ffff -} -{ .mfi - mov GR_Big = 35000 // If N this big then certain overflow - fcvt.fx.trunc.s1 FR_N_float_int = FR_Floating_N // Get N in significand - nop.i 0 -} -;; - -{ .mfi - getf.exp GR_signexp_X = FR_Floating_X // Get signexp of x - fclass.m p7,p0 = FR_Floating_N, 0x0b // Test for n=unorm - nop.i 0 + alloc r32=ar.pfs,0,3,4,0 + fclass.m.unc p7,p0 = FR_Floating_X, 0xe7 //@snan | @qnan | @inf | @zero + addl GR_Scratch = 0x019C3F,r0 } // -// Normalize n +// Is y a NAN, INF, ZERO, +-? // { .mfi - mov GR_exp_mask = 0x1ffff // Exponent mask - fnorm.s1 FR_Norm_N = FR_Floating_N - nop.i 0 + nop.m 999 + fclass.m.unc p6,p0 = FR_Floating_N, 0xe7 //@snan | @qnan | @inf | @zero + addl GR_Scratch1 = 0x063BF,r0 } ;; // -// Is n NAN, INF, ZERO, +-? +// Convert N to a fp integer +// Normalize x // { .mfi - mov GR_big_exp = 0x1003e // Exponent at which n is integer - fclass.m p9,p0 = FR_Floating_N, 0xe7 // @snan | @qnan | @inf | @zero - mov GR_max_exp = 0x103fe // Exponent of maximum double + nop.m 0 + fnorm.s1 FR_Norm_N = FR_Floating_N + nop.i 999 } +{ .mfi + nop.m 999 + fnorm.s1 FR_Norm_X = FR_Floating_X + nop.i 999 +};; + // +// Create 2*big +// Create 2**-big // Normalize x +// Branch on special values. // -{ .mfb - nop.m 0 - fnorm.s1 FR_Norm_X = FR_Floating_X -(p7) br.cond.spnt SCALB_N_UNORM // Branch if n=unorm -} -;; - -SCALB_COMMON1: -// Main path continues. Also return here from u=unorm path. -// Handle special cases if x = Nan, Inf, Zero -{ .mfb - nop.m 0 - fcmp.lt.s1 p7,p0 = FR_Floating_N, f0 // Test N negative -(p6) br.cond.spnt SCALB_NAN_INF_ZERO +{ .mib + setf.exp FR_Big = GR_Scratch + nop.i 0 +(p6) br.cond.spnt L(SCALB_NAN_INF_ZERO) } -;; +{ .mib + setf.exp FR_NBig = GR_Scratch1 + nop.i 0 +(p7) br.cond.spnt L(SCALB_NAN_INF_ZERO) +};; -// Handle special cases if n = Nan, Inf, Zero +// +// Convert N to a fp integer +// Create -35000 +// { .mfi - getf.sig GR_N_as_int = FR_N_float_int // Get n from significand - fclass.m p8,p0 = FR_Floating_X, 0x0b // Test for x=unorm - mov GR_exp_sure_ou = 0x1000e // Exp_N where x*2^N sure over/under -} -{ .mfb - mov GR_min_exp = 0x0fc01 // Exponent of minimum double - fcvt.xf FR_N_float_int = FR_N_float_int // Convert N to FP integer -(p9) br.cond.spnt SCALB_NAN_INF_ZERO -} -;; - -{ .mmi - and GR_exp_N = GR_exp_mask, GR_signexp_N // Get exponent of N -(p7) sub GR_Big = r0, GR_Big // Limit for N - nop.i 0 + addl GR_Scratch = 1,r0 + fcvt.fx.trunc.s1 FR_N_float_int = FR_Norm_N + addl GR_NBig = -35000,r0 } ;; -{ .mib - cmp.lt p9,p0 = GR_exp_N, GR_big_exp // N possible non-integer? - cmp.ge p6,p0 = GR_exp_N, GR_exp_sure_ou // N certain over/under? -(p8) br.cond.spnt SCALB_X_UNORM // Branch if x=unorm +// +// Put N if a GP register +// Convert N_float_int to floating point value +// Create 35000 +// Build the exponent Bias +// +{ .mii + getf.sig GR_N_as_int = FR_N_float_int + shl GR_Scratch = GR_Scratch,63 + addl GR_Big = 35000,r0 } -;; +{ .mfi + addl GR_Bias = 0x0FFFF,r0 + fcvt.xf FR_N_float_int = FR_N_float_int + nop.i 0 +};; -SCALB_COMMON2: -// Main path continues. Also return here from x=unorm path. -// Create biased exponent for 2**N -{ .mmi -(p6) mov GR_N_as_int = GR_Big // Limit N -;; - add GR_N_Biased = GR_Bias,GR_N_as_int - nop.i 0 +// +// Catch those fp values that are beyond 2**64-1 +// Is N > 35000 +// Is N < -35000 +// +{ .mfi + cmp.ne.unc p9,p10 = GR_N_as_int,GR_Scratch + nop.f 0 + nop.i 0 } -;; +{ .mmi + cmp.ge.unc p6, p0 = GR_N_as_int, GR_Big + cmp.le.unc p8, p0 = GR_N_as_int, GR_NBig + nop.i 0 +};; +// +// Is N really an int, only for those non-int indefinites? +// Create exp bias. +// { .mfi - setf.exp FR_Two_N = GR_N_Biased // Form 2**N -(p9) fcmp.neq.unc.s1 p9,p0 = FR_Norm_N, FR_N_float_int // Test if N an integer - and GR_exp_X = GR_exp_mask, GR_signexp_X // Get exponent of X -} -;; + add GR_N_Biased = GR_Bias,GR_N_as_int +(p9) fcmp.neq.unc.s1 p7,p0 = FR_Norm_N, FR_N_float_int + nop.i 0 +};; // -// Compute biased result exponent -// Branch if N is not an integer +// Branch and return if N is not an int. +// Main path, create 2**N // -{ .mib - add GR_exp_Result = GR_exp_X, GR_N_as_int - mov GR_min_den_exp = 0x0fc01 - 52 // Exponent of min denorm dble -(p9) br.cond.spnt SCALB_N_NOT_INT +{ .mfi + setf.exp FR_Two_N = GR_N_Biased + nop.i 999 } -;; +{ .mfb + nop.m 0 +(p7) frcpa f8,p11 = f0,f0 +(p7) br.ret.spnt b0 +};; // -// Raise Denormal operand flag with compare -// Do final operation +// Set denormal on denormal input x and denormal input N // { .mfi - cmp.lt p7,p6 = GR_exp_Result, GR_max_exp // Test no overflow - fcmp.ge.s0 p0,p11 = FR_Floating_X,FR_Floating_N // Dummy to set denorm - cmp.lt p9,p0 = GR_exp_Result, GR_min_den_exp // Test sure underflow -} -{ .mfb - nop.m 0 - fma.d.s0 FR_Result = FR_Two_N,FR_Norm_X,f0 -(p9) br.cond.spnt SCALB_UNDERFLOW // Branch if certain underflow + nop.m 999 +(p10)fcmp.ge.s1 p6,p8 = FR_Norm_N,f0 + nop.i 0 +};; +{ .mfi + nop.m 999 + fcmp.ge.s0 p0,p11 = FR_Floating_X,f0 + nop.i 999 } -;; +{ .mfi + nop.m 999 + fcmp.ge.s0 p12,p13 = FR_Floating_N,f0 + nop.i 0 +};; -{ .mib -(p6) cmp.gt.unc p6,p8 = GR_exp_Result, GR_max_exp // Test sure overflow -(p7) cmp.ge.unc p7,p9 = GR_exp_Result, GR_min_exp // Test no over/underflow -(p7) br.ret.sptk b0 // Return from main path -} -;; +// +// Adjust 2**N if N was very small or very large +// -{ .bbb -(p6) br.cond.spnt SCALB_OVERFLOW // Branch if certain overflow -(p8) br.cond.spnt SCALB_POSSIBLE_OVERFLOW // Branch if possible overflow -(p9) br.cond.spnt SCALB_POSSIBLE_UNDERFLOW // Branch if possible underflow +{ .mfi + nop.m 0 +(p6) fma.s1 FR_Two_N = FR_Big,f1,f0 + nop.i 0 } -;; - -// Here if possible underflow. -// Resulting exponent: 0x0fc01-52 <= exp_Result < 0x0fc01 -SCALB_POSSIBLE_UNDERFLOW: -// -// Here if possible overflow. -// Resulting exponent: 0x103fe = exp_Result -SCALB_POSSIBLE_OVERFLOW: +{ .mlx + nop.m 999 +(p0) movl GR_Scratch = 0x00000000000303FF +};; +{ .mfi + nop.m 0 +(p8) fma.s1 FR_Two_N = FR_NBig,f1,f0 + nop.i 0 +} +{ .mlx + nop.m 999 +(p0) movl GR_Scratch1= 0x00000000000103FF +};; -// Set up necessary status fields +// Set up necessary status fields // // S0 user supplied status // S2 user supplied status + WRE + TD (Overflows) // S3 user supplied status + FZ + TD (Underflows) // { .mfi - mov GR_pos_ov_limit = 0x103ff // Exponent for positive overflow - fsetc.s3 0x7F,0x41 - nop.i 0 + nop.m 999 +(p0) fsetc.s3 0x7F,0x41 + nop.i 999 } { .mfi - mov GR_neg_ov_limit = 0x303ff // Exponent for negative overflow - fsetc.s2 0x7F,0x42 - nop.i 0 -} -;; + nop.m 999 +(p0) fsetc.s2 0x7F,0x42 + nop.i 999 +};; // -// Do final operation with s2 and s3 +// Do final operation // { .mfi - setf.exp FR_NBig = GR_neg_ov_limit - fma.d.s3 FR_Result3 = FR_Two_N,FR_Norm_X,f0 - nop.i 0 + setf.exp FR_NBig = GR_Scratch + fma.d.s0 FR_Result = FR_Two_N,FR_Norm_X,f0 + nop.i 999 } { .mfi - setf.exp FR_Big = GR_pos_ov_limit - fma.d.s2 FR_Result2 = FR_Two_N,FR_Norm_X,f0 - nop.i 0 -} -;; + nop.m 999 + fma.d.s3 FR_Result3 = FR_Two_N,FR_Norm_X,f0 + nop.i 999 +};; +{ .mfi + setf.exp FR_Big = GR_Scratch1 + fma.d.s2 FR_Result2 = FR_Two_N,FR_Norm_X,f0 + nop.i 999 +};; // Check for overflow or underflow. +// +// S0 user supplied status +// S2 user supplied status + WRE + TD (Overflow) +// S3 user supplied status + FZ + TD (Underflow) +// +// // Restore s3 // Restore s2 // { .mfi - nop.m 0 - fsetc.s3 0x7F,0x40 - nop.i 0 + nop.m 0 + fsetc.s3 0x7F,0x40 + nop.i 999 } { .mfi - nop.m 0 - fsetc.s2 0x7F,0x40 - nop.i 0 -} -;; + nop.m 0 + fsetc.s2 0x7F,0x40 + nop.i 999 +};; // // Is the result zero? // { .mfi - nop.m 0 - fclass.m p6, p0 = FR_Result3, 0x007 - nop.i 0 -} + nop.m 999 + fclass.m.unc p6, p0 = FR_Result3, 0x007 + nop.i 999 +} { .mfi - nop.m 0 - fcmp.ge.s1 p7, p8 = FR_Result2 , FR_Big - nop.i 0 -} -;; + addl GR_Tag = 53, r0 + fcmp.ge.unc.s1 p7, p8 = FR_Result2 , FR_Big + nop.i 0 +};; // // Detect masked underflow - Tiny + Inexact Only // { .mfi - nop.m 0 + nop.m 999 (p6) fcmp.neq.unc.s1 p6, p0 = FR_Result , FR_Result2 - nop.i 0 -} -;; + nop.i 999 +};; // // Is result bigger the allowed range? // Branch out for underflow // { .mfb - nop.m 0 +(p6) addl GR_Tag = 54, r0 (p8) fcmp.le.unc.s1 p9, p10 = FR_Result2 , FR_NBig -(p6) br.cond.spnt SCALB_UNDERFLOW -} -;; +(p6) br.cond.spnt L(SCALB_UNDERFLOW) +};; // // Branch out for overflow // -{ .bbb -(p7) br.cond.spnt SCALB_OVERFLOW -(p9) br.cond.spnt SCALB_OVERFLOW - br.ret.sptk b0 // Return from main path. -} -;; - -// Here if result overflows -SCALB_OVERFLOW: -{ .mib - alloc r32=ar.pfs,3,0,4,0 - addl GR_Tag = 53, r0 // Set error tag for overflow - br.cond.sptk __libm_error_region // Call error support for overflow -} -;; +{ .mbb + nop.m 0 +(p7) br.cond.spnt L(SCALB_OVERFLOW) +(p9) br.cond.spnt L(SCALB_OVERFLOW) +};; -// Here if result underflows -SCALB_UNDERFLOW: -{ .mib - alloc r32=ar.pfs,3,0,4,0 - addl GR_Tag = 54, r0 // Set error tag for underflow - br.cond.sptk __libm_error_region // Call error support for underflow +// +// Return from main path. +// +{ .mfb + nop.m 999 + nop.f 0 + br.ret.sptk b0;; } -;; -SCALB_NAN_INF_ZERO: +L(SCALB_NAN_INF_ZERO): // -// Before entry, N has been converted to a fp integer in significand of -// FR_N_float_int -// -// Convert N_float_int to floating point value -// +// Convert N to a fp integer +// { .mfi - getf.sig GR_N_as_int = FR_N_float_int - fclass.m p6,p0 = FR_Floating_N, 0xc3 //@snan | @qnan - nop.i 0 + addl GR_Scratch = 1,r0 + fcvt.fx.trunc.s1 FR_N_float_int = FR_Norm_N + nop.i 999 } { .mfi - addl GR_Scratch = 1,r0 - fcvt.xf FR_N_float_int = FR_N_float_int - nop.i 0 -} -;; - -{ .mfi - nop.m 0 - fclass.m p7,p0 = FR_Floating_X, 0xc3 //@snan | @qnan - shl GR_Scratch = GR_Scratch,63 -} -;; - + nop.m 0 + fclass.m.unc p6,p0 = FR_Floating_N, 0xc3 //@snan | @qnan + nop.i 0 +};; { .mfi - nop.m 0 - fclass.m p8,p0 = FR_Floating_N, 0x21 // @inf - nop.i 0 -} + nop.m 0 + fclass.m.unc p7,p0 = FR_Floating_X, 0xc3 //@snan | @qnan + shl GR_Scratch = GR_Scratch,63 +};; { .mfi - nop.m 0 - fclass.m p9,p0 = FR_Floating_N, 0x22 // @-inf - nop.i 0 -} -;; + nop.m 0 + fclass.m.unc p8,p0 = FR_Floating_N, 0x21 // @inf + nop.i 0 +} + { .mfi + nop.m 0 + fclass.m.unc p9,p0 = FR_Floating_N, 0x22 // @-inf + nop.i 0 +};; // // Either X or N is a Nan, return result and possible raise invalid. // { .mfb - nop.m 0 -(p6) fma.d.s0 FR_Result = FR_Floating_N,FR_Floating_X,f0 + nop.m 0 +(p6) fma.d.s0 FR_Result = FR_Floating_N,FR_Floating_X,f0 (p6) br.ret.spnt b0 -} -;; - +};; { .mfb - nop.m 0 -(p7) fma.d.s0 FR_Result = FR_Floating_N,FR_Floating_X,f0 + getf.sig GR_N_as_int = FR_N_float_int +(p7) fma.d.s0 FR_Result = FR_Floating_N,FR_Floating_X,f0 (p7) br.ret.spnt b0 -} -;; +};; // // If N + Inf do something special // For N = -Inf, create Int // { .mfb - nop.m 0 -(p8) fma.d.s0 FR_Result = FR_Floating_X, FR_Floating_N,f0 -(p8) br.ret.spnt b0 + nop.m 0 +(p8) fma.d.s0 FR_Result = FR_Floating_X, FR_Floating_N,f0 +(p8) br.ret.spnt b0 } { .mfi - nop.m 0 -(p9) fnma.d.s0 FR_Floating_N = FR_Floating_N, f1, f0 - nop.i 0 -} -;; + nop.m 0 +(p9) fnma.d.s0 FR_Floating_N = FR_Floating_N, f1, f0 + nop.i 0 +};; // // If N==-Inf,return x/(-N) // { .mfb - cmp.ne p7,p0 = GR_N_as_int,GR_Scratch -(p9) frcpa.s0 FR_Result,p0 = FR_Floating_X,FR_Floating_N -(p9) br.ret.spnt b0 -} -;; + nop.m 0 +(p9) frcpa.s0 FR_Result,p6 = FR_Floating_X,FR_Floating_N +(p9) br.ret.spnt b0 +};; + +// +// Convert N_float_int to floating point value +// +{ .mfi + cmp.ne.unc p9,p0 = GR_N_as_int,GR_Scratch + fcvt.xf FR_N_float_int = FR_N_float_int + nop.i 0 +};; // // Is N an integer. // { .mfi - nop.m 0 -(p7) fcmp.neq.unc.s1 p7,p0 = FR_Norm_N, FR_N_float_int - nop.i 0 -} -;; + nop.m 0 +(p9) fcmp.neq.unc.s1 p7,p0 = FR_Norm_N, FR_N_float_int + nop.i 0 +};; // // If N not an int, return NaN and raise invalid. // { .mfb - nop.m 0 -(p7) frcpa.s0 FR_Result,p0 = f0,f0 -(p7) br.ret.spnt b0 -} -;; + nop.m 0 +(p7) frcpa.s0 FR_Result,p6 = f0,f0 +(p7) br.ret.spnt b0 +};; // -// Always return x in other path. +// Always return x in other path. // { .mfb - nop.m 0 - fma.d.s0 FR_Result = FR_Floating_X,f1,f0 - br.ret.sptk b0 -} -;; - -// Here if n not int -// Return NaN and raise invalid. -SCALB_N_NOT_INT: -{ .mfb - nop.m 0 - frcpa.s0 FR_Result,p0 = f0,f0 - br.ret.sptk b0 -} -;; - -// Here if n=unorm -SCALB_N_UNORM: -{ .mfb - getf.exp GR_signexp_N = FR_Norm_N // Get signexp of normalized n - fcvt.fx.trunc.s1 FR_N_float_int = FR_Norm_N // Get N in significand - br.cond.sptk SCALB_COMMON1 // Return to main path -} -;; + nop.m 0 + fma.d.s0 FR_Result = FR_Floating_X,f1,f0 + br.ret.sptk b0 +};; -// Here if x=unorm -SCALB_X_UNORM: -{ .mib - getf.exp GR_signexp_X = FR_Norm_X // Get signexp of normalized x - nop.i 0 - br.cond.sptk SCALB_COMMON2 // Return to main path -} -;; +.endp scalb +ASM_SIZE_DIRECTIVE(scalb) +#ifdef _LIBC +ASM_SIZE_DIRECTIVE(__ieee754_scalb) +#endif +.proc __libm_error_region +__libm_error_region: -GLOBAL_IEEE754_END(scalb) -LOCAL_LIBM_ENTRY(__libm_error_region) +L(SCALB_OVERFLOW): +L(SCALB_UNDERFLOW): // // Get stack address of N // .prologue { .mfi - add GR_Parameter_Y=-32,sp + add GR_Parameter_Y=-32,sp nop.f 0 .save ar.pfs,GR_SAVE_PFS - mov GR_SAVE_PFS=ar.pfs + mov GR_SAVE_PFS=ar.pfs } // -// Adjust sp +// Adjust sp // { .mfi .fframe 64 - add sp=-64,sp + add sp=-64,sp nop.f 0 - mov GR_SAVE_GP=gp + mov GR_SAVE_GP=gp };; // -// Store N on stack in correct position +// Store N on stack in correct position // Locate the address of x on stack // { .mmi - stfd [GR_Parameter_Y] = FR_Norm_N,16 - add GR_Parameter_X = 16,sp + stfd [GR_Parameter_Y] = FR_Norm_N,16 + add GR_Parameter_X = 16,sp .save b0, GR_SAVE_B0 - mov GR_SAVE_B0=b0 + mov GR_SAVE_B0=b0 };; // @@ -555,45 +519,46 @@ LOCAL_LIBM_ENTRY(__libm_error_region) // .body { .mib - stfd [GR_Parameter_X] = FR_Norm_X - add GR_Parameter_RESULT = 0,GR_Parameter_Y + stfd [GR_Parameter_X] = FR_Norm_X + add GR_Parameter_RESULT = 0,GR_Parameter_Y nop.b 0 } { .mib - stfd [GR_Parameter_Y] = FR_Result + stfd [GR_Parameter_Y] = FR_Result add GR_Parameter_Y = -16,GR_Parameter_Y - br.call.sptk b0=__libm_error_support# + br.call.sptk b0=__libm_error_support# };; // // Get location of result on stack // { .mmi - add GR_Parameter_RESULT = 48,sp nop.m 0 - nop.i 0 + nop.m 0 + add GR_Parameter_RESULT = 48,sp };; // -// Get the new result +// Get the new result // { .mmi - ldfd FR_Result = [GR_Parameter_RESULT] + ldfd FR_Result = [GR_Parameter_RESULT] .restore sp - add sp = 64,sp - mov b0 = GR_SAVE_B0 + add sp = 64,sp + mov b0 = GR_SAVE_B0 };; // // Restore gp, ar.pfs and return // { .mib - mov gp = GR_SAVE_GP - mov ar.pfs = GR_SAVE_PFS - br.ret.sptk b0 + mov gp = GR_SAVE_GP + mov ar.pfs = GR_SAVE_PFS + br.ret.sptk b0 };; -LOCAL_LIBM_END(__libm_error_region) +.endp __libm_error_region +ASM_SIZE_DIRECTIVE(__libm_error_region) .type __libm_error_support#,@function .global __libm_error_support# |