| blob | 342532a4cc4161724def629eb7d46e1567cd276d |
1 /* Software floating-point emulation. Common operations.
2 Copyright (C) 1997-2015 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4 Contributed by Richard Henderson (rth@cygnus.com),
5 Jakub Jelinek (jj@ultra.linux.cz),
6 David S. Miller (davem@redhat.com) and
7 Peter Maydell (pmaydell@chiark.greenend.org.uk).
9 The GNU C Library is free software; you can redistribute it and/or
10 modify it under the terms of the GNU Lesser General Public
11 License as published by the Free Software Foundation; either
12 version 2.1 of the License, or (at your option) any later version.
14 In addition to the permissions in the GNU Lesser General Public
15 License, the Free Software Foundation gives you unlimited
16 permission to link the compiled version of this file into
17 combinations with other programs, and to distribute those
18 combinations without any restriction coming from the use of this
19 file. (The Lesser General Public License restrictions do apply in
20 other respects; for example, they cover modification of the file,
21 and distribution when not linked into a combine executable.)
23 The GNU C Library is distributed in the hope that it will be useful,
24 but WITHOUT ANY WARRANTY; without even the implied warranty of
25 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
26 Lesser General Public License for more details.
28 You should have received a copy of the GNU Lesser General Public
29 License along with the GNU C Library; if not, see
30 <http://www.gnu.org/licenses/>. */
32 #define _FP_DECL(wc, X) \
33 _FP_I_TYPE X##_c __attribute__ ((unused)); \
34 _FP_I_TYPE X##_s __attribute__ ((unused)); \
35 _FP_I_TYPE X##_e __attribute__ ((unused)); \
36 _FP_FRAC_DECL_##wc (X)
38 /* Test whether the qNaN bit denotes a signaling NaN. */
39 #define _FP_FRAC_SNANP(fs, X) \
40 ((_FP_QNANNEGATEDP) \
41 ? (_FP_FRAC_HIGH_RAW_##fs (X) & _FP_QNANBIT_##fs) \
42 : !(_FP_FRAC_HIGH_RAW_##fs (X) & _FP_QNANBIT_##fs))
43 #define _FP_FRAC_SNANP_SEMIRAW(fs, X) \
44 ((_FP_QNANNEGATEDP) \
45 ? (_FP_FRAC_HIGH_##fs (X) & _FP_QNANBIT_SH_##fs) \
46 : !(_FP_FRAC_HIGH_##fs (X) & _FP_QNANBIT_SH_##fs))
48 /* Finish truly unpacking a native fp value by classifying the kind
49 of fp value and normalizing both the exponent and the fraction. */
51 #define _FP_UNPACK_CANONICAL(fs, wc, X) \
52 do \
53 { \
54 switch (X##_e) \
55 { \
56 default: \
57 _FP_FRAC_HIGH_RAW_##fs (X) |= _FP_IMPLBIT_##fs; \
58 _FP_FRAC_SLL_##wc (X, _FP_WORKBITS); \
59 X##_e -= _FP_EXPBIAS_##fs; \
60 X##_c = FP_CLS_NORMAL; \
61 break; \
62 \
63 case 0: \
64 if (_FP_FRAC_ZEROP_##wc (X)) \
65 X##_c = FP_CLS_ZERO; \
66 else if (FP_DENORM_ZERO) \
67 { \
68 X##_c = FP_CLS_ZERO; \
69 _FP_FRAC_SET_##wc (X, _FP_ZEROFRAC_##wc); \
70 FP_SET_EXCEPTION (FP_EX_DENORM); \
71 } \
72 else \
73 { \
75 _FP_I_TYPE _FP_UNPACK_CANONICAL_shift; \
76 _FP_FRAC_CLZ_##wc (_FP_UNPACK_CANONICAL_shift, \
77 X); \
78 _FP_UNPACK_CANONICAL_shift -= _FP_FRACXBITS_##fs; \
79 _FP_FRAC_SLL_##wc (X, (_FP_UNPACK_CANONICAL_shift \
80 + _FP_WORKBITS)); \
81 X##_e -= (_FP_EXPBIAS_##fs - 1 \
82 + _FP_UNPACK_CANONICAL_shift); \
83 X##_c = FP_CLS_NORMAL; \
84 FP_SET_EXCEPTION (FP_EX_DENORM); \
85 } \
86 break; \
87 \
88 case _FP_EXPMAX_##fs: \
89 if (_FP_FRAC_ZEROP_##wc (X)) \
90 X##_c = FP_CLS_INF; \
91 else \
92 { \
93 X##_c = FP_CLS_NAN; \
95 if (_FP_FRAC_SNANP (fs, X)) \
96 FP_SET_EXCEPTION (FP_EX_INVALID \
97 | FP_EX_INVALID_SNAN); \
98 } \
99 break; \
100 } \
101 } \
102 while (0)
104 /* Finish unpacking an fp value in semi-raw mode: the mantissa is
105 shifted by _FP_WORKBITS but the implicit MSB is not inserted and
106 other classification is not done. */
107 #define _FP_UNPACK_SEMIRAW(fs, wc, X) _FP_FRAC_SLL_##wc (X, _FP_WORKBITS)
109 /* Check whether a raw or semi-raw input value should be flushed to
110 zero, and flush it to zero if so. */
111 #define _FP_CHECK_FLUSH_ZERO(fs, wc, X) \
112 do \
113 { \
114 if (FP_DENORM_ZERO \
115 && X##_e == 0 \
116 && !_FP_FRAC_ZEROP_##wc (X)) \
117 { \
118 _FP_FRAC_SET_##wc (X, _FP_ZEROFRAC_##wc); \
119 FP_SET_EXCEPTION (FP_EX_DENORM); \
120 } \
121 } \
122 while (0)
124 /* A semi-raw value has overflowed to infinity. Adjust the mantissa
125 and exponent appropriately. */
126 #define _FP_OVERFLOW_SEMIRAW(fs, wc, X) \
127 do \
128 { \
129 if (FP_ROUNDMODE == FP_RND_NEAREST \
130 || (FP_ROUNDMODE == FP_RND_PINF && !X##_s) \
131 || (FP_ROUNDMODE == FP_RND_MINF && X##_s)) \
132 { \
133 X##_e = _FP_EXPMAX_##fs; \
134 _FP_FRAC_SET_##wc (X, _FP_ZEROFRAC_##wc); \
135 } \
136 else \
137 { \
138 X##_e = _FP_EXPMAX_##fs - 1; \
139 _FP_FRAC_SET_##wc (X, _FP_MAXFRAC_##wc); \
140 } \
141 FP_SET_EXCEPTION (FP_EX_INEXACT); \
142 FP_SET_EXCEPTION (FP_EX_OVERFLOW); \
143 } \
144 while (0)
146 /* Check for a semi-raw value being a signaling NaN and raise the
147 invalid exception if so. */
148 #define _FP_CHECK_SIGNAN_SEMIRAW(fs, wc, X) \
149 do \
150 { \
151 if (X##_e == _FP_EXPMAX_##fs \
152 && !_FP_FRAC_ZEROP_##wc (X) \
153 && _FP_FRAC_SNANP_SEMIRAW (fs, X)) \
154 FP_SET_EXCEPTION (FP_EX_INVALID | FP_EX_INVALID_SNAN); \
155 } \
156 while (0)
158 /* Choose a NaN result from an operation on two semi-raw NaN
159 values. */
160 #define _FP_CHOOSENAN_SEMIRAW(fs, wc, R, X, Y, OP) \
161 do \
162 { \
164 _FP_FRAC_SRL_##wc (X, _FP_WORKBITS); \
165 _FP_FRAC_SRL_##wc (Y, _FP_WORKBITS); \
166 _FP_CHOOSENAN (fs, wc, R, X, Y, OP); \
167 _FP_FRAC_SLL_##wc (R, _FP_WORKBITS); \
168 } \
169 while (0)
171 /* Make the fractional part a quiet NaN, preserving the payload
172 if possible, otherwise make it the canonical quiet NaN and set
173 the sign bit accordingly. */
174 #define _FP_SETQNAN(fs, wc, X) \
175 do \
176 { \
177 if (_FP_QNANNEGATEDP) \
178 { \
179 _FP_FRAC_HIGH_RAW_##fs (X) &= _FP_QNANBIT_##fs - 1; \
180 if (_FP_FRAC_ZEROP_##wc (X)) \
181 { \
182 X##_s = _FP_NANSIGN_##fs; \
183 _FP_FRAC_SET_##wc (X, _FP_NANFRAC_##fs); \
184 } \
185 } \
186 else \
187 _FP_FRAC_HIGH_RAW_##fs (X) |= _FP_QNANBIT_##fs; \
188 } \
189 while (0)
190 #define _FP_SETQNAN_SEMIRAW(fs, wc, X) \
191 do \
192 { \
193 if (_FP_QNANNEGATEDP) \
194 { \
195 _FP_FRAC_HIGH_##fs (X) &= _FP_QNANBIT_SH_##fs - 1; \
196 if (_FP_FRAC_ZEROP_##wc (X)) \
197 { \
198 X##_s = _FP_NANSIGN_##fs; \
199 _FP_FRAC_SET_##wc (X, _FP_NANFRAC_##fs); \
200 _FP_FRAC_SLL_##wc (X, _FP_WORKBITS); \
201 } \
202 } \
203 else \
204 _FP_FRAC_HIGH_##fs (X) |= _FP_QNANBIT_SH_##fs; \
205 } \
206 while (0)
208 /* Test whether a biased exponent is normal (not zero or maximum). */
209 #define _FP_EXP_NORMAL(fs, wc, X) (((X##_e + 1) & _FP_EXPMAX_##fs) > 1)
211 /* Prepare to pack an fp value in semi-raw mode: the mantissa is
212 rounded and shifted right, with the rounding possibly increasing
213 the exponent (including changing a finite value to infinity). */
214 #define _FP_PACK_SEMIRAW(fs, wc, X) \
215 do \
216 { \
217 int _FP_PACK_SEMIRAW_is_tiny \
218 = X##_e == 0 && !_FP_FRAC_ZEROP_##wc (X); \
219 if (_FP_TININESS_AFTER_ROUNDING \
220 && _FP_PACK_SEMIRAW_is_tiny) \
221 { \
222 FP_DECL_##fs (_FP_PACK_SEMIRAW_T); \
223 _FP_FRAC_COPY_##wc (_FP_PACK_SEMIRAW_T, X); \
224 _FP_PACK_SEMIRAW_T##_s = X##_s; \
225 _FP_PACK_SEMIRAW_T##_e = X##_e; \
226 _FP_FRAC_SLL_##wc (_FP_PACK_SEMIRAW_T, 1); \
227 _FP_ROUND (wc, _FP_PACK_SEMIRAW_T); \
228 if (_FP_FRAC_OVERP_##wc (fs, _FP_PACK_SEMIRAW_T)) \
229 _FP_PACK_SEMIRAW_is_tiny = 0; \
230 } \
231 _FP_ROUND (wc, X); \
232 if (_FP_PACK_SEMIRAW_is_tiny) \
233 { \
234 if ((FP_CUR_EXCEPTIONS & FP_EX_INEXACT) \
235 || (FP_TRAPPING_EXCEPTIONS & FP_EX_UNDERFLOW)) \
236 FP_SET_EXCEPTION (FP_EX_UNDERFLOW); \
237 } \
238 if (_FP_FRAC_HIGH_##fs (X) \
239 & (_FP_OVERFLOW_##fs >> 1)) \
240 { \
241 _FP_FRAC_HIGH_##fs (X) &= ~(_FP_OVERFLOW_##fs >> 1); \
242 X##_e++; \
243 if (X##_e == _FP_EXPMAX_##fs) \
244 _FP_OVERFLOW_SEMIRAW (fs, wc, X); \
245 } \
246 _FP_FRAC_SRL_##wc (X, _FP_WORKBITS); \
247 if (X##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc (X)) \
248 { \
249 if (!_FP_KEEPNANFRACP) \
250 { \
251 _FP_FRAC_SET_##wc (X, _FP_NANFRAC_##fs); \
252 X##_s = _FP_NANSIGN_##fs; \
253 } \
254 else \
255 _FP_SETQNAN (fs, wc, X); \
256 } \
257 } \
258 while (0)
260 /* Before packing the bits back into the native fp result, take care
261 of such mundane things as rounding and overflow. Also, for some
262 kinds of fp values, the original parts may not have been fully
263 extracted -- but that is ok, we can regenerate them now. */
265 #define _FP_PACK_CANONICAL(fs, wc, X) \
266 do \
267 { \
268 switch (X##_c) \
269 { \
270 case FP_CLS_NORMAL: \
271 X##_e += _FP_EXPBIAS_##fs; \
272 if (X##_e > 0) \
273 { \
274 _FP_ROUND (wc, X); \
275 if (_FP_FRAC_OVERP_##wc (fs, X)) \
276 { \
277 _FP_FRAC_CLEAR_OVERP_##wc (fs, X); \
278 X##_e++; \
279 } \
280 _FP_FRAC_SRL_##wc (X, _FP_WORKBITS); \
281 if (X##_e >= _FP_EXPMAX_##fs) \
282 { \
284 switch (FP_ROUNDMODE) \
285 { \
286 case FP_RND_NEAREST: \
287 X##_c = FP_CLS_INF; \
288 break; \
289 case FP_RND_PINF: \
290 if (!X##_s) \
291 X##_c = FP_CLS_INF; \
292 break; \
293 case FP_RND_MINF: \
294 if (X##_s) \
295 X##_c = FP_CLS_INF; \
296 break; \
297 } \
298 if (X##_c == FP_CLS_INF) \
299 { \
301 X##_e = _FP_EXPMAX_##fs; \
302 _FP_FRAC_SET_##wc (X, _FP_ZEROFRAC_##wc); \
303 } \
304 else \
305 { \
307 X##_e = _FP_EXPMAX_##fs - 1; \
308 _FP_FRAC_SET_##wc (X, _FP_MAXFRAC_##wc); \
309 } \
310 FP_SET_EXCEPTION (FP_EX_OVERFLOW); \
311 FP_SET_EXCEPTION (FP_EX_INEXACT); \
312 } \
313 } \
314 else \
315 { \
317 int _FP_PACK_CANONICAL_is_tiny = 1; \
318 if (_FP_TININESS_AFTER_ROUNDING && X##_e == 0) \
319 { \
320 FP_DECL_##fs (_FP_PACK_CANONICAL_T); \
321 _FP_FRAC_COPY_##wc (_FP_PACK_CANONICAL_T, X); \
322 _FP_PACK_CANONICAL_T##_s = X##_s; \
323 _FP_PACK_CANONICAL_T##_e = X##_e; \
324 _FP_ROUND (wc, _FP_PACK_CANONICAL_T); \
325 if (_FP_FRAC_OVERP_##wc (fs, _FP_PACK_CANONICAL_T)) \
326 _FP_PACK_CANONICAL_is_tiny = 0; \
327 } \
328 X##_e = -X##_e + 1; \
329 if (X##_e <= _FP_WFRACBITS_##fs) \
330 { \
331 _FP_FRAC_SRS_##wc (X, X##_e, _FP_WFRACBITS_##fs); \
332 _FP_ROUND (wc, X); \
333 if (_FP_FRAC_HIGH_##fs (X) \
334 & (_FP_OVERFLOW_##fs >> 1)) \
335 { \
336 X##_e = 1; \
337 _FP_FRAC_SET_##wc (X, _FP_ZEROFRAC_##wc); \
338 FP_SET_EXCEPTION (FP_EX_INEXACT); \
339 } \
340 else \
341 { \
342 X##_e = 0; \
343 _FP_FRAC_SRL_##wc (X, _FP_WORKBITS); \
344 } \
345 if (_FP_PACK_CANONICAL_is_tiny \
346 && ((FP_CUR_EXCEPTIONS & FP_EX_INEXACT) \
347 || (FP_TRAPPING_EXCEPTIONS \
348 & FP_EX_UNDERFLOW))) \
349 FP_SET_EXCEPTION (FP_EX_UNDERFLOW); \
350 } \
351 else \
352 { \
354 X##_e = 0; \
355 if (!_FP_FRAC_ZEROP_##wc (X)) \
356 { \
357 _FP_FRAC_SET_##wc (X, _FP_MINFRAC_##wc); \
358 _FP_ROUND (wc, X); \
359 _FP_FRAC_LOW_##wc (X) >>= (_FP_WORKBITS); \
360 } \
361 FP_SET_EXCEPTION (FP_EX_UNDERFLOW); \
362 } \
363 } \
364 break; \
365 \
366 case FP_CLS_ZERO: \
367 X##_e = 0; \
368 _FP_FRAC_SET_##wc (X, _FP_ZEROFRAC_##wc); \
369 break; \
370 \
371 case FP_CLS_INF: \
372 X##_e = _FP_EXPMAX_##fs; \
373 _FP_FRAC_SET_##wc (X, _FP_ZEROFRAC_##wc); \
374 break; \
375 \
376 case FP_CLS_NAN: \
377 X##_e = _FP_EXPMAX_##fs; \
378 if (!_FP_KEEPNANFRACP) \
379 { \
380 _FP_FRAC_SET_##wc (X, _FP_NANFRAC_##fs); \
381 X##_s = _FP_NANSIGN_##fs; \
382 } \
383 else \
384 _FP_SETQNAN (fs, wc, X); \
385 break; \
386 } \
387 } \
388 while (0)
390 /* This one accepts raw argument and not cooked, returns
391 1 if X is a signaling NaN. */
392 #define _FP_ISSIGNAN(fs, wc, X) \
393 ({ \
394 int _FP_ISSIGNAN_ret = 0; \
395 if (X##_e == _FP_EXPMAX_##fs) \
396 { \
397 if (!_FP_FRAC_ZEROP_##wc (X) \
398 && _FP_FRAC_SNANP (fs, X)) \
399 _FP_ISSIGNAN_ret = 1; \
400 } \
401 _FP_ISSIGNAN_ret; \
402 })
408 /* Addition on semi-raw values. */
409 #define _FP_ADD_INTERNAL(fs, wc, R, X, Y, OP) \
410 do \
411 { \
412 _FP_CHECK_FLUSH_ZERO (fs, wc, X); \
413 _FP_CHECK_FLUSH_ZERO (fs, wc, Y); \
414 if (X##_s == Y##_s) \
415 { \
417 __label__ add1, add2, add3, add_done; \
418 R##_s = X##_s; \
419 int _FP_ADD_INTERNAL_ediff = X##_e - Y##_e; \
420 if (_FP_ADD_INTERNAL_ediff > 0) \
421 { \
422 R##_e = X##_e; \
423 if (Y##_e == 0) \
424 { \
426 if (_FP_FRAC_ZEROP_##wc (Y)) \
427 { \
428 _FP_CHECK_SIGNAN_SEMIRAW (fs, wc, X); \
429 _FP_FRAC_COPY_##wc (R, X); \
430 goto add_done; \
431 } \
432 else \
433 { \
434 FP_SET_EXCEPTION (FP_EX_DENORM); \
435 _FP_ADD_INTERNAL_ediff--; \
436 if (_FP_ADD_INTERNAL_ediff == 0) \
437 { \
438 _FP_FRAC_ADD_##wc (R, X, Y); \
439 goto add3; \
440 } \
441 if (X##_e == _FP_EXPMAX_##fs) \
442 { \
443 _FP_CHECK_SIGNAN_SEMIRAW (fs, wc, X); \
444 _FP_FRAC_COPY_##wc (R, X); \
445 goto add_done; \
446 } \
447 goto add1; \
448 } \
449 } \
450 else if (X##_e == _FP_EXPMAX_##fs) \
451 { \
453 _FP_CHECK_SIGNAN_SEMIRAW (fs, wc, X); \
454 _FP_FRAC_COPY_##wc (R, X); \
455 goto add_done; \
456 } \
457 \
459 _FP_FRAC_HIGH_##fs (Y) |= _FP_IMPLBIT_SH_##fs; \
460 \
461 add1: \
462 /* Shift the mantissa of Y to the right \
463 _FP_ADD_INTERNAL_EDIFF steps; remember to account \
465 if (_FP_ADD_INTERNAL_ediff <= _FP_WFRACBITS_##fs) \
466 _FP_FRAC_SRS_##wc (Y, _FP_ADD_INTERNAL_ediff, \
467 _FP_WFRACBITS_##fs); \
468 else if (!_FP_FRAC_ZEROP_##wc (Y)) \
469 _FP_FRAC_SET_##wc (Y, _FP_MINFRAC_##wc); \
470 _FP_FRAC_ADD_##wc (R, X, Y); \
471 } \
472 else if (_FP_ADD_INTERNAL_ediff < 0) \
473 { \
474 _FP_ADD_INTERNAL_ediff = -_FP_ADD_INTERNAL_ediff; \
475 R##_e = Y##_e; \
476 if (X##_e == 0) \
477 { \
479 if (_FP_FRAC_ZEROP_##wc (X)) \
480 { \
481 _FP_CHECK_SIGNAN_SEMIRAW (fs, wc, Y); \
482 _FP_FRAC_COPY_##wc (R, Y); \
483 goto add_done; \
484 } \
485 else \
486 { \
487 FP_SET_EXCEPTION (FP_EX_DENORM); \
488 _FP_ADD_INTERNAL_ediff--; \
489 if (_FP_ADD_INTERNAL_ediff == 0) \
490 { \
491 _FP_FRAC_ADD_##wc (R, Y, X); \
492 goto add3; \
493 } \
494 if (Y##_e == _FP_EXPMAX_##fs) \
495 { \
496 _FP_CHECK_SIGNAN_SEMIRAW (fs, wc, Y); \
497 _FP_FRAC_COPY_##wc (R, Y); \
498 goto add_done; \
499 } \
500 goto add2; \
501 } \
502 } \
503 else if (Y##_e == _FP_EXPMAX_##fs) \
504 { \
506 _FP_CHECK_SIGNAN_SEMIRAW (fs, wc, Y); \
507 _FP_FRAC_COPY_##wc (R, Y); \
508 goto add_done; \
509 } \
510 \
512 _FP_FRAC_HIGH_##fs (X) |= _FP_IMPLBIT_SH_##fs; \
513 \
514 add2: \
515 /* Shift the mantissa of X to the right \
516 _FP_ADD_INTERNAL_EDIFF steps; remember to account \
518 if (_FP_ADD_INTERNAL_ediff <= _FP_WFRACBITS_##fs) \
519 _FP_FRAC_SRS_##wc (X, _FP_ADD_INTERNAL_ediff, \
520 _FP_WFRACBITS_##fs); \
521 else if (!_FP_FRAC_ZEROP_##wc (X)) \
522 _FP_FRAC_SET_##wc (X, _FP_MINFRAC_##wc); \
523 _FP_FRAC_ADD_##wc (R, Y, X); \
524 } \
525 else \
526 { \
528 if (!_FP_EXP_NORMAL (fs, wc, X)) \
529 { \
530 if (X##_e == 0) \
531 { \
533 R##_e = 0; \
534 if (_FP_FRAC_ZEROP_##wc (X)) \
535 { \
536 if (!_FP_FRAC_ZEROP_##wc (Y)) \
537 FP_SET_EXCEPTION (FP_EX_DENORM); \
538 _FP_FRAC_COPY_##wc (R, Y); \
539 goto add_done; \
540 } \
541 else if (_FP_FRAC_ZEROP_##wc (Y)) \
542 { \
543 FP_SET_EXCEPTION (FP_EX_DENORM); \
544 _FP_FRAC_COPY_##wc (R, X); \
545 goto add_done; \
546 } \
547 else \
548 { \
549 FP_SET_EXCEPTION (FP_EX_DENORM); \
550 _FP_FRAC_ADD_##wc (R, X, Y); \
551 if (_FP_FRAC_HIGH_##fs (R) & _FP_IMPLBIT_SH_##fs) \
552 { \
554 _FP_FRAC_HIGH_##fs (R) \
555 &= ~(_FP_W_TYPE) _FP_IMPLBIT_SH_##fs; \
556 R##_e = 1; \
557 } \
558 goto add_done; \
559 } \
560 } \
561 else \
562 { \
564 _FP_CHECK_SIGNAN_SEMIRAW (fs, wc, X); \
565 _FP_CHECK_SIGNAN_SEMIRAW (fs, wc, Y); \
566 R##_e = _FP_EXPMAX_##fs; \
567 if (_FP_FRAC_ZEROP_##wc (X)) \
568 _FP_FRAC_COPY_##wc (R, Y); \
569 else if (_FP_FRAC_ZEROP_##wc (Y)) \
570 _FP_FRAC_COPY_##wc (R, X); \
571 else \
572 _FP_CHOOSENAN_SEMIRAW (fs, wc, R, X, Y, OP); \
573 goto add_done; \
574 } \
575 } \
576 /* The exponents of X and Y, both normal, are equal. The \
577 implicit MSBs will always add to increase the \
579 _FP_FRAC_ADD_##wc (R, X, Y); \
580 R##_e = X##_e + 1; \
581 _FP_FRAC_SRS_##wc (R, 1, _FP_WFRACBITS_##fs); \
582 if (R##_e == _FP_EXPMAX_##fs) \
584 _FP_OVERFLOW_SEMIRAW (fs, wc, R); \
585 goto add_done; \
586 } \
587 add3: \
588 if (_FP_FRAC_HIGH_##fs (R) & _FP_IMPLBIT_SH_##fs) \
589 { \
591 _FP_FRAC_HIGH_##fs (R) &= ~(_FP_W_TYPE) _FP_IMPLBIT_SH_##fs; \
592 R##_e++; \
593 _FP_FRAC_SRS_##wc (R, 1, _FP_WFRACBITS_##fs); \
594 if (R##_e == _FP_EXPMAX_##fs) \
596 _FP_OVERFLOW_SEMIRAW (fs, wc, R); \
597 } \
598 add_done: ; \
599 } \
600 else \
601 { \
603 __label__ sub1, sub2, sub3, norm, sub_done; \
604 int _FP_ADD_INTERNAL_ediff = X##_e - Y##_e; \
605 if (_FP_ADD_INTERNAL_ediff > 0) \
606 { \
607 R##_e = X##_e; \
608 R##_s = X##_s; \
609 if (Y##_e == 0) \
610 { \
612 if (_FP_FRAC_ZEROP_##wc (Y)) \
613 { \
614 _FP_CHECK_SIGNAN_SEMIRAW (fs, wc, X); \
615 _FP_FRAC_COPY_##wc (R, X); \
616 goto sub_done; \
617 } \
618 else \
619 { \
620 FP_SET_EXCEPTION (FP_EX_DENORM); \
621 _FP_ADD_INTERNAL_ediff--; \
622 if (_FP_ADD_INTERNAL_ediff == 0) \
623 { \
624 _FP_FRAC_SUB_##wc (R, X, Y); \
625 goto sub3; \
626 } \
627 if (X##_e == _FP_EXPMAX_##fs) \
628 { \
629 _FP_CHECK_SIGNAN_SEMIRAW (fs, wc, X); \
630 _FP_FRAC_COPY_##wc (R, X); \
631 goto sub_done; \
632 } \
633 goto sub1; \
634 } \
635 } \
636 else if (X##_e == _FP_EXPMAX_##fs) \
637 { \
639 _FP_CHECK_SIGNAN_SEMIRAW (fs, wc, X); \
640 _FP_FRAC_COPY_##wc (R, X); \
641 goto sub_done; \
642 } \
643 \
645 _FP_FRAC_HIGH_##fs (Y) |= _FP_IMPLBIT_SH_##fs; \
646 \
647 sub1: \
648 /* Shift the mantissa of Y to the right \
649 _FP_ADD_INTERNAL_EDIFF steps; remember to account \
651 if (_FP_ADD_INTERNAL_ediff <= _FP_WFRACBITS_##fs) \
652 _FP_FRAC_SRS_##wc (Y, _FP_ADD_INTERNAL_ediff, \
653 _FP_WFRACBITS_##fs); \
654 else if (!_FP_FRAC_ZEROP_##wc (Y)) \
655 _FP_FRAC_SET_##wc (Y, _FP_MINFRAC_##wc); \
656 _FP_FRAC_SUB_##wc (R, X, Y); \
657 } \
658 else if (_FP_ADD_INTERNAL_ediff < 0) \
659 { \
660 _FP_ADD_INTERNAL_ediff = -_FP_ADD_INTERNAL_ediff; \
661 R##_e = Y##_e; \
662 R##_s = Y##_s; \
663 if (X##_e == 0) \
664 { \
666 if (_FP_FRAC_ZEROP_##wc (X)) \
667 { \
668 _FP_CHECK_SIGNAN_SEMIRAW (fs, wc, Y); \
669 _FP_FRAC_COPY_##wc (R, Y); \
670 goto sub_done; \
671 } \
672 else \
673 { \
674 FP_SET_EXCEPTION (FP_EX_DENORM); \
675 _FP_ADD_INTERNAL_ediff--; \
676 if (_FP_ADD_INTERNAL_ediff == 0) \
677 { \
678 _FP_FRAC_SUB_##wc (R, Y, X); \
679 goto sub3; \
680 } \
681 if (Y##_e == _FP_EXPMAX_##fs) \
682 { \
683 _FP_CHECK_SIGNAN_SEMIRAW (fs, wc, Y); \
684 _FP_FRAC_COPY_##wc (R, Y); \
685 goto sub_done; \
686 } \
687 goto sub2; \
688 } \
689 } \
690 else if (Y##_e == _FP_EXPMAX_##fs) \
691 { \
693 _FP_CHECK_SIGNAN_SEMIRAW (fs, wc, Y); \
694 _FP_FRAC_COPY_##wc (R, Y); \
695 goto sub_done; \
696 } \
697 \
699 _FP_FRAC_HIGH_##fs (X) |= _FP_IMPLBIT_SH_##fs; \
700 \
701 sub2: \
702 /* Shift the mantissa of X to the right \
703 _FP_ADD_INTERNAL_EDIFF steps; remember to account \
705 if (_FP_ADD_INTERNAL_ediff <= _FP_WFRACBITS_##fs) \
706 _FP_FRAC_SRS_##wc (X, _FP_ADD_INTERNAL_ediff, \
707 _FP_WFRACBITS_##fs); \
708 else if (!_FP_FRAC_ZEROP_##wc (X)) \
709 _FP_FRAC_SET_##wc (X, _FP_MINFRAC_##wc); \
710 _FP_FRAC_SUB_##wc (R, Y, X); \
711 } \
712 else \
713 { \
715 if (!_FP_EXP_NORMAL (fs, wc, X)) \
716 { \
717 if (X##_e == 0) \
718 { \
720 R##_e = 0; \
721 if (_FP_FRAC_ZEROP_##wc (X)) \
722 { \
723 _FP_FRAC_COPY_##wc (R, Y); \
724 if (_FP_FRAC_ZEROP_##wc (Y)) \
725 R##_s = (FP_ROUNDMODE == FP_RND_MINF); \
726 else \
727 { \
728 FP_SET_EXCEPTION (FP_EX_DENORM); \
729 R##_s = Y##_s; \
730 } \
731 goto sub_done; \
732 } \
733 else if (_FP_FRAC_ZEROP_##wc (Y)) \
734 { \
735 FP_SET_EXCEPTION (FP_EX_DENORM); \
736 _FP_FRAC_COPY_##wc (R, X); \
737 R##_s = X##_s; \
738 goto sub_done; \
739 } \
740 else \
741 { \
742 FP_SET_EXCEPTION (FP_EX_DENORM); \
743 _FP_FRAC_SUB_##wc (R, X, Y); \
744 R##_s = X##_s; \
745 if (_FP_FRAC_HIGH_##fs (R) & _FP_IMPLBIT_SH_##fs) \
746 { \
748 _FP_FRAC_SUB_##wc (R, Y, X); \
749 R##_s = Y##_s; \
750 } \
751 else if (_FP_FRAC_ZEROP_##wc (R)) \
752 R##_s = (FP_ROUNDMODE == FP_RND_MINF); \
753 goto sub_done; \
754 } \
755 } \
756 else \
757 { \
759 _FP_CHECK_SIGNAN_SEMIRAW (fs, wc, X); \
760 _FP_CHECK_SIGNAN_SEMIRAW (fs, wc, Y); \
761 R##_e = _FP_EXPMAX_##fs; \
762 if (_FP_FRAC_ZEROP_##wc (X)) \
763 { \
764 if (_FP_FRAC_ZEROP_##wc (Y)) \
765 { \
767 R##_s = _FP_NANSIGN_##fs; \
768 _FP_FRAC_SET_##wc (R, _FP_NANFRAC_##fs); \
769 _FP_FRAC_SLL_##wc (R, _FP_WORKBITS); \
770 FP_SET_EXCEPTION (FP_EX_INVALID \
771 | FP_EX_INVALID_ISI); \
772 } \
773 else \
774 { \
776 R##_s = Y##_s; \
777 _FP_FRAC_COPY_##wc (R, Y); \
778 } \
779 } \
780 else \
781 { \
782 if (_FP_FRAC_ZEROP_##wc (Y)) \
783 { \
785 R##_s = X##_s; \
786 _FP_FRAC_COPY_##wc (R, X); \
787 } \
788 else \
789 { \
791 _FP_CHOOSENAN_SEMIRAW (fs, wc, R, X, Y, OP); \
792 } \
793 } \
794 goto sub_done; \
795 } \
796 } \
797 /* The exponents of X and Y, both normal, are equal. The \
799 R##_e = X##_e; \
800 _FP_FRAC_SUB_##wc (R, X, Y); \
801 R##_s = X##_s; \
802 if (_FP_FRAC_HIGH_##fs (R) & _FP_IMPLBIT_SH_##fs) \
803 { \
805 _FP_FRAC_SUB_##wc (R, Y, X); \
806 R##_s = Y##_s; \
807 } \
808 else if (_FP_FRAC_ZEROP_##wc (R)) \
809 { \
810 R##_e = 0; \
811 R##_s = (FP_ROUNDMODE == FP_RND_MINF); \
812 goto sub_done; \
813 } \
814 goto norm; \
815 } \
816 sub3: \
817 if (_FP_FRAC_HIGH_##fs (R) & _FP_IMPLBIT_SH_##fs) \
818 { \
819 int _FP_ADD_INTERNAL_diff; \
820 /* Carry into most significant bit of larger one of X and Y, \
822 _FP_FRAC_HIGH_##fs (R) &= _FP_IMPLBIT_SH_##fs - 1; \
823 norm: \
824 _FP_FRAC_CLZ_##wc (_FP_ADD_INTERNAL_diff, R); \
825 _FP_ADD_INTERNAL_diff -= _FP_WFRACXBITS_##fs; \
826 _FP_FRAC_SLL_##wc (R, _FP_ADD_INTERNAL_diff); \
827 if (R##_e <= _FP_ADD_INTERNAL_diff) \
828 { \
830 _FP_ADD_INTERNAL_diff \
831 = _FP_ADD_INTERNAL_diff - R##_e + 1; \
832 _FP_FRAC_SRS_##wc (R, _FP_ADD_INTERNAL_diff, \
833 _FP_WFRACBITS_##fs); \
834 R##_e = 0; \
835 } \
836 else \
837 { \
838 R##_e -= _FP_ADD_INTERNAL_diff; \
839 _FP_FRAC_HIGH_##fs (R) &= ~(_FP_W_TYPE) _FP_IMPLBIT_SH_##fs; \
840 } \
841 } \
842 sub_done: ; \
843 } \
844 } \
845 while (0)
848 #define _FP_SUB(fs, wc, R, X, Y) \
849 do \
850 { \
851 if (!(Y##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc (Y))) \
852 Y##_s ^= 1; \
854 } \
855 while (0)
858 /* Main negation routine. The input value is raw. */
860 #define _FP_NEG(fs, wc, R, X) \
861 do \
862 { \
863 _FP_FRAC_COPY_##wc (R, X); \
864 R##_e = X##_e; \
865 R##_s = 1 ^ X##_s; \
866 } \
867 while (0)
870 /* Main multiplication routine. The input values should be cooked. */
872 #define _FP_MUL(fs, wc, R, X, Y) \
873 do \
874 { \
875 R##_s = X##_s ^ Y##_s; \
876 R##_e = X##_e + Y##_e + 1; \
877 switch (_FP_CLS_COMBINE (X##_c, Y##_c)) \
878 { \
879 case _FP_CLS_COMBINE (FP_CLS_NORMAL, FP_CLS_NORMAL): \
880 R##_c = FP_CLS_NORMAL; \
881 \
882 _FP_MUL_MEAT_##fs (R, X, Y); \
883 \
884 if (_FP_FRAC_OVERP_##wc (fs, R)) \
885 _FP_FRAC_SRS_##wc (R, 1, _FP_WFRACBITS_##fs); \
886 else \
887 R##_e--; \
888 break; \
889 \
890 case _FP_CLS_COMBINE (FP_CLS_NAN, FP_CLS_NAN): \
892 break; \
893 \
894 case _FP_CLS_COMBINE (FP_CLS_NAN, FP_CLS_NORMAL): \
895 case _FP_CLS_COMBINE (FP_CLS_NAN, FP_CLS_INF): \
896 case _FP_CLS_COMBINE (FP_CLS_NAN, FP_CLS_ZERO): \
897 R##_s = X##_s; \
898 \
899 case _FP_CLS_COMBINE (FP_CLS_INF, FP_CLS_INF): \
900 case _FP_CLS_COMBINE (FP_CLS_INF, FP_CLS_NORMAL): \
901 case _FP_CLS_COMBINE (FP_CLS_ZERO, FP_CLS_NORMAL): \
902 case _FP_CLS_COMBINE (FP_CLS_ZERO, FP_CLS_ZERO): \
903 _FP_FRAC_COPY_##wc (R, X); \
904 R##_c = X##_c; \
905 break; \
906 \
907 case _FP_CLS_COMBINE (FP_CLS_NORMAL, FP_CLS_NAN): \
908 case _FP_CLS_COMBINE (FP_CLS_INF, FP_CLS_NAN): \
909 case _FP_CLS_COMBINE (FP_CLS_ZERO, FP_CLS_NAN): \
910 R##_s = Y##_s; \
911 \
912 case _FP_CLS_COMBINE (FP_CLS_NORMAL, FP_CLS_INF): \
913 case _FP_CLS_COMBINE (FP_CLS_NORMAL, FP_CLS_ZERO): \
914 _FP_FRAC_COPY_##wc (R, Y); \
915 R##_c = Y##_c; \
916 break; \
917 \
918 case _FP_CLS_COMBINE (FP_CLS_INF, FP_CLS_ZERO): \
919 case _FP_CLS_COMBINE (FP_CLS_ZERO, FP_CLS_INF): \
920 R##_s = _FP_NANSIGN_##fs; \
921 R##_c = FP_CLS_NAN; \
922 _FP_FRAC_SET_##wc (R, _FP_NANFRAC_##fs); \
923 FP_SET_EXCEPTION (FP_EX_INVALID | FP_EX_INVALID_IMZ); \
924 break; \
925 \
926 default: \
927 abort (); \
928 } \
929 } \
930 while (0)
933 /* Fused multiply-add. The input values should be cooked. */
935 #define _FP_FMA(fs, wc, dwc, R, X, Y, Z) \
936 do \
937 { \
938 __label__ done_fma; \
939 FP_DECL_##fs (_FP_FMA_T); \
940 _FP_FMA_T##_s = X##_s ^ Y##_s; \
941 _FP_FMA_T##_e = X##_e + Y##_e + 1; \
942 switch (_FP_CLS_COMBINE (X##_c, Y##_c)) \
943 { \
944 case _FP_CLS_COMBINE (FP_CLS_NORMAL, FP_CLS_NORMAL): \
945 switch (Z##_c) \
946 { \
947 case FP_CLS_INF: \
948 case FP_CLS_NAN: \
949 R##_s = Z##_s; \
950 _FP_FRAC_COPY_##wc (R, Z); \
951 R##_c = Z##_c; \
952 break; \
953 \
954 case FP_CLS_ZERO: \
955 R##_c = FP_CLS_NORMAL; \
956 R##_s = _FP_FMA_T##_s; \
957 R##_e = _FP_FMA_T##_e; \
958 \
959 _FP_MUL_MEAT_##fs (R, X, Y); \
960 \
961 if (_FP_FRAC_OVERP_##wc (fs, R)) \
962 _FP_FRAC_SRS_##wc (R, 1, _FP_WFRACBITS_##fs); \
963 else \
964 R##_e--; \
965 break; \
966 \
967 case FP_CLS_NORMAL:; \
968 _FP_FRAC_DECL_##dwc (_FP_FMA_TD); \
969 _FP_FRAC_DECL_##dwc (_FP_FMA_ZD); \
970 _FP_FRAC_DECL_##dwc (_FP_FMA_RD); \
971 _FP_MUL_MEAT_DW_##fs (_FP_FMA_TD, X, Y); \
972 R##_e = _FP_FMA_T##_e; \
973 int _FP_FMA_tsh \
974 = _FP_FRAC_HIGHBIT_DW_##dwc (fs, _FP_FMA_TD) == 0; \
975 _FP_FMA_T##_e -= _FP_FMA_tsh; \
976 int _FP_FMA_ediff = _FP_FMA_T##_e - Z##_e; \
977 if (_FP_FMA_ediff >= 0) \
978 { \
979 int _FP_FMA_shift \
980 = _FP_WFRACBITS_##fs - _FP_FMA_tsh - _FP_FMA_ediff; \
981 if (_FP_FMA_shift <= -_FP_WFRACBITS_##fs) \
982 _FP_FRAC_SET_##dwc (_FP_FMA_ZD, _FP_MINFRAC_##dwc); \
983 else \
984 { \
985 _FP_FRAC_COPY_##dwc##_##wc (_FP_FMA_ZD, Z); \
986 if (_FP_FMA_shift < 0) \
987 _FP_FRAC_SRS_##dwc (_FP_FMA_ZD, -_FP_FMA_shift, \
988 _FP_WFRACBITS_DW_##fs); \
989 else if (_FP_FMA_shift > 0) \
990 _FP_FRAC_SLL_##dwc (_FP_FMA_ZD, _FP_FMA_shift); \
991 } \
992 R##_s = _FP_FMA_T##_s; \
993 if (_FP_FMA_T##_s == Z##_s) \
994 _FP_FRAC_ADD_##dwc (_FP_FMA_RD, _FP_FMA_TD, \
995 _FP_FMA_ZD); \
996 else \
997 { \
998 _FP_FRAC_SUB_##dwc (_FP_FMA_RD, _FP_FMA_TD, \
999 _FP_FMA_ZD); \
1000 if (_FP_FRAC_NEGP_##dwc (_FP_FMA_RD)) \
1001 { \
1002 R##_s = Z##_s; \
1003 _FP_FRAC_SUB_##dwc (_FP_FMA_RD, _FP_FMA_ZD, \
1004 _FP_FMA_TD); \
1005 } \
1006 } \
1007 } \
1008 else \
1009 { \
1010 R##_e = Z##_e; \
1011 R##_s = Z##_s; \
1012 _FP_FRAC_COPY_##dwc##_##wc (_FP_FMA_ZD, Z); \
1013 _FP_FRAC_SLL_##dwc (_FP_FMA_ZD, _FP_WFRACBITS_##fs); \
1014 int _FP_FMA_shift = -_FP_FMA_ediff - _FP_FMA_tsh; \
1015 if (_FP_FMA_shift >= _FP_WFRACBITS_DW_##fs) \
1016 _FP_FRAC_SET_##dwc (_FP_FMA_TD, _FP_MINFRAC_##dwc); \
1017 else if (_FP_FMA_shift > 0) \
1018 _FP_FRAC_SRS_##dwc (_FP_FMA_TD, _FP_FMA_shift, \
1019 _FP_WFRACBITS_DW_##fs); \
1020 if (Z##_s == _FP_FMA_T##_s) \
1021 _FP_FRAC_ADD_##dwc (_FP_FMA_RD, _FP_FMA_ZD, \
1022 _FP_FMA_TD); \
1023 else \
1024 _FP_FRAC_SUB_##dwc (_FP_FMA_RD, _FP_FMA_ZD, \
1025 _FP_FMA_TD); \
1026 } \
1027 if (_FP_FRAC_ZEROP_##dwc (_FP_FMA_RD)) \
1028 { \
1029 if (_FP_FMA_T##_s == Z##_s) \
1030 R##_s = Z##_s; \
1031 else \
1032 R##_s = (FP_ROUNDMODE == FP_RND_MINF); \
1033 _FP_FRAC_SET_##wc (R, _FP_ZEROFRAC_##wc); \
1034 R##_c = FP_CLS_ZERO; \
1035 } \
1036 else \
1037 { \
1038 int _FP_FMA_rlz; \
1039 _FP_FRAC_CLZ_##dwc (_FP_FMA_rlz, _FP_FMA_RD); \
1040 _FP_FMA_rlz -= _FP_WFRACXBITS_DW_##fs; \
1041 R##_e -= _FP_FMA_rlz; \
1042 int _FP_FMA_shift = _FP_WFRACBITS_##fs - _FP_FMA_rlz; \
1043 if (_FP_FMA_shift > 0) \
1044 _FP_FRAC_SRS_##dwc (_FP_FMA_RD, _FP_FMA_shift, \
1045 _FP_WFRACBITS_DW_##fs); \
1046 else if (_FP_FMA_shift < 0) \
1047 _FP_FRAC_SLL_##dwc (_FP_FMA_RD, -_FP_FMA_shift); \
1048 _FP_FRAC_COPY_##wc##_##dwc (R, _FP_FMA_RD); \
1049 R##_c = FP_CLS_NORMAL; \
1050 } \
1051 break; \
1052 } \
1053 goto done_fma; \
1054 \
1055 case _FP_CLS_COMBINE (FP_CLS_NAN, FP_CLS_NAN): \
1057 break; \
1058 \
1059 case _FP_CLS_COMBINE (FP_CLS_NAN, FP_CLS_NORMAL): \
1060 case _FP_CLS_COMBINE (FP_CLS_NAN, FP_CLS_INF): \
1061 case _FP_CLS_COMBINE (FP_CLS_NAN, FP_CLS_ZERO): \
1062 _FP_FMA_T##_s = X##_s; \
1063 \
1064 case _FP_CLS_COMBINE (FP_CLS_INF, FP_CLS_INF): \
1065 case _FP_CLS_COMBINE (FP_CLS_INF, FP_CLS_NORMAL): \
1066 case _FP_CLS_COMBINE (FP_CLS_ZERO, FP_CLS_NORMAL): \
1067 case _FP_CLS_COMBINE (FP_CLS_ZERO, FP_CLS_ZERO): \
1068 _FP_FRAC_COPY_##wc (_FP_FMA_T, X); \
1069 _FP_FMA_T##_c = X##_c; \
1070 break; \
1071 \
1072 case _FP_CLS_COMBINE (FP_CLS_NORMAL, FP_CLS_NAN): \
1073 case _FP_CLS_COMBINE (FP_CLS_INF, FP_CLS_NAN): \
1074 case _FP_CLS_COMBINE (FP_CLS_ZERO, FP_CLS_NAN): \
1075 _FP_FMA_T##_s = Y##_s; \
1076 \
1077 case _FP_CLS_COMBINE (FP_CLS_NORMAL, FP_CLS_INF): \
1078 case _FP_CLS_COMBINE (FP_CLS_NORMAL, FP_CLS_ZERO): \
1079 _FP_FRAC_COPY_##wc (_FP_FMA_T, Y); \
1080 _FP_FMA_T##_c = Y##_c; \
1081 break; \
1082 \
1083 case _FP_CLS_COMBINE (FP_CLS_INF, FP_CLS_ZERO): \
1084 case _FP_CLS_COMBINE (FP_CLS_ZERO, FP_CLS_INF): \
1085 _FP_FMA_T##_s = _FP_NANSIGN_##fs; \
1086 _FP_FMA_T##_c = FP_CLS_NAN; \
1087 _FP_FRAC_SET_##wc (_FP_FMA_T, _FP_NANFRAC_##fs); \
1088 FP_SET_EXCEPTION (FP_EX_INVALID | FP_EX_INVALID_IMZ_FMA); \
1089 break; \
1090 \
1091 default: \
1092 abort (); \
1093 } \
1094 \
1096 switch (_FP_CLS_COMBINE (_FP_FMA_T##_c, Z##_c)) \
1097 { \
1098 case _FP_CLS_COMBINE (FP_CLS_NAN, FP_CLS_NAN): \
1100 break; \
1101 \
1102 case _FP_CLS_COMBINE (FP_CLS_NAN, FP_CLS_NORMAL): \
1103 case _FP_CLS_COMBINE (FP_CLS_NAN, FP_CLS_INF): \
1104 case _FP_CLS_COMBINE (FP_CLS_NAN, FP_CLS_ZERO): \
1105 case _FP_CLS_COMBINE (FP_CLS_INF, FP_CLS_NORMAL): \
1106 case _FP_CLS_COMBINE (FP_CLS_INF, FP_CLS_ZERO): \
1107 R##_s = _FP_FMA_T##_s; \
1108 _FP_FRAC_COPY_##wc (R, _FP_FMA_T); \
1109 R##_c = _FP_FMA_T##_c; \
1110 break; \
1111 \
1112 case _FP_CLS_COMBINE (FP_CLS_INF, FP_CLS_NAN): \
1113 case _FP_CLS_COMBINE (FP_CLS_ZERO, FP_CLS_NAN): \
1114 case _FP_CLS_COMBINE (FP_CLS_ZERO, FP_CLS_NORMAL): \
1115 case _FP_CLS_COMBINE (FP_CLS_ZERO, FP_CLS_INF): \
1116 R##_s = Z##_s; \
1117 _FP_FRAC_COPY_##wc (R, Z); \
1118 R##_c = Z##_c; \
1119 R##_e = Z##_e; \
1120 break; \
1121 \
1122 case _FP_CLS_COMBINE (FP_CLS_INF, FP_CLS_INF): \
1123 if (_FP_FMA_T##_s == Z##_s) \
1124 { \
1125 R##_s = Z##_s; \
1126 _FP_FRAC_COPY_##wc (R, Z); \
1127 R##_c = Z##_c; \
1128 } \
1129 else \
1130 { \
1131 R##_s = _FP_NANSIGN_##fs; \
1132 R##_c = FP_CLS_NAN; \
1133 _FP_FRAC_SET_##wc (R, _FP_NANFRAC_##fs); \
1134 FP_SET_EXCEPTION (FP_EX_INVALID | FP_EX_INVALID_ISI); \
1135 } \
1136 break; \
1137 \
1138 case _FP_CLS_COMBINE (FP_CLS_ZERO, FP_CLS_ZERO): \
1139 if (_FP_FMA_T##_s == Z##_s) \
1140 R##_s = Z##_s; \
1141 else \
1142 R##_s = (FP_ROUNDMODE == FP_RND_MINF); \
1143 _FP_FRAC_COPY_##wc (R, Z); \
1144 R##_c = Z##_c; \
1145 break; \
1146 \
1147 default: \
1148 abort (); \
1149 } \
1150 done_fma: ; \
1151 } \
1152 while (0)
1155 /* Main division routine. The input values should be cooked. */
1157 #define _FP_DIV(fs, wc, R, X, Y) \
1158 do \
1159 { \
1160 R##_s = X##_s ^ Y##_s; \
1161 R##_e = X##_e - Y##_e; \
1162 switch (_FP_CLS_COMBINE (X##_c, Y##_c)) \
1163 { \
1164 case _FP_CLS_COMBINE (FP_CLS_NORMAL, FP_CLS_NORMAL): \
1165 R##_c = FP_CLS_NORMAL; \
1166 \
1167 _FP_DIV_MEAT_##fs (R, X, Y); \
1168 break; \
1169 \
1170 case _FP_CLS_COMBINE (FP_CLS_NAN, FP_CLS_NAN): \
1172 break; \
1173 \
1174 case _FP_CLS_COMBINE (FP_CLS_NAN, FP_CLS_NORMAL): \
1175 case _FP_CLS_COMBINE (FP_CLS_NAN, FP_CLS_INF): \
1176 case _FP_CLS_COMBINE (FP_CLS_NAN, FP_CLS_ZERO): \
1177 R##_s = X##_s; \
1178 _FP_FRAC_COPY_##wc (R, X); \
1179 R##_c = X##_c; \
1180 break; \
1181 \
1182 case _FP_CLS_COMBINE (FP_CLS_NORMAL, FP_CLS_NAN): \
1183 case _FP_CLS_COMBINE (FP_CLS_INF, FP_CLS_NAN): \
1184 case _FP_CLS_COMBINE (FP_CLS_ZERO, FP_CLS_NAN): \
1185 R##_s = Y##_s; \
1186 _FP_FRAC_COPY_##wc (R, Y); \
1187 R##_c = Y##_c; \
1188 break; \
1189 \
1190 case _FP_CLS_COMBINE (FP_CLS_NORMAL, FP_CLS_INF): \
1191 case _FP_CLS_COMBINE (FP_CLS_ZERO, FP_CLS_INF): \
1192 case _FP_CLS_COMBINE (FP_CLS_ZERO, FP_CLS_NORMAL): \
1193 R##_c = FP_CLS_ZERO; \
1194 break; \
1195 \
1196 case _FP_CLS_COMBINE (FP_CLS_NORMAL, FP_CLS_ZERO): \
1197 FP_SET_EXCEPTION (FP_EX_DIVZERO); \
1198 case _FP_CLS_COMBINE (FP_CLS_INF, FP_CLS_ZERO): \
1199 case _FP_CLS_COMBINE (FP_CLS_INF, FP_CLS_NORMAL): \
1200 R##_c = FP_CLS_INF; \
1201 break; \
1202 \
1203 case _FP_CLS_COMBINE (FP_CLS_INF, FP_CLS_INF): \
1204 case _FP_CLS_COMBINE (FP_CLS_ZERO, FP_CLS_ZERO): \
1205 R##_s = _FP_NANSIGN_##fs; \
1206 R##_c = FP_CLS_NAN; \
1207 _FP_FRAC_SET_##wc (R, _FP_NANFRAC_##fs); \
1208 FP_SET_EXCEPTION (FP_EX_INVALID \
1209 | (X##_c == FP_CLS_INF \
1210 ? FP_EX_INVALID_IDI \
1211 : FP_EX_INVALID_ZDZ)); \
1212 break; \
1213 \
1214 default: \
1215 abort (); \
1216 } \
1217 } \
1218 while (0)
1221 /* Helper for comparisons. EX is 0 not to raise exceptions, 1 to
1222 raise exceptions for signaling NaN operands, 2 to raise exceptions
1223 for all NaN operands. Conditionals are organized to allow the
1224 compiler to optimize away code based on the value of EX. */
1226 #define _FP_CMP_CHECK_NAN(fs, wc, X, Y, ex) \
1227 do \
1228 { \
1229 /* The arguments are unordered, which may or may not result in \
1231 if (ex) \
1232 { \
1233 /* At least some cases of unordered arguments result in \
1235 if (FP_EX_INVALID_SNAN || FP_EX_INVALID_VC) \
1236 { \
1237 /* Check separately for each case of "invalid" \
1239 if ((ex) == 2) \
1240 FP_SET_EXCEPTION (FP_EX_INVALID | FP_EX_INVALID_VC); \
1241 if (_FP_ISSIGNAN (fs, wc, X) \
1242 || _FP_ISSIGNAN (fs, wc, Y)) \
1243 FP_SET_EXCEPTION (FP_EX_INVALID | FP_EX_INVALID_SNAN); \
1244 } \
1245 /* Otherwise, we only need to check whether to raise an \
1247 else if ((ex) == 2 \
1248 || _FP_ISSIGNAN (fs, wc, X) \
1249 || _FP_ISSIGNAN (fs, wc, Y)) \
1250 FP_SET_EXCEPTION (FP_EX_INVALID); \
1251 } \
1252 } \
1253 while (0)
1255 /* Helper for comparisons. If denormal operands would raise an
1256 exception, check for them, and flush to zero as appropriate
1257 (otherwise, we need only check and flush to zero if it might affect
1258 the result, which is done later with _FP_CMP_CHECK_FLUSH_ZERO). */
1259 #define _FP_CMP_CHECK_DENORM(fs, wc, X, Y) \
1260 do \
1261 { \
1262 if (FP_EX_DENORM != 0) \
1263 { \
1264 /* We must ensure the correct exceptions are raised for \
1265 denormal operands, even though this may not affect the \
1267 if (FP_DENORM_ZERO) \
1268 { \
1269 _FP_CHECK_FLUSH_ZERO (fs, wc, X); \
1270 _FP_CHECK_FLUSH_ZERO (fs, wc, Y); \
1271 } \
1272 else \
1273 { \
1274 if ((X##_e == 0 && !_FP_FRAC_ZEROP_##wc (X)) \
1275 || (Y##_e == 0 && !_FP_FRAC_ZEROP_##wc (Y))) \
1276 FP_SET_EXCEPTION (FP_EX_DENORM); \
1277 } \
1278 } \
1279 } \
1280 while (0)
1282 /* Helper for comparisons. Check for flushing denormals for zero if
1283 we didn't need to check earlier for any denormal operands. */
1284 #define _FP_CMP_CHECK_FLUSH_ZERO(fs, wc, X, Y) \
1285 do \
1286 { \
1287 if (FP_EX_DENORM == 0) \
1288 { \
1289 _FP_CHECK_FLUSH_ZERO (fs, wc, X); \
1290 _FP_CHECK_FLUSH_ZERO (fs, wc, Y); \
1291 } \
1292 } \
1293 while (0)
1295 /* Main differential comparison routine. The inputs should be raw not
1296 cooked. The return is -1, 0, 1 for normal values, UN
1297 otherwise. */
1299 #define _FP_CMP(fs, wc, ret, X, Y, un, ex) \
1300 do \
1301 { \
1302 _FP_CMP_CHECK_DENORM (fs, wc, X, Y); \
1304 if ((X##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc (X)) \
1305 || (Y##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc (Y))) \
1306 { \
1307 (ret) = (un); \
1308 _FP_CMP_CHECK_NAN (fs, wc, X, Y, (ex)); \
1309 } \
1310 else \
1311 { \
1312 int _FP_CMP_is_zero_x; \
1313 int _FP_CMP_is_zero_y; \
1314 \
1315 _FP_CMP_CHECK_FLUSH_ZERO (fs, wc, X, Y); \
1316 \
1317 _FP_CMP_is_zero_x \
1318 = (!X##_e && _FP_FRAC_ZEROP_##wc (X)) ? 1 : 0; \
1319 _FP_CMP_is_zero_y \
1320 = (!Y##_e && _FP_FRAC_ZEROP_##wc (Y)) ? 1 : 0; \
1321 \
1322 if (_FP_CMP_is_zero_x && _FP_CMP_is_zero_y) \
1323 (ret) = 0; \
1324 else if (_FP_CMP_is_zero_x) \
1325 (ret) = Y##_s ? 1 : -1; \
1326 else if (_FP_CMP_is_zero_y) \
1327 (ret) = X##_s ? -1 : 1; \
1328 else if (X##_s != Y##_s) \
1329 (ret) = X##_s ? -1 : 1; \
1330 else if (X##_e > Y##_e) \
1331 (ret) = X##_s ? -1 : 1; \
1332 else if (X##_e < Y##_e) \
1333 (ret) = X##_s ? 1 : -1; \
1334 else if (_FP_FRAC_GT_##wc (X, Y)) \
1335 (ret) = X##_s ? -1 : 1; \
1336 else if (_FP_FRAC_GT_##wc (Y, X)) \
1337 (ret) = X##_s ? 1 : -1; \
1338 else \
1339 (ret) = 0; \
1340 } \
1341 } \
1342 while (0)
1345 /* Simplification for strict equality. */
1347 #define _FP_CMP_EQ(fs, wc, ret, X, Y, ex) \
1348 do \
1349 { \
1350 _FP_CMP_CHECK_DENORM (fs, wc, X, Y); \
1352 if ((X##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc (X)) \
1353 || (Y##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc (Y))) \
1354 { \
1355 (ret) = 1; \
1356 _FP_CMP_CHECK_NAN (fs, wc, X, Y, (ex)); \
1357 } \
1358 else \
1359 { \
1360 _FP_CMP_CHECK_FLUSH_ZERO (fs, wc, X, Y); \
1361 \
1362 (ret) = !(X##_e == Y##_e \
1363 && _FP_FRAC_EQ_##wc (X, Y) \
1364 && (X##_s == Y##_s \
1365 || (!X##_e && _FP_FRAC_ZEROP_##wc (X)))); \
1366 } \
1367 } \
1368 while (0)
1370 /* Version to test unordered. */
1372 #define _FP_CMP_UNORD(fs, wc, ret, X, Y, ex) \
1373 do \
1374 { \
1375 _FP_CMP_CHECK_DENORM (fs, wc, X, Y); \
1376 (ret) = ((X##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc (X)) \
1377 || (Y##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc (Y))); \
1378 if (ret) \
1379 _FP_CMP_CHECK_NAN (fs, wc, X, Y, (ex)); \
1380 } \
1381 while (0)
1383 /* Main square root routine. The input value should be cooked. */
1385 #define _FP_SQRT(fs, wc, R, X) \
1386 do \
1387 { \
1388 _FP_FRAC_DECL_##wc (_FP_SQRT_T); \
1389 _FP_FRAC_DECL_##wc (_FP_SQRT_S); \
1390 _FP_W_TYPE _FP_SQRT_q; \
1391 switch (X##_c) \
1392 { \
1393 case FP_CLS_NAN: \
1394 _FP_FRAC_COPY_##wc (R, X); \
1395 R##_s = X##_s; \
1396 R##_c = FP_CLS_NAN; \
1397 break; \
1398 case FP_CLS_INF: \
1399 if (X##_s) \
1400 { \
1401 R##_s = _FP_NANSIGN_##fs; \
1403 _FP_FRAC_SET_##wc (R, _FP_NANFRAC_##fs); \
1404 FP_SET_EXCEPTION (FP_EX_INVALID | FP_EX_INVALID_SQRT); \
1405 } \
1406 else \
1407 { \
1408 R##_s = 0; \
1410 } \
1411 break; \
1412 case FP_CLS_ZERO: \
1413 R##_s = X##_s; \
1415 break; \
1416 case FP_CLS_NORMAL: \
1417 R##_s = 0; \
1418 if (X##_s) \
1419 { \
1421 R##_s = _FP_NANSIGN_##fs; \
1422 _FP_FRAC_SET_##wc (R, _FP_NANFRAC_##fs); \
1423 FP_SET_EXCEPTION (FP_EX_INVALID | FP_EX_INVALID_SQRT); \
1424 break; \
1425 } \
1426 R##_c = FP_CLS_NORMAL; \
1427 if (X##_e & 1) \
1428 _FP_FRAC_SLL_##wc (X, 1); \
1429 R##_e = X##_e >> 1; \
1430 _FP_FRAC_SET_##wc (_FP_SQRT_S, _FP_ZEROFRAC_##wc); \
1431 _FP_FRAC_SET_##wc (R, _FP_ZEROFRAC_##wc); \
1432 _FP_SQRT_q = _FP_OVERFLOW_##fs >> 1; \
1433 _FP_SQRT_MEAT_##wc (R, _FP_SQRT_S, _FP_SQRT_T, X, \
1434 _FP_SQRT_q); \
1435 } \
1436 } \
1437 while (0)
1439 /* Convert from FP to integer. Input is raw. */
1441 /* RSIGNED can have following values:
1442 0: the number is required to be 0..(2^rsize)-1, if not, NV is set plus
1443 the result is either 0 or (2^rsize)-1 depending on the sign in such
1444 case.
1445 1: the number is required to be -(2^(rsize-1))..(2^(rsize-1))-1, if not,
1446 NV is set plus the result is either -(2^(rsize-1)) or (2^(rsize-1))-1
1447 depending on the sign in such case.
1448 2: the number is required to be -(2^(rsize-1))..(2^(rsize-1))-1, if not,
1449 NV is set plus the result is reduced modulo 2^rsize.
1450 -1: the number is required to be -(2^(rsize-1))..(2^rsize)-1, if not, NV is
1451 set plus the result is either -(2^(rsize-1)) or (2^(rsize-1))-1
1452 depending on the sign in such case. */
1453 #define _FP_TO_INT(fs, wc, r, X, rsize, rsigned) \
1454 do \
1455 { \
1456 if (X##_e < _FP_EXPBIAS_##fs) \
1457 { \
1458 (r) = 0; \
1459 if (X##_e == 0) \
1460 { \
1461 if (!_FP_FRAC_ZEROP_##wc (X)) \
1462 { \
1463 if (!FP_DENORM_ZERO) \
1464 FP_SET_EXCEPTION (FP_EX_INEXACT); \
1465 FP_SET_EXCEPTION (FP_EX_DENORM); \
1466 } \
1467 } \
1468 else \
1469 FP_SET_EXCEPTION (FP_EX_INEXACT); \
1470 } \
1471 else if ((rsigned) == 2 \
1472 && (X##_e \
1473 >= ((_FP_EXPMAX_##fs \
1474 < _FP_EXPBIAS_##fs + _FP_FRACBITS_##fs + (rsize) - 1) \
1475 ? _FP_EXPMAX_##fs \
1476 : _FP_EXPBIAS_##fs + _FP_FRACBITS_##fs + (rsize) - 1))) \
1477 { \
1479 (r) = 0; \
1480 FP_SET_EXCEPTION (FP_EX_INVALID \
1481 | FP_EX_INVALID_CVI \
1482 | ((FP_EX_INVALID_SNAN \
1483 && _FP_ISSIGNAN (fs, wc, X)) \
1484 ? FP_EX_INVALID_SNAN \
1485 : 0)); \
1486 } \
1487 else if ((rsigned) != 2 \
1488 && (X##_e >= (_FP_EXPMAX_##fs < _FP_EXPBIAS_##fs + (rsize) \
1489 ? _FP_EXPMAX_##fs \
1490 : (_FP_EXPBIAS_##fs + (rsize) \
1491 - ((rsigned) > 0 || X##_s))) \
1492 || (!(rsigned) && X##_s))) \
1493 { \
1495 if (rsigned) \
1496 { \
1497 (r) = 1; \
1498 (r) <<= (rsize) - 1; \
1499 (r) -= 1 - X##_s; \
1500 } \
1501 else \
1502 { \
1503 (r) = 0; \
1504 if (!X##_s) \
1505 (r) = ~(r); \
1506 } \
1507 \
1508 if (_FP_EXPBIAS_##fs + (rsize) - 1 < _FP_EXPMAX_##fs \
1509 && (rsigned) \
1510 && X##_s \
1511 && X##_e == _FP_EXPBIAS_##fs + (rsize) - 1) \
1512 { \
1513 /* Possibly converting to most negative integer; check the \
1515 int _FP_TO_INT_inexact = 0; \
1516 (void) ((_FP_FRACBITS_##fs > (rsize)) \
1517 ? ({ \
1518 _FP_FRAC_SRST_##wc (X, _FP_TO_INT_inexact, \
1519 _FP_FRACBITS_##fs - (rsize), \
1520 _FP_FRACBITS_##fs); \
1521 0; \
1522 }) \
1523 : 0); \
1524 if (!_FP_FRAC_ZEROP_##wc (X)) \
1525 FP_SET_EXCEPTION (FP_EX_INVALID | FP_EX_INVALID_CVI); \
1526 else if (_FP_TO_INT_inexact) \
1527 FP_SET_EXCEPTION (FP_EX_INEXACT); \
1528 } \
1529 else \
1530 FP_SET_EXCEPTION (FP_EX_INVALID \
1531 | FP_EX_INVALID_CVI \
1532 | ((FP_EX_INVALID_SNAN \
1533 && _FP_ISSIGNAN (fs, wc, X)) \
1534 ? FP_EX_INVALID_SNAN \
1535 : 0)); \
1536 } \
1537 else \
1538 { \
1539 int _FP_TO_INT_inexact = 0; \
1540 _FP_FRAC_HIGH_RAW_##fs (X) |= _FP_IMPLBIT_##fs; \
1541 if (X##_e >= _FP_EXPBIAS_##fs + _FP_FRACBITS_##fs - 1) \
1542 { \
1543 _FP_FRAC_ASSEMBLE_##wc ((r), X, (rsize)); \
1544 (r) <<= X##_e - _FP_EXPBIAS_##fs - _FP_FRACBITS_##fs + 1; \
1545 } \
1546 else \
1547 { \
1548 _FP_FRAC_SRST_##wc (X, _FP_TO_INT_inexact, \
1549 (_FP_FRACBITS_##fs + _FP_EXPBIAS_##fs - 1 \
1550 - X##_e), \
1551 _FP_FRACBITS_##fs); \
1552 _FP_FRAC_ASSEMBLE_##wc ((r), X, (rsize)); \
1553 } \
1554 if ((rsigned) && X##_s) \
1555 (r) = -(r); \
1556 if ((rsigned) == 2 && X##_e >= _FP_EXPBIAS_##fs + (rsize) - 1) \
1557 { \
1559 if (X##_e > _FP_EXPBIAS_##fs + (rsize) - 1 \
1560 || !X##_s \
1561 || (r) != (((typeof (r)) 1) << ((rsize) - 1))) \
1562 { \
1563 _FP_TO_INT_inexact = 0; \
1564 FP_SET_EXCEPTION (FP_EX_INVALID | FP_EX_INVALID_CVI); \
1565 } \
1566 } \
1567 if (_FP_TO_INT_inexact) \
1568 FP_SET_EXCEPTION (FP_EX_INEXACT); \
1569 } \
1570 } \
1571 while (0)
1573 /* Convert from floating point to integer, rounding according to the
1574 current rounding direction. Input is raw. RSIGNED is as for
1575 _FP_TO_INT. */
1576 #define _FP_TO_INT_ROUND(fs, wc, r, X, rsize, rsigned) \
1577 do \
1578 { \
1579 __label__ _FP_TO_INT_ROUND_done; \
1580 if (X##_e < _FP_EXPBIAS_##fs) \
1581 { \
1582 int _FP_TO_INT_ROUND_rounds_away = 0; \
1583 if (X##_e == 0) \
1584 { \
1585 if (_FP_FRAC_ZEROP_##wc (X)) \
1586 { \
1587 (r) = 0; \
1588 goto _FP_TO_INT_ROUND_done; \
1589 } \
1590 else \
1591 { \
1592 FP_SET_EXCEPTION (FP_EX_DENORM); \
1593 if (FP_DENORM_ZERO) \
1594 { \
1595 (r) = 0; \
1596 goto _FP_TO_INT_ROUND_done; \
1597 } \
1598 } \
1599 } \
1600 /* The result is 0, 1 or -1 depending on the rounding mode; \
1602 switch (FP_ROUNDMODE) \
1603 { \
1604 case FP_RND_NEAREST: \
1605 _FP_TO_INT_ROUND_rounds_away \
1606 = (X##_e == _FP_EXPBIAS_##fs - 1 \
1607 && !_FP_FRAC_ZEROP_##wc (X)); \
1608 break; \
1609 case FP_RND_ZERO: \
1611 break; \
1612 case FP_RND_PINF: \
1613 _FP_TO_INT_ROUND_rounds_away = !X##_s; \
1614 break; \
1615 case FP_RND_MINF: \
1616 _FP_TO_INT_ROUND_rounds_away = X##_s; \
1617 break; \
1618 } \
1619 if ((rsigned) == 0 && _FP_TO_INT_ROUND_rounds_away && X##_s) \
1620 { \
1622 (r) = 0; \
1623 FP_SET_EXCEPTION (FP_EX_INVALID | FP_EX_INVALID_CVI); \
1624 } \
1625 else if ((rsize) == 1 && (rsigned) > 0 \
1626 && _FP_TO_INT_ROUND_rounds_away && !X##_s) \
1627 { \
1628 /* Converting to a 1-bit signed bit-field, which cannot \
1630 (r) = ((rsigned) == 2 ? -1 : 0); \
1631 FP_SET_EXCEPTION (FP_EX_INVALID | FP_EX_INVALID_CVI); \
1632 } \
1633 else \
1634 { \
1635 (r) = (_FP_TO_INT_ROUND_rounds_away \
1636 ? (X##_s ? -1 : 1) \
1637 : 0); \
1638 FP_SET_EXCEPTION (FP_EX_INEXACT); \
1639 } \
1640 } \
1641 else if ((rsigned) == 2 \
1642 && (X##_e \
1643 >= ((_FP_EXPMAX_##fs \
1644 < _FP_EXPBIAS_##fs + _FP_FRACBITS_##fs + (rsize) - 1) \
1645 ? _FP_EXPMAX_##fs \
1646 : _FP_EXPBIAS_##fs + _FP_FRACBITS_##fs + (rsize) - 1))) \
1647 { \
1649 (r) = 0; \
1650 FP_SET_EXCEPTION (FP_EX_INVALID \
1651 | FP_EX_INVALID_CVI \
1652 | ((FP_EX_INVALID_SNAN \
1653 && _FP_ISSIGNAN (fs, wc, X)) \
1654 ? FP_EX_INVALID_SNAN \
1655 : 0)); \
1656 } \
1657 else if ((rsigned) != 2 \
1658 && (X##_e >= (_FP_EXPMAX_##fs < _FP_EXPBIAS_##fs + (rsize) \
1659 ? _FP_EXPMAX_##fs \
1660 : (_FP_EXPBIAS_##fs + (rsize) \
1661 - ((rsigned) > 0 && !X##_s))) \
1662 || ((rsigned) == 0 && X##_s))) \
1663 { \
1665 if ((rsigned) != 0) \
1666 { \
1667 (r) = 1; \
1668 (r) <<= (rsize) - 1; \
1669 (r) -= 1 - X##_s; \
1670 } \
1671 else \
1672 { \
1673 (r) = 0; \
1674 if (!X##_s) \
1675 (r) = ~(r); \
1676 } \
1677 \
1678 FP_SET_EXCEPTION (FP_EX_INVALID \
1679 | FP_EX_INVALID_CVI \
1680 | ((FP_EX_INVALID_SNAN \
1681 && _FP_ISSIGNAN (fs, wc, X)) \
1682 ? FP_EX_INVALID_SNAN \
1683 : 0)); \
1684 } \
1685 else \
1686 { \
1687 /* The value is finite, with magnitude at least 1. If \
1688 the conversion is unsigned, the value is positive. \
1689 If RSIGNED is not 2, the value does not definitely \
1690 overflow by virtue of its exponent, but may still turn \
1691 out to overflow after rounding; if RSIGNED is 2, the \
1692 exponent may be such that the value definitely overflows, \
1694 int _FP_TO_INT_ROUND_inexact = 0; \
1695 _FP_FRAC_HIGH_RAW_##fs (X) |= _FP_IMPLBIT_##fs; \
1696 if (X##_e >= _FP_EXPBIAS_##fs + _FP_FRACBITS_##fs - 1) \
1697 { \
1699 _FP_FRAC_ASSEMBLE_##wc ((r), X, (rsize)); \
1700 (r) <<= X##_e - _FP_EXPBIAS_##fs - _FP_FRACBITS_##fs + 1; \
1701 } \
1702 else \
1703 { \
1704 /* May need to shift in order to round (unless there \
1706 int _FP_TO_INT_ROUND_rshift \
1707 = (_FP_FRACBITS_##fs + _FP_EXPBIAS_##fs \
1708 - 1 - _FP_WORKBITS - X##_e); \
1709 if (_FP_TO_INT_ROUND_rshift > 0) \
1710 _FP_FRAC_SRS_##wc (X, _FP_TO_INT_ROUND_rshift, \
1711 _FP_WFRACBITS_##fs); \
1712 else if (_FP_TO_INT_ROUND_rshift < 0) \
1713 _FP_FRAC_SLL_##wc (X, -_FP_TO_INT_ROUND_rshift); \
1714 /* Round like _FP_ROUND, but setting \
1715 _FP_TO_INT_ROUND_inexact instead of directly setting \
1716 the "inexact" exception, since it may turn out we \
1718 if (_FP_FRAC_LOW_##wc (X) & 7) \
1719 { \
1720 _FP_TO_INT_ROUND_inexact = 1; \
1721 switch (FP_ROUNDMODE) \
1722 { \
1723 case FP_RND_NEAREST: \
1724 _FP_ROUND_NEAREST (wc, X); \
1725 break; \
1726 case FP_RND_ZERO: \
1727 _FP_ROUND_ZERO (wc, X); \
1728 break; \
1729 case FP_RND_PINF: \
1730 _FP_ROUND_PINF (wc, X); \
1731 break; \
1732 case FP_RND_MINF: \
1733 _FP_ROUND_MINF (wc, X); \
1734 break; \
1735 } \
1736 } \
1737 _FP_FRAC_SRL_##wc (X, _FP_WORKBITS); \
1738 _FP_FRAC_ASSEMBLE_##wc ((r), X, (rsize)); \
1739 } \
1740 if ((rsigned) != 0 && X##_s) \
1741 (r) = -(r); \
1742 /* An exponent of RSIZE - 1 always needs testing for \
1743 overflow (either directly overflowing, or overflowing \
1744 when rounding up results in 2^RSIZE). An exponent of \
1745 RSIZE - 2 can overflow for positive values when rounding \
1746 up to 2^(RSIZE-1), but cannot overflow for negative \
1748 if (X##_e >= (_FP_EXPBIAS_##fs + (rsize) - 1 \
1749 - ((rsigned) > 0 && !X##_s))) \
1750 { \
1751 if (X##_e > _FP_EXPBIAS_##fs + (rsize) - 1 \
1752 || (X##_e == _FP_EXPBIAS_##fs + (rsize) - 1 \
1753 && (X##_s \
1754 ? (r) != (((typeof (r)) 1) << ((rsize) - 1)) \
1755 : ((rsigned) > 0 || (r) == 0))) \
1756 || ((rsigned) > 0 \
1757 && !X##_s \
1758 && X##_e == _FP_EXPBIAS_##fs + (rsize) - 2 \
1759 && (r) == (((typeof (r)) 1) << ((rsize) - 1)))) \
1760 { \
1761 if ((rsigned) != 2) \
1762 { \
1763 if ((rsigned) != 0) \
1764 { \
1765 (r) = 1; \
1766 (r) <<= (rsize) - 1; \
1767 (r) -= 1 - X##_s; \
1768 } \
1769 else \
1770 { \
1771 (r) = 0; \
1772 (r) = ~(r); \
1773 } \
1774 } \
1775 _FP_TO_INT_ROUND_inexact = 0; \
1776 FP_SET_EXCEPTION (FP_EX_INVALID | FP_EX_INVALID_CVI); \
1777 } \
1778 } \
1779 if (_FP_TO_INT_ROUND_inexact) \
1780 FP_SET_EXCEPTION (FP_EX_INEXACT); \
1781 } \
1782 _FP_TO_INT_ROUND_done: ; \
1783 } \
1784 while (0)
1786 /* Convert integer to fp. Output is raw. RTYPE is unsigned even if
1787 input is signed. */
1788 #define _FP_FROM_INT(fs, wc, X, r, rsize, rtype) \
1789 do \
1790 { \
1791 __label__ pack_semiraw; \
1792 if (r) \
1793 { \
1794 rtype _FP_FROM_INT_ur; \
1795 \
1796 if ((X##_s = ((r) < 0))) \
1797 (r) = -(rtype) (r); \
1798 \
1799 _FP_FROM_INT_ur = (rtype) (r); \
1800 (void) (((rsize) <= _FP_W_TYPE_SIZE) \
1801 ? ({ \
1802 int _FP_FROM_INT_lz; \
1803 __FP_CLZ (_FP_FROM_INT_lz, \
1804 (_FP_W_TYPE) _FP_FROM_INT_ur); \
1805 X##_e = (_FP_EXPBIAS_##fs + _FP_W_TYPE_SIZE - 1 \
1806 - _FP_FROM_INT_lz); \
1807 }) \
1808 : (((rsize) <= 2 * _FP_W_TYPE_SIZE) \
1809 ? ({ \
1810 int _FP_FROM_INT_lz; \
1811 __FP_CLZ_2 (_FP_FROM_INT_lz, \
1812 (_FP_W_TYPE) (_FP_FROM_INT_ur \
1813 >> _FP_W_TYPE_SIZE), \
1814 (_FP_W_TYPE) _FP_FROM_INT_ur); \
1815 X##_e = (_FP_EXPBIAS_##fs + 2 * _FP_W_TYPE_SIZE - 1 \
1816 - _FP_FROM_INT_lz); \
1817 }) \
1818 : (abort (), 0))); \
1819 \
1820 if ((rsize) - 1 + _FP_EXPBIAS_##fs >= _FP_EXPMAX_##fs \
1821 && X##_e >= _FP_EXPMAX_##fs) \
1822 { \
1823 /* Exponent too big; overflow to infinity. (May also \
1825 _FP_OVERFLOW_SEMIRAW (fs, wc, X); \
1826 goto pack_semiraw; \
1827 } \
1828 \
1829 if ((rsize) <= _FP_FRACBITS_##fs \
1830 || X##_e < _FP_EXPBIAS_##fs + _FP_FRACBITS_##fs) \
1831 { \
1833 _FP_FRAC_DISASSEMBLE_##wc (X, _FP_FROM_INT_ur, (rsize)); \
1834 if (_FP_EXPBIAS_##fs + _FP_FRACBITS_##fs - 1 - X##_e > 0) \
1835 _FP_FRAC_SLL_##wc (X, (_FP_EXPBIAS_##fs \
1836 + _FP_FRACBITS_##fs - 1 - X##_e)); \
1837 } \
1838 else \
1839 { \
1840 /* More bits in integer than in floating type; need to \
1842 if (_FP_EXPBIAS_##fs + _FP_WFRACBITS_##fs - 1 < X##_e) \
1843 _FP_FROM_INT_ur \
1844 = ((_FP_FROM_INT_ur >> (X##_e - _FP_EXPBIAS_##fs \
1845 - _FP_WFRACBITS_##fs + 1)) \
1846 | ((_FP_FROM_INT_ur \
1847 << ((rsize) - (X##_e - _FP_EXPBIAS_##fs \
1848 - _FP_WFRACBITS_##fs + 1))) \
1849 != 0)); \
1850 _FP_FRAC_DISASSEMBLE_##wc (X, _FP_FROM_INT_ur, (rsize)); \
1851 if ((_FP_EXPBIAS_##fs + _FP_WFRACBITS_##fs - 1 - X##_e) > 0) \
1852 _FP_FRAC_SLL_##wc (X, (_FP_EXPBIAS_##fs \
1853 + _FP_WFRACBITS_##fs - 1 - X##_e)); \
1854 _FP_FRAC_HIGH_##fs (X) &= ~(_FP_W_TYPE) _FP_IMPLBIT_SH_##fs; \
1855 pack_semiraw: \
1856 _FP_PACK_SEMIRAW (fs, wc, X); \
1857 } \
1858 } \
1859 else \
1860 { \
1861 X##_s = 0; \
1862 X##_e = 0; \
1863 _FP_FRAC_SET_##wc (X, _FP_ZEROFRAC_##wc); \
1864 } \
1865 } \
1866 while (0)
1869 /* Extend from a narrower floating-point format to a wider one. Input
1870 and output are raw. If CHECK_NAN, then signaling NaNs are
1871 converted to quiet with the "invalid" exception raised; otherwise
1872 signaling NaNs remain signaling with no exception. */
1873 #define _FP_EXTEND_CNAN(dfs, sfs, dwc, swc, D, S, check_nan) \
1874 do \
1875 { \
1876 if (_FP_FRACBITS_##dfs < _FP_FRACBITS_##sfs \
1877 || (_FP_EXPMAX_##dfs - _FP_EXPBIAS_##dfs \
1878 < _FP_EXPMAX_##sfs - _FP_EXPBIAS_##sfs) \
1879 || (_FP_EXPBIAS_##dfs < _FP_EXPBIAS_##sfs + _FP_FRACBITS_##sfs - 1 \
1880 && _FP_EXPBIAS_##dfs != _FP_EXPBIAS_##sfs)) \
1881 abort (); \
1882 D##_s = S##_s; \
1883 _FP_FRAC_COPY_##dwc##_##swc (D, S); \
1884 if (_FP_EXP_NORMAL (sfs, swc, S)) \
1885 { \
1886 D##_e = S##_e + _FP_EXPBIAS_##dfs - _FP_EXPBIAS_##sfs; \
1887 _FP_FRAC_SLL_##dwc (D, (_FP_FRACBITS_##dfs - _FP_FRACBITS_##sfs)); \
1888 } \
1889 else \
1890 { \
1891 if (S##_e == 0) \
1892 { \
1893 _FP_CHECK_FLUSH_ZERO (sfs, swc, S); \
1894 if (_FP_FRAC_ZEROP_##swc (S)) \
1895 D##_e = 0; \
1896 else if (_FP_EXPBIAS_##dfs \
1897 < _FP_EXPBIAS_##sfs + _FP_FRACBITS_##sfs - 1) \
1898 { \
1899 FP_SET_EXCEPTION (FP_EX_DENORM); \
1900 _FP_FRAC_SLL_##dwc (D, (_FP_FRACBITS_##dfs \
1901 - _FP_FRACBITS_##sfs)); \
1902 D##_e = 0; \
1903 if (FP_TRAPPING_EXCEPTIONS & FP_EX_UNDERFLOW) \
1904 FP_SET_EXCEPTION (FP_EX_UNDERFLOW); \
1905 } \
1906 else \
1907 { \
1908 int FP_EXTEND_lz; \
1909 FP_SET_EXCEPTION (FP_EX_DENORM); \
1910 _FP_FRAC_CLZ_##swc (FP_EXTEND_lz, S); \
1911 _FP_FRAC_SLL_##dwc (D, \
1912 FP_EXTEND_lz + _FP_FRACBITS_##dfs \
1913 - _FP_FRACTBITS_##sfs); \
1914 D##_e = (_FP_EXPBIAS_##dfs - _FP_EXPBIAS_##sfs + 1 \
1915 + _FP_FRACXBITS_##sfs - FP_EXTEND_lz); \
1916 } \
1917 } \
1918 else \
1919 { \
1920 D##_e = _FP_EXPMAX_##dfs; \
1921 if (!_FP_FRAC_ZEROP_##swc (S)) \
1922 { \
1923 if (check_nan && _FP_FRAC_SNANP (sfs, S)) \
1924 FP_SET_EXCEPTION (FP_EX_INVALID \
1925 | FP_EX_INVALID_SNAN); \
1926 _FP_FRAC_SLL_##dwc (D, (_FP_FRACBITS_##dfs \
1927 - _FP_FRACBITS_##sfs)); \
1928 if (check_nan) \
1929 _FP_SETQNAN (dfs, dwc, D); \
1930 } \
1931 } \
1932 } \
1933 } \
1934 while (0)
1936 #define FP_EXTEND(dfs, sfs, dwc, swc, D, S) \
1937 _FP_EXTEND_CNAN (dfs, sfs, dwc, swc, D, S, 1)
1939 /* Truncate from a wider floating-point format to a narrower one.
1940 Input and output are semi-raw. */
1941 #define FP_TRUNC(dfs, sfs, dwc, swc, D, S) \
1942 do \
1943 { \
1944 if (_FP_FRACBITS_##sfs < _FP_FRACBITS_##dfs \
1945 || (_FP_EXPBIAS_##sfs < _FP_EXPBIAS_##dfs + _FP_FRACBITS_##dfs - 1 \
1946 && _FP_EXPBIAS_##sfs != _FP_EXPBIAS_##dfs)) \
1947 abort (); \
1948 D##_s = S##_s; \
1949 if (_FP_EXP_NORMAL (sfs, swc, S)) \
1950 { \
1951 D##_e = S##_e + _FP_EXPBIAS_##dfs - _FP_EXPBIAS_##sfs; \
1952 if (D##_e >= _FP_EXPMAX_##dfs) \
1953 _FP_OVERFLOW_SEMIRAW (dfs, dwc, D); \
1954 else \
1955 { \
1956 if (D##_e <= 0) \
1957 { \
1958 if (D##_e < 1 - _FP_FRACBITS_##dfs) \
1959 { \
1960 _FP_FRAC_SET_##swc (S, _FP_ZEROFRAC_##swc); \
1961 _FP_FRAC_LOW_##swc (S) |= 1; \
1962 } \
1963 else \
1964 { \
1965 _FP_FRAC_HIGH_##sfs (S) |= _FP_IMPLBIT_SH_##sfs; \
1966 _FP_FRAC_SRS_##swc (S, (_FP_WFRACBITS_##sfs \
1967 - _FP_WFRACBITS_##dfs \
1968 + 1 - D##_e), \
1969 _FP_WFRACBITS_##sfs); \
1970 } \
1971 D##_e = 0; \
1972 } \
1973 else \
1974 _FP_FRAC_SRS_##swc (S, (_FP_WFRACBITS_##sfs \
1975 - _FP_WFRACBITS_##dfs), \
1976 _FP_WFRACBITS_##sfs); \
1977 _FP_FRAC_COPY_##dwc##_##swc (D, S); \
1978 } \
1979 } \
1980 else \
1981 { \
1982 if (S##_e == 0) \
1983 { \
1984 _FP_CHECK_FLUSH_ZERO (sfs, swc, S); \
1985 D##_e = 0; \
1986 if (_FP_FRAC_ZEROP_##swc (S)) \
1987 _FP_FRAC_SET_##dwc (D, _FP_ZEROFRAC_##dwc); \
1988 else \
1989 { \
1990 FP_SET_EXCEPTION (FP_EX_DENORM); \
1991 if (_FP_EXPBIAS_##sfs \
1992 < _FP_EXPBIAS_##dfs + _FP_FRACBITS_##dfs - 1) \
1993 { \
1994 _FP_FRAC_SRS_##swc (S, (_FP_WFRACBITS_##sfs \
1995 - _FP_WFRACBITS_##dfs), \
1996 _FP_WFRACBITS_##sfs); \
1997 _FP_FRAC_COPY_##dwc##_##swc (D, S); \
1998 } \
1999 else \
2000 { \
2001 _FP_FRAC_SET_##dwc (D, _FP_ZEROFRAC_##dwc); \
2002 _FP_FRAC_LOW_##dwc (D) |= 1; \
2003 } \
2004 } \
2005 } \
2006 else \
2007 { \
2008 D##_e = _FP_EXPMAX_##dfs; \
2009 if (_FP_FRAC_ZEROP_##swc (S)) \
2010 _FP_FRAC_SET_##dwc (D, _FP_ZEROFRAC_##dwc); \
2011 else \
2012 { \
2013 _FP_CHECK_SIGNAN_SEMIRAW (sfs, swc, S); \
2014 _FP_FRAC_SRL_##swc (S, (_FP_WFRACBITS_##sfs \
2015 - _FP_WFRACBITS_##dfs)); \
2016 _FP_FRAC_COPY_##dwc##_##swc (D, S); \
2018 _FP_FRAC_LOW_##dwc (D) \
2019 &= ~(_FP_W_TYPE) ((1 << _FP_WORKBITS) - 1); \
2020 _FP_SETQNAN_SEMIRAW (dfs, dwc, D); \
2021 } \
2022 } \
2023 } \
2024 } \
2025 while (0)
2027 /* Helper primitives. */
2029 /* Count leading zeros in a word. */
2031 #ifndef __FP_CLZ
2032 /* GCC 3.4 and later provide the builtins for us. */
2033 # define __FP_CLZ(r, x) \
2034 do \
2035 { \
2036 if (sizeof (_FP_W_TYPE) == sizeof (unsigned int)) \
2037 (r) = __builtin_clz (x); \
2038 else if (sizeof (_FP_W_TYPE) == sizeof (unsigned long)) \
2039 (r) = __builtin_clzl (x); \
2040 else if (sizeof (_FP_W_TYPE) == sizeof (unsigned long long)) \
2041 (r) = __builtin_clzll (x); \
2042 else \
2043 abort (); \
2044 } \
2045 while (0)
2048 #define _FP_DIV_HELP_imm(q, r, n, d) \
2049 do \
2050 { \
2051 (q) = (n) / (d), (r) = (n) % (d); \
2052 } \
2053 while (0)
2056 /* A restoring bit-by-bit division primitive. */
2058 #define _FP_DIV_MEAT_N_loop(fs, wc, R, X, Y) \
2059 do \
2060 { \
2061 int _FP_DIV_MEAT_N_loop_count = _FP_WFRACBITS_##fs; \
2062 _FP_FRAC_DECL_##wc (_FP_DIV_MEAT_N_loop_u); \
2063 _FP_FRAC_DECL_##wc (_FP_DIV_MEAT_N_loop_v); \
2064 _FP_FRAC_COPY_##wc (_FP_DIV_MEAT_N_loop_u, X); \
2065 _FP_FRAC_COPY_##wc (_FP_DIV_MEAT_N_loop_v, Y); \
2066 _FP_FRAC_SET_##wc (R, _FP_ZEROFRAC_##wc); \
2068 _FP_FRAC_SLL_##wc (_FP_DIV_MEAT_N_loop_u, _FP_WFRACXBITS_##fs); \
2069 _FP_FRAC_SLL_##wc (_FP_DIV_MEAT_N_loop_v, _FP_WFRACXBITS_##fs); \
2070 /* First round. Since the operands are normalized, either the \
2071 first or second bit will be set in the fraction. Produce a \
2072 normalized result by checking which and adjusting the loop \
2074 if (_FP_FRAC_GE_1 (_FP_DIV_MEAT_N_loop_u, _FP_DIV_MEAT_N_loop_v)) \
2075 { \
2076 _FP_FRAC_SUB_##wc (_FP_DIV_MEAT_N_loop_u, \
2077 _FP_DIV_MEAT_N_loop_u, \
2078 _FP_DIV_MEAT_N_loop_v); \
2079 _FP_FRAC_LOW_##wc (R) |= 1; \
2080 _FP_DIV_MEAT_N_loop_count--; \
2081 } \
2082 else \
2083 R##_e--; \
2085 do \
2086 { \
2087 int _FP_DIV_MEAT_N_loop_msb \
2088 = (_FP_WS_TYPE) _FP_FRAC_HIGH_##wc (_FP_DIV_MEAT_N_loop_u) < 0; \
2089 _FP_FRAC_SLL_##wc (_FP_DIV_MEAT_N_loop_u, 1); \
2090 _FP_FRAC_SLL_##wc (R, 1); \
2091 if (_FP_DIV_MEAT_N_loop_msb \
2092 || _FP_FRAC_GE_1 (_FP_DIV_MEAT_N_loop_u, \
2093 _FP_DIV_MEAT_N_loop_v)) \
2094 { \
2095 _FP_FRAC_SUB_##wc (_FP_DIV_MEAT_N_loop_u, \
2096 _FP_DIV_MEAT_N_loop_u, \
2097 _FP_DIV_MEAT_N_loop_v); \
2098 _FP_FRAC_LOW_##wc (R) |= 1; \
2099 } \
2100 } \
2101 while (--_FP_DIV_MEAT_N_loop_count > 0); \
2102 /* If there's anything left in _FP_DIV_MEAT_N_LOOP_U, the result \
2104 _FP_FRAC_LOW_##wc (R) \
2105 |= !_FP_FRAC_ZEROP_##wc (_FP_DIV_MEAT_N_loop_u); \
2106 } \
2107 while (0)
2109 #define _FP_DIV_MEAT_1_loop(fs, R, X, Y) _FP_DIV_MEAT_N_loop (fs, 1, R, X, Y)
2110 #define _FP_DIV_MEAT_2_loop(fs, R, X, Y) _FP_DIV_MEAT_N_loop (fs, 2, R, X, Y)
2111 #define _FP_DIV_MEAT_4_loop(fs, R, X, Y) _FP_DIV_MEAT_N_loop (fs, 4, R, X, Y)