Updated to fedora-glibc-20060328T0900
[kopensolaris-gnu/glibc.git] / sysdeps / ieee754 / ldbl-128ibm / s_llrintl.c
1 /* Round to int long double floating-point values.
2    IBM extended format long double version.
3    Copyright (C) 2006 Free Software Foundation, Inc.
4    This file is part of the GNU C Library.
5
6    The GNU C Library is free software; you can redistribute it and/or
7    modify it under the terms of the GNU Lesser General Public
8    License as published by the Free Software Foundation; either
9    version 2.1 of the License, or (at your option) any later version.
10
11    The GNU C Library is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14    Lesser General Public License for more details.
15
16    You should have received a copy of the GNU Lesser General Public
17    License along with the GNU C Library; if not, write to the Free
18    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
19    02111-1307 USA.  */
20
21 /* This has been coded in assembler because GCC makes such a mess of it
22    when it's coded in C.  */
23
24 #include <math.h>
25 #include <fenv_libc.h>
26 #include <math_ldbl_opt.h>
27 #include <float.h>
28 #include <ieee754.h>
29
30
31 #ifdef __STDC__
32 long long
33 __llrintl (long double x)
34 #else
35 long long
36 __llrintl (x)
37      long double x;
38 #endif
39 {
40   double xh, xl;
41   long long res, hi, lo;
42   int save_round;
43
44   ldbl_unpack (x, &xh, &xl);
45
46   /* Limit the range of values handled by the conversion to long long.
47      We do this because we aren't sure whether that conversion properly
48      raises FE_INVALID.  */
49   if (__builtin_expect
50       ((__builtin_fabs (xh) <= -(double) (-__LONG_LONG_MAX__ - 1)), 1)
51 #if !defined (FE_INVALID)
52       || 1
53 #endif
54     )
55     {
56       save_round = fegetround ();
57
58       if (__builtin_expect ((xh == -(double) (-__LONG_LONG_MAX__ - 1)), 0))
59         {
60           /* When XH is 9223372036854775808.0, converting to long long will
61              overflow, resulting in an invalid operation.  However, XL might
62              be negative and of sufficient magnitude that the overall long
63              double is in fact in range.  Avoid raising an exception.  In any
64              case we need to convert this value specially, because
65              the converted value is not exactly represented as a double
66              thus subtracting HI from XH suffers rounding error.  */
67           hi = __LONG_LONG_MAX__;
68           xh = 1.0;
69         }
70       else
71         {
72           hi = (long long) xh;
73           xh -= hi;
74         }
75       ldbl_canonicalize (&xh, &xl);
76
77       lo = (long long) xh;
78
79       /* Peg at max/min values, assuming that the above conversions do so.
80          Strictly speaking, we can return anything for values that overflow,
81          but this is more useful.  */
82       res = hi + lo;
83
84       /* This is just sign(hi) == sign(lo) && sign(res) != sign(hi).  */
85       if (__builtin_expect (((~(hi ^ lo) & (res ^ hi)) < 0), 0))
86         goto overflow;
87
88       xh -= lo;
89       ldbl_canonicalize (&xh, &xl);
90
91       hi = res;
92       switch (save_round)
93         {
94         case FE_TONEAREST:
95           if (fabs (xh) < 0.5
96               || (fabs (xh) == 0.5
97                   && ((xh > 0.0 && xl < 0.0)
98                       || (xh < 0.0 && xl > 0.0)
99                       || (xl == 0.0 && (res & 1) == 0))))
100             return res;
101
102           if (xh < 0.0)
103             res -= 1;
104           else
105             res += 1;
106           break;
107
108         case FE_TOWARDZERO:
109           if (res > 0 && (xh < 0.0 || (xh == 0.0 && xl < 0.0)))
110             res -= 1;
111           else if (res < 0 && (xh > 0.0 || (xh == 0.0 && xl > 0.0)))
112             res += 1;
113           return res;
114           break;
115
116         case FE_UPWARD:
117           if (xh > 0.0 || (xh == 0.0 && xl > 0.0))
118             res += 1;
119           break;
120
121         case FE_DOWNWARD:
122           if (xh < 0.0 || (xh == 0.0 && xl < 0.0))
123             res -= 1;
124           break;
125         }
126
127       if (__builtin_expect (((~(hi ^ (res - hi)) & (res ^ hi)) < 0), 0))
128         goto overflow;
129
130       return res;
131     }
132   else
133     {
134       if (xh > 0.0)
135         hi = __LONG_LONG_MAX__;
136       else if (xh < 0.0)
137         hi = -__LONG_LONG_MAX__ - 1;
138       else
139         /* Nan */
140         hi = 0;
141     }
142
143 overflow:
144 #ifdef FE_INVALID
145   feraiseexcept (FE_INVALID);
146 #endif
147   return hi;
148 }
149
150 long_double_symbol (libm, __llrintl, llrintl);