OSDN Git Service

2010-12-06 Tobias Burnus <burnus@net-b.de>
[pf3gnuchains/gcc-fork.git] / libquadmath / quadmath-imp.h
1 /* GCC Quad-Precision Math Library
2    Copyright (C) 2010 Free Software Foundation, Inc.
3    Written by Francois-Xavier Coudert  <fxcoudert@gcc.gnu.org>
4
5 This file is part of the libiberty library.
6 Libiberty 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 Libiberty 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 libiberty; 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
28
29 // Prototypes for internal functions
30 extern int32_t rem_pio2q (__float128, __float128 *);
31 extern void __kernel_sincosq (__float128, __float128, __float128 *, __float128 *, int);
32 extern __float128 __kernel_sinq (__float128, __float128, int);
33 extern __float128 __kernel_cosq (__float128, __float128);
34
35
36
37 // Frankly, if you have __float128, you have 64-bit integers, right?
38 #ifndef UINT64_C
39 # error "No way!"
40 #endif
41
42
43 // If we don't have macros to know endianess, assume little endian
44 #if !defined(__BIG_ENDIAN__) && !defined(__LITTLE_ENDIAN__)
45 # define __LITTLE_ENDIAN__ 1
46 #endif
47
48
49 // Main union type we use to manipulate the floating-point type
50 typedef union
51 {
52   __float128 value;
53
54   struct
55   {
56 #if __BIG_ENDIAN__
57     unsigned negative:1;
58     unsigned exponent:15;
59     uint64_t mant_high:48;
60     uint64_t mant_low:64;
61 #endif
62 #if __LITTLE_ENDIAN__
63     uint64_t mant_low:64;
64     uint64_t mant_high:48;
65     unsigned exponent:15;
66     unsigned negative:1;
67 #endif
68   } ieee;
69
70   struct
71   {
72 #if __BIG_ENDIAN__
73     uint64_t high;
74     uint64_t low;
75 #endif
76 #if __LITTLE_ENDIAN__
77     uint64_t low;
78     uint64_t high;
79 #endif
80   } words64;
81
82   struct
83   {
84 #if __BIG_ENDIAN__
85     uint32_t w0;
86     uint32_t w1;
87     uint32_t w2;
88     uint32_t w3;
89 #endif
90 #if __LITTLE_ENDIAN__
91     uint32_t w3;
92     uint32_t w2;
93     uint32_t w1;
94     uint32_t w0;
95 #endif
96   } words32;
97
98   struct
99   {
100 #if __BIG_ENDIAN__
101     unsigned negative:1;
102     unsigned exponent:15;
103     unsigned quiet_nan:1;
104     uint64_t mant_high:47;
105     uint64_t mant_low:64;
106 #endif
107 #if __LITTLE_ENDIAN__
108     uint64_t mant_low:64;
109     uint64_t mant_high:47;
110     unsigned quiet_nan:1;
111     unsigned exponent:15;
112     unsigned negative:1;
113 #endif
114   } nan;
115
116 } ieee854_float128;
117
118
119 /* Get two 64 bit ints from a long double.  */
120 #define GET_FLT128_WORDS64(ix0,ix1,d)  \
121 do {                                   \
122   ieee854_float128 u;                  \
123   u.value = (d);                       \
124   (ix0) = u.words64.high;              \
125   (ix1) = u.words64.low;               \
126 } while (0)
127
128 /* Set a long double from two 64 bit ints.  */
129 #define SET_FLT128_WORDS64(d,ix0,ix1)  \
130 do {                                   \
131   ieee854_float128 u;                  \
132   u.words64.high = (ix0);              \
133   u.words64.low = (ix1);               \
134   (d) = u.value;                       \
135 } while (0)
136
137 /* Get the more significant 64 bits of a long double mantissa.  */
138 #define GET_FLT128_MSW64(v,d)          \
139 do {                                   \
140   ieee854_float128 u;                  \
141   u.value = (d);                       \
142   (v) = u.words64.high;                \
143 } while (0)
144
145 /* Set the more significant 64 bits of a long double mantissa from an int.  */
146 #define SET_FLT128_MSW64(d,v)          \
147 do {                                   \
148   ieee854_float128 u;                  \
149   u.value = (d);                       \
150   u.words64.high = (v);                \
151   (d) = u.value;                       \
152 } while (0)
153
154 /* Get the least significant 64 bits of a long double mantissa.  */
155 #define GET_FLT128_LSW64(v,d)          \
156 do {                                   \
157   ieee854_float128 u;                  \
158   u.value = (d);                       \
159   (v) = u.words64.low;                 \
160 } while (0)
161
162
163 #define IEEE854_FLOAT128_BIAS 0x3fff
164
165
166 #endif