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