1 /* Software floating-point emulation. 1
2 Basic two-word fraction declaration and man
3 Copyright (C) 1997,1998,1999 Free Software
4 This file is part of the GNU C Library.
5 Contributed by Richard Henderson (rth@cygnu
6 Jakub Jelinek (jj@ultra.linu
7 David S. Miller (davem@redha
8 Peter Maydell (pmaydell@chia
9
10 The GNU C Library is free software; you can
11 modify it under the terms of the GNU Librar
12 published by the Free Software Foundation;
13 License, or (at your option) any later vers
14
15 The GNU C Library is distributed in the hop
16 but WITHOUT ANY WARRANTY; without even the
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR
18 Library General Public License for more det
19
20 You should have received a copy of the GNU
21 License along with the GNU C Library; see t
22 not, write to the Free Software Foundation,
23 59 Temple Place - Suite 330, Boston, MA 021
24
25 #ifndef __MATH_EMU_OP_2_H__
26 #define __MATH_EMU_OP_2_H__
27
28 #define _FP_FRAC_DECL_2(X) _FP_W_TYPE X##
29 #define _FP_FRAC_COPY_2(D,S) (D##_f0 = S##_
30 #define _FP_FRAC_SET_2(X,I) __FP_FRAC_SET_
31 #define _FP_FRAC_HIGH_2(X) (X##_f1)
32 #define _FP_FRAC_LOW_2(X) (X##_f0)
33 #define _FP_FRAC_WORD_2(X,w) (X##_f##w)
34 #define _FP_FRAC_SLL_2(X, N) (
35 (void) (((N) < _FP_W_TYPE_SIZE)
36 ? ({
37 if (__builtin_constant_p(N) &&
38 X##_f1 = X##_f1 + X##_
39 (((_FP_WS_TYPE
40 X##_f0 += X##_f0;
41 } else {
42 X##_f1 = X##_f1 << (N)
43
44 X##_f0 <<= (N);
45 }
46 0;
47 })
48 : ({
49 X##_f1 = X##_f0 << ((N) - _FP_W_
50 X##_f0 = 0;
51 })))
52
53
54 #define _FP_FRAC_SRL_2(X, N) (
55 (void) (((N) < _FP_W_TYPE_SIZE)
56 ? ({
57 X##_f0 = X##_f0 >> (N) | X##_f1
58 X##_f1 >>= (N);
59 })
60 : ({
61 X##_f0 = X##_f1 >> ((N) - _FP_W_
62 X##_f1 = 0;
63 })))
64
65
66 /* Right shift with sticky-lsb. */
67 #define _FP_FRAC_SRS_2(X, N, sz) (
68 (void) (((N) < _FP_W_TYPE_SIZE)
69 ? ({
70 X##_f0 = (X##_f1 << (_FP_W_TYPE_
71 | (__builtin_constant_
72 ? X##_f0 & 1
73 : (X##_f0 << (_FP_W
74 X##_f1 >>= (N);
75 })
76 : ({
77 X##_f0 = (X##_f1 >> ((N) - _FP_W
78 | ((((N) == _FP_W_TYPE
79 ? 0
80 : (X##_f1 << (2*_
81 | X##_f0) != 0));
82 X##_f1 = 0;
83 })))
84
85 #define _FP_FRAC_ADDI_2(X,I) \
86 __FP_FRAC_ADDI_2(X##_f1, X##_f0, I)
87
88 #define _FP_FRAC_ADD_2(R,X,Y) \
89 __FP_FRAC_ADD_2(R##_f1, R##_f0, X##_f1, X##_
90
91 #define _FP_FRAC_SUB_2(R,X,Y) \
92 __FP_FRAC_SUB_2(R##_f1, R##_f0, X##_f1, X##_
93
94 #define _FP_FRAC_DEC_2(X,Y) \
95 __FP_FRAC_DEC_2(X##_f1, X##_f0, Y##_f1, Y##_
96
97 #define _FP_FRAC_CLZ_2(R,X) \
98 do { \
99 if (X##_f1) \
100 __FP_CLZ(R,X##_f1); \
101 else \
102 { \
103 __FP_CLZ(R,X##_f0); \
104 R += _FP_W_TYPE_SIZE; \
105 } \
106 } while(0)
107
108 /* Predicates */
109 #define _FP_FRAC_NEGP_2(X) ((_FP_WS_TYPE)
110 #define _FP_FRAC_ZEROP_2(X) ((X##_f1 | X##
111 #define _FP_FRAC_OVERP_2(fs,X) (_FP_FRAC_HIGH
112 #define _FP_FRAC_CLEAR_OVERP_2(fs,X) (_FP_F
113 #define _FP_FRAC_EQ_2(X, Y) (X##_f1 == Y##
114 #define _FP_FRAC_GT_2(X, Y) \
115 (X##_f1 > Y##_f1 || (X##_f1 == Y##_f1 && X##
116 #define _FP_FRAC_GE_2(X, Y) \
117 (X##_f1 > Y##_f1 || (X##_f1 == Y##_f1 && X##
118
119 #define _FP_ZEROFRAC_2 0, 0
120 #define _FP_MINFRAC_2 0, 1
121 #define _FP_MAXFRAC_2 (~(_FP_WS_TYPE
122
123 /*
124 * Internals
125 */
126
127 #define __FP_FRAC_SET_2(X,I1,I0) (X##_f
128
129 #define __FP_CLZ_2(R, xh, xl) \
130 do { \
131 if (xh) \
132 __FP_CLZ(R,xh); \
133 else \
134 { \
135 __FP_CLZ(R,xl); \
136 R += _FP_W_TYPE_SIZE; \
137 } \
138 } while(0)
139
140 #if 0
141
142 #ifndef __FP_FRAC_ADDI_2
143 #define __FP_FRAC_ADDI_2(xh, xl, i) \
144 (xh += ((xl += i) < i))
145 #endif
146 #ifndef __FP_FRAC_ADD_2
147 #define __FP_FRAC_ADD_2(rh, rl, xh, xl, yh, yl
148 (rh = xh + yh + ((rl = xl + yl) < xl))
149 #endif
150 #ifndef __FP_FRAC_SUB_2
151 #define __FP_FRAC_SUB_2(rh, rl, xh, xl, yh, yl
152 (rh = xh - yh - ((rl = xl - yl) > xl))
153 #endif
154 #ifndef __FP_FRAC_DEC_2
155 #define __FP_FRAC_DEC_2(xh, xl, yh, yl) \
156 do { \
157 UWtype _t = xl; \
158 xh -= yh + ((xl -= yl) > _t); \
159 } while (0)
160 #endif
161
162 #else
163
164 #undef __FP_FRAC_ADDI_2
165 #define __FP_FRAC_ADDI_2(xh, xl, i) add_ss
166 #undef __FP_FRAC_ADD_2
167 #define __FP_FRAC_ADD_2 add_ss
168 #undef __FP_FRAC_SUB_2
169 #define __FP_FRAC_SUB_2 sub_dd
170 #undef __FP_FRAC_DEC_2
171 #define __FP_FRAC_DEC_2(xh, xl, yh, yl) sub_dd
172
173 #endif
174
175 /*
176 * Unpack the raw bits of a native fp value.
177 * normalize the data.
178 */
179
180 #define _FP_UNPACK_RAW_2(fs, X, val)
181 do {
182 union _FP_UNION_##fs _flo; _flo.flt = (val
183
184 X##_f0 = _flo.bits.frac0;
185 X##_f1 = _flo.bits.frac1;
186 X##_e = _flo.bits.exp;
187 X##_s = _flo.bits.sign;
188 } while (0)
189
190 #define _FP_UNPACK_RAW_2_P(fs, X, val)
191 do {
192 union _FP_UNION_##fs *_flo =
193 (union _FP_UNION_##fs *)(val);
194
195 X##_f0 = _flo->bits.frac0;
196 X##_f1 = _flo->bits.frac1;
197 X##_e = _flo->bits.exp;
198 X##_s = _flo->bits.sign;
199 } while (0)
200
201
202 /*
203 * Repack the raw bits of a native fp value.
204 */
205
206 #define _FP_PACK_RAW_2(fs, val, X)
207 do {
208 union _FP_UNION_##fs _flo;
209
210 _flo.bits.frac0 = X##_f0;
211 _flo.bits.frac1 = X##_f1;
212 _flo.bits.exp = X##_e;
213 _flo.bits.sign = X##_s;
214
215 (val) = _flo.flt;
216 } while (0)
217
218 #define _FP_PACK_RAW_2_P(fs, val, X)
219 do {
220 union _FP_UNION_##fs *_flo =
221 (union _FP_UNION_##fs *)(val);
222
223 _flo->bits.frac0 = X##_f0;
224 _flo->bits.frac1 = X##_f1;
225 _flo->bits.exp = X##_e;
226 _flo->bits.sign = X##_s;
227 } while (0)
228
229
230 /*
231 * Multiplication algorithms:
232 */
233
234 /* Given a 1W * 1W => 2W primitive, do the ext
235
236 #define _FP_MUL_MEAT_2_wide(wfracbits, R, X, Y
237 do {
238 _FP_FRAC_DECL_4(_z); _FP_FRAC_DECL_2(_b);
239
240 doit(_FP_FRAC_WORD_4(_z,1), _FP_FRAC_WORD_
241 doit(_b_f1, _b_f0, X##_f0, Y##_f1);
242 doit(_c_f1, _c_f0, X##_f1, Y##_f0);
243 doit(_FP_FRAC_WORD_4(_z,3), _FP_FRAC_WORD_
244
245 __FP_FRAC_ADD_3(_FP_FRAC_WORD_4(_z,3),_FP_
246 _FP_FRAC_WORD_4(_z,1), 0,
247 _FP_FRAC_WORD_4(_z,3),_FP_
248 _FP_FRAC_WORD_4(_z,1));
249 __FP_FRAC_ADD_3(_FP_FRAC_WORD_4(_z,3),_FP_
250 _FP_FRAC_WORD_4(_z,1), 0,
251 _FP_FRAC_WORD_4(_z,3),_FP_
252 _FP_FRAC_WORD_4(_z,1));
253
254 /* Normalize since we know where the msb o
255 were (bit B), we know that the msb of t
256 at either 2B or 2B-1. */
257 _FP_FRAC_SRS_4(_z, wfracbits-1, 2*wfracbit
258 R##_f0 = _FP_FRAC_WORD_4(_z,0);
259 R##_f1 = _FP_FRAC_WORD_4(_z,1);
260 } while (0)
261
262 /* Given a 1W * 1W => 2W primitive, do the ext
263 Do only 3 multiplications instead of four.
264 where multiplication is much more expensive
265
266 #define _FP_MUL_MEAT_2_wide_3mul(wfracbits, R,
267 do {
268 _FP_FRAC_DECL_4(_z); _FP_FRAC_DECL_2(_b);
269 _FP_W_TYPE _d;
270 int _c1, _c2;
271
272 _b_f0 = X##_f0 + X##_f1;
273 _c1 = _b_f0 < X##_f0;
274 _b_f1 = Y##_f0 + Y##_f1;
275 _c2 = _b_f1 < Y##_f0;
276 doit(_d, _FP_FRAC_WORD_4(_z,0), X##_f0, Y#
277 doit(_FP_FRAC_WORD_4(_z,2), _FP_FRAC_WORD_
278 doit(_c_f1, _c_f0, X##_f1, Y##_f1);
279
280 _b_f0 &= -_c2;
281 _b_f1 &= -_c1;
282 __FP_FRAC_ADD_3(_FP_FRAC_WORD_4(_z,3),_FP_
283 _FP_FRAC_WORD_4(_z,1), (_c
284 0, _FP_FRAC_WORD_4(_z,2),
285 __FP_FRAC_ADDI_2(_FP_FRAC_WORD_4(_z,3),_FP
286 _b_f0);
287 __FP_FRAC_ADDI_2(_FP_FRAC_WORD_4(_z,3),_FP
288 _b_f1);
289 __FP_FRAC_DEC_3(_FP_FRAC_WORD_4(_z,3),_FP_
290 _FP_FRAC_WORD_4(_z,1),
291 0, _d, _FP_FRAC_WORD_4(_z,
292 __FP_FRAC_DEC_3(_FP_FRAC_WORD_4(_z,3),_FP_
293 _FP_FRAC_WORD_4(_z,1), 0,
294 __FP_FRAC_ADD_2(_FP_FRAC_WORD_4(_z,3), _FP
295 _c_f1, _c_f0,
296 _FP_FRAC_WORD_4(_z,3), _FP
297
298 /* Normalize since we know where the msb o
299 were (bit B), we know that the msb of t
300 at either 2B or 2B-1. */
301 _FP_FRAC_SRS_4(_z, wfracbits-1, 2*wfracbit
302 R##_f0 = _FP_FRAC_WORD_4(_z,0);
303 R##_f1 = _FP_FRAC_WORD_4(_z,1);
304 } while (0)
305
306 #define _FP_MUL_MEAT_2_gmp(wfracbits, R, X, Y)
307 do {
308 _FP_FRAC_DECL_4(_z);
309 _FP_W_TYPE _x[2], _y[2];
310 _x[0] = X##_f0; _x[1] = X##_f1;
311 _y[0] = Y##_f0; _y[1] = Y##_f1;
312
313 mpn_mul_n(_z_f, _x, _y, 2);
314
315 /* Normalize since we know where the msb o
316 were (bit B), we know that the msb of t
317 at either 2B or 2B-1. */
318 _FP_FRAC_SRS_4(_z, wfracbits-1, 2*wfracbit
319 R##_f0 = _z_f[0];
320 R##_f1 = _z_f[1];
321 } while (0)
322
323 /* Do at most 120x120=240 bits multiplication
324 point multiplication. This is useful if fl
325 multiplication has much bigger throughput t
326 It is supposed to work for _FP_W_TYPE_SIZE
327 between 106 and 120 only.
328 Caller guarantees that X and Y has (1LLL <<
329 SETFETZ is a macro which will disable all F
330 towards zero, RESETFE should optionally re
331
332 #define _FP_MUL_MEAT_2_120_240_double(wfracbit
333 do {
334 static const double _const[] = {
335 /* 2^-24 */ 5.9604644775390625e-08,
336 /* 2^-48 */ 3.5527136788005009e-15,
337 /* 2^-72 */ 2.1175823681357508e-22,
338 /* 2^-96 */ 1.2621774483536189e-29,
339 /* 2^28 */ 2.68435456e+08,
340 /* 2^4 */ 1.600000e+01,
341 /* 2^-20 */ 9.5367431640625e-07,
342 /* 2^-44 */ 5.6843418860808015e-14,
343 /* 2^-68 */ 3.3881317890172014e-21,
344 /* 2^-92 */ 2.0194839173657902e-28,
345 /* 2^-116 */ 1.2037062152420224e-35};
346 double _a240, _b240, _c240, _d240, _e240,
347 _g240, _h240, _i240, _j240, _k240;
348 union { double d; UDItype i; } _l240, _m24
349 _p240, _q24
350 UDItype _t240, _u240, _v240, _w240, _x240,
351
352 if (wfracbits < 106 || wfracbits > 120)
353 abort();
354
355 setfetz;
356
357 _e240 = (double)(long)(X##_f0 & 0xffffff);
358 _j240 = (double)(long)(Y##_f0 & 0xffffff);
359 _d240 = (double)(long)((X##_f0 >> 24) & 0x
360 _i240 = (double)(long)((Y##_f0 >> 24) & 0x
361 _c240 = (double)(long)(((X##_f1 << 16) & 0
362 _h240 = (double)(long)(((Y##_f1 << 16) & 0
363 _b240 = (double)(long)((X##_f1 >> 8) & 0xf
364 _g240 = (double)(long)((Y##_f1 >> 8) & 0xf
365 _a240 = (double)(long)(X##_f1 >> 32);
366 _f240 = (double)(long)(Y##_f1 >> 32);
367 _e240 *= _const[3];
368 _j240 *= _const[3];
369 _d240 *= _const[2];
370 _i240 *= _const[2];
371 _c240 *= _const[1];
372 _h240 *= _const[1];
373 _b240 *= _const[0];
374 _g240 *= _const[0];
375 _s240.d =
376 _r240.d =
377 _q240.d = _c24
378 _p240.d = _b240*_j240 + _c24
379 _o240.d = _a240*_j240 + _b240*_i240 + _c24
380 _n240.d = _a240*_i240 + _b240*_h240 + _c24
381 _m240.d = _a240*_h240 + _b240*_g240 + _c24
382 _l240.d = _a240*_g240 + _b240*_f240;
383 _k240 = _a240*_f240;
384 _r240.d += _s240.d;
385 _q240.d += _r240.d;
386 _p240.d += _q240.d;
387 _o240.d += _p240.d;
388 _n240.d += _o240.d;
389 _m240.d += _n240.d;
390 _l240.d += _m240.d;
391 _k240 += _l240.d;
392 _s240.d -= ((_const[10]+_s240.d)-_const[10
393 _r240.d -= ((_const[9]+_r240.d)-_const[9])
394 _q240.d -= ((_const[8]+_q240.d)-_const[8])
395 _p240.d -= ((_const[7]+_p240.d)-_const[7])
396 _o240.d += _const[7];
397 _n240.d += _const[6];
398 _m240.d += _const[5];
399 _l240.d += _const[4];
400 if (_s240.d != 0.0) _y240 = 1;
401 if (_r240.d != 0.0) _y240 = 1;
402 if (_q240.d != 0.0) _y240 = 1;
403 if (_p240.d != 0.0) _y240 = 1;
404 _t240 = (DItype)_k240;
405 _u240 = _l240.i;
406 _v240 = _m240.i;
407 _w240 = _n240.i;
408 _x240 = _o240.i;
409 R##_f1 = (_t240 << (128 - (wfracbits - 1))
410 | ((_u240 & 0xffffff) >> ((wfracb
411 R##_f0 = ((_u240 & 0xffffff) << (168 - (wf
412 | ((_v240 & 0xffffff) << (144 - (
413 | ((_w240 & 0xffffff) << (120 - (
414 | ((_x240 & 0xffffff) >> ((wfracb
415 | _y240;
416 resetfe;
417 } while (0)
418
419 /*
420 * Division algorithms:
421 */
422
423 #define _FP_DIV_MEAT_2_udiv(fs, R, X, Y)
424 do {
425 _FP_W_TYPE _n_f2, _n_f1, _n_f0, _r_f1, _r_
426 if (_FP_FRAC_GT_2(X, Y))
427 {
428 _n_f2 = X##_f1 >> 1;
429 _n_f1 = X##_f1 << (_FP_W_TYPE_SIZE - 1
430 _n_f0 = X##_f0 << (_FP_W_TYPE_SIZE - 1
431 }
432 else
433 {
434 R##_e--;
435 _n_f2 = X##_f1;
436 _n_f1 = X##_f0;
437 _n_f0 = 0;
438 }
439
440 /* Normalize, i.e. make the most significa
441 denominator set. */
442 _FP_FRAC_SLL_2(Y, _FP_WFRACXBITS_##fs);
443
444 udiv_qrnnd(R##_f1, _r_f1, _n_f2, _n_f1, Y#
445 umul_ppmm(_m_f1, _m_f0, R##_f1, Y##_f0);
446 _r_f0 = _n_f0;
447 if (_FP_FRAC_GT_2(_m, _r))
448 {
449 R##_f1--;
450 _FP_FRAC_ADD_2(_r, Y, _r);
451 if (_FP_FRAC_GE_2(_r, Y) && _FP_FRAC_G
452 {
453 R##_f1--;
454 _FP_FRAC_ADD_2(_r, Y, _r);
455 }
456 }
457 _FP_FRAC_DEC_2(_r, _m);
458
459 if (_r_f1 == Y##_f1)
460 {
461 /* This is a special case, not an opti
462 (_r/Y##_f1 would not fit into UWtyp
463 As _r is guaranteed to be < Y, R##
464 (UWtype)-1 or (UWtype)-2. But as w
465 of bits it is (sticky, guard, round
466 We also don't care what the reminde
467 guard bit will be set anyway. -jj
468 R##_f0 = -1;
469 }
470 else
471 {
472 udiv_qrnnd(R##_f0, _r_f1, _r_f1, _r_f0
473 umul_ppmm(_m_f1, _m_f0, R##_f0, Y##_f0
474 _r_f0 = 0;
475 if (_FP_FRAC_GT_2(_m, _r))
476 {
477 R##_f0--;
478 _FP_FRAC_ADD_2(_r, Y, _r);
479 if (_FP_FRAC_GE_2(_r, Y) && _FP_FR
480 {
481 R##_f0--;
482 _FP_FRAC_ADD_2(_r, Y, _r);
483 }
484 }
485 if (!_FP_FRAC_EQ_2(_r, _m))
486 R##_f0 |= _FP_WORK_STICKY;
487 }
488 } while (0)
489
490
491 #define _FP_DIV_MEAT_2_gmp(fs, R, X, Y)
492 do {
493 _FP_W_TYPE _x[4], _y[2], _z[4];
494 _y[0] = Y##_f0; _y[1] = Y##_f1;
495 _x[0] = _x[3] = 0;
496 if (_FP_FRAC_GT_2(X, Y))
497 {
498 R##_e++;
499 _x[1] = (X##_f0 << (_FP_WFRACBITS_##fs
500 X##_f1 >> (_FP_W_TYPE_SIZE -
501 (_FP_WFRACBITS_##f
502 _x[2] = X##_f1 << (_FP_WFRACBITS_##fs-
503 }
504 else
505 {
506 _x[1] = (X##_f0 << (_FP_WFRACBITS_##fs
507 X##_f1 >> (_FP_W_TYPE_SIZE -
508 (_FP_WFRACBITS_##f
509 _x[2] = X##_f1 << (_FP_WFRACBITS_##fs
510 }
511
512 (void) mpn_divrem (_z, 0, _x, 4, _y, 2);
513 R##_f1 = _z[1];
514 R##_f0 = _z[0] | ((_x[0] | _x[1]) != 0);
515 } while (0)
516
517
518 /*
519 * Square root algorithms:
520 * We have just one right now, maybe Newton ap
521 * should be added for those machines where di
522 */
523
524 #define _FP_SQRT_MEAT_2(R, S, T, X, q)
525 do {
526 while (q)
527 {
528 T##_f1 = S##_f1 + q;
529 if (T##_f1 <= X##_f1)
530 {
531 S##_f1 = T##_f1 + q;
532 X##_f1 -= T##_f1;
533 R##_f1 += q;
534 }
535 _FP_FRAC_SLL_2(X, 1);
536 q >>= 1;
537 }
538 q = (_FP_W_TYPE)1 << (_FP_W_TYPE_SIZE - 1)
539 while (q != _FP_WORK_ROUND)
540 {
541 T##_f0 = S##_f0 + q;
542 T##_f1 = S##_f1;
543 if (T##_f1 < X##_f1 ||
544 (T##_f1 == X##_f1 && T##_f0 <= X##
545 {
546 S##_f0 = T##_f0 + q;
547 S##_f1 += (T##_f0 > S##_f0);
548 _FP_FRAC_DEC_2(X, T);
549 R##_f0 += q;
550 }
551 _FP_FRAC_SLL_2(X, 1);
552 q >>= 1;
553 }
554 if (X##_f0 | X##_f1)
555 {
556 if (S##_f1 < X##_f1 ||
557 (S##_f1 == X##_f1 && S##_f0 < X##_
558 R##_f0 |= _FP_WORK_ROUND;
559 R##_f0 |= _FP_WORK_STICKY;
560 }
561 } while (0)
562
563
564 /*
565 * Assembly/disassembly for converting to/from
566 * No shifting or overflow handled here.
567 */
568
569 #define _FP_FRAC_ASSEMBLE_2(r, X, rsize)
570 (void) (((rsize) <= _FP_W_TYPE_SIZE)
571 ? ({ (r) = X##_f0; })
572 : ({
573 (r) = X##_f1;
574 (r) <<= _FP_W_TYPE_SIZE;
575 (r) += X##_f0;
576 }))
577
578 #define _FP_FRAC_DISASSEMBLE_2(X, r, rsize)
579 do {
580 X##_f0 = r;
581 X##_f1 = (rsize <= _FP_W_TYPE_SIZE ? 0 : r
582 } while (0)
583
584 /*
585 * Convert FP values between word sizes
586 */
587
588 #define _FP_FRAC_CONV_1_2(dfs, sfs, D, S)
589 do {
590 if (S##_c != FP_CLS_NAN)
591 _FP_FRAC_SRS_2(S, (_FP_WFRACBITS_##sfs -
592 _FP_WFRACBITS_##sfs);
593 else
594 _FP_FRAC_SRL_2(S, (_FP_WFRACBITS_##sfs -
595 D##_f = S##_f0;
596 } while (0)
597
598 #define _FP_FRAC_CONV_2_1(dfs, sfs, D, S)
599 do {
600 D##_f0 = S##_f;
601 D##_f1 = 0;
602 _FP_FRAC_SLL_2(D, (_FP_WFRACBITS_##dfs - _
603 } while (0)
604
605 #endif
606
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.