Commit | Line | Data |
---|---|---|
252b5132 | 1 | /* atof_ieee.c - turn a Flonum into an IEEE floating point number |
44877466 | 2 | Copyright (C) 1987, 92, 93, 94, 95, 96, 97, 98, 99, 2000 |
252b5132 RH |
3 | Free Software Foundation, Inc. |
4 | ||
5 | This file is part of GAS, the GNU Assembler. | |
6 | ||
7 | GAS 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, or (at your option) | |
10 | any later version. | |
11 | ||
12 | GAS 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 GAS; see the file COPYING. If not, write to the Free | |
19 | Software Foundation, 59 Temple Place - Suite 330, Boston, MA | |
20 | 02111-1307, USA. */ | |
21 | ||
22 | #include "as.h" | |
23 | ||
24 | /* Flonums returned here. */ | |
25 | extern FLONUM_TYPE generic_floating_point_number; | |
26 | ||
27 | static int next_bits PARAMS ((int)); | |
28 | static void unget_bits PARAMS ((int)); | |
29 | static void make_invalid_floating_point_number PARAMS ((LITTLENUM_TYPE *)); | |
30 | ||
31 | extern const char EXP_CHARS[]; | |
32 | /* Precision in LittleNums. */ | |
33 | /* Don't count the gap in the m68k extended precision format. */ | |
34 | #define MAX_PRECISION (5) | |
35 | #define F_PRECISION (2) | |
36 | #define D_PRECISION (4) | |
37 | #define X_PRECISION (5) | |
38 | #define P_PRECISION (5) | |
39 | ||
40 | /* Length in LittleNums of guard bits. */ | |
41 | #define GUARD (2) | |
42 | ||
43 | static const unsigned long mask[] = | |
44 | { | |
45 | 0x00000000, | |
46 | 0x00000001, | |
47 | 0x00000003, | |
48 | 0x00000007, | |
49 | 0x0000000f, | |
50 | 0x0000001f, | |
51 | 0x0000003f, | |
52 | 0x0000007f, | |
53 | 0x000000ff, | |
54 | 0x000001ff, | |
55 | 0x000003ff, | |
56 | 0x000007ff, | |
57 | 0x00000fff, | |
58 | 0x00001fff, | |
59 | 0x00003fff, | |
60 | 0x00007fff, | |
61 | 0x0000ffff, | |
62 | 0x0001ffff, | |
63 | 0x0003ffff, | |
64 | 0x0007ffff, | |
65 | 0x000fffff, | |
66 | 0x001fffff, | |
67 | 0x003fffff, | |
68 | 0x007fffff, | |
69 | 0x00ffffff, | |
70 | 0x01ffffff, | |
71 | 0x03ffffff, | |
72 | 0x07ffffff, | |
73 | 0x0fffffff, | |
74 | 0x1fffffff, | |
75 | 0x3fffffff, | |
76 | 0x7fffffff, | |
77 | 0xffffffff, | |
78 | }; | |
79 | \f | |
80 | ||
81 | static int bits_left_in_littlenum; | |
82 | static int littlenums_left; | |
83 | static LITTLENUM_TYPE *littlenum_pointer; | |
84 | ||
85 | static int | |
86 | next_bits (number_of_bits) | |
87 | int number_of_bits; | |
88 | { | |
89 | int return_value; | |
90 | ||
91 | if (!littlenums_left) | |
92 | return (0); | |
93 | if (number_of_bits >= bits_left_in_littlenum) | |
94 | { | |
95 | return_value = mask[bits_left_in_littlenum] & *littlenum_pointer; | |
96 | number_of_bits -= bits_left_in_littlenum; | |
97 | return_value <<= number_of_bits; | |
98 | ||
99 | if (--littlenums_left) | |
100 | { | |
101 | bits_left_in_littlenum = LITTLENUM_NUMBER_OF_BITS - number_of_bits; | |
102 | --littlenum_pointer; | |
103 | return_value |= (*littlenum_pointer >> bits_left_in_littlenum) & mask[number_of_bits]; | |
104 | } | |
105 | } | |
106 | else | |
107 | { | |
108 | bits_left_in_littlenum -= number_of_bits; | |
109 | return_value = mask[number_of_bits] & (*littlenum_pointer >> bits_left_in_littlenum); | |
110 | } | |
111 | return (return_value); | |
112 | } | |
113 | ||
114 | /* Num had better be less than LITTLENUM_NUMBER_OF_BITS */ | |
115 | static void | |
116 | unget_bits (num) | |
117 | int num; | |
118 | { | |
119 | if (!littlenums_left) | |
120 | { | |
121 | ++littlenum_pointer; | |
122 | ++littlenums_left; | |
123 | bits_left_in_littlenum = num; | |
124 | } | |
125 | else if (bits_left_in_littlenum + num > LITTLENUM_NUMBER_OF_BITS) | |
126 | { | |
127 | bits_left_in_littlenum = num - (LITTLENUM_NUMBER_OF_BITS - bits_left_in_littlenum); | |
128 | ++littlenum_pointer; | |
129 | ++littlenums_left; | |
130 | } | |
131 | else | |
132 | bits_left_in_littlenum += num; | |
133 | } | |
134 | ||
135 | static void | |
136 | make_invalid_floating_point_number (words) | |
137 | LITTLENUM_TYPE *words; | |
138 | { | |
139 | as_bad (_("cannot create floating-point number")); | |
140 | words[0] = (LITTLENUM_TYPE) ((unsigned) -1) >> 1; /* Zero the leftmost bit */ | |
141 | words[1] = (LITTLENUM_TYPE) -1; | |
142 | words[2] = (LITTLENUM_TYPE) -1; | |
143 | words[3] = (LITTLENUM_TYPE) -1; | |
144 | words[4] = (LITTLENUM_TYPE) -1; | |
145 | words[5] = (LITTLENUM_TYPE) -1; | |
146 | } | |
147 | \f | |
148 | /************************************************************************\ | |
149 | * Warning: this returns 16-bit LITTLENUMs. It is up to the caller * | |
150 | * to figure out any alignment problems and to conspire for the * | |
151 | * bytes/word to be emitted in the right order. Bigendians beware! * | |
152 | * * | |
153 | \************************************************************************/ | |
154 | ||
155 | /* Note that atof-ieee always has X and P precisions enabled. it is up | |
156 | to md_atof to filter them out if the target machine does not support | |
157 | them. */ | |
158 | ||
159 | /* Returns pointer past text consumed. */ | |
160 | char * | |
161 | atof_ieee (str, what_kind, words) | |
162 | char *str; /* Text to convert to binary. */ | |
2ab9b79e | 163 | int what_kind; /* 'd', 'f', 'g', 'h' */ |
252b5132 RH |
164 | LITTLENUM_TYPE *words; /* Build the binary here. */ |
165 | { | |
166 | /* Extra bits for zeroed low-order bits. The 1st MAX_PRECISION are | |
167 | zeroed, the last contain flonum bits. */ | |
168 | static LITTLENUM_TYPE bits[MAX_PRECISION + MAX_PRECISION + GUARD]; | |
169 | char *return_value; | |
170 | /* Number of 16-bit words in the format. */ | |
171 | int precision; | |
172 | long exponent_bits; | |
173 | FLONUM_TYPE save_gen_flonum; | |
174 | ||
175 | /* We have to save the generic_floating_point_number because it | |
176 | contains storage allocation about the array of LITTLENUMs where | |
177 | the value is actually stored. We will allocate our own array of | |
178 | littlenums below, but have to restore the global one on exit. */ | |
179 | save_gen_flonum = generic_floating_point_number; | |
180 | ||
181 | return_value = str; | |
182 | generic_floating_point_number.low = bits + MAX_PRECISION; | |
183 | generic_floating_point_number.high = NULL; | |
184 | generic_floating_point_number.leader = NULL; | |
185 | generic_floating_point_number.exponent = 0; | |
186 | generic_floating_point_number.sign = '\0'; | |
187 | ||
188 | /* Use more LittleNums than seems necessary: the highest flonum may | |
189 | have 15 leading 0 bits, so could be useless. */ | |
190 | ||
191 | memset (bits, '\0', sizeof (LITTLENUM_TYPE) * MAX_PRECISION); | |
192 | ||
193 | switch (what_kind) | |
194 | { | |
195 | case 'f': | |
196 | case 'F': | |
197 | case 's': | |
198 | case 'S': | |
199 | precision = F_PRECISION; | |
200 | exponent_bits = 8; | |
201 | break; | |
202 | ||
203 | case 'd': | |
204 | case 'D': | |
205 | case 'r': | |
206 | case 'R': | |
207 | precision = D_PRECISION; | |
208 | exponent_bits = 11; | |
209 | break; | |
210 | ||
211 | case 'x': | |
212 | case 'X': | |
213 | case 'e': | |
214 | case 'E': | |
215 | precision = X_PRECISION; | |
216 | exponent_bits = 15; | |
217 | break; | |
218 | ||
219 | case 'p': | |
220 | case 'P': | |
221 | ||
222 | precision = P_PRECISION; | |
223 | exponent_bits = -1; | |
224 | break; | |
225 | ||
226 | default: | |
227 | make_invalid_floating_point_number (words); | |
228 | return (NULL); | |
229 | } | |
230 | ||
231 | generic_floating_point_number.high | |
232 | = generic_floating_point_number.low + precision - 1 + GUARD; | |
233 | ||
234 | if (atof_generic (&return_value, ".", EXP_CHARS, | |
235 | &generic_floating_point_number)) | |
236 | { | |
237 | make_invalid_floating_point_number (words); | |
238 | return (NULL); | |
239 | } | |
240 | gen_to_words (words, precision, exponent_bits); | |
241 | ||
242 | /* Restore the generic_floating_point_number's storage alloc (and | |
243 | everything else). */ | |
244 | generic_floating_point_number = save_gen_flonum; | |
245 | ||
246 | return return_value; | |
247 | } | |
248 | ||
249 | /* Turn generic_floating_point_number into a real float/double/extended. */ | |
250 | int | |
251 | gen_to_words (words, precision, exponent_bits) | |
252 | LITTLENUM_TYPE *words; | |
253 | int precision; | |
254 | long exponent_bits; | |
255 | { | |
256 | int return_value = 0; | |
257 | ||
258 | long exponent_1; | |
259 | long exponent_2; | |
260 | long exponent_3; | |
261 | long exponent_4; | |
262 | int exponent_skippage; | |
263 | LITTLENUM_TYPE word1; | |
264 | LITTLENUM_TYPE *lp; | |
265 | LITTLENUM_TYPE *words_end; | |
266 | ||
267 | words_end = words + precision; | |
268 | #ifdef TC_M68K | |
269 | if (precision == X_PRECISION) | |
270 | /* On the m68k the extended precision format has a gap of 16 bits | |
271 | between the exponent and the mantissa. */ | |
272 | words_end++; | |
273 | #endif | |
274 | ||
275 | if (generic_floating_point_number.low > generic_floating_point_number.leader) | |
276 | { | |
277 | /* 0.0e0 seen. */ | |
278 | if (generic_floating_point_number.sign == '+') | |
279 | words[0] = 0x0000; | |
280 | else | |
281 | words[0] = 0x8000; | |
282 | memset (&words[1], '\0', | |
283 | (words_end - words - 1) * sizeof (LITTLENUM_TYPE)); | |
284 | return (return_value); | |
285 | } | |
286 | ||
287 | /* NaN: Do the right thing */ | |
288 | if (generic_floating_point_number.sign == 0) | |
289 | { | |
290 | if (precision == F_PRECISION) | |
291 | { | |
292 | words[0] = 0x7fff; | |
293 | words[1] = 0xffff; | |
294 | } | |
295 | else if (precision == X_PRECISION) | |
296 | { | |
297 | #ifdef TC_M68K | |
298 | words[0] = 0x7fff; | |
299 | words[1] = 0; | |
300 | words[2] = 0xffff; | |
301 | words[3] = 0xffff; | |
302 | words[4] = 0xffff; | |
303 | words[5] = 0xffff; | |
304 | #else /* ! TC_M68K */ | |
305 | #ifdef TC_I386 | |
306 | words[0] = 0xffff; | |
307 | words[1] = 0xc000; | |
308 | words[2] = 0; | |
309 | words[3] = 0; | |
310 | words[4] = 0; | |
311 | #else /* ! TC_I386 */ | |
312 | abort (); | |
313 | #endif /* ! TC_I386 */ | |
314 | #endif /* ! TC_M68K */ | |
315 | } | |
316 | else | |
317 | { | |
318 | words[0] = 0x7fff; | |
319 | words[1] = 0xffff; | |
320 | words[2] = 0xffff; | |
321 | words[3] = 0xffff; | |
322 | } | |
323 | return return_value; | |
324 | } | |
325 | else if (generic_floating_point_number.sign == 'P') | |
326 | { | |
327 | /* +INF: Do the right thing */ | |
328 | if (precision == F_PRECISION) | |
329 | { | |
330 | words[0] = 0x7f80; | |
331 | words[1] = 0; | |
332 | } | |
333 | else if (precision == X_PRECISION) | |
334 | { | |
335 | #ifdef TC_M68K | |
336 | words[0] = 0x7fff; | |
337 | words[1] = 0; | |
338 | words[2] = 0; | |
339 | words[3] = 0; | |
340 | words[4] = 0; | |
341 | words[5] = 0; | |
342 | #else /* ! TC_M68K */ | |
343 | #ifdef TC_I386 | |
344 | words[0] = 0x7fff; | |
345 | words[1] = 0x8000; | |
346 | words[2] = 0; | |
347 | words[3] = 0; | |
348 | words[4] = 0; | |
349 | #else /* ! TC_I386 */ | |
350 | abort (); | |
351 | #endif /* ! TC_I386 */ | |
352 | #endif /* ! TC_M68K */ | |
353 | } | |
354 | else | |
355 | { | |
356 | words[0] = 0x7ff0; | |
357 | words[1] = 0; | |
358 | words[2] = 0; | |
359 | words[3] = 0; | |
360 | } | |
361 | return (return_value); | |
362 | } | |
363 | else if (generic_floating_point_number.sign == 'N') | |
364 | { | |
365 | /* Negative INF */ | |
366 | if (precision == F_PRECISION) | |
367 | { | |
368 | words[0] = 0xff80; | |
369 | words[1] = 0x0; | |
370 | } | |
371 | else if (precision == X_PRECISION) | |
372 | { | |
373 | #ifdef TC_M68K | |
374 | words[0] = 0xffff; | |
375 | words[1] = 0; | |
376 | words[2] = 0; | |
377 | words[3] = 0; | |
378 | words[4] = 0; | |
379 | words[5] = 0; | |
380 | #else /* ! TC_M68K */ | |
381 | #ifdef TC_I386 | |
382 | words[0] = 0xffff; | |
383 | words[1] = 0x8000; | |
384 | words[2] = 0; | |
385 | words[3] = 0; | |
386 | words[4] = 0; | |
387 | #else /* ! TC_I386 */ | |
388 | abort (); | |
389 | #endif /* ! TC_I386 */ | |
390 | #endif /* ! TC_M68K */ | |
391 | } | |
392 | else | |
393 | { | |
394 | words[0] = 0xfff0; | |
395 | words[1] = 0x0; | |
396 | words[2] = 0x0; | |
397 | words[3] = 0x0; | |
398 | } | |
399 | return (return_value); | |
400 | } | |
401 | /* | |
402 | * The floating point formats we support have: | |
403 | * Bit 15 is sign bit. | |
404 | * Bits 14:n are excess-whatever exponent. | |
405 | * Bits n-1:0 (if any) are most significant bits of fraction. | |
406 | * Bits 15:0 of the next word(s) are the next most significant bits. | |
407 | * | |
408 | * So we need: number of bits of exponent, number of bits of | |
409 | * mantissa. | |
410 | */ | |
411 | bits_left_in_littlenum = LITTLENUM_NUMBER_OF_BITS; | |
412 | littlenum_pointer = generic_floating_point_number.leader; | |
413 | littlenums_left = (1 | |
414 | + generic_floating_point_number.leader | |
415 | - generic_floating_point_number.low); | |
416 | /* Seek (and forget) 1st significant bit */ | |
417 | for (exponent_skippage = 0; !next_bits (1); ++exponent_skippage);; | |
418 | exponent_1 = (generic_floating_point_number.exponent | |
419 | + generic_floating_point_number.leader | |
420 | + 1 | |
421 | - generic_floating_point_number.low); | |
422 | /* Radix LITTLENUM_RADIX, point just higher than | |
423 | generic_floating_point_number.leader. */ | |
424 | exponent_2 = exponent_1 * LITTLENUM_NUMBER_OF_BITS; | |
425 | /* Radix 2. */ | |
426 | exponent_3 = exponent_2 - exponent_skippage; | |
427 | /* Forget leading zeros, forget 1st bit. */ | |
428 | exponent_4 = exponent_3 + ((1 << (exponent_bits - 1)) - 2); | |
429 | /* Offset exponent. */ | |
430 | ||
431 | lp = words; | |
432 | ||
433 | /* Word 1. Sign, exponent and perhaps high bits. */ | |
434 | word1 = ((generic_floating_point_number.sign == '+') | |
435 | ? 0 | |
436 | : (1 << (LITTLENUM_NUMBER_OF_BITS - 1))); | |
437 | ||
438 | /* Assume 2's complement integers. */ | |
439 | if (exponent_4 <= 0) | |
440 | { | |
441 | int prec_bits; | |
442 | int num_bits; | |
443 | ||
444 | unget_bits (1); | |
445 | num_bits = -exponent_4; | |
446 | prec_bits = LITTLENUM_NUMBER_OF_BITS * precision - (exponent_bits + 1 + num_bits); | |
447 | #ifdef TC_I386 | |
448 | if (precision == X_PRECISION && exponent_bits == 15) | |
449 | { | |
450 | /* On the i386 a denormalized extended precision float is | |
451 | shifted down by one, effectively decreasing the exponent | |
452 | bias by one. */ | |
453 | prec_bits -= 1; | |
454 | num_bits += 1; | |
455 | } | |
456 | #endif | |
457 | ||
458 | if (num_bits >= LITTLENUM_NUMBER_OF_BITS - exponent_bits) | |
459 | { | |
460 | /* Bigger than one littlenum */ | |
461 | num_bits -= (LITTLENUM_NUMBER_OF_BITS - 1) - exponent_bits; | |
462 | *lp++ = word1; | |
19b34177 | 463 | if (num_bits + exponent_bits + 1 > precision * LITTLENUM_NUMBER_OF_BITS) |
252b5132 RH |
464 | { |
465 | /* Exponent overflow */ | |
466 | make_invalid_floating_point_number (words); | |
467 | return (return_value); | |
468 | } | |
469 | #ifdef TC_M68K | |
470 | if (precision == X_PRECISION && exponent_bits == 15) | |
471 | *lp++ = 0; | |
472 | #endif | |
473 | while (num_bits >= LITTLENUM_NUMBER_OF_BITS) | |
474 | { | |
475 | num_bits -= LITTLENUM_NUMBER_OF_BITS; | |
476 | *lp++ = 0; | |
477 | } | |
478 | if (num_bits) | |
479 | *lp++ = next_bits (LITTLENUM_NUMBER_OF_BITS - (num_bits)); | |
480 | } | |
481 | else | |
482 | { | |
483 | if (precision == X_PRECISION && exponent_bits == 15) | |
484 | { | |
485 | *lp++ = word1; | |
486 | #ifdef TC_M68K | |
487 | *lp++ = 0; | |
488 | #endif | |
489 | *lp++ = next_bits (LITTLENUM_NUMBER_OF_BITS - num_bits); | |
490 | } | |
491 | else | |
492 | { | |
493 | word1 |= next_bits ((LITTLENUM_NUMBER_OF_BITS - 1) - (exponent_bits + num_bits)); | |
494 | *lp++ = word1; | |
495 | } | |
496 | } | |
497 | while (lp < words_end) | |
498 | *lp++ = next_bits (LITTLENUM_NUMBER_OF_BITS); | |
499 | ||
500 | /* Round the mantissa up, but don't change the number */ | |
501 | if (next_bits (1)) | |
502 | { | |
503 | --lp; | |
19b34177 | 504 | if (prec_bits >= LITTLENUM_NUMBER_OF_BITS) |
252b5132 RH |
505 | { |
506 | int n = 0; | |
507 | int tmp_bits; | |
508 | ||
509 | n = 0; | |
510 | tmp_bits = prec_bits; | |
511 | while (tmp_bits > LITTLENUM_NUMBER_OF_BITS) | |
512 | { | |
513 | if (lp[n] != (LITTLENUM_TYPE) - 1) | |
514 | break; | |
515 | --n; | |
516 | tmp_bits -= LITTLENUM_NUMBER_OF_BITS; | |
517 | } | |
19b34177 AS |
518 | if (tmp_bits > LITTLENUM_NUMBER_OF_BITS |
519 | || (lp[n] & mask[tmp_bits]) != mask[tmp_bits] | |
520 | || (prec_bits != (precision * LITTLENUM_NUMBER_OF_BITS | |
521 | - exponent_bits - 1) | |
522 | #ifdef TC_I386 | |
523 | /* An extended precision float with only the integer | |
524 | bit set would be invalid. That must be converted | |
525 | to the smallest normalized number. */ | |
526 | && !(precision == X_PRECISION | |
527 | && prec_bits == (precision * LITTLENUM_NUMBER_OF_BITS | |
528 | - exponent_bits - 2)) | |
529 | #endif | |
530 | )) | |
252b5132 RH |
531 | { |
532 | unsigned long carry; | |
533 | ||
534 | for (carry = 1; carry && (lp >= words); lp--) | |
535 | { | |
536 | carry = *lp + carry; | |
537 | *lp = carry; | |
538 | carry >>= LITTLENUM_NUMBER_OF_BITS; | |
539 | } | |
540 | } | |
541 | else | |
542 | { | |
543 | /* This is an overflow of the denormal numbers. We | |
544 | need to forget what we have produced, and instead | |
545 | generate the smallest normalized number. */ | |
546 | lp = words; | |
547 | word1 = ((generic_floating_point_number.sign == '+') | |
548 | ? 0 | |
549 | : (1 << (LITTLENUM_NUMBER_OF_BITS - 1))); | |
550 | word1 |= (1 | |
551 | << ((LITTLENUM_NUMBER_OF_BITS - 1) | |
552 | - exponent_bits)); | |
553 | *lp++ = word1; | |
19b34177 AS |
554 | #ifdef TC_I386 |
555 | /* Set the integer bit in the extended precision format. | |
556 | This cannot happen on the m68k where the mantissa | |
557 | just overflows into the integer bit above. */ | |
558 | if (precision == X_PRECISION) | |
559 | *lp++ = 1 << (LITTLENUM_NUMBER_OF_BITS - 1); | |
560 | #endif | |
252b5132 RH |
561 | while (lp < words_end) |
562 | *lp++ = 0; | |
563 | } | |
564 | } | |
19b34177 | 565 | else |
252b5132 RH |
566 | *lp += 1; |
567 | } | |
568 | ||
569 | return return_value; | |
570 | } | |
571 | else if ((unsigned long) exponent_4 >= mask[exponent_bits]) | |
572 | { | |
573 | /* | |
574 | * Exponent overflow. Lose immediately. | |
575 | */ | |
576 | ||
577 | /* | |
578 | * We leave return_value alone: admit we read the | |
579 | * number, but return a floating exception | |
580 | * because we can't encode the number. | |
581 | */ | |
582 | make_invalid_floating_point_number (words); | |
583 | return return_value; | |
584 | } | |
585 | else | |
586 | { | |
587 | word1 |= (exponent_4 << ((LITTLENUM_NUMBER_OF_BITS - 1) - exponent_bits)) | |
588 | | next_bits ((LITTLENUM_NUMBER_OF_BITS - 1) - exponent_bits); | |
589 | } | |
590 | ||
591 | *lp++ = word1; | |
592 | ||
593 | /* X_PRECISION is special: on the 68k, it has 16 bits of zero in the | |
594 | middle. Either way, it is then followed by a 1 bit. */ | |
595 | if (exponent_bits == 15 && precision == X_PRECISION) | |
596 | { | |
597 | #ifdef TC_M68K | |
598 | *lp++ = 0; | |
599 | #endif | |
600 | *lp++ = (1 << (LITTLENUM_NUMBER_OF_BITS - 1) | |
601 | | next_bits (LITTLENUM_NUMBER_OF_BITS - 1)); | |
602 | } | |
603 | ||
604 | /* The rest of the words are just mantissa bits. */ | |
605 | while (lp < words_end) | |
606 | *lp++ = next_bits (LITTLENUM_NUMBER_OF_BITS); | |
607 | ||
608 | if (next_bits (1)) | |
609 | { | |
610 | unsigned long carry; | |
611 | /* | |
612 | * Since the NEXT bit is a 1, round UP the mantissa. | |
613 | * The cunning design of these hidden-1 floats permits | |
614 | * us to let the mantissa overflow into the exponent, and | |
615 | * it 'does the right thing'. However, we lose if the | |
616 | * highest-order bit of the lowest-order word flips. | |
617 | * Is that clear? | |
618 | */ | |
619 | ||
620 | /* #if (sizeof(carry)) < ((sizeof(bits[0]) * BITS_PER_CHAR) + 2) | |
621 | Please allow at least 1 more bit in carry than is in a LITTLENUM. | |
622 | We need that extra bit to hold a carry during a LITTLENUM carry | |
623 | propagation. Another extra bit (kept 0) will assure us that we | |
624 | don't get a sticky sign bit after shifting right, and that | |
625 | permits us to propagate the carry without any masking of bits. | |
626 | #endif */ | |
44877466 | 627 | for (carry = 1, lp--; carry; lp--) |
252b5132 RH |
628 | { |
629 | carry = *lp + carry; | |
630 | *lp = carry; | |
631 | carry >>= LITTLENUM_NUMBER_OF_BITS; | |
44877466 ILT |
632 | if (lp == words) |
633 | break; | |
252b5132 RH |
634 | } |
635 | if (precision == X_PRECISION && exponent_bits == 15) | |
636 | { | |
637 | /* Extended precision numbers have an explicit integer bit | |
638 | that we may have to restore. */ | |
639 | if (lp == words) | |
640 | { | |
641 | #ifdef TC_M68K | |
642 | /* On the m68k there is a gap of 16 bits. We must | |
643 | explicitly propagate the carry into the exponent. */ | |
644 | words[0] += words[1]; | |
645 | words[1] = 0; | |
646 | lp++; | |
647 | #endif | |
648 | /* Put back the integer bit. */ | |
649 | lp[1] |= 1 << (LITTLENUM_NUMBER_OF_BITS - 1); | |
650 | } | |
651 | } | |
652 | if ((word1 ^ *words) & (1 << (LITTLENUM_NUMBER_OF_BITS - 1))) | |
653 | { | |
654 | /* We leave return_value alone: admit we read the | |
655 | * number, but return a floating exception | |
656 | * because we can't encode the number. | |
657 | */ | |
658 | *words &= ~(1 << (LITTLENUM_NUMBER_OF_BITS - 1)); | |
659 | /* make_invalid_floating_point_number (words); */ | |
660 | /* return return_value; */ | |
661 | } | |
662 | } | |
663 | return (return_value); | |
664 | } | |
665 | ||
666 | #if 0 /* unused */ | |
667 | /* This routine is a real kludge. Someone really should do it better, | |
668 | but I'm too lazy, and I don't understand this stuff all too well | |
669 | anyway. (JF) */ | |
670 | static void | |
671 | int_to_gen (x) | |
672 | long x; | |
673 | { | |
674 | char buf[20]; | |
675 | char *bufp; | |
676 | ||
677 | sprintf (buf, "%ld", x); | |
678 | bufp = &buf[0]; | |
679 | if (atof_generic (&bufp, ".", EXP_CHARS, &generic_floating_point_number)) | |
680 | as_bad (_("Error converting number to floating point (Exponent overflow?)")); | |
681 | } | |
682 | #endif | |
683 | ||
684 | #ifdef TEST | |
685 | char * | |
686 | print_gen (gen) | |
687 | FLONUM_TYPE *gen; | |
688 | { | |
689 | FLONUM_TYPE f; | |
690 | LITTLENUM_TYPE arr[10]; | |
691 | double dv; | |
692 | float fv; | |
693 | static char sbuf[40]; | |
694 | ||
695 | if (gen) | |
696 | { | |
697 | f = generic_floating_point_number; | |
698 | generic_floating_point_number = *gen; | |
699 | } | |
700 | gen_to_words (&arr[0], 4, 11); | |
701 | memcpy (&dv, &arr[0], sizeof (double)); | |
702 | sprintf (sbuf, "%x %x %x %x %.14G ", arr[0], arr[1], arr[2], arr[3], dv); | |
703 | gen_to_words (&arr[0], 2, 8); | |
704 | memcpy (&fv, &arr[0], sizeof (float)); | |
705 | sprintf (sbuf + strlen (sbuf), "%x %x %.12g\n", arr[0], arr[1], fv); | |
706 | ||
707 | if (gen) | |
708 | { | |
709 | generic_floating_point_number = f; | |
710 | } | |
711 | ||
712 | return (sbuf); | |
713 | } | |
714 | ||
715 | #endif | |
716 | ||
717 | /* end of atof-ieee.c */ |