remove unused files
[platform/upstream/gcc48.git] / libquadmath / quadmath-imp.h
1 /* GCC Quad-Precision Math Library
2    Copyright (C) 2010, 2011 Free Software Foundation, Inc.
3    Written by Francois-Xavier Coudert  <fxcoudert@gcc.gnu.org>
4
5 This file is part of the libquadmath library.
6 Libquadmath is free software; you can redistribute it and/or
7 modify it under the terms of the GNU Library General Public
8 License as published by the Free Software Foundation; either
9 version 2 of the License, or (at your option) any later version.
10
11 Libquadmath 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 Library General Public License for more details.
15
16 You should have received a copy of the GNU Library General Public
17 License along with libquadmath; see the file COPYING.LIB.  If
18 not, write to the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor,
19 Boston, MA 02110-1301, USA.  */
20
21 #ifndef QUADMATH_IMP_H
22 #define QUADMATH_IMP_H
23
24 #include <stdint.h>
25 #include <stdlib.h>
26 #include "quadmath.h"
27 #include "config.h"
28
29
30 /* Under IEEE 754, an architecture may determine tininess of
31    floating-point results either "before rounding" or "after
32    rounding", but must do so in the same way for all operations
33    returning binary results.  Define TININESS_AFTER_ROUNDING to 1 for
34    "after rounding" architectures, 0 for "before rounding"
35    architectures.  */
36
37 #define TININESS_AFTER_ROUNDING   1
38
39
40 /* Prototypes for internal functions.  */
41 extern int32_t __quadmath_rem_pio2q (__float128, __float128 *);
42 extern void __quadmath_kernel_sincosq (__float128, __float128, __float128 *,
43                                        __float128 *, int);
44 extern __float128 __quadmath_kernel_sinq (__float128, __float128, int);
45 extern __float128 __quadmath_kernel_cosq (__float128, __float128);
46 extern __float128 __quadmath_x2y2m1q (__float128 x, __float128 y);
47 extern int __quadmath_isinf_nsq (__float128 x);
48
49
50
51
52
53 /* Frankly, if you have __float128, you have 64-bit integers, right?  */
54 #ifndef UINT64_C
55 # error "No way!"
56 #endif
57
58
59 /* Main union type we use to manipulate the floating-point type.  */
60 typedef union
61 {
62   __float128 value;
63
64   struct
65 #ifdef __MINGW32__
66   /* On mingw targets the ms-bitfields option is active by default.
67      Therefore enforce gnu-bitfield style.  */
68   __attribute__ ((gcc_struct))
69 #endif
70   {
71 #if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
72     unsigned negative:1;
73     unsigned exponent:15;
74     uint64_t mant_high:48;
75     uint64_t mant_low:64;
76 #else
77     uint64_t mant_low:64;
78     uint64_t mant_high:48;
79     unsigned exponent:15;
80     unsigned negative:1;
81 #endif
82   } ieee;
83
84   struct
85   {
86 #if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
87     uint64_t high;
88     uint64_t low;
89 #else
90     uint64_t low;
91     uint64_t high;
92 #endif
93   } words64;
94
95   struct
96   {
97 #if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
98     uint32_t w0;
99     uint32_t w1;
100     uint32_t w2;
101     uint32_t w3;
102 #else
103     uint32_t w3;
104     uint32_t w2;
105     uint32_t w1;
106     uint32_t w0;
107 #endif
108   } words32;
109
110   struct
111 #ifdef __MINGW32__
112   /* Make sure we are using gnu-style bitfield handling.  */
113   __attribute__ ((gcc_struct))
114 #endif
115   {
116 #if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
117     unsigned negative:1;
118     unsigned exponent:15;
119     unsigned quiet_nan:1;
120     uint64_t mant_high:47;
121     uint64_t mant_low:64;
122 #else
123     uint64_t mant_low:64;
124     uint64_t mant_high:47;
125     unsigned quiet_nan:1;
126     unsigned exponent:15;
127     unsigned negative:1;
128 #endif
129   } nan;
130
131 } ieee854_float128;
132
133
134 /* Get two 64 bit ints from a long double.  */
135 #define GET_FLT128_WORDS64(ix0,ix1,d)  \
136 do {                                   \
137   ieee854_float128 u;                  \
138   u.value = (d);                       \
139   (ix0) = u.words64.high;              \
140   (ix1) = u.words64.low;               \
141 } while (0)
142
143 /* Set a long double from two 64 bit ints.  */
144 #define SET_FLT128_WORDS64(d,ix0,ix1)  \
145 do {                                   \
146   ieee854_float128 u;                  \
147   u.words64.high = (ix0);              \
148   u.words64.low = (ix1);               \
149   (d) = u.value;                       \
150 } while (0)
151
152 /* Get the more significant 64 bits of a long double mantissa.  */
153 #define GET_FLT128_MSW64(v,d)          \
154 do {                                   \
155   ieee854_float128 u;                  \
156   u.value = (d);                       \
157   (v) = u.words64.high;                \
158 } while (0)
159
160 /* Set the more significant 64 bits of a long double mantissa from an int.  */
161 #define SET_FLT128_MSW64(d,v)          \
162 do {                                   \
163   ieee854_float128 u;                  \
164   u.value = (d);                       \
165   u.words64.high = (v);                \
166   (d) = u.value;                       \
167 } while (0)
168
169 /* Get the least significant 64 bits of a long double mantissa.  */
170 #define GET_FLT128_LSW64(v,d)          \
171 do {                                   \
172   ieee854_float128 u;                  \
173   u.value = (d);                       \
174   (v) = u.words64.low;                 \
175 } while (0)
176
177
178 #define IEEE854_FLOAT128_BIAS 0x3fff
179
180 #define QUADFP_NAN              0
181 #define QUADFP_INFINITE         1
182 #define QUADFP_ZERO             2
183 #define QUADFP_SUBNORMAL        3
184 #define QUADFP_NORMAL           4
185 #define fpclassifyq(x) \
186   __builtin_fpclassify (QUADFP_NAN, QUADFP_INFINITE, QUADFP_NORMAL, \
187                         QUADFP_SUBNORMAL, QUADFP_ZERO, x)
188
189 #endif