|
0
|
1 /* This is a software floating point library which can be used
|
|
|
2 for targets without hardware floating point.
|
|
|
3 Copyright (C) 1994, 1995, 1996, 1997, 1998, 2000, 2001, 2002, 2003,
|
|
|
4 2004, 2005, 2008, 2009 Free Software Foundation, Inc.
|
|
|
5
|
|
|
6 This file is part of GCC.
|
|
|
7
|
|
|
8 GCC is free software; you can redistribute it and/or modify it under
|
|
|
9 the terms of the GNU General Public License as published by the Free
|
|
|
10 Software Foundation; either version 3, or (at your option) any later
|
|
|
11 version.
|
|
|
12
|
|
|
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
|
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
16 for more details.
|
|
|
17
|
|
|
18 Under Section 7 of GPL version 3, you are granted additional
|
|
|
19 permissions described in the GCC Runtime Library Exception, version
|
|
|
20 3.1, as published by the Free Software Foundation.
|
|
|
21
|
|
|
22 You should have received a copy of the GNU General Public License and
|
|
|
23 a copy of the GCC Runtime Library Exception along with this program;
|
|
|
24 see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
|
|
|
25 <http://www.gnu.org/licenses/>. */
|
|
|
26
|
|
|
27 /* This implements IEEE 754 format arithmetic, but does not provide a
|
|
|
28 mechanism for setting the rounding mode, or for generating or handling
|
|
|
29 exceptions.
|
|
|
30
|
|
|
31 The original code by Steve Chamberlain, hacked by Mark Eichin and Jim
|
|
|
32 Wilson, all of Cygnus Support. */
|
|
|
33
|
|
|
34 /* The intended way to use this file is to make two copies, add `#define FLOAT'
|
|
|
35 to one copy, then compile both copies and add them to libgcc.a. */
|
|
|
36
|
|
|
37 #include "tconfig.h"
|
|
|
38 #include "coretypes.h"
|
|
|
39 #include "tm.h"
|
|
|
40 #include "config/fp-bit.h"
|
|
|
41
|
|
|
42 /* The following macros can be defined to change the behavior of this file:
|
|
|
43 FLOAT: Implement a `float', aka SFmode, fp library. If this is not
|
|
|
44 defined, then this file implements a `double', aka DFmode, fp library.
|
|
|
45 FLOAT_ONLY: Used with FLOAT, to implement a `float' only library, i.e.
|
|
|
46 don't include float->double conversion which requires the double library.
|
|
|
47 This is useful only for machines which can't support doubles, e.g. some
|
|
|
48 8-bit processors.
|
|
|
49 CMPtype: Specify the type that floating point compares should return.
|
|
|
50 This defaults to SItype, aka int.
|
|
|
51 US_SOFTWARE_GOFAST: This makes all entry points use the same names as the
|
|
|
52 US Software goFast library.
|
|
|
53 _DEBUG_BITFLOAT: This makes debugging the code a little easier, by adding
|
|
|
54 two integers to the FLO_union_type.
|
|
|
55 NO_DENORMALS: Disable handling of denormals.
|
|
|
56 NO_NANS: Disable nan and infinity handling
|
|
|
57 SMALL_MACHINE: Useful when operations on QIs and HIs are faster
|
|
|
58 than on an SI */
|
|
|
59
|
|
|
60 /* We don't currently support extended floats (long doubles) on machines
|
|
|
61 without hardware to deal with them.
|
|
|
62
|
|
|
63 These stubs are just to keep the linker from complaining about unresolved
|
|
|
64 references which can be pulled in from libio & libstdc++, even if the
|
|
|
65 user isn't using long doubles. However, they may generate an unresolved
|
|
|
66 external to abort if abort is not used by the function, and the stubs
|
|
|
67 are referenced from within libc, since libgcc goes before and after the
|
|
|
68 system library. */
|
|
|
69
|
|
|
70 #ifdef DECLARE_LIBRARY_RENAMES
|
|
|
71 DECLARE_LIBRARY_RENAMES
|
|
|
72 #endif
|
|
|
73
|
|
|
74 #ifdef EXTENDED_FLOAT_STUBS
|
|
|
75 extern void abort (void);
|
|
|
76 void __extendsfxf2 (void) { abort(); }
|
|
|
77 void __extenddfxf2 (void) { abort(); }
|
|
|
78 void __truncxfdf2 (void) { abort(); }
|
|
|
79 void __truncxfsf2 (void) { abort(); }
|
|
|
80 void __fixxfsi (void) { abort(); }
|
|
|
81 void __floatsixf (void) { abort(); }
|
|
|
82 void __addxf3 (void) { abort(); }
|
|
|
83 void __subxf3 (void) { abort(); }
|
|
|
84 void __mulxf3 (void) { abort(); }
|
|
|
85 void __divxf3 (void) { abort(); }
|
|
|
86 void __negxf2 (void) { abort(); }
|
|
|
87 void __eqxf2 (void) { abort(); }
|
|
|
88 void __nexf2 (void) { abort(); }
|
|
|
89 void __gtxf2 (void) { abort(); }
|
|
|
90 void __gexf2 (void) { abort(); }
|
|
|
91 void __lexf2 (void) { abort(); }
|
|
|
92 void __ltxf2 (void) { abort(); }
|
|
|
93
|
|
|
94 void __extendsftf2 (void) { abort(); }
|
|
|
95 void __extenddftf2 (void) { abort(); }
|
|
|
96 void __trunctfdf2 (void) { abort(); }
|
|
|
97 void __trunctfsf2 (void) { abort(); }
|
|
|
98 void __fixtfsi (void) { abort(); }
|
|
|
99 void __floatsitf (void) { abort(); }
|
|
|
100 void __addtf3 (void) { abort(); }
|
|
|
101 void __subtf3 (void) { abort(); }
|
|
|
102 void __multf3 (void) { abort(); }
|
|
|
103 void __divtf3 (void) { abort(); }
|
|
|
104 void __negtf2 (void) { abort(); }
|
|
|
105 void __eqtf2 (void) { abort(); }
|
|
|
106 void __netf2 (void) { abort(); }
|
|
|
107 void __gttf2 (void) { abort(); }
|
|
|
108 void __getf2 (void) { abort(); }
|
|
|
109 void __letf2 (void) { abort(); }
|
|
|
110 void __lttf2 (void) { abort(); }
|
|
|
111 #else /* !EXTENDED_FLOAT_STUBS, rest of file */
|
|
|
112
|
|
|
113 /* IEEE "special" number predicates */
|
|
|
114
|
|
|
115 #ifdef NO_NANS
|
|
|
116
|
|
|
117 #define nan() 0
|
|
|
118 #define isnan(x) 0
|
|
|
119 #define isinf(x) 0
|
|
|
120 #else
|
|
|
121
|
|
|
122 #if defined L_thenan_sf
|
|
|
123 const fp_number_type __thenan_sf = { CLASS_SNAN, 0, 0, {(fractype) 0} };
|
|
|
124 #elif defined L_thenan_df
|
|
|
125 const fp_number_type __thenan_df = { CLASS_SNAN, 0, 0, {(fractype) 0} };
|
|
|
126 #elif defined L_thenan_tf
|
|
|
127 const fp_number_type __thenan_tf = { CLASS_SNAN, 0, 0, {(fractype) 0} };
|
|
|
128 #elif defined TFLOAT
|
|
|
129 extern const fp_number_type __thenan_tf;
|
|
|
130 #elif defined FLOAT
|
|
|
131 extern const fp_number_type __thenan_sf;
|
|
|
132 #else
|
|
|
133 extern const fp_number_type __thenan_df;
|
|
|
134 #endif
|
|
|
135
|
|
|
136 INLINE
|
|
|
137 static const fp_number_type *
|
|
|
138 makenan (void)
|
|
|
139 {
|
|
|
140 #ifdef TFLOAT
|
|
|
141 return & __thenan_tf;
|
|
|
142 #elif defined FLOAT
|
|
|
143 return & __thenan_sf;
|
|
|
144 #else
|
|
|
145 return & __thenan_df;
|
|
|
146 #endif
|
|
|
147 }
|
|
|
148
|
|
|
149 INLINE
|
|
|
150 static int
|
|
|
151 isnan (const fp_number_type *x)
|
|
|
152 {
|
|
|
153 return __builtin_expect (x->class == CLASS_SNAN || x->class == CLASS_QNAN,
|
|
|
154 0);
|
|
|
155 }
|
|
|
156
|
|
|
157 INLINE
|
|
|
158 static int
|
|
|
159 isinf (const fp_number_type * x)
|
|
|
160 {
|
|
|
161 return __builtin_expect (x->class == CLASS_INFINITY, 0);
|
|
|
162 }
|
|
|
163
|
|
|
164 #endif /* NO_NANS */
|
|
|
165
|
|
|
166 INLINE
|
|
|
167 static int
|
|
|
168 iszero (const fp_number_type * x)
|
|
|
169 {
|
|
|
170 return x->class == CLASS_ZERO;
|
|
|
171 }
|
|
|
172
|
|
|
173 INLINE
|
|
|
174 static void
|
|
|
175 flip_sign ( fp_number_type * x)
|
|
|
176 {
|
|
|
177 x->sign = !x->sign;
|
|
|
178 }
|
|
|
179
|
|
|
180 /* Count leading zeroes in N. */
|
|
|
181 INLINE
|
|
|
182 static int
|
|
|
183 clzusi (USItype n)
|
|
|
184 {
|
|
|
185 extern int __clzsi2 (USItype);
|
|
|
186 if (sizeof (USItype) == sizeof (unsigned int))
|
|
|
187 return __builtin_clz (n);
|
|
|
188 else if (sizeof (USItype) == sizeof (unsigned long))
|
|
|
189 return __builtin_clzl (n);
|
|
|
190 else if (sizeof (USItype) == sizeof (unsigned long long))
|
|
|
191 return __builtin_clzll (n);
|
|
|
192 else
|
|
|
193 return __clzsi2 (n);
|
|
|
194 }
|
|
|
195
|
|
|
196 extern FLO_type pack_d (const fp_number_type * );
|
|
|
197
|
|
|
198 #if defined(L_pack_df) || defined(L_pack_sf) || defined(L_pack_tf)
|
|
|
199 FLO_type
|
|
|
200 pack_d (const fp_number_type *src)
|
|
|
201 {
|
|
|
202 FLO_union_type dst;
|
|
|
203 fractype fraction = src->fraction.ll; /* wasn't unsigned before? */
|
|
|
204 int sign = src->sign;
|
|
|
205 int exp = 0;
|
|
|
206
|
|
|
207 if (LARGEST_EXPONENT_IS_NORMAL (FRAC_NBITS) && (isnan (src) || isinf (src)))
|
|
|
208 {
|
|
|
209 /* We can't represent these values accurately. By using the
|
|
|
210 largest possible magnitude, we guarantee that the conversion
|
|
|
211 of infinity is at least as big as any finite number. */
|
|
|
212 exp = EXPMAX;
|
|
|
213 fraction = ((fractype) 1 << FRACBITS) - 1;
|
|
|
214 }
|
|
|
215 else if (isnan (src))
|
|
|
216 {
|
|
|
217 exp = EXPMAX;
|
|
|
218 if (src->class == CLASS_QNAN || 1)
|
|
|
219 {
|
|
|
220 #ifdef QUIET_NAN_NEGATED
|
|
|
221 fraction |= QUIET_NAN - 1;
|
|
|
222 #else
|
|
|
223 fraction |= QUIET_NAN;
|
|
|
224 #endif
|
|
|
225 }
|
|
|
226 }
|
|
|
227 else if (isinf (src))
|
|
|
228 {
|
|
|
229 exp = EXPMAX;
|
|
|
230 fraction = 0;
|
|
|
231 }
|
|
|
232 else if (iszero (src))
|
|
|
233 {
|
|
|
234 exp = 0;
|
|
|
235 fraction = 0;
|
|
|
236 }
|
|
|
237 else if (fraction == 0)
|
|
|
238 {
|
|
|
239 exp = 0;
|
|
|
240 }
|
|
|
241 else
|
|
|
242 {
|
|
|
243 if (__builtin_expect (src->normal_exp < NORMAL_EXPMIN, 0))
|
|
|
244 {
|
|
|
245 #ifdef NO_DENORMALS
|
|
|
246 /* Go straight to a zero representation if denormals are not
|
|
|
247 supported. The denormal handling would be harmless but
|
|
|
248 isn't unnecessary. */
|
|
|
249 exp = 0;
|
|
|
250 fraction = 0;
|
|
|
251 #else /* NO_DENORMALS */
|
|
|
252 /* This number's exponent is too low to fit into the bits
|
|
|
253 available in the number, so we'll store 0 in the exponent and
|
|
|
254 shift the fraction to the right to make up for it. */
|
|
|
255
|
|
|
256 int shift = NORMAL_EXPMIN - src->normal_exp;
|
|
|
257
|
|
|
258 exp = 0;
|
|
|
259
|
|
|
260 if (shift > FRAC_NBITS - NGARDS)
|
|
|
261 {
|
|
|
262 /* No point shifting, since it's more that 64 out. */
|
|
|
263 fraction = 0;
|
|
|
264 }
|
|
|
265 else
|
|
|
266 {
|
|
|
267 int lowbit = (fraction & (((fractype)1 << shift) - 1)) ? 1 : 0;
|
|
|
268 fraction = (fraction >> shift) | lowbit;
|
|
|
269 }
|
|
|
270 if ((fraction & GARDMASK) == GARDMSB)
|
|
|
271 {
|
|
|
272 if ((fraction & (1 << NGARDS)))
|
|
|
273 fraction += GARDROUND + 1;
|
|
|
274 }
|
|
|
275 else
|
|
|
276 {
|
|
|
277 /* Add to the guards to round up. */
|
|
|
278 fraction += GARDROUND;
|
|
|
279 }
|
|
|
280 /* Perhaps the rounding means we now need to change the
|
|
|
281 exponent, because the fraction is no longer denormal. */
|
|
|
282 if (fraction >= IMPLICIT_1)
|
|
|
283 {
|
|
|
284 exp += 1;
|
|
|
285 }
|
|
|
286 fraction >>= NGARDS;
|
|
|
287 #endif /* NO_DENORMALS */
|
|
|
288 }
|
|
|
289 else if (!LARGEST_EXPONENT_IS_NORMAL (FRAC_NBITS)
|
|
|
290 && __builtin_expect (src->normal_exp > EXPBIAS, 0))
|
|
|
291 {
|
|
|
292 exp = EXPMAX;
|
|
|
293 fraction = 0;
|
|
|
294 }
|
|
|
295 else
|
|
|
296 {
|
|
|
297 exp = src->normal_exp + EXPBIAS;
|
|
|
298 if (!ROUND_TOWARDS_ZERO)
|
|
|
299 {
|
|
|
300 /* IF the gard bits are the all zero, but the first, then we're
|
|
|
301 half way between two numbers, choose the one which makes the
|
|
|
302 lsb of the answer 0. */
|
|
|
303 if ((fraction & GARDMASK) == GARDMSB)
|
|
|
304 {
|
|
|
305 if (fraction & (1 << NGARDS))
|
|
|
306 fraction += GARDROUND + 1;
|
|
|
307 }
|
|
|
308 else
|
|
|
309 {
|
|
|
310 /* Add a one to the guards to round up */
|
|
|
311 fraction += GARDROUND;
|
|
|
312 }
|
|
|
313 if (fraction >= IMPLICIT_2)
|
|
|
314 {
|
|
|
315 fraction >>= 1;
|
|
|
316 exp += 1;
|
|
|
317 }
|
|
|
318 }
|
|
|
319 fraction >>= NGARDS;
|
|
|
320
|
|
|
321 if (LARGEST_EXPONENT_IS_NORMAL (FRAC_NBITS) && exp > EXPMAX)
|
|
|
322 {
|
|
|
323 /* Saturate on overflow. */
|
|
|
324 exp = EXPMAX;
|
|
|
325 fraction = ((fractype) 1 << FRACBITS) - 1;
|
|
|
326 }
|
|
|
327 }
|
|
|
328 }
|
|
|
329
|
|
|
330 /* We previously used bitfields to store the number, but this doesn't
|
|
|
331 handle little/big endian systems conveniently, so use shifts and
|
|
|
332 masks */
|
|
|
333 #ifdef FLOAT_BIT_ORDER_MISMATCH
|
|
|
334 dst.bits.fraction = fraction;
|
|
|
335 dst.bits.exp = exp;
|
|
|
336 dst.bits.sign = sign;
|
|
|
337 #else
|
|
|
338 # if defined TFLOAT && defined HALFFRACBITS
|
|
|
339 {
|
|
|
340 halffractype high, low, unity;
|
|
|
341 int lowsign, lowexp;
|
|
|
342
|
|
|
343 unity = (halffractype) 1 << HALFFRACBITS;
|
|
|
344
|
|
|
345 /* Set HIGH to the high double's significand, masking out the implicit 1.
|
|
|
346 Set LOW to the low double's full significand. */
|
|
|
347 high = (fraction >> (FRACBITS - HALFFRACBITS)) & (unity - 1);
|
|
|
348 low = fraction & (unity * 2 - 1);
|
|
|
349
|
|
|
350 /* Get the initial sign and exponent of the low double. */
|
|
|
351 lowexp = exp - HALFFRACBITS - 1;
|
|
|
352 lowsign = sign;
|
|
|
353
|
|
|
354 /* HIGH should be rounded like a normal double, making |LOW| <=
|
|
|
355 0.5 ULP of HIGH. Assume round-to-nearest. */
|
|
|
356 if (exp < EXPMAX)
|
|
|
357 if (low > unity || (low == unity && (high & 1) == 1))
|
|
|
358 {
|
|
|
359 /* Round HIGH up and adjust LOW to match. */
|
|
|
360 high++;
|
|
|
361 if (high == unity)
|
|
|
362 {
|
|
|
363 /* May make it infinite, but that's OK. */
|
|
|
364 high = 0;
|
|
|
365 exp++;
|
|
|
366 }
|
|
|
367 low = unity * 2 - low;
|
|
|
368 lowsign ^= 1;
|
|
|
369 }
|
|
|
370
|
|
|
371 high |= (halffractype) exp << HALFFRACBITS;
|
|
|
372 high |= (halffractype) sign << (HALFFRACBITS + EXPBITS);
|
|
|
373
|
|
|
374 if (exp == EXPMAX || exp == 0 || low == 0)
|
|
|
375 low = 0;
|
|
|
376 else
|
|
|
377 {
|
|
|
378 while (lowexp > 0 && low < unity)
|
|
|
379 {
|
|
|
380 low <<= 1;
|
|
|
381 lowexp--;
|
|
|
382 }
|
|
|
383
|
|
|
384 if (lowexp <= 0)
|
|
|
385 {
|
|
|
386 halffractype roundmsb, round;
|
|
|
387 int shift;
|
|
|
388
|
|
|
389 shift = 1 - lowexp;
|
|
|
390 roundmsb = (1 << (shift - 1));
|
|
|
391 round = low & ((roundmsb << 1) - 1);
|
|
|
392
|
|
|
393 low >>= shift;
|
|
|
394 lowexp = 0;
|
|
|
395
|
|
|
396 if (round > roundmsb || (round == roundmsb && (low & 1) == 1))
|
|
|
397 {
|
|
|
398 low++;
|
|
|
399 if (low == unity)
|
|
|
400 /* LOW rounds up to the smallest normal number. */
|
|
|
401 lowexp++;
|
|
|
402 }
|
|
|
403 }
|
|
|
404
|
|
|
405 low &= unity - 1;
|
|
|
406 low |= (halffractype) lowexp << HALFFRACBITS;
|
|
|
407 low |= (halffractype) lowsign << (HALFFRACBITS + EXPBITS);
|
|
|
408 }
|
|
|
409 dst.value_raw = ((fractype) high << HALFSHIFT) | low;
|
|
|
410 }
|
|
|
411 # else
|
|
|
412 dst.value_raw = fraction & ((((fractype)1) << FRACBITS) - (fractype)1);
|
|
|
413 dst.value_raw |= ((fractype) (exp & ((1 << EXPBITS) - 1))) << FRACBITS;
|
|
|
414 dst.value_raw |= ((fractype) (sign & 1)) << (FRACBITS | EXPBITS);
|
|
|
415 # endif
|
|
|
416 #endif
|
|
|
417
|
|
|
418 #if defined(FLOAT_WORD_ORDER_MISMATCH) && !defined(FLOAT)
|
|
|
419 #ifdef TFLOAT
|
|
|
420 {
|
|
|
421 qrtrfractype tmp1 = dst.words[0];
|
|
|
422 qrtrfractype tmp2 = dst.words[1];
|
|
|
423 dst.words[0] = dst.words[3];
|
|
|
424 dst.words[1] = dst.words[2];
|
|
|
425 dst.words[2] = tmp2;
|
|
|
426 dst.words[3] = tmp1;
|
|
|
427 }
|
|
|
428 #else
|
|
|
429 {
|
|
|
430 halffractype tmp = dst.words[0];
|
|
|
431 dst.words[0] = dst.words[1];
|
|
|
432 dst.words[1] = tmp;
|
|
|
433 }
|
|
|
434 #endif
|
|
|
435 #endif
|
|
|
436
|
|
|
437 return dst.value;
|
|
|
438 }
|
|
|
439 #endif
|
|
|
440
|
|
|
441 #if defined(L_unpack_df) || defined(L_unpack_sf) || defined(L_unpack_tf)
|
|
|
442 void
|
|
|
443 unpack_d (FLO_union_type * src, fp_number_type * dst)
|
|
|
444 {
|
|
|
445 /* We previously used bitfields to store the number, but this doesn't
|
|
|
446 handle little/big endian systems conveniently, so use shifts and
|
|
|
447 masks */
|
|
|
448 fractype fraction;
|
|
|
449 int exp;
|
|
|
450 int sign;
|
|
|
451
|
|
|
452 #if defined(FLOAT_WORD_ORDER_MISMATCH) && !defined(FLOAT)
|
|
|
453 FLO_union_type swapped;
|
|
|
454
|
|
|
455 #ifdef TFLOAT
|
|
|
456 swapped.words[0] = src->words[3];
|
|
|
457 swapped.words[1] = src->words[2];
|
|
|
458 swapped.words[2] = src->words[1];
|
|
|
459 swapped.words[3] = src->words[0];
|
|
|
460 #else
|
|
|
461 swapped.words[0] = src->words[1];
|
|
|
462 swapped.words[1] = src->words[0];
|
|
|
463 #endif
|
|
|
464 src = &swapped;
|
|
|
465 #endif
|
|
|
466
|
|
|
467 #ifdef FLOAT_BIT_ORDER_MISMATCH
|
|
|
468 fraction = src->bits.fraction;
|
|
|
469 exp = src->bits.exp;
|
|
|
470 sign = src->bits.sign;
|
|
|
471 #else
|
|
|
472 # if defined TFLOAT && defined HALFFRACBITS
|
|
|
473 {
|
|
|
474 halffractype high, low;
|
|
|
475
|
|
|
476 high = src->value_raw >> HALFSHIFT;
|
|
|
477 low = src->value_raw & (((fractype)1 << HALFSHIFT) - 1);
|
|
|
478
|
|
|
479 fraction = high & ((((fractype)1) << HALFFRACBITS) - 1);
|
|
|
480 fraction <<= FRACBITS - HALFFRACBITS;
|
|
|
481 exp = ((int)(high >> HALFFRACBITS)) & ((1 << EXPBITS) - 1);
|
|
|
482 sign = ((int)(high >> (((HALFFRACBITS + EXPBITS))))) & 1;
|
|
|
483
|
|
|
484 if (exp != EXPMAX && exp != 0 && low != 0)
|
|
|
485 {
|
|
|
486 int lowexp = ((int)(low >> HALFFRACBITS)) & ((1 << EXPBITS) - 1);
|
|
|
487 int lowsign = ((int)(low >> (((HALFFRACBITS + EXPBITS))))) & 1;
|
|
|
488 int shift;
|
|
|
489 fractype xlow;
|
|
|
490
|
|
|
491 xlow = low & ((((fractype)1) << HALFFRACBITS) - 1);
|
|
|
492 if (lowexp)
|
|
|
493 xlow |= (((halffractype)1) << HALFFRACBITS);
|
|
|
494 else
|
|
|
495 lowexp = 1;
|
|
|
496 shift = (FRACBITS - HALFFRACBITS) - (exp - lowexp);
|
|
|
497 if (shift > 0)
|
|
|
498 xlow <<= shift;
|
|
|
499 else if (shift < 0)
|
|
|
500 xlow >>= -shift;
|
|
|
501 if (sign == lowsign)
|
|
|
502 fraction += xlow;
|
|
|
503 else if (fraction >= xlow)
|
|
|
504 fraction -= xlow;
|
|
|
505 else
|
|
|
506 {
|
|
|
507 /* The high part is a power of two but the full number is lower.
|
|
|
508 This code will leave the implicit 1 in FRACTION, but we'd
|
|
|
509 have added that below anyway. */
|
|
|
510 fraction = (((fractype) 1 << FRACBITS) - xlow) << 1;
|
|
|
511 exp--;
|
|
|
512 }
|
|
|
513 }
|
|
|
514 }
|
|
|
515 # else
|
|
|
516 fraction = src->value_raw & ((((fractype)1) << FRACBITS) - 1);
|
|
|
517 exp = ((int)(src->value_raw >> FRACBITS)) & ((1 << EXPBITS) - 1);
|
|
|
518 sign = ((int)(src->value_raw >> (FRACBITS + EXPBITS))) & 1;
|
|
|
519 # endif
|
|
|
520 #endif
|
|
|
521
|
|
|
522 dst->sign = sign;
|
|
|
523 if (exp == 0)
|
|
|
524 {
|
|
|
525 /* Hmm. Looks like 0 */
|
|
|
526 if (fraction == 0
|
|
|
527 #ifdef NO_DENORMALS
|
|
|
528 || 1
|
|
|
529 #endif
|
|
|
530 )
|
|
|
531 {
|
|
|
532 /* tastes like zero */
|
|
|
533 dst->class = CLASS_ZERO;
|
|
|
534 }
|
|
|
535 else
|
|
|
536 {
|
|
|
537 /* Zero exponent with nonzero fraction - it's denormalized,
|
|
|
538 so there isn't a leading implicit one - we'll shift it so
|
|
|
539 it gets one. */
|
|
|
540 dst->normal_exp = exp - EXPBIAS + 1;
|
|
|
541 fraction <<= NGARDS;
|
|
|
542
|
|
|
543 dst->class = CLASS_NUMBER;
|
|
|
544 #if 1
|
|
|
545 while (fraction < IMPLICIT_1)
|
|
|
546 {
|
|
|
547 fraction <<= 1;
|
|
|
548 dst->normal_exp--;
|
|
|
549 }
|
|
|
550 #endif
|
|
|
551 dst->fraction.ll = fraction;
|
|
|
552 }
|
|
|
553 }
|
|
|
554 else if (!LARGEST_EXPONENT_IS_NORMAL (FRAC_NBITS)
|
|
|
555 && __builtin_expect (exp == EXPMAX, 0))
|
|
|
556 {
|
|
|
557 /* Huge exponent*/
|
|
|
558 if (fraction == 0)
|
|
|
559 {
|
|
|
560 /* Attached to a zero fraction - means infinity */
|
|
|
561 dst->class = CLASS_INFINITY;
|
|
|
562 }
|
|
|
563 else
|
|
|
564 {
|
|
|
565 /* Nonzero fraction, means nan */
|
|
|
566 #ifdef QUIET_NAN_NEGATED
|
|
|
567 if ((fraction & QUIET_NAN) == 0)
|
|
|
568 #else
|
|
|
569 if (fraction & QUIET_NAN)
|
|
|
570 #endif
|
|
|
571 {
|
|
|
572 dst->class = CLASS_QNAN;
|
|
|
573 }
|
|
|
574 else
|
|
|
575 {
|
|
|
576 dst->class = CLASS_SNAN;
|
|
|
577 }
|
|
|
578 /* Keep the fraction part as the nan number */
|
|
|
579 dst->fraction.ll = fraction;
|
|
|
580 }
|
|
|
581 }
|
|
|
582 else
|
|
|
583 {
|
|
|
584 /* Nothing strange about this number */
|
|
|
585 dst->normal_exp = exp - EXPBIAS;
|
|
|
586 dst->class = CLASS_NUMBER;
|
|
|
587 dst->fraction.ll = (fraction << NGARDS) | IMPLICIT_1;
|
|
|
588 }
|
|
|
589 }
|
|
|
590 #endif /* L_unpack_df || L_unpack_sf */
|
|
|
591
|
|
|
592 #if defined(L_addsub_sf) || defined(L_addsub_df) || defined(L_addsub_tf)
|
|
|
593 static const fp_number_type *
|
|
|
594 _fpadd_parts (fp_number_type * a,
|
|
|
595 fp_number_type * b,
|
|
|
596 fp_number_type * tmp)
|
|
|
597 {
|
|
|
598 intfrac tfraction;
|
|
|
599
|
|
|
600 /* Put commonly used fields in local variables. */
|
|
|
601 int a_normal_exp;
|
|
|
602 int b_normal_exp;
|
|
|
603 fractype a_fraction;
|
|
|
604 fractype b_fraction;
|
|
|
605
|
|
|
606 if (isnan (a))
|
|
|
607 {
|
|
|
608 return a;
|
|
|
609 }
|
|
|
610 if (isnan (b))
|
|
|
611 {
|
|
|
612 return b;
|
|
|
613 }
|
|
|
614 if (isinf (a))
|
|
|
615 {
|
|
|
616 /* Adding infinities with opposite signs yields a NaN. */
|
|
|
617 if (isinf (b) && a->sign != b->sign)
|
|
|
618 return makenan ();
|
|
|
619 return a;
|
|
|
620 }
|
|
|
621 if (isinf (b))
|
|
|
622 {
|
|
|
623 return b;
|
|
|
624 }
|
|
|
625 if (iszero (b))
|
|
|
626 {
|
|
|
627 if (iszero (a))
|
|
|
628 {
|
|
|
629 *tmp = *a;
|
|
|
630 tmp->sign = a->sign & b->sign;
|
|
|
631 return tmp;
|
|
|
632 }
|
|
|
633 return a;
|
|
|
634 }
|
|
|
635 if (iszero (a))
|
|
|
636 {
|
|
|
637 return b;
|
|
|
638 }
|
|
|
639
|
|
|
640 /* Got two numbers. shift the smaller and increment the exponent till
|
|
|
641 they're the same */
|
|
|
642 {
|
|
|
643 int diff;
|
|
|
644 int sdiff;
|
|
|
645
|
|
|
646 a_normal_exp = a->normal_exp;
|
|
|
647 b_normal_exp = b->normal_exp;
|
|
|
648 a_fraction = a->fraction.ll;
|
|
|
649 b_fraction = b->fraction.ll;
|
|
|
650
|
|
|
651 diff = a_normal_exp - b_normal_exp;
|
|
|
652 sdiff = diff;
|
|
|
653
|
|
|
654 if (diff < 0)
|
|
|
655 diff = -diff;
|
|
|
656 if (diff < FRAC_NBITS)
|
|
|
657 {
|
|
|
658 if (sdiff > 0)
|
|
|
659 {
|
|
|
660 b_normal_exp += diff;
|
|
|
661 LSHIFT (b_fraction, diff);
|
|
|
662 }
|
|
|
663 else if (sdiff < 0)
|
|
|
664 {
|
|
|
665 a_normal_exp += diff;
|
|
|
666 LSHIFT (a_fraction, diff);
|
|
|
667 }
|
|
|
668 }
|
|
|
669 else
|
|
|
670 {
|
|
|
671 /* Somethings's up.. choose the biggest */
|
|
|
672 if (a_normal_exp > b_normal_exp)
|
|
|
673 {
|
|
|
674 b_normal_exp = a_normal_exp;
|
|
|
675 b_fraction = 0;
|
|
|
676 }
|
|
|
677 else
|
|
|
678 {
|
|
|
679 a_normal_exp = b_normal_exp;
|
|
|
680 a_fraction = 0;
|
|
|
681 }
|
|
|
682 }
|
|
|
683 }
|
|
|
684
|
|
|
685 if (a->sign != b->sign)
|
|
|
686 {
|
|
|
687 if (a->sign)
|
|
|
688 {
|
|
|
689 tfraction = -a_fraction + b_fraction;
|
|
|
690 }
|
|
|
691 else
|
|
|
692 {
|
|
|
693 tfraction = a_fraction - b_fraction;
|
|
|
694 }
|
|
|
695 if (tfraction >= 0)
|
|
|
696 {
|
|
|
697 tmp->sign = 0;
|
|
|
698 tmp->normal_exp = a_normal_exp;
|
|
|
699 tmp->fraction.ll = tfraction;
|
|
|
700 }
|
|
|
701 else
|
|
|
702 {
|
|
|
703 tmp->sign = 1;
|
|
|
704 tmp->normal_exp = a_normal_exp;
|
|
|
705 tmp->fraction.ll = -tfraction;
|
|
|
706 }
|
|
|
707 /* and renormalize it */
|
|
|
708
|
|
|
709 while (tmp->fraction.ll < IMPLICIT_1 && tmp->fraction.ll)
|
|
|
710 {
|
|
|
711 tmp->fraction.ll <<= 1;
|
|
|
712 tmp->normal_exp--;
|
|
|
713 }
|
|
|
714 }
|
|
|
715 else
|
|
|
716 {
|
|
|
717 tmp->sign = a->sign;
|
|
|
718 tmp->normal_exp = a_normal_exp;
|
|
|
719 tmp->fraction.ll = a_fraction + b_fraction;
|
|
|
720 }
|
|
|
721 tmp->class = CLASS_NUMBER;
|
|
|
722 /* Now the fraction is added, we have to shift down to renormalize the
|
|
|
723 number */
|
|
|
724
|
|
|
725 if (tmp->fraction.ll >= IMPLICIT_2)
|
|
|
726 {
|
|
|
727 LSHIFT (tmp->fraction.ll, 1);
|
|
|
728 tmp->normal_exp++;
|
|
|
729 }
|
|
|
730 return tmp;
|
|
|
731 }
|
|
|
732
|
|
|
733 FLO_type
|
|
|
734 add (FLO_type arg_a, FLO_type arg_b)
|
|
|
735 {
|
|
|
736 fp_number_type a;
|
|
|
737 fp_number_type b;
|
|
|
738 fp_number_type tmp;
|
|
|
739 const fp_number_type *res;
|
|
|
740 FLO_union_type au, bu;
|
|
|
741
|
|
|
742 au.value = arg_a;
|
|
|
743 bu.value = arg_b;
|
|
|
744
|
|
|
745 unpack_d (&au, &a);
|
|
|
746 unpack_d (&bu, &b);
|
|
|
747
|
|
|
748 res = _fpadd_parts (&a, &b, &tmp);
|
|
|
749
|
|
|
750 return pack_d (res);
|
|
|
751 }
|
|
|
752
|
|
|
753 FLO_type
|
|
|
754 sub (FLO_type arg_a, FLO_type arg_b)
|
|
|
755 {
|
|
|
756 fp_number_type a;
|
|
|
757 fp_number_type b;
|
|
|
758 fp_number_type tmp;
|
|
|
759 const fp_number_type *res;
|
|
|
760 FLO_union_type au, bu;
|
|
|
761
|
|
|
762 au.value = arg_a;
|
|
|
763 bu.value = arg_b;
|
|
|
764
|
|
|
765 unpack_d (&au, &a);
|
|
|
766 unpack_d (&bu, &b);
|
|
|
767
|
|
|
768 b.sign ^= 1;
|
|
|
769
|
|
|
770 res = _fpadd_parts (&a, &b, &tmp);
|
|
|
771
|
|
|
772 return pack_d (res);
|
|
|
773 }
|
|
|
774 #endif /* L_addsub_sf || L_addsub_df */
|
|
|
775
|
|
|
776 #if defined(L_mul_sf) || defined(L_mul_df) || defined(L_mul_tf)
|
|
|
777 static inline __attribute__ ((__always_inline__)) const fp_number_type *
|
|
|
778 _fpmul_parts ( fp_number_type * a,
|
|
|
779 fp_number_type * b,
|
|
|
780 fp_number_type * tmp)
|
|
|
781 {
|
|
|
782 fractype low = 0;
|
|
|
783 fractype high = 0;
|
|
|
784
|
|
|
785 if (isnan (a))
|
|
|
786 {
|
|
|
787 a->sign = a->sign != b->sign;
|
|
|
788 return a;
|
|
|
789 }
|
|
|
790 if (isnan (b))
|
|
|
791 {
|
|
|
792 b->sign = a->sign != b->sign;
|
|
|
793 return b;
|
|
|
794 }
|
|
|
795 if (isinf (a))
|
|
|
796 {
|
|
|
797 if (iszero (b))
|
|
|
798 return makenan ();
|
|
|
799 a->sign = a->sign != b->sign;
|
|
|
800 return a;
|
|
|
801 }
|
|
|
802 if (isinf (b))
|
|
|
803 {
|
|
|
804 if (iszero (a))
|
|
|
805 {
|
|
|
806 return makenan ();
|
|
|
807 }
|
|
|
808 b->sign = a->sign != b->sign;
|
|
|
809 return b;
|
|
|
810 }
|
|
|
811 if (iszero (a))
|
|
|
812 {
|
|
|
813 a->sign = a->sign != b->sign;
|
|
|
814 return a;
|
|
|
815 }
|
|
|
816 if (iszero (b))
|
|
|
817 {
|
|
|
818 b->sign = a->sign != b->sign;
|
|
|
819 return b;
|
|
|
820 }
|
|
|
821
|
|
|
822 /* Calculate the mantissa by multiplying both numbers to get a
|
|
|
823 twice-as-wide number. */
|
|
|
824 {
|
|
|
825 #if defined(NO_DI_MODE) || defined(TFLOAT)
|
|
|
826 {
|
|
|
827 fractype x = a->fraction.ll;
|
|
|
828 fractype ylow = b->fraction.ll;
|
|
|
829 fractype yhigh = 0;
|
|
|
830 int bit;
|
|
|
831
|
|
|
832 /* ??? This does multiplies one bit at a time. Optimize. */
|
|
|
833 for (bit = 0; bit < FRAC_NBITS; bit++)
|
|
|
834 {
|
|
|
835 int carry;
|
|
|
836
|
|
|
837 if (x & 1)
|
|
|
838 {
|
|
|
839 carry = (low += ylow) < ylow;
|
|
|
840 high += yhigh + carry;
|
|
|
841 }
|
|
|
842 yhigh <<= 1;
|
|
|
843 if (ylow & FRACHIGH)
|
|
|
844 {
|
|
|
845 yhigh |= 1;
|
|
|
846 }
|
|
|
847 ylow <<= 1;
|
|
|
848 x >>= 1;
|
|
|
849 }
|
|
|
850 }
|
|
|
851 #elif defined(FLOAT)
|
|
|
852 /* Multiplying two USIs to get a UDI, we're safe. */
|
|
|
853 {
|
|
|
854 UDItype answer = (UDItype)a->fraction.ll * (UDItype)b->fraction.ll;
|
|
|
855
|
|
|
856 high = answer >> BITS_PER_SI;
|
|
|
857 low = answer;
|
|
|
858 }
|
|
|
859 #else
|
|
|
860 /* fractype is DImode, but we need the result to be twice as wide.
|
|
|
861 Assuming a widening multiply from DImode to TImode is not
|
|
|
862 available, build one by hand. */
|
|
|
863 {
|
|
|
864 USItype nl = a->fraction.ll;
|
|
|
865 USItype nh = a->fraction.ll >> BITS_PER_SI;
|
|
|
866 USItype ml = b->fraction.ll;
|
|
|
867 USItype mh = b->fraction.ll >> BITS_PER_SI;
|
|
|
868 UDItype pp_ll = (UDItype) ml * nl;
|
|
|
869 UDItype pp_hl = (UDItype) mh * nl;
|
|
|
870 UDItype pp_lh = (UDItype) ml * nh;
|
|
|
871 UDItype pp_hh = (UDItype) mh * nh;
|
|
|
872 UDItype res2 = 0;
|
|
|
873 UDItype res0 = 0;
|
|
|
874 UDItype ps_hh__ = pp_hl + pp_lh;
|
|
|
875 if (ps_hh__ < pp_hl)
|
|
|
876 res2 += (UDItype)1 << BITS_PER_SI;
|
|
|
877 pp_hl = (UDItype)(USItype)ps_hh__ << BITS_PER_SI;
|
|
|
878 res0 = pp_ll + pp_hl;
|
|
|
879 if (res0 < pp_ll)
|
|
|
880 res2++;
|
|
|
881 res2 += (ps_hh__ >> BITS_PER_SI) + pp_hh;
|
|
|
882 high = res2;
|
|
|
883 low = res0;
|
|
|
884 }
|
|
|
885 #endif
|
|
|
886 }
|
|
|
887
|
|
|
888 tmp->normal_exp = a->normal_exp + b->normal_exp
|
|
|
889 + FRAC_NBITS - (FRACBITS + NGARDS);
|
|
|
890 tmp->sign = a->sign != b->sign;
|
|
|
891 while (high >= IMPLICIT_2)
|
|
|
892 {
|
|
|
893 tmp->normal_exp++;
|
|
|
894 if (high & 1)
|
|
|
895 {
|
|
|
896 low >>= 1;
|
|
|
897 low |= FRACHIGH;
|
|
|
898 }
|
|
|
899 high >>= 1;
|
|
|
900 }
|
|
|
901 while (high < IMPLICIT_1)
|
|
|
902 {
|
|
|
903 tmp->normal_exp--;
|
|
|
904
|
|
|
905 high <<= 1;
|
|
|
906 if (low & FRACHIGH)
|
|
|
907 high |= 1;
|
|
|
908 low <<= 1;
|
|
|
909 }
|
|
|
910
|
|
|
911 if (!ROUND_TOWARDS_ZERO && (high & GARDMASK) == GARDMSB)
|
|
|
912 {
|
|
|
913 if (high & (1 << NGARDS))
|
|
|
914 {
|
|
|
915 /* Because we're half way, we would round to even by adding
|
|
|
916 GARDROUND + 1, except that's also done in the packing
|
|
|
917 function, and rounding twice will lose precision and cause
|
|
|
918 the result to be too far off. Example: 32-bit floats with
|
|
|
919 bit patterns 0xfff * 0x3f800400 ~= 0xfff (less than 0.5ulp
|
|
|
920 off), not 0x1000 (more than 0.5ulp off). */
|
|
|
921 }
|
|
|
922 else if (low)
|
|
|
923 {
|
|
|
924 /* We're a further than half way by a small amount corresponding
|
|
|
925 to the bits set in "low". Knowing that, we round here and
|
|
|
926 not in pack_d, because there we don't have "low" available
|
|
|
927 anymore. */
|
|
|
928 high += GARDROUND + 1;
|
|
|
929
|
|
|
930 /* Avoid further rounding in pack_d. */
|
|
|
931 high &= ~(fractype) GARDMASK;
|
|
|
932 }
|
|
|
933 }
|
|
|
934 tmp->fraction.ll = high;
|
|
|
935 tmp->class = CLASS_NUMBER;
|
|
|
936 return tmp;
|
|
|
937 }
|
|
|
938
|
|
|
939 FLO_type
|
|
|
940 multiply (FLO_type arg_a, FLO_type arg_b)
|
|
|
941 {
|
|
|
942 fp_number_type a;
|
|
|
943 fp_number_type b;
|
|
|
944 fp_number_type tmp;
|
|
|
945 const fp_number_type *res;
|
|
|
946 FLO_union_type au, bu;
|
|
|
947
|
|
|
948 au.value = arg_a;
|
|
|
949 bu.value = arg_b;
|
|
|
950
|
|
|
951 unpack_d (&au, &a);
|
|
|
952 unpack_d (&bu, &b);
|
|
|
953
|
|
|
954 res = _fpmul_parts (&a, &b, &tmp);
|
|
|
955
|
|
|
956 return pack_d (res);
|
|
|
957 }
|
|
|
958 #endif /* L_mul_sf || L_mul_df || L_mul_tf */
|
|
|
959
|
|
|
960 #if defined(L_div_sf) || defined(L_div_df) || defined(L_div_tf)
|
|
|
961 static inline __attribute__ ((__always_inline__)) const fp_number_type *
|
|
|
962 _fpdiv_parts (fp_number_type * a,
|
|
|
963 fp_number_type * b)
|
|
|
964 {
|
|
|
965 fractype bit;
|
|
|
966 fractype numerator;
|
|
|
967 fractype denominator;
|
|
|
968 fractype quotient;
|
|
|
969
|
|
|
970 if (isnan (a))
|
|
|
971 {
|
|
|
972 return a;
|
|
|
973 }
|
|
|
974 if (isnan (b))
|
|
|
975 {
|
|
|
976 return b;
|
|
|
977 }
|
|
|
978
|
|
|
979 a->sign = a->sign ^ b->sign;
|
|
|
980
|
|
|
981 if (isinf (a) || iszero (a))
|
|
|
982 {
|
|
|
983 if (a->class == b->class)
|
|
|
984 return makenan ();
|
|
|
985 return a;
|
|
|
986 }
|
|
|
987
|
|
|
988 if (isinf (b))
|
|
|
989 {
|
|
|
990 a->fraction.ll = 0;
|
|
|
991 a->normal_exp = 0;
|
|
|
992 return a;
|
|
|
993 }
|
|
|
994 if (iszero (b))
|
|
|
995 {
|
|
|
996 a->class = CLASS_INFINITY;
|
|
|
997 return a;
|
|
|
998 }
|
|
|
999
|
|
|
1000 /* Calculate the mantissa by multiplying both 64bit numbers to get a
|
|
|
1001 128 bit number */
|
|
|
1002 {
|
|
|
1003 /* quotient =
|
|
|
1004 ( numerator / denominator) * 2^(numerator exponent - denominator exponent)
|
|
|
1005 */
|
|
|
1006
|
|
|
1007 a->normal_exp = a->normal_exp - b->normal_exp;
|
|
|
1008 numerator = a->fraction.ll;
|
|
|
1009 denominator = b->fraction.ll;
|
|
|
1010
|
|
|
1011 if (numerator < denominator)
|
|
|
1012 {
|
|
|
1013 /* Fraction will be less than 1.0 */
|
|
|
1014 numerator *= 2;
|
|
|
1015 a->normal_exp--;
|
|
|
1016 }
|
|
|
1017 bit = IMPLICIT_1;
|
|
|
1018 quotient = 0;
|
|
|
1019 /* ??? Does divide one bit at a time. Optimize. */
|
|
|
1020 while (bit)
|
|
|
1021 {
|
|
|
1022 if (numerator >= denominator)
|
|
|
1023 {
|
|
|
1024 quotient |= bit;
|
|
|
1025 numerator -= denominator;
|
|
|
1026 }
|
|
|
1027 bit >>= 1;
|
|
|
1028 numerator *= 2;
|
|
|
1029 }
|
|
|
1030
|
|
|
1031 if (!ROUND_TOWARDS_ZERO && (quotient & GARDMASK) == GARDMSB)
|
|
|
1032 {
|
|
|
1033 if (quotient & (1 << NGARDS))
|
|
|
1034 {
|
|
|
1035 /* Because we're half way, we would round to even by adding
|
|
|
1036 GARDROUND + 1, except that's also done in the packing
|
|
|
1037 function, and rounding twice will lose precision and cause
|
|
|
1038 the result to be too far off. */
|
|
|
1039 }
|
|
|
1040 else if (numerator)
|
|
|
1041 {
|
|
|
1042 /* We're a further than half way by the small amount
|
|
|
1043 corresponding to the bits set in "numerator". Knowing
|
|
|
1044 that, we round here and not in pack_d, because there we
|
|
|
1045 don't have "numerator" available anymore. */
|
|
|
1046 quotient += GARDROUND + 1;
|
|
|
1047
|
|
|
1048 /* Avoid further rounding in pack_d. */
|
|
|
1049 quotient &= ~(fractype) GARDMASK;
|
|
|
1050 }
|
|
|
1051 }
|
|
|
1052
|
|
|
1053 a->fraction.ll = quotient;
|
|
|
1054 return (a);
|
|
|
1055 }
|
|
|
1056 }
|
|
|
1057
|
|
|
1058 FLO_type
|
|
|
1059 divide (FLO_type arg_a, FLO_type arg_b)
|
|
|
1060 {
|
|
|
1061 fp_number_type a;
|
|
|
1062 fp_number_type b;
|
|
|
1063 const fp_number_type *res;
|
|
|
1064 FLO_union_type au, bu;
|
|
|
1065
|
|
|
1066 au.value = arg_a;
|
|
|
1067 bu.value = arg_b;
|
|
|
1068
|
|
|
1069 unpack_d (&au, &a);
|
|
|
1070 unpack_d (&bu, &b);
|
|
|
1071
|
|
|
1072 res = _fpdiv_parts (&a, &b);
|
|
|
1073
|
|
|
1074 return pack_d (res);
|
|
|
1075 }
|
|
|
1076 #endif /* L_div_sf || L_div_df */
|
|
|
1077
|
|
|
1078 #if defined(L_fpcmp_parts_sf) || defined(L_fpcmp_parts_df) \
|
|
|
1079 || defined(L_fpcmp_parts_tf)
|
|
|
1080 /* according to the demo, fpcmp returns a comparison with 0... thus
|
|
|
1081 a<b -> -1
|
|
|
1082 a==b -> 0
|
|
|
1083 a>b -> +1
|
|
|
1084 */
|
|
|
1085
|
|
|
1086 int
|
|
|
1087 __fpcmp_parts (fp_number_type * a, fp_number_type * b)
|
|
|
1088 {
|
|
|
1089 #if 0
|
|
|
1090 /* either nan -> unordered. Must be checked outside of this routine. */
|
|
|
1091 if (isnan (a) && isnan (b))
|
|
|
1092 {
|
|
|
1093 return 1; /* still unordered! */
|
|
|
1094 }
|
|
|
1095 #endif
|
|
|
1096
|
|
|
1097 if (isnan (a) || isnan (b))
|
|
|
1098 {
|
|
|
1099 return 1; /* how to indicate unordered compare? */
|
|
|
1100 }
|
|
|
1101 if (isinf (a) && isinf (b))
|
|
|
1102 {
|
|
|
1103 /* +inf > -inf, but +inf != +inf */
|
|
|
1104 /* b \a| +inf(0)| -inf(1)
|
|
|
1105 ______\+--------+--------
|
|
|
1106 +inf(0)| a==b(0)| a<b(-1)
|
|
|
1107 -------+--------+--------
|
|
|
1108 -inf(1)| a>b(1) | a==b(0)
|
|
|
1109 -------+--------+--------
|
|
|
1110 So since unordered must be nonzero, just line up the columns...
|
|
|
1111 */
|
|
|
1112 return b->sign - a->sign;
|
|
|
1113 }
|
|
|
1114 /* but not both... */
|
|
|
1115 if (isinf (a))
|
|
|
1116 {
|
|
|
1117 return a->sign ? -1 : 1;
|
|
|
1118 }
|
|
|
1119 if (isinf (b))
|
|
|
1120 {
|
|
|
1121 return b->sign ? 1 : -1;
|
|
|
1122 }
|
|
|
1123 if (iszero (a) && iszero (b))
|
|
|
1124 {
|
|
|
1125 return 0;
|
|
|
1126 }
|
|
|
1127 if (iszero (a))
|
|
|
1128 {
|
|
|
1129 return b->sign ? 1 : -1;
|
|
|
1130 }
|
|
|
1131 if (iszero (b))
|
|
|
1132 {
|
|
|
1133 return a->sign ? -1 : 1;
|
|
|
1134 }
|
|
|
1135 /* now both are "normal". */
|
|
|
1136 if (a->sign != b->sign)
|
|
|
1137 {
|
|
|
1138 /* opposite signs */
|
|
|
1139 return a->sign ? -1 : 1;
|
|
|
1140 }
|
|
|
1141 /* same sign; exponents? */
|
|
|
1142 if (a->normal_exp > b->normal_exp)
|
|
|
1143 {
|
|
|
1144 return a->sign ? -1 : 1;
|
|
|
1145 }
|
|
|
1146 if (a->normal_exp < b->normal_exp)
|
|
|
1147 {
|
|
|
1148 return a->sign ? 1 : -1;
|
|
|
1149 }
|
|
|
1150 /* same exponents; check size. */
|
|
|
1151 if (a->fraction.ll > b->fraction.ll)
|
|
|
1152 {
|
|
|
1153 return a->sign ? -1 : 1;
|
|
|
1154 }
|
|
|
1155 if (a->fraction.ll < b->fraction.ll)
|
|
|
1156 {
|
|
|
1157 return a->sign ? 1 : -1;
|
|
|
1158 }
|
|
|
1159 /* after all that, they're equal. */
|
|
|
1160 return 0;
|
|
|
1161 }
|
|
|
1162 #endif
|
|
|
1163
|
|
|
1164 #if defined(L_compare_sf) || defined(L_compare_df) || defined(L_compoare_tf)
|
|
|
1165 CMPtype
|
|
|
1166 compare (FLO_type arg_a, FLO_type arg_b)
|
|
|
1167 {
|
|
|
1168 fp_number_type a;
|
|
|
1169 fp_number_type b;
|
|
|
1170 FLO_union_type au, bu;
|
|
|
1171
|
|
|
1172 au.value = arg_a;
|
|
|
1173 bu.value = arg_b;
|
|
|
1174
|
|
|
1175 unpack_d (&au, &a);
|
|
|
1176 unpack_d (&bu, &b);
|
|
|
1177
|
|
|
1178 return __fpcmp_parts (&a, &b);
|
|
|
1179 }
|
|
|
1180 #endif /* L_compare_sf || L_compare_df */
|
|
|
1181
|
|
|
1182 #ifndef US_SOFTWARE_GOFAST
|
|
|
1183
|
|
|
1184 /* These should be optimized for their specific tasks someday. */
|
|
|
1185
|
|
|
1186 #if defined(L_eq_sf) || defined(L_eq_df) || defined(L_eq_tf)
|
|
|
1187 CMPtype
|
|
|
1188 _eq_f2 (FLO_type arg_a, FLO_type arg_b)
|
|
|
1189 {
|
|
|
1190 fp_number_type a;
|
|
|
1191 fp_number_type b;
|
|
|
1192 FLO_union_type au, bu;
|
|
|
1193
|
|
|
1194 au.value = arg_a;
|
|
|
1195 bu.value = arg_b;
|
|
|
1196
|
|
|
1197 unpack_d (&au, &a);
|
|
|
1198 unpack_d (&bu, &b);
|
|
|
1199
|
|
|
1200 if (isnan (&a) || isnan (&b))
|
|
|
1201 return 1; /* false, truth == 0 */
|
|
|
1202
|
|
|
1203 return __fpcmp_parts (&a, &b) ;
|
|
|
1204 }
|
|
|
1205 #endif /* L_eq_sf || L_eq_df */
|
|
|
1206
|
|
|
1207 #if defined(L_ne_sf) || defined(L_ne_df) || defined(L_ne_tf)
|
|
|
1208 CMPtype
|
|
|
1209 _ne_f2 (FLO_type arg_a, FLO_type arg_b)
|
|
|
1210 {
|
|
|
1211 fp_number_type a;
|
|
|
1212 fp_number_type b;
|
|
|
1213 FLO_union_type au, bu;
|
|
|
1214
|
|
|
1215 au.value = arg_a;
|
|
|
1216 bu.value = arg_b;
|
|
|
1217
|
|
|
1218 unpack_d (&au, &a);
|
|
|
1219 unpack_d (&bu, &b);
|
|
|
1220
|
|
|
1221 if (isnan (&a) || isnan (&b))
|
|
|
1222 return 1; /* true, truth != 0 */
|
|
|
1223
|
|
|
1224 return __fpcmp_parts (&a, &b) ;
|
|
|
1225 }
|
|
|
1226 #endif /* L_ne_sf || L_ne_df */
|
|
|
1227
|
|
|
1228 #if defined(L_gt_sf) || defined(L_gt_df) || defined(L_gt_tf)
|
|
|
1229 CMPtype
|
|
|
1230 _gt_f2 (FLO_type arg_a, FLO_type arg_b)
|
|
|
1231 {
|
|
|
1232 fp_number_type a;
|
|
|
1233 fp_number_type b;
|
|
|
1234 FLO_union_type au, bu;
|
|
|
1235
|
|
|
1236 au.value = arg_a;
|
|
|
1237 bu.value = arg_b;
|
|
|
1238
|
|
|
1239 unpack_d (&au, &a);
|
|
|
1240 unpack_d (&bu, &b);
|
|
|
1241
|
|
|
1242 if (isnan (&a) || isnan (&b))
|
|
|
1243 return -1; /* false, truth > 0 */
|
|
|
1244
|
|
|
1245 return __fpcmp_parts (&a, &b);
|
|
|
1246 }
|
|
|
1247 #endif /* L_gt_sf || L_gt_df */
|
|
|
1248
|
|
|
1249 #if defined(L_ge_sf) || defined(L_ge_df) || defined(L_ge_tf)
|
|
|
1250 CMPtype
|
|
|
1251 _ge_f2 (FLO_type arg_a, FLO_type arg_b)
|
|
|
1252 {
|
|
|
1253 fp_number_type a;
|
|
|
1254 fp_number_type b;
|
|
|
1255 FLO_union_type au, bu;
|
|
|
1256
|
|
|
1257 au.value = arg_a;
|
|
|
1258 bu.value = arg_b;
|
|
|
1259
|
|
|
1260 unpack_d (&au, &a);
|
|
|
1261 unpack_d (&bu, &b);
|
|
|
1262
|
|
|
1263 if (isnan (&a) || isnan (&b))
|
|
|
1264 return -1; /* false, truth >= 0 */
|
|
|
1265 return __fpcmp_parts (&a, &b) ;
|
|
|
1266 }
|
|
|
1267 #endif /* L_ge_sf || L_ge_df */
|
|
|
1268
|
|
|
1269 #if defined(L_lt_sf) || defined(L_lt_df) || defined(L_lt_tf)
|
|
|
1270 CMPtype
|
|
|
1271 _lt_f2 (FLO_type arg_a, FLO_type arg_b)
|
|
|
1272 {
|
|
|
1273 fp_number_type a;
|
|
|
1274 fp_number_type b;
|
|
|
1275 FLO_union_type au, bu;
|
|
|
1276
|
|
|
1277 au.value = arg_a;
|
|
|
1278 bu.value = arg_b;
|
|
|
1279
|
|
|
1280 unpack_d (&au, &a);
|
|
|
1281 unpack_d (&bu, &b);
|
|
|
1282
|
|
|
1283 if (isnan (&a) || isnan (&b))
|
|
|
1284 return 1; /* false, truth < 0 */
|
|
|
1285
|
|
|
1286 return __fpcmp_parts (&a, &b);
|
|
|
1287 }
|
|
|
1288 #endif /* L_lt_sf || L_lt_df */
|
|
|
1289
|
|
|
1290 #if defined(L_le_sf) || defined(L_le_df) || defined(L_le_tf)
|
|
|
1291 CMPtype
|
|
|
1292 _le_f2 (FLO_type arg_a, FLO_type arg_b)
|
|
|
1293 {
|
|
|
1294 fp_number_type a;
|
|
|
1295 fp_number_type b;
|
|
|
1296 FLO_union_type au, bu;
|
|
|
1297
|
|
|
1298 au.value = arg_a;
|
|
|
1299 bu.value = arg_b;
|
|
|
1300
|
|
|
1301 unpack_d (&au, &a);
|
|
|
1302 unpack_d (&bu, &b);
|
|
|
1303
|
|
|
1304 if (isnan (&a) || isnan (&b))
|
|
|
1305 return 1; /* false, truth <= 0 */
|
|
|
1306
|
|
|
1307 return __fpcmp_parts (&a, &b) ;
|
|
|
1308 }
|
|
|
1309 #endif /* L_le_sf || L_le_df */
|
|
|
1310
|
|
|
1311 #endif /* ! US_SOFTWARE_GOFAST */
|
|
|
1312
|
|
|
1313 #if defined(L_unord_sf) || defined(L_unord_df) || defined(L_unord_tf)
|
|
|
1314 CMPtype
|
|
|
1315 _unord_f2 (FLO_type arg_a, FLO_type arg_b)
|
|
|
1316 {
|
|
|
1317 fp_number_type a;
|
|
|
1318 fp_number_type b;
|
|
|
1319 FLO_union_type au, bu;
|
|
|
1320
|
|
|
1321 au.value = arg_a;
|
|
|
1322 bu.value = arg_b;
|
|
|
1323
|
|
|
1324 unpack_d (&au, &a);
|
|
|
1325 unpack_d (&bu, &b);
|
|
|
1326
|
|
|
1327 return (isnan (&a) || isnan (&b));
|
|
|
1328 }
|
|
|
1329 #endif /* L_unord_sf || L_unord_df */
|
|
|
1330
|
|
|
1331 #if defined(L_si_to_sf) || defined(L_si_to_df) || defined(L_si_to_tf)
|
|
|
1332 FLO_type
|
|
|
1333 si_to_float (SItype arg_a)
|
|
|
1334 {
|
|
|
1335 fp_number_type in;
|
|
|
1336
|
|
|
1337 in.class = CLASS_NUMBER;
|
|
|
1338 in.sign = arg_a < 0;
|
|
|
1339 if (!arg_a)
|
|
|
1340 {
|
|
|
1341 in.class = CLASS_ZERO;
|
|
|
1342 }
|
|
|
1343 else
|
|
|
1344 {
|
|
|
1345 USItype uarg;
|
|
|
1346 int shift;
|
|
|
1347 in.normal_exp = FRACBITS + NGARDS;
|
|
|
1348 if (in.sign)
|
|
|
1349 {
|
|
|
1350 /* Special case for minint, since there is no +ve integer
|
|
|
1351 representation for it */
|
|
|
1352 if (arg_a == (- MAX_SI_INT - 1))
|
|
|
1353 {
|
|
|
1354 return (FLO_type)(- MAX_SI_INT - 1);
|
|
|
1355 }
|
|
|
1356 uarg = (-arg_a);
|
|
|
1357 }
|
|
|
1358 else
|
|
|
1359 uarg = arg_a;
|
|
|
1360
|
|
|
1361 in.fraction.ll = uarg;
|
|
|
1362 shift = clzusi (uarg) - (BITS_PER_SI - 1 - FRACBITS - NGARDS);
|
|
|
1363 if (shift > 0)
|
|
|
1364 {
|
|
|
1365 in.fraction.ll <<= shift;
|
|
|
1366 in.normal_exp -= shift;
|
|
|
1367 }
|
|
|
1368 }
|
|
|
1369 return pack_d (&in);
|
|
|
1370 }
|
|
|
1371 #endif /* L_si_to_sf || L_si_to_df */
|
|
|
1372
|
|
|
1373 #if defined(L_usi_to_sf) || defined(L_usi_to_df) || defined(L_usi_to_tf)
|
|
|
1374 FLO_type
|
|
|
1375 usi_to_float (USItype arg_a)
|
|
|
1376 {
|
|
|
1377 fp_number_type in;
|
|
|
1378
|
|
|
1379 in.sign = 0;
|
|
|
1380 if (!arg_a)
|
|
|
1381 {
|
|
|
1382 in.class = CLASS_ZERO;
|
|
|
1383 }
|
|
|
1384 else
|
|
|
1385 {
|
|
|
1386 int shift;
|
|
|
1387 in.class = CLASS_NUMBER;
|
|
|
1388 in.normal_exp = FRACBITS + NGARDS;
|
|
|
1389 in.fraction.ll = arg_a;
|
|
|
1390
|
|
|
1391 shift = clzusi (arg_a) - (BITS_PER_SI - 1 - FRACBITS - NGARDS);
|
|
|
1392 if (shift < 0)
|
|
|
1393 {
|
|
|
1394 fractype guard = in.fraction.ll & (((fractype)1 << -shift) - 1);
|
|
|
1395 in.fraction.ll >>= -shift;
|
|
|
1396 in.fraction.ll |= (guard != 0);
|
|
|
1397 in.normal_exp -= shift;
|
|
|
1398 }
|
|
|
1399 else if (shift > 0)
|
|
|
1400 {
|
|
|
1401 in.fraction.ll <<= shift;
|
|
|
1402 in.normal_exp -= shift;
|
|
|
1403 }
|
|
|
1404 }
|
|
|
1405 return pack_d (&in);
|
|
|
1406 }
|
|
|
1407 #endif
|
|
|
1408
|
|
|
1409 #if defined(L_sf_to_si) || defined(L_df_to_si) || defined(L_tf_to_si)
|
|
|
1410 SItype
|
|
|
1411 float_to_si (FLO_type arg_a)
|
|
|
1412 {
|
|
|
1413 fp_number_type a;
|
|
|
1414 SItype tmp;
|
|
|
1415 FLO_union_type au;
|
|
|
1416
|
|
|
1417 au.value = arg_a;
|
|
|
1418 unpack_d (&au, &a);
|
|
|
1419
|
|
|
1420 if (iszero (&a))
|
|
|
1421 return 0;
|
|
|
1422 if (isnan (&a))
|
|
|
1423 return 0;
|
|
|
1424 /* get reasonable MAX_SI_INT... */
|
|
|
1425 if (isinf (&a))
|
|
|
1426 return a.sign ? (-MAX_SI_INT)-1 : MAX_SI_INT;
|
|
|
1427 /* it is a number, but a small one */
|
|
|
1428 if (a.normal_exp < 0)
|
|
|
1429 return 0;
|
|
|
1430 if (a.normal_exp > BITS_PER_SI - 2)
|
|
|
1431 return a.sign ? (-MAX_SI_INT)-1 : MAX_SI_INT;
|
|
|
1432 tmp = a.fraction.ll >> ((FRACBITS + NGARDS) - a.normal_exp);
|
|
|
1433 return a.sign ? (-tmp) : (tmp);
|
|
|
1434 }
|
|
|
1435 #endif /* L_sf_to_si || L_df_to_si */
|
|
|
1436
|
|
|
1437 #if defined(L_sf_to_usi) || defined(L_df_to_usi) || defined(L_tf_to_usi)
|
|
|
1438 #if defined US_SOFTWARE_GOFAST || defined(L_tf_to_usi)
|
|
|
1439 /* While libgcc2.c defines its own __fixunssfsi and __fixunsdfsi routines,
|
|
|
1440 we also define them for GOFAST because the ones in libgcc2.c have the
|
|
|
1441 wrong names and I'd rather define these here and keep GOFAST CYG-LOC's
|
|
|
1442 out of libgcc2.c. We can't define these here if not GOFAST because then
|
|
|
1443 there'd be duplicate copies. */
|
|
|
1444
|
|
|
1445 USItype
|
|
|
1446 float_to_usi (FLO_type arg_a)
|
|
|
1447 {
|
|
|
1448 fp_number_type a;
|
|
|
1449 FLO_union_type au;
|
|
|
1450
|
|
|
1451 au.value = arg_a;
|
|
|
1452 unpack_d (&au, &a);
|
|
|
1453
|
|
|
1454 if (iszero (&a))
|
|
|
1455 return 0;
|
|
|
1456 if (isnan (&a))
|
|
|
1457 return 0;
|
|
|
1458 /* it is a negative number */
|
|
|
1459 if (a.sign)
|
|
|
1460 return 0;
|
|
|
1461 /* get reasonable MAX_USI_INT... */
|
|
|
1462 if (isinf (&a))
|
|
|
1463 return MAX_USI_INT;
|
|
|
1464 /* it is a number, but a small one */
|
|
|
1465 if (a.normal_exp < 0)
|
|
|
1466 return 0;
|
|
|
1467 if (a.normal_exp > BITS_PER_SI - 1)
|
|
|
1468 return MAX_USI_INT;
|
|
|
1469 else if (a.normal_exp > (FRACBITS + NGARDS))
|
|
|
1470 return a.fraction.ll << (a.normal_exp - (FRACBITS + NGARDS));
|
|
|
1471 else
|
|
|
1472 return a.fraction.ll >> ((FRACBITS + NGARDS) - a.normal_exp);
|
|
|
1473 }
|
|
|
1474 #endif /* US_SOFTWARE_GOFAST */
|
|
|
1475 #endif /* L_sf_to_usi || L_df_to_usi */
|
|
|
1476
|
|
|
1477 #if defined(L_negate_sf) || defined(L_negate_df) || defined(L_negate_tf)
|
|
|
1478 FLO_type
|
|
|
1479 negate (FLO_type arg_a)
|
|
|
1480 {
|
|
|
1481 fp_number_type a;
|
|
|
1482 FLO_union_type au;
|
|
|
1483
|
|
|
1484 au.value = arg_a;
|
|
|
1485 unpack_d (&au, &a);
|
|
|
1486
|
|
|
1487 flip_sign (&a);
|
|
|
1488 return pack_d (&a);
|
|
|
1489 }
|
|
|
1490 #endif /* L_negate_sf || L_negate_df */
|
|
|
1491
|
|
|
1492 #ifdef FLOAT
|
|
|
1493
|
|
|
1494 #if defined(L_make_sf)
|
|
|
1495 SFtype
|
|
|
1496 __make_fp(fp_class_type class,
|
|
|
1497 unsigned int sign,
|
|
|
1498 int exp,
|
|
|
1499 USItype frac)
|
|
|
1500 {
|
|
|
1501 fp_number_type in;
|
|
|
1502
|
|
|
1503 in.class = class;
|
|
|
1504 in.sign = sign;
|
|
|
1505 in.normal_exp = exp;
|
|
|
1506 in.fraction.ll = frac;
|
|
|
1507 return pack_d (&in);
|
|
|
1508 }
|
|
|
1509 #endif /* L_make_sf */
|
|
|
1510
|
|
|
1511 #ifndef FLOAT_ONLY
|
|
|
1512
|
|
|
1513 /* This enables one to build an fp library that supports float but not double.
|
|
|
1514 Otherwise, we would get an undefined reference to __make_dp.
|
|
|
1515 This is needed for some 8-bit ports that can't handle well values that
|
|
|
1516 are 8-bytes in size, so we just don't support double for them at all. */
|
|
|
1517
|
|
|
1518 #if defined(L_sf_to_df)
|
|
|
1519 DFtype
|
|
|
1520 sf_to_df (SFtype arg_a)
|
|
|
1521 {
|
|
|
1522 fp_number_type in;
|
|
|
1523 FLO_union_type au;
|
|
|
1524
|
|
|
1525 au.value = arg_a;
|
|
|
1526 unpack_d (&au, &in);
|
|
|
1527
|
|
|
1528 return __make_dp (in.class, in.sign, in.normal_exp,
|
|
|
1529 ((UDItype) in.fraction.ll) << F_D_BITOFF);
|
|
|
1530 }
|
|
|
1531 #endif /* L_sf_to_df */
|
|
|
1532
|
|
|
1533 #if defined(L_sf_to_tf) && defined(TMODES)
|
|
|
1534 TFtype
|
|
|
1535 sf_to_tf (SFtype arg_a)
|
|
|
1536 {
|
|
|
1537 fp_number_type in;
|
|
|
1538 FLO_union_type au;
|
|
|
1539
|
|
|
1540 au.value = arg_a;
|
|
|
1541 unpack_d (&au, &in);
|
|
|
1542
|
|
|
1543 return __make_tp (in.class, in.sign, in.normal_exp,
|
|
|
1544 ((UTItype) in.fraction.ll) << F_T_BITOFF);
|
|
|
1545 }
|
|
|
1546 #endif /* L_sf_to_df */
|
|
|
1547
|
|
|
1548 #endif /* ! FLOAT_ONLY */
|
|
|
1549 #endif /* FLOAT */
|
|
|
1550
|
|
|
1551 #ifndef FLOAT
|
|
|
1552
|
|
|
1553 extern SFtype __make_fp (fp_class_type, unsigned int, int, USItype);
|
|
|
1554
|
|
|
1555 #if defined(L_make_df)
|
|
|
1556 DFtype
|
|
|
1557 __make_dp (fp_class_type class, unsigned int sign, int exp, UDItype frac)
|
|
|
1558 {
|
|
|
1559 fp_number_type in;
|
|
|
1560
|
|
|
1561 in.class = class;
|
|
|
1562 in.sign = sign;
|
|
|
1563 in.normal_exp = exp;
|
|
|
1564 in.fraction.ll = frac;
|
|
|
1565 return pack_d (&in);
|
|
|
1566 }
|
|
|
1567 #endif /* L_make_df */
|
|
|
1568
|
|
|
1569 #if defined(L_df_to_sf)
|
|
|
1570 SFtype
|
|
|
1571 df_to_sf (DFtype arg_a)
|
|
|
1572 {
|
|
|
1573 fp_number_type in;
|
|
|
1574 USItype sffrac;
|
|
|
1575 FLO_union_type au;
|
|
|
1576
|
|
|
1577 au.value = arg_a;
|
|
|
1578 unpack_d (&au, &in);
|
|
|
1579
|
|
|
1580 sffrac = in.fraction.ll >> F_D_BITOFF;
|
|
|
1581
|
|
|
1582 /* We set the lowest guard bit in SFFRAC if we discarded any non
|
|
|
1583 zero bits. */
|
|
|
1584 if ((in.fraction.ll & (((USItype) 1 << F_D_BITOFF) - 1)) != 0)
|
|
|
1585 sffrac |= 1;
|
|
|
1586
|
|
|
1587 return __make_fp (in.class, in.sign, in.normal_exp, sffrac);
|
|
|
1588 }
|
|
|
1589 #endif /* L_df_to_sf */
|
|
|
1590
|
|
|
1591 #if defined(L_df_to_tf) && defined(TMODES) \
|
|
|
1592 && !defined(FLOAT) && !defined(TFLOAT)
|
|
|
1593 TFtype
|
|
|
1594 df_to_tf (DFtype arg_a)
|
|
|
1595 {
|
|
|
1596 fp_number_type in;
|
|
|
1597 FLO_union_type au;
|
|
|
1598
|
|
|
1599 au.value = arg_a;
|
|
|
1600 unpack_d (&au, &in);
|
|
|
1601
|
|
|
1602 return __make_tp (in.class, in.sign, in.normal_exp,
|
|
|
1603 ((UTItype) in.fraction.ll) << D_T_BITOFF);
|
|
|
1604 }
|
|
|
1605 #endif /* L_sf_to_df */
|
|
|
1606
|
|
|
1607 #ifdef TFLOAT
|
|
|
1608 #if defined(L_make_tf)
|
|
|
1609 TFtype
|
|
|
1610 __make_tp(fp_class_type class,
|
|
|
1611 unsigned int sign,
|
|
|
1612 int exp,
|
|
|
1613 UTItype frac)
|
|
|
1614 {
|
|
|
1615 fp_number_type in;
|
|
|
1616
|
|
|
1617 in.class = class;
|
|
|
1618 in.sign = sign;
|
|
|
1619 in.normal_exp = exp;
|
|
|
1620 in.fraction.ll = frac;
|
|
|
1621 return pack_d (&in);
|
|
|
1622 }
|
|
|
1623 #endif /* L_make_tf */
|
|
|
1624
|
|
|
1625 #if defined(L_tf_to_df)
|
|
|
1626 DFtype
|
|
|
1627 tf_to_df (TFtype arg_a)
|
|
|
1628 {
|
|
|
1629 fp_number_type in;
|
|
|
1630 UDItype sffrac;
|
|
|
1631 FLO_union_type au;
|
|
|
1632
|
|
|
1633 au.value = arg_a;
|
|
|
1634 unpack_d (&au, &in);
|
|
|
1635
|
|
|
1636 sffrac = in.fraction.ll >> D_T_BITOFF;
|
|
|
1637
|
|
|
1638 /* We set the lowest guard bit in SFFRAC if we discarded any non
|
|
|
1639 zero bits. */
|
|
|
1640 if ((in.fraction.ll & (((UTItype) 1 << D_T_BITOFF) - 1)) != 0)
|
|
|
1641 sffrac |= 1;
|
|
|
1642
|
|
|
1643 return __make_dp (in.class, in.sign, in.normal_exp, sffrac);
|
|
|
1644 }
|
|
|
1645 #endif /* L_tf_to_df */
|
|
|
1646
|
|
|
1647 #if defined(L_tf_to_sf)
|
|
|
1648 SFtype
|
|
|
1649 tf_to_sf (TFtype arg_a)
|
|
|
1650 {
|
|
|
1651 fp_number_type in;
|
|
|
1652 USItype sffrac;
|
|
|
1653 FLO_union_type au;
|
|
|
1654
|
|
|
1655 au.value = arg_a;
|
|
|
1656 unpack_d (&au, &in);
|
|
|
1657
|
|
|
1658 sffrac = in.fraction.ll >> F_T_BITOFF;
|
|
|
1659
|
|
|
1660 /* We set the lowest guard bit in SFFRAC if we discarded any non
|
|
|
1661 zero bits. */
|
|
|
1662 if ((in.fraction.ll & (((UTItype) 1 << F_T_BITOFF) - 1)) != 0)
|
|
|
1663 sffrac |= 1;
|
|
|
1664
|
|
|
1665 return __make_fp (in.class, in.sign, in.normal_exp, sffrac);
|
|
|
1666 }
|
|
|
1667 #endif /* L_tf_to_sf */
|
|
|
1668 #endif /* TFLOAT */
|
|
|
1669
|
|
|
1670 #endif /* ! FLOAT */
|
|
|
1671 #endif /* !EXTENDED_FLOAT_STUBS */
|
