soft-fp updated from GLIBC upstream.

From-SVN: r193540

diff --git a/libgcc/ChangeLog b/libgcc/ChangeLog
index 0458afe..1cd6f9f 100644 (file)
--- a/libgcc/ChangeLog
+++ b/libgcc/ChangeLog
@@ -1,3 +1,7 @@
+2012-11-15  Marcus Shawcroft <marcus.shawcroft@arm.com>
+
+       * soft-fp: Updated from glibc upstream.
+
 2012-11-06  Ian Lance Taylor  <iant@google.com>
 
        * generic-morestack.c (__generic_morestack): Align the returned

diff --git a/libgcc/soft-fp/op-common.h b/libgcc/soft-fp/op-common.h
index b70026f..12fb16e 100644 (file)
--- a/libgcc/soft-fp/op-common.h
+++ b/libgcc/soft-fp/op-common.h
@@ -1,5 +1,5 @@
 /* Software floating-point emulation. Common operations.
-   Copyright (C) 1997,1998,1999,2006,2007 Free Software Foundation, Inc.
+   Copyright (C) 1997,1998,1999,2006,2007,2012 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Richard Henderson (rth@cygnus.com),
                  Jakub Jelinek (jj@ultra.linux.cz),
@@ -134,6 +134,12 @@ do {                                                                       \
 #define _FP_PACK_SEMIRAW(fs, wc, X)                            \
 do {                                                           \
   _FP_ROUND(wc, X);                                            \
+  if (X##_e == 0 && !_FP_FRAC_ZEROP_##wc(X))                   \
+       { \
+         if ((FP_CUR_EXCEPTIONS & FP_EX_INEXACT)               \
+             || (FP_TRAPPING_EXCEPTIONS & FP_EX_UNDERFLOW))    \
+           FP_SET_EXCEPTION(FP_EX_UNDERFLOW);                  \
+       } \
   if (_FP_FRAC_HIGH_##fs(X)                                    \
       & (_FP_OVERFLOW_##fs >> 1))                              \
     {                                                          \
@@ -143,20 +149,15 @@ do {                                                              \
        _FP_OVERFLOW_SEMIRAW(fs, wc, X);                        \
     }                                                          \
   _FP_FRAC_SRL_##wc(X, _FP_WORKBITS);                          \
-  if (!_FP_EXP_NORMAL(fs, wc, X) && !_FP_FRAC_ZEROP_##wc(X))   \
+  if (X##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc(X))     \
     {                                                          \
-      if (X##_e == 0)                                          \
-       FP_SET_EXCEPTION(FP_EX_UNDERFLOW);                      \
-      else                                                     \
+      if (!_FP_KEEPNANFRACP)                                   \
        {                                                       \
-         if (!_FP_KEEPNANFRACP)                                \
-           {                                                   \
-             _FP_FRAC_SET_##wc(X, _FP_NANFRAC_##fs);           \
-             X##_s = _FP_NANSIGN_##fs;                         \
-           }                                                   \
-         else                                                  \
-           _FP_FRAC_HIGH_RAW_##fs(X) |= _FP_QNANBIT_##fs;      \
+         _FP_FRAC_SET_##wc(X, _FP_NANFRAC_##fs);               \
+         X##_s = _FP_NANSIGN_##fs;                             \
        }                                                       \
+      else                                                     \
+       _FP_FRAC_HIGH_RAW_##fs(X) |= _FP_QNANBIT_##fs;          \
     }                                                          \
 } while (0)
 
@@ -226,13 +227,16 @@ do {                                                              \
              {                                                 \
                X##_e = 1;                                      \
                _FP_FRAC_SET_##wc(X, _FP_ZEROFRAC_##wc);        \
+               FP_SET_EXCEPTION(FP_EX_INEXACT);                \
              }                                                 \
            else                                                \
              {                                                 \
                X##_e = 0;                                      \
                _FP_FRAC_SRL_##wc(X, _FP_WORKBITS);             \
-               FP_SET_EXCEPTION(FP_EX_UNDERFLOW);              \
              }                                                 \
+           if ((FP_CUR_EXCEPTIONS & FP_EX_INEXACT)             \
+               || (FP_TRAPPING_EXCEPTIONS & FP_EX_UNDERFLOW))  \
+             FP_SET_EXCEPTION(FP_EX_UNDERFLOW);                \
          }                                                     \
        else                                                    \
          {                                                     \

diff --git a/libgcc/soft-fp/soft-fp.h b/libgcc/soft-fp/soft-fp.h
index 46cb1cf..49a8770 100644 (file)
--- a/libgcc/soft-fp/soft-fp.h
+++ b/libgcc/soft-fp/soft-fp.h
@@ -128,6 +128,13 @@
 #define FP_CLEAR_EXCEPTIONS                            \
   _fex = 0
 
+#define FP_CUR_EXCEPTIONS                              \
+  (_fex)
+
+#ifndef FP_TRAPPING_EXCEPTIONS
+#define FP_TRAPPING_EXCEPTIONS 0
+#endif
+
 #define _FP_ROUND_NEAREST(wc, X)                       \
 do {                                                   \
     if ((_FP_FRAC_LOW_##wc(X) & 15) != _FP_WORK_ROUND) \
@@ -151,22 +158,24 @@ do {                                                      \
 #define _FP_ROUND(wc, X)                       \
 do {                                           \
        if (_FP_FRAC_LOW_##wc(X) & 7)           \
-         FP_SET_EXCEPTION(FP_EX_INEXACT);      \
-       switch (FP_ROUNDMODE)                   \
-       {                                       \
-         case FP_RND_NEAREST:                  \
-           _FP_ROUND_NEAREST(wc,X);            \
-           break;                              \
-         case FP_RND_ZERO:                     \
-           _FP_ROUND_ZERO(wc,X);               \
-           break;                              \
-         case FP_RND_PINF:                     \
-           _FP_ROUND_PINF(wc,X);               \
-           break;                              \
-         case FP_RND_MINF:                     \
-           _FP_ROUND_MINF(wc,X);               \
-           break;                              \
-       }                                       \
+         {                                     \
+           FP_SET_EXCEPTION(FP_EX_INEXACT);    \
+           switch (FP_ROUNDMODE)               \
+             {                                 \
+             case FP_RND_NEAREST:              \
+               _FP_ROUND_NEAREST(wc,X);        \
+               break;                          \
+             case FP_RND_ZERO:                 \
+               _FP_ROUND_ZERO(wc,X);           \
+               break;                          \
+             case FP_RND_PINF:                 \
+               _FP_ROUND_PINF(wc,X);           \
+               break;                          \
+             case FP_RND_MINF:                 \
+               _FP_ROUND_MINF(wc,X);           \
+               break;                          \
+             }                                 \
+         }                                     \
 } while (0)
 
 #define FP_CLS_NORMAL          0