Use glibc_likely instead __builtin_expect.

[jlayton/glibc.git] / sysdeps / ieee754 / dbl-64 / s_modf.c

diff --git a/sysdeps/ieee754/dbl-64/s_modf.c b/sysdeps/ieee754/dbl-64/s_modf.c
index 7851f675a466122f0a12e9a347f8a829fdb89561..0a1e13008f496fbf081845163ecf90e22f2fc8e6 100644 (file)
--- a/sysdeps/ieee754/dbl-64/s_modf.c
+++ b/sysdeps/ieee754/dbl-64/s_modf.c
@@ -1,4 +1,3 @@
-/* @(#)s_modf.c 5.1 93/09/24 */
 /*
  * ====================================================
  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
@@ -10,10 +9,6 @@
  * ====================================================
  */
 
-#if defined(LIBM_SCCS) && !defined(lint)
-static char rcsid[] = "$NetBSD: s_modf.c,v 1.8 1995/05/10 20:47:55 jtc Exp $";
-#endif
-
 /*
  * modf(double x, double *iptr)
  * return fraction part of x, and return x's integral part in *iptr.
@@ -24,59 +19,65 @@ static char rcsid[] = "$NetBSD: s_modf.c,v 1.8 1995/05/10 20:47:55 jtc Exp $";
  *     No exception.
  */
 
-#include "math.h"
-#include "math_private.h"
+#include <math.h>
+#include <math_private.h>
 
-#ifdef __STDC__
 static const double one = 1.0;
-#else
-static double one = 1.0;
-#endif
 
-#ifdef __STDC__
-       double __modf(double x, double *iptr)
-#else
-       double __modf(x, iptr)
-       double x,*iptr;
-#endif
+double
+__modf (double x, double *iptr)
 {
-       int32_t i0,i1,j0;
-       u_int32_t i;
-       EXTRACT_WORDS(i0,i1,x);
-       j0 = ((i0>>20)&0x7ff)-0x3ff;    /* exponent of x */
-       if(j0<20) {                     /* integer part in high x */
-           if(j0<0) {                  /* |x|<1 */
-               INSERT_WORDS(*iptr,i0&0x80000000,0);    /* *iptr = +-0 */
-               return x;
-           } else {
-               i = (0x000fffff)>>j0;
-               if(((i0&i)|i1)==0) {            /* x is integral */
-                   *iptr = x;
-                   INSERT_WORDS(x,i0&0x80000000,0);    /* return +-0 */
-                   return x;
-               } else {
-                   INSERT_WORDS(*iptr,i0&(~i),0);
-                   return x - *iptr;
-               }
+  int32_t i0, i1, j0;
+  u_int32_t i;
+  EXTRACT_WORDS (i0, i1, x);
+  j0 = ((i0 >> 20) & 0x7ff) - 0x3ff;    /* exponent of x */
+  if (j0 < 20)                          /* integer part in high x */
+    {
+      if (j0 < 0)                       /* |x|<1 */
+       {
+         INSERT_WORDS (*iptr, i0 & 0x80000000, 0);     /* *iptr = +-0 */
+         return x;
+       }
+      else
+       {
+         i = (0x000fffff) >> j0;
+         if (((i0 & i) | i1) == 0)             /* x is integral */
+           {
+             *iptr = x;
+             INSERT_WORDS (x, i0 & 0x80000000, 0);     /* return +-0 */
+             return x;
            }
-       } else if (j0>51) {             /* no fraction part */
-           *iptr = x*one;
-           /* We must handle NaNs separately.  */
-           if (j0 == 0x400 && ((i0 & 0xfffff) | i1))
-             return x*one;
-           INSERT_WORDS(x,i0&0x80000000,0);    /* return +-0 */
-           return x;
-       } else {                        /* fraction part in low x */
-           i = ((u_int32_t)(0xffffffff))>>(j0-20);
-           if((i1&i)==0) {             /* x is integral */
-               *iptr = x;
-               INSERT_WORDS(x,i0&0x80000000,0);        /* return +-0 */
-               return x;
-           } else {
-               INSERT_WORDS(*iptr,i0,i1&(~i));
-               return x - *iptr;
+         else
+           {
+             INSERT_WORDS (*iptr, i0 & (~i), 0);
+             return x - *iptr;
            }
        }
+    }
+  else if (__glibc_unlikely (j0 > 51))              /* no fraction part */
+    {
+      *iptr = x * one;
+      /* We must handle NaNs separately.  */
+      if (j0 == 0x400 && ((i0 & 0xfffff) | i1))
+       return x * one;
+      INSERT_WORDS (x, i0 & 0x80000000, 0);     /* return +-0 */
+      return x;
+    }
+  else                                  /* fraction part in low x */
+    {
+      i = ((u_int32_t) (0xffffffff)) >> (j0 - 20);
+      if ((i1 & i) == 0)                /* x is integral */
+       {
+         *iptr = x;
+         INSERT_WORDS (x, i0 & 0x80000000, 0);         /* return +-0 */
+         return x;
+       }
+      else
+       {
+         INSERT_WORDS (*iptr, i0, i1 & (~i));
+         return x - *iptr;
+       }
+    }
 }
 weak_alias (__modf, modf)
 #ifdef NO_LONG_DOUBLE