Commit | Line | Data |
---|---|---|
252b5132 | 1 | /* IEEE floating point support routines, for GDB, the GNU Debugger. |
e27d251e | 2 | Copyright 1991, 1994, 1999, 2000, 2003, 2005, 2006 |
3b6940c0 | 3 | Free Software Foundation, Inc. |
252b5132 RH |
4 | |
5 | This file is part of GDB. | |
6 | ||
7 | This program is free software; you can redistribute it and/or modify | |
8 | it under the terms of the GNU General Public License as published by | |
9 | the Free Software Foundation; either version 2 of the License, or | |
10 | (at your option) any later version. | |
11 | ||
12 | This program is distributed in the hope that it will be useful, | |
13 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
15 | GNU General Public License for more details. | |
16 | ||
17 | You should have received a copy of the GNU General Public License | |
18 | along with this program; if not, write to the Free Software | |
979c05d3 | 19 | Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ |
252b5132 | 20 | |
b52927b7 DD |
21 | /* This is needed to pick up the NAN macro on some systems. */ |
22 | #define _GNU_SOURCE | |
23 | ||
24 | #ifdef HAVE_CONFIG_H | |
25 | #include "config.h" | |
26 | #endif | |
27 | ||
28 | #include <math.h> | |
29 | ||
30 | #ifdef HAVE_STRING_H | |
31 | #include <string.h> | |
32 | #endif | |
33 | ||
e27d251e DD |
34 | /* On some platforms, <float.h> provides DBL_QNAN. */ |
35 | #ifdef STDC_HEADERS | |
36 | #include <float.h> | |
37 | #endif | |
38 | ||
1ea16ec5 | 39 | #include "ansidecl.h" |
b52927b7 | 40 | #include "libiberty.h" |
252b5132 | 41 | #include "floatformat.h" |
b52927b7 DD |
42 | |
43 | #ifndef INFINITY | |
44 | #ifdef HUGE_VAL | |
45 | #define INFINITY HUGE_VAL | |
252b5132 | 46 | #else |
b52927b7 DD |
47 | #define INFINITY (1.0 / 0.0) |
48 | #endif | |
49 | #endif | |
50 | ||
51 | #ifndef NAN | |
e27d251e DD |
52 | #ifdef DBL_QNAN |
53 | #define NAN DBL_QNAN | |
54 | #else | |
b52927b7 | 55 | #define NAN (0.0 / 0.0) |
252b5132 | 56 | #endif |
e27d251e | 57 | #endif |
252b5132 | 58 | |
49b1fae4 DD |
59 | static unsigned long get_field (const unsigned char *, |
60 | enum floatformat_byteorders, | |
61 | unsigned int, | |
62 | unsigned int, | |
63 | unsigned int); | |
64 | static int floatformat_always_valid (const struct floatformat *fmt, | |
3b6940c0 | 65 | const void *from); |
5324d185 AC |
66 | |
67 | static int | |
49b1fae4 | 68 | floatformat_always_valid (const struct floatformat *fmt ATTRIBUTE_UNUSED, |
3b6940c0 | 69 | const void *from ATTRIBUTE_UNUSED) |
5324d185 AC |
70 | { |
71 | return 1; | |
72 | } | |
73 | ||
252b5132 RH |
74 | /* The odds that CHAR_BIT will be anything but 8 are low enough that I'm not |
75 | going to bother with trying to muck around with whether it is defined in | |
76 | a system header, what we do if not, etc. */ | |
77 | #define FLOATFORMAT_CHAR_BIT 8 | |
78 | ||
79 | /* floatformats for IEEE single and double, big and little endian. */ | |
80 | const struct floatformat floatformat_ieee_single_big = | |
81 | { | |
f03aa80d AC |
82 | floatformat_big, 32, 0, 1, 8, 127, 255, 9, 23, |
83 | floatformat_intbit_no, | |
5324d185 AC |
84 | "floatformat_ieee_single_big", |
85 | floatformat_always_valid | |
252b5132 RH |
86 | }; |
87 | const struct floatformat floatformat_ieee_single_little = | |
88 | { | |
f03aa80d AC |
89 | floatformat_little, 32, 0, 1, 8, 127, 255, 9, 23, |
90 | floatformat_intbit_no, | |
5324d185 AC |
91 | "floatformat_ieee_single_little", |
92 | floatformat_always_valid | |
252b5132 RH |
93 | }; |
94 | const struct floatformat floatformat_ieee_double_big = | |
95 | { | |
f03aa80d AC |
96 | floatformat_big, 64, 0, 1, 11, 1023, 2047, 12, 52, |
97 | floatformat_intbit_no, | |
5324d185 AC |
98 | "floatformat_ieee_double_big", |
99 | floatformat_always_valid | |
252b5132 RH |
100 | }; |
101 | const struct floatformat floatformat_ieee_double_little = | |
102 | { | |
f03aa80d AC |
103 | floatformat_little, 64, 0, 1, 11, 1023, 2047, 12, 52, |
104 | floatformat_intbit_no, | |
5324d185 AC |
105 | "floatformat_ieee_double_little", |
106 | floatformat_always_valid | |
252b5132 RH |
107 | }; |
108 | ||
109 | /* floatformat for IEEE double, little endian byte order, with big endian word | |
110 | ordering, as on the ARM. */ | |
111 | ||
112 | const struct floatformat floatformat_ieee_double_littlebyte_bigword = | |
113 | { | |
f03aa80d AC |
114 | floatformat_littlebyte_bigword, 64, 0, 1, 11, 1023, 2047, 12, 52, |
115 | floatformat_intbit_no, | |
5324d185 AC |
116 | "floatformat_ieee_double_littlebyte_bigword", |
117 | floatformat_always_valid | |
252b5132 RH |
118 | }; |
119 | ||
fb10537e DD |
120 | /* floatformat for VAX. Not quite IEEE, but close enough. */ |
121 | ||
122 | const struct floatformat floatformat_vax_f = | |
123 | { | |
124 | floatformat_vax, 32, 0, 1, 8, 129, 0, 9, 23, | |
125 | floatformat_intbit_no, | |
126 | "floatformat_vax_f", | |
127 | floatformat_always_valid | |
128 | }; | |
129 | const struct floatformat floatformat_vax_d = | |
130 | { | |
131 | floatformat_vax, 64, 0, 1, 8, 129, 0, 9, 55, | |
132 | floatformat_intbit_no, | |
133 | "floatformat_vax_d", | |
134 | floatformat_always_valid | |
135 | }; | |
136 | const struct floatformat floatformat_vax_g = | |
137 | { | |
138 | floatformat_vax, 64, 0, 1, 11, 1025, 0, 12, 52, | |
139 | floatformat_intbit_no, | |
140 | "floatformat_vax_g", | |
141 | floatformat_always_valid | |
142 | }; | |
143 | ||
3b6940c0 DD |
144 | static int floatformat_i387_ext_is_valid (const struct floatformat *fmt, |
145 | const void *from); | |
5324d185 AC |
146 | |
147 | static int | |
3b6940c0 | 148 | floatformat_i387_ext_is_valid (const struct floatformat *fmt, const void *from) |
5324d185 AC |
149 | { |
150 | /* In the i387 double-extended format, if the exponent is all ones, | |
151 | then the integer bit must be set. If the exponent is neither 0 | |
152 | nor ~0, the intbit must also be set. Only if the exponent is | |
153 | zero can it be zero, and then it must be zero. */ | |
154 | unsigned long exponent, int_bit; | |
648c3dc0 | 155 | const unsigned char *ufrom = (const unsigned char *) from; |
3b6940c0 | 156 | |
5324d185 AC |
157 | exponent = get_field (ufrom, fmt->byteorder, fmt->totalsize, |
158 | fmt->exp_start, fmt->exp_len); | |
159 | int_bit = get_field (ufrom, fmt->byteorder, fmt->totalsize, | |
160 | fmt->man_start, 1); | |
3b6940c0 | 161 | |
5324d185 AC |
162 | if ((exponent == 0) != (int_bit == 0)) |
163 | return 0; | |
164 | else | |
165 | return 1; | |
166 | } | |
167 | ||
252b5132 RH |
168 | const struct floatformat floatformat_i387_ext = |
169 | { | |
170 | floatformat_little, 80, 0, 1, 15, 0x3fff, 0x7fff, 16, 64, | |
f03aa80d | 171 | floatformat_intbit_yes, |
5324d185 AC |
172 | "floatformat_i387_ext", |
173 | floatformat_i387_ext_is_valid | |
252b5132 RH |
174 | }; |
175 | const struct floatformat floatformat_m68881_ext = | |
176 | { | |
177 | /* Note that the bits from 16 to 31 are unused. */ | |
f03aa80d AC |
178 | floatformat_big, 96, 0, 1, 15, 0x3fff, 0x7fff, 32, 64, |
179 | floatformat_intbit_yes, | |
5324d185 AC |
180 | "floatformat_m68881_ext", |
181 | floatformat_always_valid | |
252b5132 RH |
182 | }; |
183 | const struct floatformat floatformat_i960_ext = | |
184 | { | |
185 | /* Note that the bits from 0 to 15 are unused. */ | |
186 | floatformat_little, 96, 16, 17, 15, 0x3fff, 0x7fff, 32, 64, | |
f03aa80d | 187 | floatformat_intbit_yes, |
5324d185 AC |
188 | "floatformat_i960_ext", |
189 | floatformat_always_valid | |
252b5132 RH |
190 | }; |
191 | const struct floatformat floatformat_m88110_ext = | |
192 | { | |
eb828599 AC |
193 | floatformat_big, 80, 0, 1, 15, 0x3fff, 0x7fff, 16, 64, |
194 | floatformat_intbit_yes, | |
5324d185 AC |
195 | "floatformat_m88110_ext", |
196 | floatformat_always_valid | |
eb828599 AC |
197 | }; |
198 | const struct floatformat floatformat_m88110_harris_ext = | |
199 | { | |
252b5132 RH |
200 | /* Harris uses raw format 128 bytes long, but the number is just an ieee |
201 | double, and the last 64 bits are wasted. */ | |
202 | floatformat_big,128, 0, 1, 11, 0x3ff, 0x7ff, 12, 52, | |
f03aa80d | 203 | floatformat_intbit_no, |
5324d185 AC |
204 | "floatformat_m88110_ext_harris", |
205 | floatformat_always_valid | |
252b5132 | 206 | }; |
eb828599 AC |
207 | const struct floatformat floatformat_arm_ext_big = |
208 | { | |
209 | /* Bits 1 to 16 are unused. */ | |
210 | floatformat_big, 96, 0, 17, 15, 0x3fff, 0x7fff, 32, 64, | |
211 | floatformat_intbit_yes, | |
5324d185 AC |
212 | "floatformat_arm_ext_big", |
213 | floatformat_always_valid | |
eb828599 AC |
214 | }; |
215 | const struct floatformat floatformat_arm_ext_littlebyte_bigword = | |
216 | { | |
217 | /* Bits 1 to 16 are unused. */ | |
218 | floatformat_littlebyte_bigword, 96, 0, 17, 15, 0x3fff, 0x7fff, 32, 64, | |
219 | floatformat_intbit_yes, | |
5324d185 AC |
220 | "floatformat_arm_ext_littlebyte_bigword", |
221 | floatformat_always_valid | |
eb828599 AC |
222 | }; |
223 | const struct floatformat floatformat_ia64_spill_big = | |
224 | { | |
225 | floatformat_big, 128, 0, 1, 17, 65535, 0x1ffff, 18, 64, | |
226 | floatformat_intbit_yes, | |
5324d185 AC |
227 | "floatformat_ia64_spill_big", |
228 | floatformat_always_valid | |
eb828599 AC |
229 | }; |
230 | const struct floatformat floatformat_ia64_spill_little = | |
231 | { | |
232 | floatformat_little, 128, 0, 1, 17, 65535, 0x1ffff, 18, 64, | |
233 | floatformat_intbit_yes, | |
5324d185 AC |
234 | "floatformat_ia64_spill_little", |
235 | floatformat_always_valid | |
eb828599 AC |
236 | }; |
237 | const struct floatformat floatformat_ia64_quad_big = | |
238 | { | |
239 | floatformat_big, 128, 0, 1, 15, 16383, 0x7fff, 16, 112, | |
240 | floatformat_intbit_no, | |
5324d185 AC |
241 | "floatformat_ia64_quad_big", |
242 | floatformat_always_valid | |
eb828599 AC |
243 | }; |
244 | const struct floatformat floatformat_ia64_quad_little = | |
245 | { | |
246 | floatformat_little, 128, 0, 1, 15, 16383, 0x7fff, 16, 112, | |
247 | floatformat_intbit_no, | |
5324d185 AC |
248 | "floatformat_ia64_quad_little", |
249 | floatformat_always_valid | |
eb828599 | 250 | }; |
252b5132 | 251 | \f |
9e59254c JB |
252 | |
253 | #ifndef min | |
254 | #define min(a, b) ((a) < (b) ? (a) : (b)) | |
255 | #endif | |
256 | ||
3f2aacaf | 257 | /* Extract a field which starts at START and is LEN bits long. DATA and |
252b5132 RH |
258 | TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER. */ |
259 | static unsigned long | |
49b1fae4 DD |
260 | get_field (const unsigned char *data, enum floatformat_byteorders order, |
261 | unsigned int total_len, unsigned int start, unsigned int len) | |
252b5132 | 262 | { |
9e59254c | 263 | unsigned long result = 0; |
252b5132 | 264 | unsigned int cur_byte; |
9e59254c JB |
265 | int lo_bit, hi_bit, cur_bitshift = 0; |
266 | int nextbyte = (order == floatformat_little) ? 1 : -1; | |
267 | ||
268 | /* Start is in big-endian bit order! Fix that first. */ | |
269 | start = total_len - (start + len); | |
252b5132 RH |
270 | |
271 | /* Start at the least significant part of the field. */ | |
252b5132 | 272 | if (order == floatformat_little) |
9e59254c | 273 | cur_byte = start / FLOATFORMAT_CHAR_BIT; |
252b5132 | 274 | else |
9e59254c | 275 | cur_byte = (total_len - start - 1) / FLOATFORMAT_CHAR_BIT; |
252b5132 | 276 | |
9e59254c JB |
277 | lo_bit = start % FLOATFORMAT_CHAR_BIT; |
278 | hi_bit = min (lo_bit + len, FLOATFORMAT_CHAR_BIT); | |
279 | ||
280 | do | |
252b5132 | 281 | { |
9e59254c JB |
282 | unsigned int shifted = *(data + cur_byte) >> lo_bit; |
283 | unsigned int bits = hi_bit - lo_bit; | |
284 | unsigned int mask = (1 << bits) - 1; | |
285 | result |= (shifted & mask) << cur_bitshift; | |
286 | len -= bits; | |
287 | cur_bitshift += bits; | |
288 | cur_byte += nextbyte; | |
289 | lo_bit = 0; | |
290 | hi_bit = min (len, FLOATFORMAT_CHAR_BIT); | |
252b5132 | 291 | } |
9e59254c JB |
292 | while (len != 0); |
293 | ||
252b5132 RH |
294 | return result; |
295 | } | |
296 | ||
252b5132 RH |
297 | /* Convert from FMT to a double. |
298 | FROM is the address of the extended float. | |
299 | Store the double in *TO. */ | |
300 | ||
301 | void | |
49b1fae4 | 302 | floatformat_to_double (const struct floatformat *fmt, |
3b6940c0 | 303 | const void *from, double *to) |
252b5132 | 304 | { |
648c3dc0 | 305 | const unsigned char *ufrom = (const unsigned char *) from; |
252b5132 RH |
306 | double dto; |
307 | long exponent; | |
308 | unsigned long mant; | |
309 | unsigned int mant_bits, mant_off; | |
310 | int mant_bits_left; | |
311 | int special_exponent; /* It's a NaN, denorm or zero */ | |
312 | ||
313 | exponent = get_field (ufrom, fmt->byteorder, fmt->totalsize, | |
314 | fmt->exp_start, fmt->exp_len); | |
b52927b7 DD |
315 | |
316 | /* If the exponent indicates a NaN, we don't have information to | |
317 | decide what to do. So we handle it like IEEE, except that we | |
318 | don't try to preserve the type of NaN. FIXME. */ | |
319 | if ((unsigned long) exponent == fmt->exp_nan) | |
320 | { | |
321 | int nan; | |
322 | ||
323 | mant_off = fmt->man_start; | |
324 | mant_bits_left = fmt->man_len; | |
325 | nan = 0; | |
326 | while (mant_bits_left > 0) | |
327 | { | |
328 | mant_bits = min (mant_bits_left, 32); | |
329 | ||
330 | if (get_field (ufrom, fmt->byteorder, fmt->totalsize, | |
331 | mant_off, mant_bits) != 0) | |
332 | { | |
333 | /* This is a NaN. */ | |
334 | nan = 1; | |
335 | break; | |
336 | } | |
337 | ||
338 | mant_off += mant_bits; | |
339 | mant_bits_left -= mant_bits; | |
340 | } | |
341 | ||
f2942ea4 DD |
342 | /* On certain systems (such as GNU/Linux), the use of the |
343 | INFINITY macro below may generate a warning that can not be | |
344 | silenced due to a bug in GCC (PR preprocessor/11931). The | |
345 | preprocessor fails to recognise the __extension__ keyword in | |
346 | conjunction with the GNU/C99 extension for hexadecimal | |
347 | floating point constants and will issue a warning when | |
348 | compiling with -pedantic. */ | |
b52927b7 DD |
349 | if (nan) |
350 | dto = NAN; | |
351 | else | |
352 | dto = INFINITY; | |
353 | ||
354 | if (get_field (ufrom, fmt->byteorder, fmt->totalsize, fmt->sign_start, 1)) | |
355 | dto = -dto; | |
356 | ||
357 | *to = dto; | |
358 | ||
359 | return; | |
360 | } | |
252b5132 RH |
361 | |
362 | mant_bits_left = fmt->man_len; | |
363 | mant_off = fmt->man_start; | |
364 | dto = 0.0; | |
365 | ||
08372f14 | 366 | special_exponent = exponent == 0 || (unsigned long) exponent == fmt->exp_nan; |
252b5132 RH |
367 | |
368 | /* Don't bias zero's, denorms or NaNs. */ | |
369 | if (!special_exponent) | |
370 | exponent -= fmt->exp_bias; | |
371 | ||
372 | /* Build the result algebraically. Might go infinite, underflow, etc; | |
373 | who cares. */ | |
374 | ||
375 | /* If this format uses a hidden bit, explicitly add it in now. Otherwise, | |
376 | increment the exponent by one to account for the integer bit. */ | |
377 | ||
378 | if (!special_exponent) | |
379 | { | |
380 | if (fmt->intbit == floatformat_intbit_no) | |
381 | dto = ldexp (1.0, exponent); | |
382 | else | |
383 | exponent++; | |
384 | } | |
385 | ||
386 | while (mant_bits_left > 0) | |
387 | { | |
388 | mant_bits = min (mant_bits_left, 32); | |
389 | ||
390 | mant = get_field (ufrom, fmt->byteorder, fmt->totalsize, | |
391 | mant_off, mant_bits); | |
392 | ||
b52927b7 DD |
393 | /* Handle denormalized numbers. FIXME: What should we do for |
394 | non-IEEE formats? */ | |
c77d28ac | 395 | if (special_exponent && exponent == 0 && mant != 0) |
b52927b7 DD |
396 | dto += ldexp ((double)mant, |
397 | (- fmt->exp_bias | |
398 | - mant_bits | |
399 | - (mant_off - fmt->man_start) | |
400 | + 1)); | |
401 | else | |
402 | dto += ldexp ((double)mant, exponent - mant_bits); | |
403 | if (exponent != 0) | |
404 | exponent -= mant_bits; | |
252b5132 RH |
405 | mant_off += mant_bits; |
406 | mant_bits_left -= mant_bits; | |
407 | } | |
408 | ||
409 | /* Negate it if negative. */ | |
410 | if (get_field (ufrom, fmt->byteorder, fmt->totalsize, fmt->sign_start, 1)) | |
411 | dto = -dto; | |
412 | *to = dto; | |
413 | } | |
414 | \f | |
49b1fae4 DD |
415 | static void put_field (unsigned char *, enum floatformat_byteorders, |
416 | unsigned int, | |
417 | unsigned int, | |
418 | unsigned int, | |
419 | unsigned long); | |
252b5132 | 420 | |
3f2aacaf | 421 | /* Set a field which starts at START and is LEN bits long. DATA and |
252b5132 RH |
422 | TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER. */ |
423 | static void | |
49b1fae4 DD |
424 | put_field (unsigned char *data, enum floatformat_byteorders order, |
425 | unsigned int total_len, unsigned int start, unsigned int len, | |
426 | unsigned long stuff_to_put) | |
252b5132 RH |
427 | { |
428 | unsigned int cur_byte; | |
9e59254c JB |
429 | int lo_bit, hi_bit; |
430 | int nextbyte = (order == floatformat_little) ? 1 : -1; | |
431 | ||
432 | /* Start is in big-endian bit order! Fix that first. */ | |
433 | start = total_len - (start + len); | |
252b5132 RH |
434 | |
435 | /* Start at the least significant part of the field. */ | |
252b5132 | 436 | if (order == floatformat_little) |
9e59254c | 437 | cur_byte = start / FLOATFORMAT_CHAR_BIT; |
252b5132 | 438 | else |
9e59254c | 439 | cur_byte = (total_len - start - 1) / FLOATFORMAT_CHAR_BIT; |
252b5132 | 440 | |
9e59254c JB |
441 | lo_bit = start % FLOATFORMAT_CHAR_BIT; |
442 | hi_bit = min (lo_bit + len, FLOATFORMAT_CHAR_BIT); | |
443 | ||
444 | do | |
252b5132 | 445 | { |
9e59254c JB |
446 | unsigned char *byte_ptr = data + cur_byte; |
447 | unsigned int bits = hi_bit - lo_bit; | |
448 | unsigned int mask = ((1 << bits) - 1) << lo_bit; | |
449 | *byte_ptr = (*byte_ptr & ~mask) | ((stuff_to_put << lo_bit) & mask); | |
450 | stuff_to_put >>= bits; | |
451 | len -= bits; | |
452 | cur_byte += nextbyte; | |
453 | lo_bit = 0; | |
454 | hi_bit = min (len, FLOATFORMAT_CHAR_BIT); | |
252b5132 | 455 | } |
9e59254c | 456 | while (len != 0); |
252b5132 RH |
457 | } |
458 | ||
459 | /* The converse: convert the double *FROM to an extended float | |
460 | and store where TO points. Neither FROM nor TO have any alignment | |
461 | restrictions. */ | |
462 | ||
463 | void | |
49b1fae4 | 464 | floatformat_from_double (const struct floatformat *fmt, |
3b6940c0 | 465 | const double *from, void *to) |
252b5132 RH |
466 | { |
467 | double dfrom; | |
468 | int exponent; | |
469 | double mant; | |
470 | unsigned int mant_bits, mant_off; | |
471 | int mant_bits_left; | |
648c3dc0 | 472 | unsigned char *uto = (unsigned char *) to; |
252b5132 | 473 | |
b52927b7 | 474 | dfrom = *from; |
252b5132 | 475 | memset (uto, 0, fmt->totalsize / FLOATFORMAT_CHAR_BIT); |
b52927b7 DD |
476 | |
477 | /* If negative, set the sign bit. */ | |
478 | if (dfrom < 0) | |
479 | { | |
480 | put_field (uto, fmt->byteorder, fmt->totalsize, fmt->sign_start, 1, 1); | |
481 | dfrom = -dfrom; | |
482 | } | |
483 | ||
252b5132 | 484 | if (dfrom == 0) |
b52927b7 DD |
485 | { |
486 | /* 0.0. */ | |
487 | return; | |
488 | } | |
489 | ||
252b5132 RH |
490 | if (dfrom != dfrom) |
491 | { | |
b52927b7 | 492 | /* NaN. */ |
252b5132 RH |
493 | put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start, |
494 | fmt->exp_len, fmt->exp_nan); | |
b52927b7 | 495 | /* Be sure it's not infinity, but NaN value is irrelevant. */ |
252b5132 RH |
496 | put_field (uto, fmt->byteorder, fmt->totalsize, fmt->man_start, |
497 | 32, 1); | |
498 | return; | |
499 | } | |
500 | ||
b52927b7 | 501 | if (dfrom + dfrom == dfrom) |
252b5132 | 502 | { |
b52927b7 DD |
503 | /* This can only happen for an infinite value (or zero, which we |
504 | already handled above). */ | |
505 | put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start, | |
506 | fmt->exp_len, fmt->exp_nan); | |
507 | return; | |
252b5132 RH |
508 | } |
509 | ||
252b5132 | 510 | mant = frexp (dfrom, &exponent); |
b52927b7 DD |
511 | if (exponent + fmt->exp_bias - 1 > 0) |
512 | put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start, | |
513 | fmt->exp_len, exponent + fmt->exp_bias - 1); | |
514 | else | |
515 | { | |
516 | /* Handle a denormalized number. FIXME: What should we do for | |
517 | non-IEEE formats? */ | |
518 | put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start, | |
519 | fmt->exp_len, 0); | |
520 | mant = ldexp (mant, exponent + fmt->exp_bias - 1); | |
521 | } | |
252b5132 RH |
522 | |
523 | mant_bits_left = fmt->man_len; | |
524 | mant_off = fmt->man_start; | |
525 | while (mant_bits_left > 0) | |
526 | { | |
527 | unsigned long mant_long; | |
528 | mant_bits = mant_bits_left < 32 ? mant_bits_left : 32; | |
529 | ||
530 | mant *= 4294967296.0; | |
531 | mant_long = (unsigned long)mant; | |
532 | mant -= mant_long; | |
533 | ||
b52927b7 DD |
534 | /* If the integer bit is implicit, and we are not creating a |
535 | denormalized number, then we need to discard it. */ | |
08372f14 | 536 | if ((unsigned int) mant_bits_left == fmt->man_len |
b52927b7 DD |
537 | && fmt->intbit == floatformat_intbit_no |
538 | && exponent + fmt->exp_bias - 1 > 0) | |
252b5132 RH |
539 | { |
540 | mant_long &= 0x7fffffff; | |
541 | mant_bits -= 1; | |
542 | } | |
543 | else if (mant_bits < 32) | |
544 | { | |
545 | /* The bits we want are in the most significant MANT_BITS bits of | |
546 | mant_long. Move them to the least significant. */ | |
547 | mant_long >>= 32 - mant_bits; | |
548 | } | |
549 | ||
550 | put_field (uto, fmt->byteorder, fmt->totalsize, | |
551 | mant_off, mant_bits, mant_long); | |
552 | mant_off += mant_bits; | |
553 | mant_bits_left -= mant_bits; | |
554 | } | |
555 | } | |
556 | ||
3f2aacaf DJ |
557 | /* Return non-zero iff the data at FROM is a valid number in format FMT. */ |
558 | ||
559 | int | |
3b6940c0 | 560 | floatformat_is_valid (const struct floatformat *fmt, const void *from) |
3f2aacaf | 561 | { |
5324d185 | 562 | return fmt->is_valid (fmt, from); |
3f2aacaf DJ |
563 | } |
564 | ||
252b5132 RH |
565 | |
566 | #ifdef IEEE_DEBUG | |
567 | ||
b52927b7 DD |
568 | #include <stdio.h> |
569 | ||
252b5132 RH |
570 | /* This is to be run on a host which uses IEEE floating point. */ |
571 | ||
572 | void | |
49b1fae4 | 573 | ieee_test (double n) |
252b5132 RH |
574 | { |
575 | double result; | |
252b5132 | 576 | |
3b6940c0 | 577 | floatformat_to_double (&floatformat_ieee_double_little, &n, &result); |
b52927b7 DD |
578 | if ((n != result && (! isnan (n) || ! isnan (result))) |
579 | || (n < 0 && result >= 0) | |
580 | || (n >= 0 && result < 0)) | |
252b5132 | 581 | printf ("Differ(to): %.20g -> %.20g\n", n, result); |
b52927b7 | 582 | |
3b6940c0 | 583 | floatformat_from_double (&floatformat_ieee_double_little, &n, &result); |
b52927b7 DD |
584 | if ((n != result && (! isnan (n) || ! isnan (result))) |
585 | || (n < 0 && result >= 0) | |
586 | || (n >= 0 && result < 0)) | |
252b5132 RH |
587 | printf ("Differ(from): %.20g -> %.20g\n", n, result); |
588 | ||
b52927b7 DD |
589 | #if 0 |
590 | { | |
591 | char exten[16]; | |
592 | ||
593 | floatformat_from_double (&floatformat_m68881_ext, &n, exten); | |
594 | floatformat_to_double (&floatformat_m68881_ext, exten, &result); | |
595 | if (n != result) | |
596 | printf ("Differ(to+from): %.20g -> %.20g\n", n, result); | |
597 | } | |
598 | #endif | |
252b5132 RH |
599 | |
600 | #if IEEE_DEBUG > 1 | |
601 | /* This is to be run on a host which uses 68881 format. */ | |
602 | { | |
603 | long double ex = *(long double *)exten; | |
604 | if (ex != n) | |
605 | printf ("Differ(from vs. extended): %.20g\n", n); | |
606 | } | |
607 | #endif | |
608 | } | |
609 | ||
610 | int | |
49b1fae4 | 611 | main (void) |
252b5132 | 612 | { |
b52927b7 | 613 | ieee_test (0.0); |
252b5132 RH |
614 | ieee_test (0.5); |
615 | ieee_test (256.0); | |
616 | ieee_test (0.12345); | |
617 | ieee_test (234235.78907234); | |
618 | ieee_test (-512.0); | |
619 | ieee_test (-0.004321); | |
b52927b7 DD |
620 | ieee_test (1.2E-70); |
621 | ieee_test (1.2E-316); | |
622 | ieee_test (4.9406564584124654E-324); | |
623 | ieee_test (- 4.9406564584124654E-324); | |
624 | ieee_test (- 0.0); | |
625 | ieee_test (- INFINITY); | |
626 | ieee_test (- NAN); | |
627 | ieee_test (INFINITY); | |
628 | ieee_test (NAN); | |
252b5132 RH |
629 | return 0; |
630 | } | |
631 | #endif |