?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[BZ #18796]
[glibc.git] / soft-fp / extended.h
blob428f9178a6f3348dafdcc9f53b59983430fd855b
1 /* Software floating-point emulation.
2 Definitions for IEEE Extended Precision.
3 Copyright (C) 1999-2015 Free Software Foundation, Inc.
4 This file is part of the GNU C Library.
5 Contributed by Jakub Jelinek (jj@ultra.linux.cz).
6
7 The GNU C Library is free software; you can redistribute it and/or
8 modify it under the terms of the GNU Lesser General Public
9 License as published by the Free Software Foundation; either
10 version 2.1 of the License, or (at your option) any later version.
11
12 In addition to the permissions in the GNU Lesser General Public
13 License, the Free Software Foundation gives you unlimited
14 permission to link the compiled version of this file into
15 combinations with other programs, and to distribute those
16 combinations without any restriction coming from the use of this
17 file. (The Lesser General Public License restrictions do apply in
18 other respects; for example, they cover modification of the file,
19 and distribution when not linked into a combine executable.)
20
21 The GNU C Library is distributed in the hope that it will be useful,
22 but WITHOUT ANY WARRANTY; without even the implied warranty of
23 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
24 Lesser General Public License for more details.
25
26 You should have received a copy of the GNU Lesser General Public
27 License along with the GNU C Library; if not, see
28 <http://www.gnu.org/licenses/>. */
29
30 #ifndef SOFT_FP_EXTENDED_H
31 #define SOFT_FP_EXTENDED_H 1
32
33 #if _FP_W_TYPE_SIZE < 32
34 # error "Here's a nickel, kid. Go buy yourself a real computer."
35 #endif
36
37 #if _FP_W_TYPE_SIZE < 64
38 # define _FP_FRACTBITS_E (4*_FP_W_TYPE_SIZE)
39 # define _FP_FRACTBITS_DW_E (8*_FP_W_TYPE_SIZE)
40 #else
41 # define _FP_FRACTBITS_E (2*_FP_W_TYPE_SIZE)
42 # define _FP_FRACTBITS_DW_E (4*_FP_W_TYPE_SIZE)
43 #endif
44
45 #define _FP_FRACBITS_E 64
46 #define _FP_FRACXBITS_E (_FP_FRACTBITS_E - _FP_FRACBITS_E)
47 #define _FP_WFRACBITS_E (_FP_WORKBITS + _FP_FRACBITS_E)
48 #define _FP_WFRACXBITS_E (_FP_FRACTBITS_E - _FP_WFRACBITS_E)
49 #define _FP_EXPBITS_E 15
50 #define _FP_EXPBIAS_E 16383
51 #define _FP_EXPMAX_E 32767
52
53 #define _FP_QNANBIT_E \
54 ((_FP_W_TYPE) 1 << (_FP_FRACBITS_E-2) % _FP_W_TYPE_SIZE)
55 #define _FP_QNANBIT_SH_E \
56 ((_FP_W_TYPE) 1 << (_FP_FRACBITS_E-2+_FP_WORKBITS) % _FP_W_TYPE_SIZE)
57 #define _FP_IMPLBIT_E \
58 ((_FP_W_TYPE) 1 << (_FP_FRACBITS_E-1) % _FP_W_TYPE_SIZE)
59 #define _FP_IMPLBIT_SH_E \
60 ((_FP_W_TYPE) 1 << (_FP_FRACBITS_E-1+_FP_WORKBITS) % _FP_W_TYPE_SIZE)
61 #define _FP_OVERFLOW_E \
62 ((_FP_W_TYPE) 1 << (_FP_WFRACBITS_E % _FP_W_TYPE_SIZE))
63
64 #define _FP_WFRACBITS_DW_E (2 * _FP_WFRACBITS_E)
65 #define _FP_WFRACXBITS_DW_E (_FP_FRACTBITS_DW_E - _FP_WFRACBITS_DW_E)
66 #define _FP_HIGHBIT_DW_E \
67 ((_FP_W_TYPE) 1 << (_FP_WFRACBITS_DW_E - 1) % _FP_W_TYPE_SIZE)
68
69 typedef float XFtype __attribute__ ((mode (XF)));
70
71 #if _FP_W_TYPE_SIZE < 64
72
73 union _FP_UNION_E
74 {
75 XFtype flt;
76 struct _FP_STRUCT_LAYOUT
77 {
78 # if __BYTE_ORDER == __BIG_ENDIAN
79 unsigned long pad1 : _FP_W_TYPE_SIZE;
80 unsigned long pad2 : (_FP_W_TYPE_SIZE - 1 - _FP_EXPBITS_E);
81 unsigned long sign : 1;
82 unsigned long exp : _FP_EXPBITS_E;
83 unsigned long frac1 : _FP_W_TYPE_SIZE;
84 unsigned long frac0 : _FP_W_TYPE_SIZE;
85 # else
86 unsigned long frac0 : _FP_W_TYPE_SIZE;
87 unsigned long frac1 : _FP_W_TYPE_SIZE;
88 unsigned exp : _FP_EXPBITS_E;
89 unsigned sign : 1;
90 # endif /* not bigendian */
91 } bits __attribute__ ((packed));
92 };
93
94
95 # define FP_DECL_E(X) _FP_DECL (4, X)
96
97 # define FP_UNPACK_RAW_E(X, val) \
98 do \
99 { \
100 union _FP_UNION_E FP_UNPACK_RAW_E_flo; \
101 FP_UNPACK_RAW_E_flo.flt = (val); \
102 \
103 X##_f[2] = 0; \
104 X##_f[3] = 0; \
105 X##_f[0] = FP_UNPACK_RAW_E_flo.bits.frac0; \
106 X##_f[1] = FP_UNPACK_RAW_E_flo.bits.frac1; \
107 X##_e = FP_UNPACK_RAW_E_flo.bits.exp; \
108 X##_s = FP_UNPACK_RAW_E_flo.bits.sign; \
109 } \
110 while (0)
111
112 # define FP_UNPACK_RAW_EP(X, val) \
113 do \
114 { \
115 union _FP_UNION_E *FP_UNPACK_RAW_EP_flo \
116 = (union _FP_UNION_E *) (val); \
117 \
118 X##_f[2] = 0; \
119 X##_f[3] = 0; \
120 X##_f[0] = FP_UNPACK_RAW_EP_flo->bits.frac0; \
121 X##_f[1] = FP_UNPACK_RAW_EP_flo->bits.frac1; \
122 X##_e = FP_UNPACK_RAW_EP_flo->bits.exp; \
123 X##_s = FP_UNPACK_RAW_EP_flo->bits.sign; \
124 } \
125 while (0)
126
127 # define FP_PACK_RAW_E(val, X) \
128 do \
129 { \
130 union _FP_UNION_E FP_PACK_RAW_E_flo; \
131 \
132 if (X##_e) \
133 X##_f[1] |= _FP_IMPLBIT_E; \
134 else \
135 X##_f[1] &= ~(_FP_IMPLBIT_E); \
136 FP_PACK_RAW_E_flo.bits.frac0 = X##_f[0]; \
137 FP_PACK_RAW_E_flo.bits.frac1 = X##_f[1]; \
138 FP_PACK_RAW_E_flo.bits.exp = X##_e; \
139 FP_PACK_RAW_E_flo.bits.sign = X##_s; \
140 \
141 (val) = FP_PACK_RAW_E_flo.flt; \
142 } \
143 while (0)
144
145 # define FP_PACK_RAW_EP(val, X) \
146 do \
147 { \
148 if (!FP_INHIBIT_RESULTS) \
149 { \
150 union _FP_UNION_E *FP_PACK_RAW_EP_flo \
151 = (union _FP_UNION_E *) (val); \
152 \
153 if (X##_e) \
154 X##_f[1] |= _FP_IMPLBIT_E; \
155 else \
156 X##_f[1] &= ~(_FP_IMPLBIT_E); \
157 FP_PACK_RAW_EP_flo->bits.frac0 = X##_f[0]; \
158 FP_PACK_RAW_EP_flo->bits.frac1 = X##_f[1]; \
159 FP_PACK_RAW_EP_flo->bits.exp = X##_e; \
160 FP_PACK_RAW_EP_flo->bits.sign = X##_s; \
161 } \
162 } \
163 while (0)
164
165 # define FP_UNPACK_E(X, val) \
166 do \
167 { \
168 FP_UNPACK_RAW_E (X, (val)); \
169 _FP_UNPACK_CANONICAL (E, 4, X); \
170 } \
171 while (0)
172
173 # define FP_UNPACK_EP(X, val) \
174 do \
175 { \
176 FP_UNPACK_RAW_EP (X, (val)); \
177 _FP_UNPACK_CANONICAL (E, 4, X); \
178 } \
179 while (0)
180
181 # define FP_UNPACK_SEMIRAW_E(X, val) \
182 do \
183 { \
184 FP_UNPACK_RAW_E (X, (val)); \
185 _FP_UNPACK_SEMIRAW (E, 4, X); \
186 } \
187 while (0)
188
189 # define FP_UNPACK_SEMIRAW_EP(X, val) \
190 do \
191 { \
192 FP_UNPACK_RAW_EP (X, (val)); \
193 _FP_UNPACK_SEMIRAW (E, 4, X); \
194 } \
195 while (0)
196
197 # define FP_PACK_E(val, X) \
198 do \
199 { \
200 _FP_PACK_CANONICAL (E, 4, X); \
201 FP_PACK_RAW_E ((val), X); \
202 } \
203 while (0)
204
205 # define FP_PACK_EP(val, X) \
206 do \
207 { \
208 _FP_PACK_CANONICAL (E, 4, X); \
209 FP_PACK_RAW_EP ((val), X); \
210 } \
211 while (0)
212
213 # define FP_PACK_SEMIRAW_E(val, X) \
214 do \
215 { \
216 _FP_PACK_SEMIRAW (E, 4, X); \
217 FP_PACK_RAW_E ((val), X); \
218 } \
219 while (0)
220
221 # define FP_PACK_SEMIRAW_EP(val, X) \
222 do \
223 { \
224 _FP_PACK_SEMIRAW (E, 4, X); \
225 FP_PACK_RAW_EP ((val), X); \
226 } \
227 while (0)
228
229 # define FP_ISSIGNAN_E(X) _FP_ISSIGNAN (E, 4, X)
230 # define FP_NEG_E(R, X) _FP_NEG (E, 4, R, X)
231 # define FP_ADD_E(R, X, Y) _FP_ADD (E, 4, R, X, Y)
232 # define FP_SUB_E(R, X, Y) _FP_SUB (E, 4, R, X, Y)
233 # define FP_MUL_E(R, X, Y) _FP_MUL (E, 4, R, X, Y)
234 # define FP_DIV_E(R, X, Y) _FP_DIV (E, 4, R, X, Y)
235 # define FP_SQRT_E(R, X) _FP_SQRT (E, 4, R, X)
236 # define FP_FMA_E(R, X, Y, Z) _FP_FMA (E, 4, 8, R, X, Y, Z)
237
238 /* Square root algorithms:
239 We have just one right now, maybe Newton approximation
240 should be added for those machines where division is fast.
241 This has special _E version because standard _4 square
242 root would not work (it has to start normally with the
243 second word and not the first), but as we have to do it
244 anyway, we optimize it by doing most of the calculations
245 in two UWtype registers instead of four. */
246
247 # define _FP_SQRT_MEAT_E(R, S, T, X, q) \
248 do \
249 { \
250 (q) = (_FP_W_TYPE) 1 << (_FP_W_TYPE_SIZE - 1); \
251 _FP_FRAC_SRL_4 (X, (_FP_WORKBITS)); \
252 while (q) \
253 { \
254 T##_f[1] = S##_f[1] + (q); \
255 if (T##_f[1] <= X##_f[1]) \
256 { \
257 S##_f[1] = T##_f[1] + (q); \
258 X##_f[1] -= T##_f[1]; \
259 R##_f[1] += (q); \
260 } \
261 _FP_FRAC_SLL_2 (X, 1); \
262 (q) >>= 1; \
263 } \
264 (q) = (_FP_W_TYPE) 1 << (_FP_W_TYPE_SIZE - 1); \
265 while (q) \
266 { \
267 T##_f[0] = S##_f[0] + (q); \
268 T##_f[1] = S##_f[1]; \
269 if (T##_f[1] < X##_f[1] \
270 || (T##_f[1] == X##_f[1] \
271 && T##_f[0] <= X##_f[0])) \
272 { \
273 S##_f[0] = T##_f[0] + (q); \
274 S##_f[1] += (T##_f[0] > S##_f[0]); \
275 _FP_FRAC_DEC_2 (X, T); \
276 R##_f[0] += (q); \
277 } \
278 _FP_FRAC_SLL_2 (X, 1); \
279 (q) >>= 1; \
280 } \
281 _FP_FRAC_SLL_4 (R, (_FP_WORKBITS)); \
282 if (X##_f[0] | X##_f[1]) \
283 { \
284 if (S##_f[1] < X##_f[1] \
285 || (S##_f[1] == X##_f[1] \
286 && S##_f[0] < X##_f[0])) \
287 R##_f[0] |= _FP_WORK_ROUND; \
288 R##_f[0] |= _FP_WORK_STICKY; \
289 } \
290 } \
291 while (0)
292
293 # define FP_CMP_E(r, X, Y, un, ex) _FP_CMP (E, 4, (r), X, Y, (un), (ex))
294 # define FP_CMP_EQ_E(r, X, Y, ex) _FP_CMP_EQ (E, 4, (r), X, Y, (ex))
295 # define FP_CMP_UNORD_E(r, X, Y, ex) _FP_CMP_UNORD (E, 4, (r), X, Y, (ex))
296
297 # define FP_TO_INT_E(r, X, rsz, rsg) _FP_TO_INT (E, 4, (r), X, (rsz), (rsg))
298 # define FP_TO_INT_ROUND_E(r, X, rsz, rsg) \
299 _FP_TO_INT_ROUND (E, 4, (r), X, (rsz), (rsg))
300 # define FP_FROM_INT_E(X, r, rs, rt) _FP_FROM_INT (E, 4, X, (r), (rs), rt)
301
302 # define _FP_FRAC_HIGH_E(X) (X##_f[2])
303 # define _FP_FRAC_HIGH_RAW_E(X) (X##_f[1])
304
305 # define _FP_FRAC_HIGH_DW_E(X) (X##_f[4])
306
307 #else /* not _FP_W_TYPE_SIZE < 64 */
308 union _FP_UNION_E
309 {
310 XFtype flt;
311 struct _FP_STRUCT_LAYOUT
312 {
313 # if __BYTE_ORDER == __BIG_ENDIAN
314 _FP_W_TYPE pad : (_FP_W_TYPE_SIZE - 1 - _FP_EXPBITS_E);
315 unsigned sign : 1;
316 unsigned exp : _FP_EXPBITS_E;
317 _FP_W_TYPE frac : _FP_W_TYPE_SIZE;
318 # else
319 _FP_W_TYPE frac : _FP_W_TYPE_SIZE;
320 unsigned exp : _FP_EXPBITS_E;
321 unsigned sign : 1;
322 # endif
323 } bits;
324 };
325
326 # define FP_DECL_E(X) _FP_DECL (2, X)
327
328 # define FP_UNPACK_RAW_E(X, val) \
329 do \
330 { \
331 union _FP_UNION_E FP_UNPACK_RAW_E_flo; \
332 FP_UNPACK_RAW_E_flo.flt = (val); \
333 \
334 X##_f0 = FP_UNPACK_RAW_E_flo.bits.frac; \
335 X##_f1 = 0; \
336 X##_e = FP_UNPACK_RAW_E_flo.bits.exp; \
337 X##_s = FP_UNPACK_RAW_E_flo.bits.sign; \
338 } \
339 while (0)
340
341 # define FP_UNPACK_RAW_EP(X, val) \
342 do \
343 { \
344 union _FP_UNION_E *FP_UNPACK_RAW_EP_flo \
345 = (union _FP_UNION_E *) (val); \
346 \
347 X##_f0 = FP_UNPACK_RAW_EP_flo->bits.frac; \
348 X##_f1 = 0; \
349 X##_e = FP_UNPACK_RAW_EP_flo->bits.exp; \
350 X##_s = FP_UNPACK_RAW_EP_flo->bits.sign; \
351 } \
352 while (0)
353
354 # define FP_PACK_RAW_E(val, X) \
355 do \
356 { \
357 union _FP_UNION_E FP_PACK_RAW_E_flo; \
358 \
359 if (X##_e) \
360 X##_f0 |= _FP_IMPLBIT_E; \
361 else \
362 X##_f0 &= ~(_FP_IMPLBIT_E); \
363 FP_PACK_RAW_E_flo.bits.frac = X##_f0; \
364 FP_PACK_RAW_E_flo.bits.exp = X##_e; \
365 FP_PACK_RAW_E_flo.bits.sign = X##_s; \
366 \
367 (val) = FP_PACK_RAW_E_flo.flt; \
368 } \
369 while (0)
370
371 # define FP_PACK_RAW_EP(fs, val, X) \
372 do \
373 { \
374 if (!FP_INHIBIT_RESULTS) \
375 { \
376 union _FP_UNION_E *FP_PACK_RAW_EP_flo \
377 = (union _FP_UNION_E *) (val); \
378 \
379 if (X##_e) \
380 X##_f0 |= _FP_IMPLBIT_E; \
381 else \
382 X##_f0 &= ~(_FP_IMPLBIT_E); \
383 FP_PACK_RAW_EP_flo->bits.frac = X##_f0; \
384 FP_PACK_RAW_EP_flo->bits.exp = X##_e; \
385 FP_PACK_RAW_EP_flo->bits.sign = X##_s; \
386 } \
387 } \
388 while (0)
389
390
391 # define FP_UNPACK_E(X, val) \
392 do \
393 { \
394 FP_UNPACK_RAW_E (X, (val)); \
395 _FP_UNPACK_CANONICAL (E, 2, X); \
396 } \
397 while (0)
398
399 # define FP_UNPACK_EP(X, val) \
400 do \
401 { \
402 FP_UNPACK_RAW_EP (X, (val)); \
403 _FP_UNPACK_CANONICAL (E, 2, X); \
404 } \
405 while (0)
406
407 # define FP_UNPACK_SEMIRAW_E(X, val) \
408 do \
409 { \
410 FP_UNPACK_RAW_E (X, (val)); \
411 _FP_UNPACK_SEMIRAW (E, 2, X); \
412 } \
413 while (0)
414
415 # define FP_UNPACK_SEMIRAW_EP(X, val) \
416 do \
417 { \
418 FP_UNPACK_RAW_EP (X, (val)); \
419 _FP_UNPACK_SEMIRAW (E, 2, X); \
420 } \
421 while (0)
422
423 # define FP_PACK_E(val, X) \
424 do \
425 { \
426 _FP_PACK_CANONICAL (E, 2, X); \
427 FP_PACK_RAW_E ((val), X); \
428 } \
429 while (0)
430
431 # define FP_PACK_EP(val, X) \
432 do \
433 { \
434 _FP_PACK_CANONICAL (E, 2, X); \
435 FP_PACK_RAW_EP ((val), X); \
436 } \
437 while (0)
438
439 # define FP_PACK_SEMIRAW_E(val, X) \
440 do \
441 { \
442 _FP_PACK_SEMIRAW (E, 2, X); \
443 FP_PACK_RAW_E ((val), X); \
444 } \
445 while (0)
446
447 # define FP_PACK_SEMIRAW_EP(val, X) \
448 do \
449 { \
450 _FP_PACK_SEMIRAW (E, 2, X); \
451 FP_PACK_RAW_EP ((val), X); \
452 } \
453 while (0)
454
455 # define FP_ISSIGNAN_E(X) _FP_ISSIGNAN (E, 2, X)
456 # define FP_NEG_E(R, X) _FP_NEG (E, 2, R, X)
457 # define FP_ADD_E(R, X, Y) _FP_ADD (E, 2, R, X, Y)
458 # define FP_SUB_E(R, X, Y) _FP_SUB (E, 2, R, X, Y)
459 # define FP_MUL_E(R, X, Y) _FP_MUL (E, 2, R, X, Y)
460 # define FP_DIV_E(R, X, Y) _FP_DIV (E, 2, R, X, Y)
461 # define FP_SQRT_E(R, X) _FP_SQRT (E, 2, R, X)
462 # define FP_FMA_E(R, X, Y, Z) _FP_FMA (E, 2, 4, R, X, Y, Z)
463
464 /* Square root algorithms:
465 We have just one right now, maybe Newton approximation
466 should be added for those machines where division is fast.
467 We optimize it by doing most of the calculations
468 in one UWtype registers instead of two, although we don't
469 have to. */
470 # define _FP_SQRT_MEAT_E(R, S, T, X, q) \
471 do \
472 { \
473 (q) = (_FP_W_TYPE) 1 << (_FP_W_TYPE_SIZE - 1); \
474 _FP_FRAC_SRL_2 (X, (_FP_WORKBITS)); \
475 while (q) \
476 { \
477 T##_f0 = S##_f0 + (q); \
478 if (T##_f0 <= X##_f0) \
479 { \
480 S##_f0 = T##_f0 + (q); \
481 X##_f0 -= T##_f0; \
482 R##_f0 += (q); \
483 } \
484 _FP_FRAC_SLL_1 (X, 1); \
485 (q) >>= 1; \
486 } \
487 _FP_FRAC_SLL_2 (R, (_FP_WORKBITS)); \
488 if (X##_f0) \
489 { \
490 if (S##_f0 < X##_f0) \
491 R##_f0 |= _FP_WORK_ROUND; \
492 R##_f0 |= _FP_WORK_STICKY; \
493 } \
494 } \
495 while (0)
496
497 # define FP_CMP_E(r, X, Y, un, ex) _FP_CMP (E, 2, (r), X, Y, (un), (ex))
498 # define FP_CMP_EQ_E(r, X, Y, ex) _FP_CMP_EQ (E, 2, (r), X, Y, (ex))
499 # define FP_CMP_UNORD_E(r, X, Y, ex) _FP_CMP_UNORD (E, 2, (r), X, Y, (ex))
500
501 # define FP_TO_INT_E(r, X, rsz, rsg) _FP_TO_INT (E, 2, (r), X, (rsz), (rsg))
502 # define FP_TO_INT_ROUND_E(r, X, rsz, rsg) \
503 _FP_TO_INT_ROUND (E, 2, (r), X, (rsz), (rsg))
504 # define FP_FROM_INT_E(X, r, rs, rt) _FP_FROM_INT (E, 2, X, (r), (rs), rt)
505
506 # define _FP_FRAC_HIGH_E(X) (X##_f1)
507 # define _FP_FRAC_HIGH_RAW_E(X) (X##_f0)
508
509 # define _FP_FRAC_HIGH_DW_E(X) (X##_f[2])
510
511 #endif /* not _FP_W_TYPE_SIZE < 64 */
512
513 #endif /* !SOFT_FP_EXTENDED_H */
sources.redhat.com git mirror of glibc CVS