1 /* atof_ieee.c - turn a Flonum into an IEEE floating point number 2 Copyright (C) 1987-2020 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. */ 24 extern FLONUM_TYPE generic_floating_point_number; 25 26 /* Precision in LittleNums. */ 27 /* Don't count the gap in the m68k extended precision format. */ 28 #define MAX_PRECISION 5 29 #define H_PRECISION 1 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 42 static 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 79 static int bits_left_in_littlenum; 80 static int littlenums_left; 81 static LITTLENUM_TYPE *littlenum_pointer; 82 83 static int 84 next_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 117 static void 118 unget_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 137 static void 138 make_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 /* Build a floating point constant at str into a IEEE floating 151 point number. This function does the same thing as atof_ieee 152 however it allows more control over the exact format, i.e. 153 explicitly specifying the precision and number of exponent bits 154 instead of relying on this infomation being deduced from a given type. 155 156 If generic_float_info is not NULL then it will be set to contain generic 157 infomation about the parsed floating point number. 158 159 Returns pointer past text consumed. */ 160 char * 161 atof_ieee_detail (char * str, 162 int precision, 163 int exponent_bits, 164 LITTLENUM_TYPE * words, 165 FLONUM_TYPE * generic_float_info) 166 { 167 /* Extra bits for zeroed low-order bits. 168 The 1st MAX_PRECISION are zeroed, the last contain flonum bits. */ 169 static LITTLENUM_TYPE bits[MAX_PRECISION + MAX_PRECISION + GUARD]; 170 char *return_value; 171 172 /* Number of 16-bit words in the format. */ 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 generic_floating_point_number.high 194 = generic_floating_point_number.low + precision - 1 + GUARD; 195 196 if (atof_generic (&return_value, ".", EXP_CHARS, 197 &generic_floating_point_number)) 198 { 199 make_invalid_floating_point_number (words); 200 return NULL; 201 } 202 203 if (generic_float_info) 204 *generic_float_info = generic_floating_point_number; 205 206 gen_to_words (words, precision, exponent_bits); 207 208 /* Restore the generic_floating_point_number's storage alloc (and 209 everything else). */ 210 generic_floating_point_number = save_gen_flonum; 211 212 return return_value; 213 } 214 215 /* Warning: This returns 16-bit LITTLENUMs. It is up to the caller to 216 figure out any alignment problems and to conspire for the 217 bytes/word to be emitted in the right order. Bigendians beware! */ 218 219 /* Note that atof-ieee always has X and P precisions enabled. it is up 220 to md_atof to filter them out if the target machine does not support 221 them. */ 222 223 /* Returns pointer past text consumed. */ 224 char * 225 atof_ieee (char *str, /* Text to convert to binary. */ 226 int what_kind, /* 'd', 'f', 'x', 'p'. */ 227 LITTLENUM_TYPE *words) /* Build the binary here. */ 228 { 229 int precision; 230 long exponent_bits; 231 232 switch (what_kind) 233 { 234 case 'h': 235 case 'H': 236 precision = H_PRECISION; 237 exponent_bits = 5; 238 break; 239 240 case 'f': 241 case 'F': 242 case 's': 243 case 'S': 244 precision = F_PRECISION; 245 exponent_bits = 8; 246 break; 247 248 case 'd': 249 case 'D': 250 case 'r': 251 case 'R': 252 precision = D_PRECISION; 253 exponent_bits = 11; 254 break; 255 256 case 'x': 257 case 'X': 258 case 'e': 259 case 'E': 260 precision = X_PRECISION; 261 exponent_bits = 15; 262 break; 263 264 case 'p': 265 case 'P': 266 precision = P_PRECISION; 267 exponent_bits = -1; 268 break; 269 270 default: 271 make_invalid_floating_point_number (words); 272 return (NULL); 273 } 274 275 return atof_ieee_detail (str, precision, exponent_bits, words, NULL); 276 } 277 278 /* Turn generic_floating_point_number into a real float/double/extended. */ 279 280 int 281 gen_to_words (LITTLENUM_TYPE *words, int precision, long exponent_bits) 282 { 283 int return_value = 0; 284 285 long exponent_1; 286 long exponent_2; 287 long exponent_3; 288 long exponent_4; 289 int exponent_skippage; 290 LITTLENUM_TYPE word1; 291 LITTLENUM_TYPE *lp; 292 LITTLENUM_TYPE *words_end; 293 294 words_end = words + precision; 295 #ifdef TC_M68K 296 if (precision == X_PRECISION) 297 /* On the m68k the extended precision format has a gap of 16 bits 298 between the exponent and the mantissa. */ 299 words_end++; 300 #endif 301 302 if (generic_floating_point_number.low > generic_floating_point_number.leader) 303 { 304 /* 0.0e0 seen. */ 305 if (generic_floating_point_number.sign == '+') 306 words[0] = 0x0000; 307 else 308 words[0] = 0x8000; 309 memset (&words[1], '\0', 310 (words_end - words - 1) * sizeof (LITTLENUM_TYPE)); 311 return return_value; 312 } 313 314 /* NaN: Do the right thing. */ 315 if (generic_floating_point_number.sign == 0) 316 { 317 if (TC_LARGEST_EXPONENT_IS_NORMAL (precision)) 318 as_warn (_("NaNs are not supported by this target")); 319 320 if (precision == H_PRECISION) 321 { 322 words[0] = 0x7fff; 323 } 324 else if (precision == F_PRECISION) 325 { 326 words[0] = 0x7fff; 327 words[1] = 0xffff; 328 } 329 else if (precision == X_PRECISION) 330 { 331 #ifdef TC_M68K 332 words[0] = 0x7fff; 333 words[1] = 0; 334 words[2] = 0xffff; 335 words[3] = 0xffff; 336 words[4] = 0xffff; 337 words[5] = 0xffff; 338 #else /* ! TC_M68K */ 339 #ifdef TC_I386 340 words[0] = 0xffff; 341 words[1] = 0xc000; 342 words[2] = 0; 343 words[3] = 0; 344 words[4] = 0; 345 #else /* ! TC_I386 */ 346 abort (); 347 #endif /* ! TC_I386 */ 348 #endif /* ! TC_M68K */ 349 } 350 else 351 { 352 words[0] = 0x7fff; 353 words[1] = 0xffff; 354 words[2] = 0xffff; 355 words[3] = 0xffff; 356 } 357 return return_value; 358 } 359 else if (generic_floating_point_number.sign == 'P') 360 { 361 if (TC_LARGEST_EXPONENT_IS_NORMAL (precision)) 362 as_warn (_("Infinities are not supported by this target")); 363 364 /* +INF: Do the right thing. */ 365 if (precision == H_PRECISION) 366 { 367 words[0] = 0x7c00; 368 } 369 else if (precision == F_PRECISION) 370 { 371 words[0] = 0x7f80; 372 words[1] = 0; 373 } 374 else if (precision == X_PRECISION) 375 { 376 #ifdef TC_M68K 377 words[0] = 0x7fff; 378 words[1] = 0; 379 words[2] = 0; 380 words[3] = 0; 381 words[4] = 0; 382 words[5] = 0; 383 #else /* ! TC_M68K */ 384 #ifdef TC_I386 385 words[0] = 0x7fff; 386 words[1] = 0x8000; 387 words[2] = 0; 388 words[3] = 0; 389 words[4] = 0; 390 #else /* ! TC_I386 */ 391 abort (); 392 #endif /* ! TC_I386 */ 393 #endif /* ! TC_M68K */ 394 } 395 else 396 { 397 words[0] = 0x7ff0; 398 words[1] = 0; 399 words[2] = 0; 400 words[3] = 0; 401 } 402 return return_value; 403 } 404 else if (generic_floating_point_number.sign == 'N') 405 { 406 if (TC_LARGEST_EXPONENT_IS_NORMAL (precision)) 407 as_warn (_("Infinities are not supported by this target")); 408 409 /* Negative INF. */ 410 if (precision == H_PRECISION) 411 { 412 words[0] = 0xfc00; 413 } 414 else if (precision == F_PRECISION) 415 { 416 words[0] = 0xff80; 417 words[1] = 0x0; 418 } 419 else if (precision == X_PRECISION) 420 { 421 #ifdef TC_M68K 422 words[0] = 0xffff; 423 words[1] = 0; 424 words[2] = 0; 425 words[3] = 0; 426 words[4] = 0; 427 words[5] = 0; 428 #else /* ! TC_M68K */ 429 #ifdef TC_I386 430 words[0] = 0xffff; 431 words[1] = 0x8000; 432 words[2] = 0; 433 words[3] = 0; 434 words[4] = 0; 435 #else /* ! TC_I386 */ 436 abort (); 437 #endif /* ! TC_I386 */ 438 #endif /* ! TC_M68K */ 439 } 440 else 441 { 442 words[0] = 0xfff0; 443 words[1] = 0x0; 444 words[2] = 0x0; 445 words[3] = 0x0; 446 } 447 return return_value; 448 } 449 450 /* The floating point formats we support have: 451 Bit 15 is sign bit. 452 Bits 14:n are excess-whatever exponent. 453 Bits n-1:0 (if any) are most significant bits of fraction. 454 Bits 15:0 of the next word(s) are the next most significant bits. 455 456 So we need: number of bits of exponent, number of bits of 457 mantissa. */ 458 bits_left_in_littlenum = LITTLENUM_NUMBER_OF_BITS; 459 littlenum_pointer = generic_floating_point_number.leader; 460 littlenums_left = (1 461 + generic_floating_point_number.leader 462 - generic_floating_point_number.low); 463 464 /* Seek (and forget) 1st significant bit. */ 465 for (exponent_skippage = 0; !next_bits (1); ++exponent_skippage); 466 exponent_1 = (generic_floating_point_number.exponent 467 + generic_floating_point_number.leader 468 + 1 469 - generic_floating_point_number.low); 470 471 /* Radix LITTLENUM_RADIX, point just higher than 472 generic_floating_point_number.leader. */ 473 exponent_2 = exponent_1 * LITTLENUM_NUMBER_OF_BITS; 474 475 /* Radix 2. */ 476 exponent_3 = exponent_2 - exponent_skippage; 477 478 /* Forget leading zeros, forget 1st bit. */ 479 exponent_4 = exponent_3 + ((1 << (exponent_bits - 1)) - 2); 480 481 /* Offset exponent. */ 482 lp = words; 483 484 /* Word 1. Sign, exponent and perhaps high bits. */ 485 word1 = ((generic_floating_point_number.sign == '+') 486 ? 0 487 : (1 << (LITTLENUM_NUMBER_OF_BITS - 1))); 488 489 /* Assume 2's complement integers. */ 490 if (exponent_4 <= 0) 491 { 492 int prec_bits; 493 int num_bits; 494 495 unget_bits (1); 496 num_bits = -exponent_4; 497 prec_bits = 498 LITTLENUM_NUMBER_OF_BITS * precision - (exponent_bits + 1 + num_bits); 499 #ifdef TC_I386 500 if (precision == X_PRECISION && exponent_bits == 15) 501 { 502 /* On the i386 a denormalized extended precision float is 503 shifted down by one, effectively decreasing the exponent 504 bias by one. */ 505 prec_bits -= 1; 506 num_bits += 1; 507 } 508 #endif 509 510 if (num_bits >= LITTLENUM_NUMBER_OF_BITS - exponent_bits) 511 { 512 /* Bigger than one littlenum. */ 513 num_bits -= (LITTLENUM_NUMBER_OF_BITS - 1) - exponent_bits; 514 *lp++ = word1; 515 if (num_bits + exponent_bits + 1 516 > precision * LITTLENUM_NUMBER_OF_BITS) 517 { 518 /* Exponent overflow. */ 519 make_invalid_floating_point_number (words); 520 return return_value; 521 } 522 #ifdef TC_M68K 523 if (precision == X_PRECISION && exponent_bits == 15) 524 *lp++ = 0; 525 #endif 526 while (num_bits >= LITTLENUM_NUMBER_OF_BITS) 527 { 528 num_bits -= LITTLENUM_NUMBER_OF_BITS; 529 *lp++ = 0; 530 } 531 if (num_bits) 532 *lp++ = next_bits (LITTLENUM_NUMBER_OF_BITS - (num_bits)); 533 } 534 else 535 { 536 if (precision == X_PRECISION && exponent_bits == 15) 537 { 538 *lp++ = word1; 539 #ifdef TC_M68K 540 *lp++ = 0; 541 #endif 542 *lp++ = next_bits (LITTLENUM_NUMBER_OF_BITS - num_bits); 543 } 544 else 545 { 546 word1 |= next_bits ((LITTLENUM_NUMBER_OF_BITS - 1) 547 - (exponent_bits + num_bits)); 548 *lp++ = word1; 549 } 550 } 551 while (lp < words_end) 552 *lp++ = next_bits (LITTLENUM_NUMBER_OF_BITS); 553 554 /* Round the mantissa up, but don't change the number. */ 555 if (next_bits (1)) 556 { 557 --lp; 558 if (prec_bits >= LITTLENUM_NUMBER_OF_BITS) 559 { 560 int n = 0; 561 int tmp_bits; 562 563 n = 0; 564 tmp_bits = prec_bits; 565 while (tmp_bits > LITTLENUM_NUMBER_OF_BITS) 566 { 567 if (lp[n] != (LITTLENUM_TYPE) - 1) 568 break; 569 --n; 570 tmp_bits -= LITTLENUM_NUMBER_OF_BITS; 571 } 572 if (tmp_bits > LITTLENUM_NUMBER_OF_BITS 573 || (lp[n] & mask[tmp_bits]) != mask[tmp_bits] 574 || (prec_bits != (precision * LITTLENUM_NUMBER_OF_BITS 575 - exponent_bits - 1) 576 #ifdef TC_I386 577 /* An extended precision float with only the integer 578 bit set would be invalid. That must be converted 579 to the smallest normalized number. */ 580 && !(precision == X_PRECISION 581 && prec_bits == (precision * LITTLENUM_NUMBER_OF_BITS 582 - exponent_bits - 2)) 583 #endif 584 )) 585 { 586 unsigned long carry; 587 588 for (carry = 1; carry && (lp >= words); lp--) 589 { 590 carry = *lp + carry; 591 *lp = carry; 592 carry >>= LITTLENUM_NUMBER_OF_BITS; 593 } 594 } 595 else 596 { 597 /* This is an overflow of the denormal numbers. We 598 need to forget what we have produced, and instead 599 generate the smallest normalized number. */ 600 lp = words; 601 word1 = ((generic_floating_point_number.sign == '+') 602 ? 0 603 : (1 << (LITTLENUM_NUMBER_OF_BITS - 1))); 604 word1 |= (1 605 << ((LITTLENUM_NUMBER_OF_BITS - 1) 606 - exponent_bits)); 607 *lp++ = word1; 608 #ifdef TC_I386 609 /* Set the integer bit in the extended precision format. 610 This cannot happen on the m68k where the mantissa 611 just overflows into the integer bit above. */ 612 if (precision == X_PRECISION) 613 *lp++ = 1 << (LITTLENUM_NUMBER_OF_BITS - 1); 614 #endif 615 while (lp < words_end) 616 *lp++ = 0; 617 } 618 } 619 else 620 *lp += 1; 621 } 622 623 return return_value; 624 } 625 else if ((unsigned long) exponent_4 > mask[exponent_bits] 626 || (! TC_LARGEST_EXPONENT_IS_NORMAL (precision) 627 && (unsigned long) exponent_4 == mask[exponent_bits])) 628 { 629 /* Exponent overflow. Lose immediately. */ 630 631 /* We leave return_value alone: admit we read the 632 number, but return a floating exception 633 because we can't encode the number. */ 634 make_invalid_floating_point_number (words); 635 return return_value; 636 } 637 else 638 { 639 word1 |= (exponent_4 << ((LITTLENUM_NUMBER_OF_BITS - 1) - exponent_bits)) 640 | next_bits ((LITTLENUM_NUMBER_OF_BITS - 1) - exponent_bits); 641 } 642 643 *lp++ = word1; 644 645 /* X_PRECISION is special: on the 68k, it has 16 bits of zero in the 646 middle. Either way, it is then followed by a 1 bit. */ 647 if (exponent_bits == 15 && precision == X_PRECISION) 648 { 649 #ifdef TC_M68K 650 *lp++ = 0; 651 #endif 652 *lp++ = (1 << (LITTLENUM_NUMBER_OF_BITS - 1) 653 | next_bits (LITTLENUM_NUMBER_OF_BITS - 1)); 654 } 655 656 /* The rest of the words are just mantissa bits. */ 657 while (lp < words_end) 658 *lp++ = next_bits (LITTLENUM_NUMBER_OF_BITS); 659 660 if (next_bits (1)) 661 { 662 unsigned long carry; 663 /* Since the NEXT bit is a 1, round UP the mantissa. 664 The cunning design of these hidden-1 floats permits 665 us to let the mantissa overflow into the exponent, and 666 it 'does the right thing'. However, we lose if the 667 highest-order bit of the lowest-order word flips. 668 Is that clear? */ 669 670 /* #if (sizeof(carry)) < ((sizeof(bits[0]) * BITS_PER_CHAR) + 2) 671 Please allow at least 1 more bit in carry than is in a LITTLENUM. 672 We need that extra bit to hold a carry during a LITTLENUM carry 673 propagation. Another extra bit (kept 0) will assure us that we 674 don't get a sticky sign bit after shifting right, and that 675 permits us to propagate the carry without any masking of bits. 676 #endif */ 677 for (carry = 1, lp--; carry; lp--) 678 { 679 carry = *lp + carry; 680 *lp = carry; 681 carry >>= LITTLENUM_NUMBER_OF_BITS; 682 if (lp == words) 683 break; 684 } 685 if (precision == X_PRECISION && exponent_bits == 15) 686 { 687 /* Extended precision numbers have an explicit integer bit 688 that we may have to restore. */ 689 if (lp == words) 690 { 691 #ifdef TC_M68K 692 /* On the m68k there is a gap of 16 bits. We must 693 explicitly propagate the carry into the exponent. */ 694 words[0] += words[1]; 695 words[1] = 0; 696 lp++; 697 #endif 698 /* Put back the integer bit. */ 699 lp[1] |= 1 << (LITTLENUM_NUMBER_OF_BITS - 1); 700 } 701 } 702 if ((word1 ^ *words) & (1 << (LITTLENUM_NUMBER_OF_BITS - 1))) 703 { 704 /* We leave return_value alone: admit we read the number, 705 but return a floating exception because we can't encode 706 the number. */ 707 *words &= ~(1 << (LITTLENUM_NUMBER_OF_BITS - 1)); 708 } 709 } 710 return return_value; 711 } 712 713 #ifdef TEST 714 char * 715 print_gen (gen) 716 FLONUM_TYPE *gen; 717 { 718 FLONUM_TYPE f; 719 LITTLENUM_TYPE arr[10]; 720 double dv; 721 float fv; 722 static char sbuf[40]; 723 724 if (gen) 725 { 726 f = generic_floating_point_number; 727 generic_floating_point_number = *gen; 728 } 729 gen_to_words (&arr[0], 4, 11); 730 memcpy (&dv, &arr[0], sizeof (double)); 731 sprintf (sbuf, "%x %x %x %x %.14G ", arr[0], arr[1], arr[2], arr[3], dv); 732 gen_to_words (&arr[0], 2, 8); 733 memcpy (&fv, &arr[0], sizeof (float)); 734 sprintf (sbuf + strlen (sbuf), "%x %x %.12g\n", arr[0], arr[1], fv); 735 736 if (gen) 737 generic_floating_point_number = f; 738 739 return (sbuf); 740 } 741 #endif 742 743 /* This is a utility function called from various tc-*.c files. It 744 is here in order to reduce code duplication. 745 746 Turn a string at input_line_pointer into a floating point constant 747 of type TYPE (a character found in the FLT_CHARS macro), and store 748 it as LITTLENUMS in the bytes buffer LITP. The number of chars 749 emitted is stored in *SIZEP. BIG_WORDIAN is TRUE if the littlenums 750 should be emitted most significant littlenum first. 751 752 An error message is returned, or a NULL pointer if everything went OK. */ 753 754 const char * 755 ieee_md_atof (int type, 756 char *litP, 757 int *sizeP, 758 bfd_boolean big_wordian) 759 { 760 LITTLENUM_TYPE words[MAX_LITTLENUMS]; 761 LITTLENUM_TYPE *wordP; 762 char *t; 763 int prec = 0; 764 765 if (strchr (FLT_CHARS, type) != NULL) 766 { 767 switch (type) 768 { 769 case 'H': 770 case 'h': 771 prec = H_PRECISION; 772 break; 773 774 case 'f': 775 case 'F': 776 case 's': 777 case 'S': 778 prec = F_PRECISION; 779 break; 780 781 case 'd': 782 case 'D': 783 case 'r': 784 case 'R': 785 prec = D_PRECISION; 786 break; 787 788 case 't': 789 case 'T': 790 prec = X_PRECISION; 791 type = 'x'; /* This is what atof_ieee() understands. */ 792 break; 793 794 case 'x': 795 case 'X': 796 case 'p': 797 case 'P': 798 #ifdef TC_M68K 799 /* Note: on the m68k there is a gap of 16 bits (one littlenum) 800 between the exponent and mantissa. Hence the precision is 801 6 and not 5. */ 802 prec = P_PRECISION + 1; 803 #else 804 prec = P_PRECISION; 805 #endif 806 break; 807 808 default: 809 break; 810 } 811 } 812 /* The 'f' and 'd' types are always recognised, even if the target has 813 not put them into the FLT_CHARS macro. This is because the 'f' type 814 can come from the .dc.s, .dcb.s, .float or .single pseudo-ops and the 815 'd' type from the .dc.d, .dbc.d or .double pseudo-ops. 816 817 The 'x' type is not implicitly recognised however, even though it can 818 be generated by the .dc.x and .dbc.x pseudo-ops because not all targets 819 can support floating point values that big. ie the target has to 820 explicitly allow them by putting them into FLT_CHARS. */ 821 else if (type == 'f') 822 prec = F_PRECISION; 823 else if (type == 'd') 824 prec = D_PRECISION; 825 826 if (prec == 0) 827 { 828 *sizeP = 0; 829 return _("Unrecognized or unsupported floating point constant"); 830 } 831 832 gas_assert (prec <= MAX_LITTLENUMS); 833 834 t = atof_ieee (input_line_pointer, type, words); 835 if (t) 836 input_line_pointer = t; 837 838 *sizeP = prec * sizeof (LITTLENUM_TYPE); 839 840 if (big_wordian) 841 { 842 for (wordP = words; prec --;) 843 { 844 md_number_to_chars (litP, (valueT) (* wordP ++), sizeof (LITTLENUM_TYPE)); 845 litP += sizeof (LITTLENUM_TYPE); 846 } 847 } 848 else 849 { 850 for (wordP = words + prec; prec --;) 851 { 852 md_number_to_chars (litP, (valueT) (* -- wordP), sizeof (LITTLENUM_TYPE)); 853 litP += sizeof (LITTLENUM_TYPE); 854 } 855 } 856 857 return NULL; 858 } 859