Fix up RET instructions in sysdeps/i386/fpu

sysdeps/i386/fpu/s_cexpf.S

 /* ix87 specific implementation of complex exponential function for double.
    Copyright (C) 1997, 2005 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
 
    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 101 matching lines @@
         fmulp   %st, %st(3)     /* sin(y) : e^x : e^x * cos(y) */
         fmulp   %st, %st(1)     /* e^x * sin(y) : e^x * cos(y) */
         subl    $8, %esp
         cfi_adjust_cfa_offset (8)
         fstps   4(%esp)
         fstps   (%esp)
         popl    %eax
         cfi_adjust_cfa_offset (-4)
         popl    %edx
         cfi_adjust_cfa_offset (-4)
-        ret
+        NACLRET
 
         /* We have to reduce the argument to fsincos.  */
         .align ALIGNARG(4)
 7:      fldt    MO(twopi)       /* 2*pi : y : e^x : e^x */
         fxch                    /* y : 2*pi : e^x : e^x */
 8:      fprem1                  /* y%(2*pi) : 2*pi : e^x : e^x */
         fnstsw
         testl   $0x400, %eax
         jnz     8b
         fstp    %st(1)          /* y%(2*pi) : e^x : e^x */
         fsincos                 /* cos(y) : sin(y) : e^x : e^x */
         fmulp   %st, %st(3)
         fmulp   %st, %st(1)
         subl    $8, %esp
         cfi_adjust_cfa_offset (8)
         fstps   4(%esp)
         fstps   (%esp)
         popl    %eax
         cfi_adjust_cfa_offset (-4)
         popl    %edx
         cfi_adjust_cfa_offset (-4)
-        ret
+        NACLRET
 
         /* The real part is +-inf.  We must make further differences.  */
         .align ALIGNARG(4)
 1:      fxam                    /* y : x */
         fnstsw
         movb    %ah, %dl
         testb   $0x01, %ah      /* See above why 0x01 is usable here.  */
         jne     3f
 
 
@@ skipping 20 matching lines @@
         andl    $0x80000000, %eax
         orl     MOX(huge_nan_null_null,%edx,1), %eax
         movl    MOX(huge_nan_null_null,%edx,1), %ecx
         movl    %eax, %edx
         ftst
         fnstsw
         fstp    %st(0)
         shll    $23, %eax
         andl    $0x80000000, %eax
         orl     %ecx, %eax
-        ret
+        NACLRET
         /* We must reduce the argument to fsincos.  */
         .align ALIGNARG(4)
 5:      fldt    MO(twopi)
         fxch
 6:      fprem1
         fnstsw
         testl   $0x400, %eax
         jnz     6b
         fstp    %st(1)
         fsincos
         fxch
         ftst
         fnstsw
         fstp    %st(0)
         shll    $23, %eax
         andl    $0x80000000, %eax
         orl     MOX(huge_nan_null_null,%edx,1), %eax
         movl    MOX(huge_nan_null_null,%edx,1), %ecx
         movl    %eax, %edx
         ftst
         fnstsw
         fstp    %st(0)
         shll    $23, %eax
         andl    $0x80000000, %eax
         orl     %ecx, %eax
-        ret
+        NACLRET
 
         /* The real part is +-Inf and the imaginary part is +-0.  So return
            +-Inf+-0i.  */
         .align ALIGNARG(4)
 4:      subl    $4, %esp
         cfi_adjust_cfa_offset (4)
         fstps   (%esp)
         shrl    $6, %edx
         fstp    %st(0)
         andl    $8, %edx
         movl    MOX(huge_nan_null_null,%edx,1), %eax
         popl    %edx
         cfi_adjust_cfa_offset (-4)
-        ret
+        NACLRET
 
         /* The real part is +-Inf, the imaginary is also is not finite.  */
         .align ALIGNARG(4)
 3:      fstp    %st(0)
         fstp    %st(0)          /* <empty> */
         andb    $0x45, %ah
         andb    $0x47, %dh
         xorb    %dh, %ah
         jnz     30f
         flds    MO(infinity)    /* Raise invalid exception.  */
         fmuls   MO(zero)
         fstp    %st(0)
 30:     movl    %edx, %eax
         shrl    $6, %edx
         shll    $3, %eax
         andl    $8, %edx
         andl    $16, %eax
         orl     %eax, %edx
 
         movl    MOX(huge_nan_null_null,%edx,1), %eax
         movl    MOX(huge_nan_null_null+4,%edx,1), %edx
-        ret
+        NACLRET
 
         /* The real part is NaN.  */
         .align ALIGNARG(4)
 20:     flds    MO(infinity)            /* Raise invalid exception.  */
         fmuls   MO(zero)
         fstp    %st(0)
 2:      fstp    %st(0)
         fstp    %st(0)
         movl    MO(huge_nan_null_null+4), %eax
         movl    %eax, %edx
-        ret
+        NACLRET
 
 END(__cexpf)
 weak_alias (__cexpf, cexpf)