?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
GUI: Fix Tomato RAF theme for all builds. Compilation typo.
[tomato.git] / release / src-rt-6.x.4708 / linux / linux-2.6.36 / include / math-emu / op-common.h
blobf2a55df6fad8accb03095e55b4794d5816070de1
1 /* Software floating-point emulation. Common operations.
2 Copyright (C) 1997,1998,1999 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).
8
9 The GNU C Library is free software; you can redistribute it and/or
10 modify it under the terms of the GNU Library General Public License as
11 published by the Free Software Foundation; either version 2 of the
12 License, or (at your option) any later version.
13
14 The GNU C Library is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 Library General Public License for more details.
18
19 You should have received a copy of the GNU Library General Public
20 License along with the GNU C Library; see the file COPYING.LIB. If
21 not, write to the Free Software Foundation, Inc.,
22 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
23
24 #ifndef __MATH_EMU_OP_COMMON_H__
25 #define __MATH_EMU_OP_COMMON_H__
26
27 #define _FP_DECL(wc, X) \
28 _FP_I_TYPE X##_c=0, X##_s=0, X##_e=0; \
29 _FP_FRAC_DECL_##wc(X)
30
31 /*
32 * Finish truly unpacking a native fp value by classifying the kind
33 * of fp value and normalizing both the exponent and the fraction.
34 */
35
36 #define _FP_UNPACK_CANONICAL(fs, wc, X) \
37 do { \
38 switch (X##_e) \
39 { \
40 default: \
41 _FP_FRAC_HIGH_RAW_##fs(X) |= _FP_IMPLBIT_##fs; \
42 _FP_FRAC_SLL_##wc(X, _FP_WORKBITS); \
43 X##_e -= _FP_EXPBIAS_##fs; \
44 X##_c = FP_CLS_NORMAL; \
45 break; \
46 \
47 case 0: \
48 if (_FP_FRAC_ZEROP_##wc(X)) \
49 X##_c = FP_CLS_ZERO; \
50 else \
51 { \
52 /* a denormalized number */ \
53 _FP_I_TYPE _shift; \
54 _FP_FRAC_CLZ_##wc(_shift, X); \
55 _shift -= _FP_FRACXBITS_##fs; \
56 _FP_FRAC_SLL_##wc(X, (_shift+_FP_WORKBITS)); \
57 X##_e -= _FP_EXPBIAS_##fs - 1 + _shift; \
58 X##_c = FP_CLS_NORMAL; \
59 FP_SET_EXCEPTION(FP_EX_DENORM); \
60 if (FP_DENORM_ZERO) \
61 { \
62 FP_SET_EXCEPTION(FP_EX_INEXACT); \
63 X##_c = FP_CLS_ZERO; \
64 } \
65 } \
66 break; \
67 \
68 case _FP_EXPMAX_##fs: \
69 if (_FP_FRAC_ZEROP_##wc(X)) \
70 X##_c = FP_CLS_INF; \
71 else \
72 { \
73 X##_c = FP_CLS_NAN; \
74 /* Check for signaling NaN */ \
75 if (!(_FP_FRAC_HIGH_RAW_##fs(X) & _FP_QNANBIT_##fs)) \
76 FP_SET_EXCEPTION(FP_EX_INVALID | FP_EX_INVALID_SNAN); \
77 } \
78 break; \
79 } \
80 } while (0)
81
82 /*
83 * Before packing the bits back into the native fp result, take care
84 * of such mundane things as rounding and overflow. Also, for some
85 * kinds of fp values, the original parts may not have been fully
86 * extracted -- but that is ok, we can regenerate them now.
87 */
88
89 #define _FP_PACK_CANONICAL(fs, wc, X) \
90 do { \
91 switch (X##_c) \
92 { \
93 case FP_CLS_NORMAL: \
94 X##_e += _FP_EXPBIAS_##fs; \
95 if (X##_e > 0) \
96 { \
97 _FP_ROUND(wc, X); \
98 if (_FP_FRAC_OVERP_##wc(fs, X)) \
99 { \
100 _FP_FRAC_CLEAR_OVERP_##wc(fs, X); \
101 X##_e++; \
102 } \
103 _FP_FRAC_SRL_##wc(X, _FP_WORKBITS); \
104 if (X##_e >= _FP_EXPMAX_##fs) \
105 { \
106 /* overflow */ \
107 switch (FP_ROUNDMODE) \
108 { \
109 case FP_RND_NEAREST: \
110 X##_c = FP_CLS_INF; \
111 break; \
112 case FP_RND_PINF: \
113 if (!X##_s) X##_c = FP_CLS_INF; \
114 break; \
115 case FP_RND_MINF: \
116 if (X##_s) X##_c = FP_CLS_INF; \
117 break; \
118 } \
119 if (X##_c == FP_CLS_INF) \
120 { \
121 /* Overflow to infinity */ \
122 X##_e = _FP_EXPMAX_##fs; \
123 _FP_FRAC_SET_##wc(X, _FP_ZEROFRAC_##wc); \
124 } \
125 else \
126 { \
127 /* Overflow to maximum normal */ \
128 X##_e = _FP_EXPMAX_##fs - 1; \
129 _FP_FRAC_SET_##wc(X, _FP_MAXFRAC_##wc); \
130 } \
131 FP_SET_EXCEPTION(FP_EX_OVERFLOW); \
132 FP_SET_EXCEPTION(FP_EX_INEXACT); \
133 } \
134 } \
135 else \
136 { \
137 /* we've got a denormalized number */ \
138 X##_e = -X##_e + 1; \
139 if (X##_e <= _FP_WFRACBITS_##fs) \
140 { \
141 _FP_FRAC_SRS_##wc(X, X##_e, _FP_WFRACBITS_##fs); \
142 if (_FP_FRAC_HIGH_##fs(X) \
143 & (_FP_OVERFLOW_##fs >> 1)) \
144 { \
145 X##_e = 1; \
146 _FP_FRAC_SET_##wc(X, _FP_ZEROFRAC_##wc); \
147 } \
148 else \
149 { \
150 _FP_ROUND(wc, X); \
151 if (_FP_FRAC_HIGH_##fs(X) \
152 & (_FP_OVERFLOW_##fs >> 1)) \
153 { \
154 X##_e = 1; \
155 _FP_FRAC_SET_##wc(X, _FP_ZEROFRAC_##wc); \
156 FP_SET_EXCEPTION(FP_EX_INEXACT); \
157 } \
158 else \
159 { \
160 X##_e = 0; \
161 _FP_FRAC_SRL_##wc(X, _FP_WORKBITS); \
162 } \
163 } \
164 if ((FP_CUR_EXCEPTIONS & FP_EX_INEXACT) || \
165 (FP_TRAPPING_EXCEPTIONS & FP_EX_UNDERFLOW)) \
166 FP_SET_EXCEPTION(FP_EX_UNDERFLOW); \
167 } \
168 else \
169 { \
170 /* underflow to zero */ \
171 X##_e = 0; \
172 if (!_FP_FRAC_ZEROP_##wc(X)) \
173 { \
174 _FP_FRAC_SET_##wc(X, _FP_MINFRAC_##wc); \
175 _FP_ROUND(wc, X); \
176 _FP_FRAC_LOW_##wc(X) >>= (_FP_WORKBITS); \
177 } \
178 FP_SET_EXCEPTION(FP_EX_UNDERFLOW); \
179 } \
180 } \
181 break; \
182 \
183 case FP_CLS_ZERO: \
184 X##_e = 0; \
185 _FP_FRAC_SET_##wc(X, _FP_ZEROFRAC_##wc); \
186 break; \
187 \
188 case FP_CLS_INF: \
189 X##_e = _FP_EXPMAX_##fs; \
190 _FP_FRAC_SET_##wc(X, _FP_ZEROFRAC_##wc); \
191 break; \
192 \
193 case FP_CLS_NAN: \
194 X##_e = _FP_EXPMAX_##fs; \
195 if (!_FP_KEEPNANFRACP) \
196 { \
197 _FP_FRAC_SET_##wc(X, _FP_NANFRAC_##fs); \
198 X##_s = _FP_NANSIGN_##fs; \
199 } \
200 else \
201 _FP_FRAC_HIGH_RAW_##fs(X) |= _FP_QNANBIT_##fs; \
202 break; \
203 } \
204 } while (0)
205
206 /* This one accepts raw argument and not cooked, returns
207 * 1 if X is a signaling NaN.
208 */
209 #define _FP_ISSIGNAN(fs, wc, X) \
210 ({ \
211 int __ret = 0; \
212 if (X##_e == _FP_EXPMAX_##fs) \
213 { \
214 if (!_FP_FRAC_ZEROP_##wc(X) \
215 && !(_FP_FRAC_HIGH_RAW_##fs(X) & _FP_QNANBIT_##fs)) \
216 __ret = 1; \
217 } \
218 __ret; \
219 })
220
221
222
223
224
225 /*
226 * Main addition routine. The input values should be cooked.
227 */
228
229 #define _FP_ADD_INTERNAL(fs, wc, R, X, Y, OP) \
230 do { \
231 switch (_FP_CLS_COMBINE(X##_c, Y##_c)) \
232 { \
233 case _FP_CLS_COMBINE(FP_CLS_NORMAL,FP_CLS_NORMAL): \
234 { \
235 /* shift the smaller number so that its exponent matches the larger */ \
236 _FP_I_TYPE diff = X##_e - Y##_e; \
237 \
238 if (diff < 0) \
239 { \
240 diff = -diff; \
241 if (diff <= _FP_WFRACBITS_##fs) \
242 _FP_FRAC_SRS_##wc(X, diff, _FP_WFRACBITS_##fs); \
243 else if (!_FP_FRAC_ZEROP_##wc(X)) \
244 _FP_FRAC_SET_##wc(X, _FP_MINFRAC_##wc); \
245 R##_e = Y##_e; \
246 } \
247 else \
248 { \
249 if (diff > 0) \
250 { \
251 if (diff <= _FP_WFRACBITS_##fs) \
252 _FP_FRAC_SRS_##wc(Y, diff, _FP_WFRACBITS_##fs); \
253 else if (!_FP_FRAC_ZEROP_##wc(Y)) \
254 _FP_FRAC_SET_##wc(Y, _FP_MINFRAC_##wc); \
255 } \
256 R##_e = X##_e; \
257 } \
258 \
259 R##_c = FP_CLS_NORMAL; \
260 \
261 if (X##_s == Y##_s) \
262 { \
263 R##_s = X##_s; \
264 _FP_FRAC_ADD_##wc(R, X, Y); \
265 if (_FP_FRAC_OVERP_##wc(fs, R)) \
266 { \
267 _FP_FRAC_SRS_##wc(R, 1, _FP_WFRACBITS_##fs); \
268 R##_e++; \
269 } \
270 } \
271 else \
272 { \
273 R##_s = X##_s; \
274 _FP_FRAC_SUB_##wc(R, X, Y); \
275 if (_FP_FRAC_ZEROP_##wc(R)) \
276 { \
277 /* return an exact zero */ \
278 if (FP_ROUNDMODE == FP_RND_MINF) \
279 R##_s |= Y##_s; \
280 else \
281 R##_s &= Y##_s; \
282 R##_c = FP_CLS_ZERO; \
283 } \
284 else \
285 { \
286 if (_FP_FRAC_NEGP_##wc(R)) \
287 { \
288 _FP_FRAC_SUB_##wc(R, Y, X); \
289 R##_s = Y##_s; \
290 } \
291 \
292 /* renormalize after subtraction */ \
293 _FP_FRAC_CLZ_##wc(diff, R); \
294 diff -= _FP_WFRACXBITS_##fs; \
295 if (diff) \
296 { \
297 R##_e -= diff; \
298 _FP_FRAC_SLL_##wc(R, diff); \
299 } \
300 } \
301 } \
302 break; \
303 } \
304 \
305 case _FP_CLS_COMBINE(FP_CLS_NAN,FP_CLS_NAN): \
306 _FP_CHOOSENAN(fs, wc, R, X, Y, OP); \
307 break; \
308 \
309 case _FP_CLS_COMBINE(FP_CLS_NORMAL,FP_CLS_ZERO): \
310 R##_e = X##_e; \
311 case _FP_CLS_COMBINE(FP_CLS_NAN,FP_CLS_NORMAL): \
312 case _FP_CLS_COMBINE(FP_CLS_NAN,FP_CLS_INF): \
313 case _FP_CLS_COMBINE(FP_CLS_NAN,FP_CLS_ZERO): \
314 _FP_FRAC_COPY_##wc(R, X); \
315 R##_s = X##_s; \
316 R##_c = X##_c; \
317 break; \
318 \
319 case _FP_CLS_COMBINE(FP_CLS_ZERO,FP_CLS_NORMAL): \
320 R##_e = Y##_e; \
321 case _FP_CLS_COMBINE(FP_CLS_NORMAL,FP_CLS_NAN): \
322 case _FP_CLS_COMBINE(FP_CLS_INF,FP_CLS_NAN): \
323 case _FP_CLS_COMBINE(FP_CLS_ZERO,FP_CLS_NAN): \
324 _FP_FRAC_COPY_##wc(R, Y); \
325 R##_s = Y##_s; \
326 R##_c = Y##_c; \
327 break; \
328 \
329 case _FP_CLS_COMBINE(FP_CLS_INF,FP_CLS_INF): \
330 if (X##_s != Y##_s) \
331 { \
332 /* +INF + -INF => NAN */ \
333 _FP_FRAC_SET_##wc(R, _FP_NANFRAC_##fs); \
334 R##_s = _FP_NANSIGN_##fs; \
335 R##_c = FP_CLS_NAN; \
336 FP_SET_EXCEPTION(FP_EX_INVALID | FP_EX_INVALID_ISI); \
337 break; \
338 } \
339 /* FALLTHRU */ \
340 \
341 case _FP_CLS_COMBINE(FP_CLS_INF,FP_CLS_NORMAL): \
342 case _FP_CLS_COMBINE(FP_CLS_INF,FP_CLS_ZERO): \
343 R##_s = X##_s; \
344 R##_c = FP_CLS_INF; \
345 break; \
346 \
347 case _FP_CLS_COMBINE(FP_CLS_NORMAL,FP_CLS_INF): \
348 case _FP_CLS_COMBINE(FP_CLS_ZERO,FP_CLS_INF): \
349 R##_s = Y##_s; \
350 R##_c = FP_CLS_INF; \
351 break; \
352 \
353 case _FP_CLS_COMBINE(FP_CLS_ZERO,FP_CLS_ZERO): \
354 /* make sure the sign is correct */ \
355 if (FP_ROUNDMODE == FP_RND_MINF) \
356 R##_s = X##_s | Y##_s; \
357 else \
358 R##_s = X##_s & Y##_s; \
359 R##_c = FP_CLS_ZERO; \
360 break; \
361 \
362 default: \
363 abort(); \
364 } \
365 } while (0)
366
367 #define _FP_ADD(fs, wc, R, X, Y) _FP_ADD_INTERNAL(fs, wc, R, X, Y, '+')
368 #define _FP_SUB(fs, wc, R, X, Y) \
369 do { \
370 if (Y##_c != FP_CLS_NAN) Y##_s ^= 1; \
371 _FP_ADD_INTERNAL(fs, wc, R, X, Y, '-'); \
372 } while (0)
373
374
375
376 #define _FP_NEG(fs, wc, R, X) \
377 do { \
378 _FP_FRAC_COPY_##wc(R, X); \
379 R##_c = X##_c; \
380 R##_e = X##_e; \
381 R##_s = 1 ^ X##_s; \
382 } while (0)
383
384
385 /*
386 * Main multiplication routine. The input values should be cooked.
387 */
388
389 #define _FP_MUL(fs, wc, R, X, Y) \
390 do { \
391 R##_s = X##_s ^ Y##_s; \
392 switch (_FP_CLS_COMBINE(X##_c, Y##_c)) \
393 { \
394 case _FP_CLS_COMBINE(FP_CLS_NORMAL,FP_CLS_NORMAL): \
395 R##_c = FP_CLS_NORMAL; \
396 R##_e = X##_e + Y##_e + 1; \
397 \
398 _FP_MUL_MEAT_##fs(R,X,Y); \
399 \
400 if (_FP_FRAC_OVERP_##wc(fs, R)) \
401 _FP_FRAC_SRS_##wc(R, 1, _FP_WFRACBITS_##fs); \
402 else \
403 R##_e--; \
404 break; \
405 \
406 case _FP_CLS_COMBINE(FP_CLS_NAN,FP_CLS_NAN): \
407 _FP_CHOOSENAN(fs, wc, R, X, Y, '*'); \
408 break; \
409 \
410 case _FP_CLS_COMBINE(FP_CLS_NAN,FP_CLS_NORMAL): \
411 case _FP_CLS_COMBINE(FP_CLS_NAN,FP_CLS_INF): \
412 case _FP_CLS_COMBINE(FP_CLS_NAN,FP_CLS_ZERO): \
413 R##_s = X##_s; \
414 \
415 case _FP_CLS_COMBINE(FP_CLS_INF,FP_CLS_INF): \
416 case _FP_CLS_COMBINE(FP_CLS_INF,FP_CLS_NORMAL): \
417 case _FP_CLS_COMBINE(FP_CLS_ZERO,FP_CLS_NORMAL): \
418 case _FP_CLS_COMBINE(FP_CLS_ZERO,FP_CLS_ZERO): \
419 _FP_FRAC_COPY_##wc(R, X); \
420 R##_c = X##_c; \
421 break; \
422 \
423 case _FP_CLS_COMBINE(FP_CLS_NORMAL,FP_CLS_NAN): \
424 case _FP_CLS_COMBINE(FP_CLS_INF,FP_CLS_NAN): \
425 case _FP_CLS_COMBINE(FP_CLS_ZERO,FP_CLS_NAN): \
426 R##_s = Y##_s; \
427 \
428 case _FP_CLS_COMBINE(FP_CLS_NORMAL,FP_CLS_INF): \
429 case _FP_CLS_COMBINE(FP_CLS_NORMAL,FP_CLS_ZERO): \
430 _FP_FRAC_COPY_##wc(R, Y); \
431 R##_c = Y##_c; \
432 break; \
433 \
434 case _FP_CLS_COMBINE(FP_CLS_INF,FP_CLS_ZERO): \
435 case _FP_CLS_COMBINE(FP_CLS_ZERO,FP_CLS_INF): \
436 R##_s = _FP_NANSIGN_##fs; \
437 R##_c = FP_CLS_NAN; \
438 _FP_FRAC_SET_##wc(R, _FP_NANFRAC_##fs); \
439 FP_SET_EXCEPTION(FP_EX_INVALID | FP_EX_INVALID_IMZ);\
440 break; \
441 \
442 default: \
443 abort(); \
444 } \
445 } while (0)
446
447
448 /*
449 * Main division routine. The input values should be cooked.
450 */
451
452 #define _FP_DIV(fs, wc, R, X, Y) \
453 do { \
454 R##_s = X##_s ^ Y##_s; \
455 switch (_FP_CLS_COMBINE(X##_c, Y##_c)) \
456 { \
457 case _FP_CLS_COMBINE(FP_CLS_NORMAL,FP_CLS_NORMAL): \
458 R##_c = FP_CLS_NORMAL; \
459 R##_e = X##_e - Y##_e; \
460 \
461 _FP_DIV_MEAT_##fs(R,X,Y); \
462 break; \
463 \
464 case _FP_CLS_COMBINE(FP_CLS_NAN,FP_CLS_NAN): \
465 _FP_CHOOSENAN(fs, wc, R, X, Y, '/'); \
466 break; \
467 \
468 case _FP_CLS_COMBINE(FP_CLS_NAN,FP_CLS_NORMAL): \
469 case _FP_CLS_COMBINE(FP_CLS_NAN,FP_CLS_INF): \
470 case _FP_CLS_COMBINE(FP_CLS_NAN,FP_CLS_ZERO): \
471 R##_s = X##_s; \
472 _FP_FRAC_COPY_##wc(R, X); \
473 R##_c = X##_c; \
474 break; \
475 \
476 case _FP_CLS_COMBINE(FP_CLS_NORMAL,FP_CLS_NAN): \
477 case _FP_CLS_COMBINE(FP_CLS_INF,FP_CLS_NAN): \
478 case _FP_CLS_COMBINE(FP_CLS_ZERO,FP_CLS_NAN): \
479 R##_s = Y##_s; \
480 _FP_FRAC_COPY_##wc(R, Y); \
481 R##_c = Y##_c; \
482 break; \
483 \
484 case _FP_CLS_COMBINE(FP_CLS_NORMAL,FP_CLS_INF): \
485 case _FP_CLS_COMBINE(FP_CLS_ZERO,FP_CLS_INF): \
486 case _FP_CLS_COMBINE(FP_CLS_ZERO,FP_CLS_NORMAL): \
487 R##_c = FP_CLS_ZERO; \
488 break; \
489 \
490 case _FP_CLS_COMBINE(FP_CLS_NORMAL,FP_CLS_ZERO): \
491 FP_SET_EXCEPTION(FP_EX_DIVZERO); \
492 case _FP_CLS_COMBINE(FP_CLS_INF,FP_CLS_ZERO): \
493 case _FP_CLS_COMBINE(FP_CLS_INF,FP_CLS_NORMAL): \
494 R##_c = FP_CLS_INF; \
495 break; \
496 \
497 case _FP_CLS_COMBINE(FP_CLS_INF,FP_CLS_INF): \
498 R##_s = _FP_NANSIGN_##fs; \
499 R##_c = FP_CLS_NAN; \
500 _FP_FRAC_SET_##wc(R, _FP_NANFRAC_##fs); \
501 FP_SET_EXCEPTION(FP_EX_INVALID | FP_EX_INVALID_IDI);\
502 break; \
503 \
504 case _FP_CLS_COMBINE(FP_CLS_ZERO,FP_CLS_ZERO): \
505 R##_s = _FP_NANSIGN_##fs; \
506 R##_c = FP_CLS_NAN; \
507 _FP_FRAC_SET_##wc(R, _FP_NANFRAC_##fs); \
508 FP_SET_EXCEPTION(FP_EX_INVALID | FP_EX_INVALID_ZDZ);\
509 break; \
510 \
511 default: \
512 abort(); \
513 } \
514 } while (0)
515
516
517 /*
518 * Main differential comparison routine. The inputs should be raw not
519 * cooked. The return is -1,0,1 for normal values, 2 otherwise.
520 */
521
522 #define _FP_CMP(fs, wc, ret, X, Y, un) \
523 do { \
524 /* NANs are unordered */ \
525 if ((X##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc(X)) \
526 || (Y##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc(Y))) \
527 { \
528 ret = un; \
529 } \
530 else \
531 { \
532 int __is_zero_x; \
533 int __is_zero_y; \
534 \
535 __is_zero_x = (!X##_e && _FP_FRAC_ZEROP_##wc(X)) ? 1 : 0; \
536 __is_zero_y = (!Y##_e && _FP_FRAC_ZEROP_##wc(Y)) ? 1 : 0; \
537 \
538 if (__is_zero_x && __is_zero_y) \
539 ret = 0; \
540 else if (__is_zero_x) \
541 ret = Y##_s ? 1 : -1; \
542 else if (__is_zero_y) \
543 ret = X##_s ? -1 : 1; \
544 else if (X##_s != Y##_s) \
545 ret = X##_s ? -1 : 1; \
546 else if (X##_e > Y##_e) \
547 ret = X##_s ? -1 : 1; \
548 else if (X##_e < Y##_e) \
549 ret = X##_s ? 1 : -1; \
550 else if (_FP_FRAC_GT_##wc(X, Y)) \
551 ret = X##_s ? -1 : 1; \
552 else if (_FP_FRAC_GT_##wc(Y, X)) \
553 ret = X##_s ? 1 : -1; \
554 else \
555 ret = 0; \
556 } \
557 } while (0)
558
559
560 /* Simplification for strict equality. */
561
562 #define _FP_CMP_EQ(fs, wc, ret, X, Y) \
563 do { \
564 /* NANs are unordered */ \
565 if ((X##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc(X)) \
566 || (Y##_e == _FP_EXPMAX_##fs && !_FP_FRAC_ZEROP_##wc(Y))) \
567 { \
568 ret = 1; \
569 } \
570 else \
571 { \
572 ret = !(X##_e == Y##_e \
573 && _FP_FRAC_EQ_##wc(X, Y) \
574 && (X##_s == Y##_s || !X##_e && _FP_FRAC_ZEROP_##wc(X))); \
575 } \
576 } while (0)
577
578 /*
579 * Main square root routine. The input value should be cooked.
580 */
581
582 #define _FP_SQRT(fs, wc, R, X) \
583 do { \
584 _FP_FRAC_DECL_##wc(T); _FP_FRAC_DECL_##wc(S); \
585 _FP_W_TYPE q; \
586 switch (X##_c) \
587 { \
588 case FP_CLS_NAN: \
589 _FP_FRAC_COPY_##wc(R, X); \
590 R##_s = X##_s; \
591 R##_c = FP_CLS_NAN; \
592 break; \
593 case FP_CLS_INF: \
594 if (X##_s) \
595 { \
596 R##_s = _FP_NANSIGN_##fs; \
597 R##_c = FP_CLS_NAN; /* NAN */ \
598 _FP_FRAC_SET_##wc(R, _FP_NANFRAC_##fs); \
599 FP_SET_EXCEPTION(FP_EX_INVALID); \
600 } \
601 else \
602 { \
603 R##_s = 0; \
604 R##_c = FP_CLS_INF; /* sqrt(+inf) = +inf */ \
605 } \
606 break; \
607 case FP_CLS_ZERO: \
608 R##_s = X##_s; \
609 R##_c = FP_CLS_ZERO; /* sqrt(+-0) = +-0 */ \
610 break; \
611 case FP_CLS_NORMAL: \
612 R##_s = 0; \
613 if (X##_s) \
614 { \
615 R##_c = FP_CLS_NAN; /* sNAN */ \
616 R##_s = _FP_NANSIGN_##fs; \
617 _FP_FRAC_SET_##wc(R, _FP_NANFRAC_##fs); \
618 FP_SET_EXCEPTION(FP_EX_INVALID); \
619 break; \
620 } \
621 R##_c = FP_CLS_NORMAL; \
622 if (X##_e & 1) \
623 _FP_FRAC_SLL_##wc(X, 1); \
624 R##_e = X##_e >> 1; \
625 _FP_FRAC_SET_##wc(S, _FP_ZEROFRAC_##wc); \
626 _FP_FRAC_SET_##wc(R, _FP_ZEROFRAC_##wc); \
627 q = _FP_OVERFLOW_##fs >> 1; \
628 _FP_SQRT_MEAT_##wc(R, S, T, X, q); \
629 } \
630 } while (0)
631
632 /*
633 * Convert from FP to integer
634 */
635
636 /* RSIGNED can have following values:
637 * 0: the number is required to be 0..(2^rsize)-1, if not, NV is set plus
638 * the result is either 0 or (2^rsize)-1 depending on the sign in such case.
639 * 1: the number is required to be -(2^(rsize-1))..(2^(rsize-1))-1, if not, NV is
640 * set plus the result is either -(2^(rsize-1)) or (2^(rsize-1))-1 depending
641 * on the sign in such case.
642 * 2: the number is required to be -(2^(rsize-1))..(2^(rsize-1))-1, if not, NV is
643 * set plus the result is truncated to fit into destination.
644 * -1: the number is required to be -(2^(rsize-1))..(2^rsize)-1, if not, NV is
645 * set plus the result is either -(2^(rsize-1)) or (2^(rsize-1))-1 depending
646 * on the sign in such case.
647 */
648 #define _FP_TO_INT(fs, wc, r, X, rsize, rsigned) \
649 do { \
650 switch (X##_c) \
651 { \
652 case FP_CLS_NORMAL: \
653 if (X##_e < 0) \
654 { \
655 FP_SET_EXCEPTION(FP_EX_INEXACT); \
656 case FP_CLS_ZERO: \
657 r = 0; \
658 } \
659 else if (X##_e >= rsize - (rsigned > 0 || X##_s) \
660 || (!rsigned && X##_s)) \
661 { /* overflow */ \
662 case FP_CLS_NAN: \
663 case FP_CLS_INF: \
664 if (rsigned == 2) \
665 { \
666 if (X##_c != FP_CLS_NORMAL \
667 || X##_e >= rsize - 1 + _FP_WFRACBITS_##fs) \
668 r = 0; \
669 else \
670 { \
671 _FP_FRAC_SLL_##wc(X, (X##_e - _FP_WFRACBITS_##fs + 1)); \
672 _FP_FRAC_ASSEMBLE_##wc(r, X, rsize); \
673 } \
674 } \
675 else if (rsigned) \
676 { \
677 r = 1; \
678 r <<= rsize - 1; \
679 r -= 1 - X##_s; \
680 } \
681 else \
682 { \
683 r = 0; \
684 if (X##_s) \
685 r = ~r; \
686 } \
687 FP_SET_EXCEPTION(FP_EX_INVALID); \
688 } \
689 else \
690 { \
691 if (_FP_W_TYPE_SIZE*wc < rsize) \
692 { \
693 _FP_FRAC_ASSEMBLE_##wc(r, X, rsize); \
694 r <<= X##_e - _FP_WFRACBITS_##fs; \
695 } \
696 else \
697 { \
698 if (X##_e >= _FP_WFRACBITS_##fs) \
699 _FP_FRAC_SLL_##wc(X, (X##_e - _FP_WFRACBITS_##fs + 1)); \
700 else if (X##_e < _FP_WFRACBITS_##fs - 1) \
701 { \
702 _FP_FRAC_SRS_##wc(X, (_FP_WFRACBITS_##fs - X##_e - 2), \
703 _FP_WFRACBITS_##fs); \
704 if (_FP_FRAC_LOW_##wc(X) & 1) \
705 FP_SET_EXCEPTION(FP_EX_INEXACT); \
706 _FP_FRAC_SRL_##wc(X, 1); \
707 } \
708 _FP_FRAC_ASSEMBLE_##wc(r, X, rsize); \
709 } \
710 if (rsigned && X##_s) \
711 r = -r; \
712 } \
713 break; \
714 } \
715 } while (0)
716
717 #define _FP_TO_INT_ROUND(fs, wc, r, X, rsize, rsigned) \
718 do { \
719 r = 0; \
720 switch (X##_c) \
721 { \
722 case FP_CLS_NORMAL: \
723 if (X##_e >= _FP_FRACBITS_##fs - 1) \
724 { \
725 if (X##_e < rsize - 1 + _FP_WFRACBITS_##fs) \
726 { \
727 if (X##_e >= _FP_WFRACBITS_##fs - 1) \
728 { \
729 _FP_FRAC_ASSEMBLE_##wc(r, X, rsize); \
730 r <<= X##_e - _FP_WFRACBITS_##fs + 1; \
731 } \
732 else \
733 { \
734 _FP_FRAC_SRL_##wc(X, _FP_WORKBITS - X##_e \
735 + _FP_FRACBITS_##fs - 1); \
736 _FP_FRAC_ASSEMBLE_##wc(r, X, rsize); \
737 } \
738 } \
739 } \
740 else \
741 { \
742 if (X##_e <= -_FP_WORKBITS - 1) \
743 _FP_FRAC_SET_##wc(X, _FP_MINFRAC_##wc); \
744 else \
745 _FP_FRAC_SRS_##wc(X, _FP_FRACBITS_##fs - 1 - X##_e, \
746 _FP_WFRACBITS_##fs); \
747 _FP_ROUND(wc, X); \
748 _FP_FRAC_SRL_##wc(X, _FP_WORKBITS); \
749 _FP_FRAC_ASSEMBLE_##wc(r, X, rsize); \
750 } \
751 if (rsigned && X##_s) \
752 r = -r; \
753 if (X##_e >= rsize - (rsigned > 0 || X##_s) \
754 || (!rsigned && X##_s)) \
755 { /* overflow */ \
756 case FP_CLS_NAN: \
757 case FP_CLS_INF: \
758 if (!rsigned) \
759 { \
760 r = 0; \
761 if (X##_s) \
762 r = ~r; \
763 } \
764 else if (rsigned != 2) \
765 { \
766 r = 1; \
767 r <<= rsize - 1; \
768 r -= 1 - X##_s; \
769 } \
770 FP_SET_EXCEPTION(FP_EX_INVALID); \
771 } \
772 break; \
773 case FP_CLS_ZERO: \
774 break; \
775 } \
776 } while (0)
777
778 #define _FP_FROM_INT(fs, wc, X, r, rsize, rtype) \
779 do { \
780 if (r) \
781 { \
782 unsigned rtype ur_; \
783 X##_c = FP_CLS_NORMAL; \
784 \
785 if ((X##_s = (r < 0))) \
786 ur_ = (unsigned rtype) -r; \
787 else \
788 ur_ = (unsigned rtype) r; \
789 if (rsize <= _FP_W_TYPE_SIZE) \
790 __FP_CLZ(X##_e, ur_); \
791 else \
792 __FP_CLZ_2(X##_e, (_FP_W_TYPE)(ur_ >> _FP_W_TYPE_SIZE), \
793 (_FP_W_TYPE)ur_); \
794 if (rsize < _FP_W_TYPE_SIZE) \
795 X##_e -= (_FP_W_TYPE_SIZE - rsize); \
796 X##_e = rsize - X##_e - 1; \
797 \
798 if (_FP_FRACBITS_##fs < rsize && _FP_WFRACBITS_##fs <= X##_e) \
799 __FP_FRAC_SRS_1(ur_, (X##_e - _FP_WFRACBITS_##fs + 1), rsize);\
800 _FP_FRAC_DISASSEMBLE_##wc(X, ur_, rsize); \
801 if ((_FP_WFRACBITS_##fs - X##_e - 1) > 0) \
802 _FP_FRAC_SLL_##wc(X, (_FP_WFRACBITS_##fs - X##_e - 1)); \
803 } \
804 else \
805 { \
806 X##_c = FP_CLS_ZERO, X##_s = 0; \
807 } \
808 } while (0)
809
810
811 #define FP_CONV(dfs,sfs,dwc,swc,D,S) \
812 do { \
813 _FP_FRAC_CONV_##dwc##_##swc(dfs, sfs, D, S); \
814 D##_e = S##_e; \
815 D##_c = S##_c; \
816 D##_s = S##_s; \
817 } while (0)
818
819 /*
820 * Helper primitives.
821 */
822
823 /* Count leading zeros in a word. */
824
825 #ifndef __FP_CLZ
826 #if _FP_W_TYPE_SIZE < 64
827 /* this is just to shut the compiler up about shifts > word length -- PMM 02/1998 */
828 #define __FP_CLZ(r, x) \
829 do { \
830 _FP_W_TYPE _t = (x); \
831 r = _FP_W_TYPE_SIZE - 1; \
832 if (_t > 0xffff) r -= 16; \
833 if (_t > 0xffff) _t >>= 16; \
834 if (_t > 0xff) r -= 8; \
835 if (_t > 0xff) _t >>= 8; \
836 if (_t & 0xf0) r -= 4; \
837 if (_t & 0xf0) _t >>= 4; \
838 if (_t & 0xc) r -= 2; \
839 if (_t & 0xc) _t >>= 2; \
840 if (_t & 0x2) r -= 1; \
841 } while (0)
842 #else /* not _FP_W_TYPE_SIZE < 64 */
843 #define __FP_CLZ(r, x) \
844 do { \
845 _FP_W_TYPE _t = (x); \
846 r = _FP_W_TYPE_SIZE - 1; \
847 if (_t > 0xffffffff) r -= 32; \
848 if (_t > 0xffffffff) _t >>= 32; \
849 if (_t > 0xffff) r -= 16; \
850 if (_t > 0xffff) _t >>= 16; \
851 if (_t > 0xff) r -= 8; \
852 if (_t > 0xff) _t >>= 8; \
853 if (_t & 0xf0) r -= 4; \
854 if (_t & 0xf0) _t >>= 4; \
855 if (_t & 0xc) r -= 2; \
856 if (_t & 0xc) _t >>= 2; \
857 if (_t & 0x2) r -= 1; \
858 } while (0)
859 #endif /* not _FP_W_TYPE_SIZE < 64 */
860 #endif /* ndef __FP_CLZ */
861
862 #define _FP_DIV_HELP_imm(q, r, n, d) \
863 do { \
864 q = n / d, r = n % d; \
865 } while (0)
866
867 #endif /* __MATH_EMU_OP_COMMON_H__ */
Tomato firmware and modifications.