Fix up RET instructions in sysdeps/i386/fpu

sysdeps/i386/fpu/e_powf.S

 /* ix87 specific implementation of pow function.
    Copyright (C) 1996, 1997, 1999, 2001, 2004, 2005, 2007
    Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Ulrich Drepper <drepper@cygnus.com>, 1996.
 
    The GNU C Library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.
@@ skipping 119 matching lines @@
 
 6:      shrl    $1, %edx
         jnc     5f
         fxch
         fmul    %st(1)          // x : ST*x
         fxch
 5:      fmul    %st(0), %st     // x*x : ST*x
         testl   %edx, %edx
         jnz     6b
         fstp    %st(0)          // ST*x
-        ret
+        NACLRET
 
         /* y is ±NAN */
 30:     flds    4(%esp)         // x : y
         fldl    MO(one)         // 1.0 : x : y
         fucomp  %st(1)          // x : y
         fnstsw
         sahf
         je      31f
         fxch                    // y : x
 31:     fstp    %st(1)
-        ret
+        NACLRET
 
         cfi_adjust_cfa_offset (4)
         .align ALIGNARG(4)
 2:      /* y is a real number.  */
         fxch                    // x : y
         fldl    MO(one)         // 1.0 : x : y
         fldl    MO(limit)       // 0.29 : 1.0 : x : y
         fld     %st(2)          // x : 0.29 : 1.0 : x : y
         fsub    %st(2)          // x-1 : 0.29 : 1.0 : x : y
         fabs                    // |x-1| : 0.29 : 1.0 : x : y
@@ skipping 11 matching lines @@
         fst     %st(1)          // y*log2(x) : y*log2(x)
         frndint                 // int(y*log2(x)) : y*log2(x)
         fsubr   %st, %st(1)     // int(y*log2(x)) : fract(y*log2(x))
         fxch                    // fract(y*log2(x)) : int(y*log2(x))
         f2xm1                   // 2^fract(y*log2(x))-1 : int(y*log2(x))
         faddl   MO(one)         // 2^fract(y*log2(x)) : int(y*log2(x))
         fscale                  // 2^fract(y*log2(x))*2^int(y*log2(x)) : int(y*log2(x))
         addl    $4, %esp
         cfi_adjust_cfa_offset (-4)
         fstp    %st(1)          // 2^fract(y*log2(x))*2^int(y*log2(x))
-        ret
+        NACLRET
 
 
         // pow(x,±0) = 1
         .align ALIGNARG(4)
 11:     fstp    %st(0)          // pop y
         fldl    MO(one)
-        ret
+        NACLRET
 
         // y == ±inf
         .align ALIGNARG(4)
 12:     fstp    %st(0)          // pop y
         fldl    MO(one)         // 1
         flds    4(%esp)         // x : 1
         fabs                    // abs(x) : 1
         fucompp                 // < 1, == 1, or > 1
         fnstsw
         andb    $0x45, %ah
         cmpb    $0x45, %ah
         je      13f             // jump if x is NaN
 
         cmpb    $0x40, %ah
         je      14f             // jump if |x| == 1
 
         shlb    $1, %ah
         xorb    %ah, %dl
         andl    $2, %edx
         fldl    MOX(inf_zero, %edx, 4)
-        ret
+        NACLRET
 
         .align ALIGNARG(4)
 14:     fldl    MO(one)
-        ret
+        NACLRET
 
         .align ALIGNARG(4)
 13:     flds    4(%esp)         // load x == NaN
-        ret
+        NACLRET
 
         cfi_adjust_cfa_offset (4)
         .align ALIGNARG(4)
         // x is ±inf
 15:     fstp    %st(0)          // y
         testb   $2, %dh
         jz      16f             // jump if x == +inf
 
         // We must find out whether y is an odd integer.
         fld     %st             // y : y
@@ skipping 12 matching lines @@
         jz      18f             // jump if not odd
         movl    %edx, %eax
         orl     %edx, %edx
         jns     155f
         negl    %eax
 155:    cmpl    $0x01000000, %eax
         ja      18f             // does not fit in mantissa bits
         // It's an odd integer.
         shrl    $31, %edx
         fldl    MOX(minf_mzero, %edx, 8)
-        ret
+        NACLRET
 
         cfi_adjust_cfa_offset (4)
         .align ALIGNARG(4)
 16:     fcompl  MO(zero)
         addl    $4, %esp
         cfi_adjust_cfa_offset (-4)
         fnstsw
         shrl    $5, %eax
         andl    $8, %eax
         fldl    MOX(inf_zero, %eax, 1)
-        ret
+        NACLRET
 
         cfi_adjust_cfa_offset (4)
         .align ALIGNARG(4)
 17:     shll    $30, %edx       // sign bit for y in right position
         addl    $4, %esp
         cfi_adjust_cfa_offset (-4)
 18:     shrl    $31, %edx
         fldl    MOX(inf_zero, %edx, 8)
-        ret
+        NACLRET
 
         cfi_adjust_cfa_offset (4)
         .align ALIGNARG(4)
         // x is ±0
 20:     fstp    %st(0)          // y
         testb   $2, %dl
         jz      21f             // y > 0
 
         // x is ±0 and y is < 0.  We must find out whether y is an odd integer.
         testb   $2, %dh
@@ skipping 13 matching lines @@
         cfi_adjust_cfa_offset (-4)
         testb   $1, %dl
         jz      27f             // jump if not odd
         cmpl    $0xff000000, %edx
         jbe     27f             // does not fit in mantissa bits
         // It's an odd integer.
         // Raise divide-by-zero exception and get minus infinity value.
         fldl    MO(one)
         fdivl   MO(zero)
         fchs
-        ret
+        NACLRET
 
         cfi_adjust_cfa_offset (4)
 25:     fstp    %st(0)
 26:     addl    $4, %esp
         cfi_adjust_cfa_offset (-4)
 27:     // Raise divide-by-zero exception and get infinity value.
         fldl    MO(one)
         fdivl   MO(zero)
-        ret
+        NACLRET
 
         cfi_adjust_cfa_offset (4)
         .align ALIGNARG(4)
         // x is ±0 and y is > 0.  We must find out whether y is an odd integer.
 21:     testb   $2, %dh
         jz      22f
 
         fld     %st             // y : y
         fistpl  (%esp)          // y
         fildl   (%esp)          // int(y) : y
         fucompp                 // <empty>
         fnstsw
         sahf
         jne     23f
 
         // OK, the value is an integer, but is the number of bits small
         // enough so that all are coming from the mantissa?
         popl    %edx
         cfi_adjust_cfa_offset (-4)
         testb   $1, %dl
         jz      24f             // jump if not odd
         cmpl    $0xff000000, %edx
         jae     24f             // does not fit in mantissa bits
         // It's an odd integer.
         fldl    MO(mzero)
-        ret
+        NACLRET
 
         cfi_adjust_cfa_offset (4)
 22:     fstp    %st(0)
 23:     addl    $4, %esp        // Don't use pop.
         cfi_adjust_cfa_offset (-4)
 24:     fldl    MO(zero)
-        ret
+        NACLRET
 
 END(__ieee754_powf)