Update copyright dates with scripts/update-copyrights.

[thirdparty/glibc.git] / sysdeps / ieee754 / ldbl-128ibm / s_roundl.c

diff --git a/sysdeps/ieee754/ldbl-128ibm/s_roundl.c b/sysdeps/ieee754/ldbl-128ibm/s_roundl.c
index ebdf700a43cfde1f9291893c904693d920184d40..5915d53a189c4da5d76c8d83103c215d6debb001 100644 (file)
--- a/sysdeps/ieee754/ldbl-128ibm/s_roundl.c
+++ b/sysdeps/ieee754/ldbl-128ibm/s_roundl.c
@@ -1,6 +1,6 @@
 /* Round to int long double floating-point values.
    IBM extended format long double version.
-   Copyright (C) 2006, 2007, 2012 Free Software Foundation, Inc.
+   Copyright (C) 2006-2018 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -38,47 +38,48 @@ __roundl (long double x)
                        && __builtin_isless (__builtin_fabs (xh),
                                             __builtin_inf ()), 1))
     {
-      double orig_xh;
-
-      /* Long double arithmetic, including the canonicalisation below,
-        only works in round-to-nearest mode.  */
-
-      /* Convert the high double to integer.  */
-      orig_xh = xh;
-      hi = ldbl_nearbyint (xh);
-
-      /* Subtract integral high part from the value.  */
-      xh -= hi;
-      ldbl_canonicalize (&xh, &xl);
-
-      /* Now convert the low double, adjusted for any remainder from the
-        high double.  */
-      lo = ldbl_nearbyint (xh);
-
-      /* Adjust the result when the remainder is exactly 0.5.  nearbyint
-        rounds values halfway between integers to the nearest even
-        integer.  roundl must round away from zero.
-        Also correct cases where nearbyint returns an incorrect value
-        for LO.  */
-      xh -= lo;
-      ldbl_canonicalize (&xh, &xl);
-      if (xh == 0.5)
+      hi = __round (xh);
+      if (hi != xh)
        {
-         if (xl > 0.0 || (xl == 0.0 && orig_xh > 0.0))
-           lo += 1.0;
+         /* The high part is not an integer; the low part only
+            affects the result if the high part is exactly half way
+            between two integers and the low part is nonzero with the
+            opposite sign.  */
+         if (fabs (hi - xh) == 0.5)
+           {
+             if (xh > 0 && xl < 0)
+               xh = hi - 1;
+             else if (xh < 0 && xl > 0)
+               xh = hi + 1;
+             else
+               xh = hi;
+           }
+         else
+           xh = hi;
+         xl = 0;
        }
-      else if (-xh == 0.5)
+      else
        {
-         if (xl < 0.0 || (xl == 0.0 && orig_xh < 0.0))
-           lo -= 1.0;
+         /* The high part is a nonzero integer.  */
+         lo = __round (xl);
+         if (fabs (lo - xl) == 0.5)
+           {
+             if (xh > 0 && xl < 0)
+               xl = lo + 1;
+             else if (xh < 0 && lo > 0)
+               xl = lo - 1;
+             else
+               xl = lo;
+           }
+         else
+           xl = lo;
+         xh = hi;
+         ldbl_canonicalize_int (&xh, &xl);
        }
-
-      /* Ensure the final value is canonical.  In certain cases,
-        rounding causes hi,lo calculated so far to be non-canonical.  */
-      xh = hi;
-      xl = lo;
-      ldbl_canonicalize (&xh, &xl);
     }
+  else
+    /* Quiet signaling NaN arguments.  */
+    xh += xh;
 
   return ldbl_pack (xh, xl);
 }