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