(CFLAGS-tst-align.c): Add -mpreferred-stack-boundary=4.

1 files changed, 317 insertions, 352 deletions

diff --git a/sysdeps/ia64/fpu/e_scalbl.S b/sysdeps/ia64/fpu/e_scalbl.S
index 9b6467ff20..43eac7a2ad 100644
--- a/sysdeps/ia64/fpu/e_scalbl.S
+++ b/sysdeps/ia64/fpu/e_scalbl.S
@@ -1,10 +1,10 @@
 .file "scalbl.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
 //==============================================================
-// long double = scalbl  (long double x, long double n)
+// double-extended = scalbl  (double-extended x, double-extended 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 > 0x13ffe                 -> Certain overflow
-//   exp_Result = 0x13ffe                 -> Possible overflow
-//   0x0c001 <= exp_Result < 0x13ffe      -> No over/underflow (main path)
-//   0x0c001 - 63 <= exp_Result < 0x0c001 -> Possible underflow
-//   exp_Result < 0x0c001 - 63            -> 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 scalbl
+
 .section .text
-GLOBAL_IEEE754_ENTRY(scalbl)
+.proc  scalbl
+.align 32
+
+scalbl: 
+#ifdef _LIBC
+.global __ieee754_scalbl
+.type __ieee754_scalbl,@function
+__ieee754_scalbl:
+#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 = 0x13ffe      // Exponent of maximum long 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  SCALBL_N_UNORM             // Branch if n=unorm
-}
-;;
-
-SCALBL_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  SCALBL_NAN_INF_ZERO
+{ .mib
+     setf.exp      FR_Big = GR_Scratch                  
+     nop.i 0 
+(p6) br.cond.spnt  L(SCALBL_NAN_INF_ZERO) 
 }
-;;
+{ .mib
+     setf.exp      FR_NBig = GR_Scratch1                  
+     nop.i 0 
+(p7) br.cond.spnt  L(SCALBL_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 = 0x0c001      // Exponent of minimum long double
-     fcvt.xf       FR_N_float_int = FR_N_float_int // Convert N to FP integer
-(p9) br.cond.spnt  SCALBL_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  SCALBL_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
+};;
 
-SCALBL_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 = 0x0c001 - 63 // Exp of min denorm long dble
-(p9) br.cond.spnt  SCALBL_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.s0        FR_Result = FR_Two_N,FR_Norm_X,f0
-(p9) br.cond.spnt  SCALBL_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  SCALBL_OVERFLOW            // Branch if certain overflow
-(p8) br.cond.spnt  SCALBL_POSSIBLE_OVERFLOW   // Branch if possible overflow
-(p9) br.cond.spnt  SCALBL_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: 0x0c001-63 <= exp_Result < 0x0c001
-SCALBL_POSSIBLE_UNDERFLOW:
-//
-// Here if possible overflow.
-// Resulting exponent: 0x13ffe = exp_Result
-SCALBL_POSSIBLE_OVERFLOW:
+{ .mlx
+     nop.m 999
+(p0) movl GR_Scratch = 0x0000000000033FFF 
+};;
+{    .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= 0x0000000000013FFF 
+};;
 
-//   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 = 0x13fff // 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 = 0x33fff // 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.s3        FR_Result3 = FR_Two_N,FR_Norm_X,f0
-     nop.i         0
+     setf.exp FR_NBig = GR_Scratch
+     fma.s0     FR_Result = FR_Two_N,FR_Norm_X,f0 
+     nop.i                           999
 }
 {    .mfi
-     setf.exp      FR_Big = GR_pos_ov_limit
-     fma.s2        FR_Result2 = FR_Two_N,FR_Norm_X,f0
-     nop.i         0
-}
-;;
+     nop.m                           999
+     fma.s3     FR_Result3 = FR_Two_N,FR_Norm_X,f0 
+     nop.i                           999
+};;
+{    .mfi
+     setf.exp FR_Big = GR_Scratch1
+     fma.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 = 51, 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 = 52, r0
 (p8) fcmp.le.unc.s1 p9, p10 = FR_Result2 , FR_NBig
-(p6) br.cond.spnt   SCALBL_UNDERFLOW
-}
-;;
+(p6) br.cond.spnt L(SCALBL_UNDERFLOW) 
+};;
 
 //
 //   Branch out for overflow
 //
-{ .bbb
-(p7) br.cond.spnt   SCALBL_OVERFLOW
-(p9) br.cond.spnt   SCALBL_OVERFLOW
-     br.ret.sptk    b0             //   Return from main path.
-}
-;;
-
-// Here if result overflows
-SCALBL_OVERFLOW:
-{ .mib
-     alloc         r32=ar.pfs,3,0,4,0
-     addl          GR_Tag = 51, 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(SCALBL_OVERFLOW) 
+(p9) br.cond.spnt L(SCALBL_OVERFLOW) 
+};;
 
-// Here if result underflows
-SCALBL_UNDERFLOW:
-{ .mib
-     alloc         r32=ar.pfs,3,0,4,0
-     addl          GR_Tag = 52, 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;;                   
 }
-;;
 
-SCALBL_NAN_INF_ZERO:
+L(SCALBL_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.s0       FR_Result = FR_Floating_N,FR_Floating_X,f0
+     nop.m 0
+(p6) fma.s0     FR_Result = FR_Floating_N,FR_Floating_X,f0 
 (p6) br.ret.spnt  b0
-}
-;;
-
+};;
 {    .mfb
-     nop.m        0
-(p7) fma.s0       FR_Result = FR_Floating_N,FR_Floating_X,f0
+     getf.sig     GR_N_as_int = FR_N_float_int
+(p7) fma.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.s0       FR_Result = FR_Floating_X, FR_Floating_N,f0
-(p8) br.ret.spnt  b0
+     nop.m 0
+(p8) fma.s0    FR_Result = FR_Floating_X, FR_Floating_N,f0 
+(p8) br.ret.spnt   b0
 }
 {    .mfi
-     nop.m        0
-(p9) fnma.s0      FR_Floating_N = FR_Floating_N, f1, f0
-     nop.i        0
-}
-;;
+     nop.m 0
+(p9) fnma.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.s0       FR_Result = FR_Floating_X,f1,f0
-     br.ret.sptk  b0
-}
-;;
-
-// Here if n not int
-// Return NaN and raise invalid.
-SCALBL_N_NOT_INT:
-{    .mfb
-     nop.m        0
-     frcpa.s0     FR_Result,p0 = f0,f0
-     br.ret.sptk  b0
-}
-;;
-
-// Here if n=unorm
-SCALBL_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  SCALBL_COMMON1            // Return to main path
-}
-;;
+     nop.m 0
+     fma.s0      FR_Result = FR_Floating_X,f1,f0 
+     br.ret.sptk   b0
+};;
 
-// Here if x=unorm
-SCALBL_X_UNORM:
-{ .mib
-     getf.exp      GR_signexp_X = FR_Norm_X // Get signexp of normalized x
-     nop.i         0
-     br.cond.sptk  SCALBL_COMMON2            // Return to main path
-}
-;;
+.endp scalbl
+ASM_SIZE_DIRECTIVE(scalbl)
+#ifdef _LIBC
+ASM_SIZE_DIRECTIVE(__ieee754_scalbl)
+#endif
+.proc __libm_error_region
+__libm_error_region:
 
-GLOBAL_IEEE754_END(scalbl)
-LOCAL_LIBM_ENTRY(__libm_error_region)
+L(SCALBL_OVERFLOW): 
+L(SCALBL_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
-   stfe [GR_Parameter_Y] = FR_Norm_N,16
-   add GR_Parameter_X = 16,sp
+   stfe [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
-   stfe [GR_Parameter_X] = FR_Norm_X
-   add   GR_Parameter_RESULT = 0,GR_Parameter_Y
+   stfe [GR_Parameter_X] = FR_Norm_X 
+   add   GR_Parameter_RESULT = 0,GR_Parameter_Y   
    nop.b 0
 }
 { .mib
-   stfe [GR_Parameter_Y] = FR_Result
+   stfe [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
-   ldfe  FR_Result = [GR_Parameter_RESULT]
+   ldfe  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#