1 /* atof_vax.c - turn a Flonum into a VAX floating point number 2 Copyright (C) 1987, 1992, 93, 95, 1997 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 2, 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, 59 Temple Place - Suite 330, Boston, MA 19 02111-1307, USA. */ 20 21 #include "as.h" 22 23 static int atof_vax_sizeof PARAMS ((int)); 24 static int next_bits PARAMS ((int)); 25 static void make_invalid_floating_point_number PARAMS ((LITTLENUM_TYPE *)); 26 static int what_kind_of_float PARAMS ((int, int *, long *)); 27 static char *atof_vax PARAMS ((char *, int, LITTLENUM_TYPE *)); 28 29 /* Precision in LittleNums. */ 30 #define MAX_PRECISION (8) 31 #define H_PRECISION (8) 32 #define G_PRECISION (4) 33 #define D_PRECISION (4) 34 #define F_PRECISION (2) 35 36 /* Length in LittleNums of guard bits. */ 37 #define GUARD (2) 38 39 int flonum_gen2vax PARAMS ((int format_letter, FLONUM_TYPE * f, 40 LITTLENUM_TYPE * words)); 41 42 /* Number of chars in flonum type 'letter'. */ 43 static int 44 atof_vax_sizeof (letter) 45 int letter; 46 { 47 int return_value; 48 49 /* 50 * Permitting uppercase letters is probably a bad idea. 51 * Please use only lower-cased letters in case the upper-cased 52 * ones become unsupported! 53 */ 54 switch (letter) 55 { 56 case 'f': 57 case 'F': 58 return_value = 4; 59 break; 60 61 case 'd': 62 case 'D': 63 case 'g': 64 case 'G': 65 return_value = 8; 66 break; 67 68 case 'h': 69 case 'H': 70 return_value = 16; 71 break; 72 73 default: 74 return_value = 0; 75 break; 76 } 77 return (return_value); 78 } /* atof_vax_sizeof */ 79 80 static const long mask[] = 81 { 82 0x00000000, 83 0x00000001, 84 0x00000003, 85 0x00000007, 86 0x0000000f, 87 0x0000001f, 88 0x0000003f, 89 0x0000007f, 90 0x000000ff, 91 0x000001ff, 92 0x000003ff, 93 0x000007ff, 94 0x00000fff, 95 0x00001fff, 96 0x00003fff, 97 0x00007fff, 98 0x0000ffff, 99 0x0001ffff, 100 0x0003ffff, 101 0x0007ffff, 102 0x000fffff, 103 0x001fffff, 104 0x003fffff, 105 0x007fffff, 106 0x00ffffff, 107 0x01ffffff, 108 0x03ffffff, 109 0x07ffffff, 110 0x0fffffff, 111 0x1fffffff, 112 0x3fffffff, 113 0x7fffffff, 114 0xffffffff 115 }; 116 117 118 /* Shared between flonum_gen2vax and next_bits */ 119 static int bits_left_in_littlenum; 120 static LITTLENUM_TYPE *littlenum_pointer; 121 static LITTLENUM_TYPE *littlenum_end; 122 123 static int 124 next_bits (number_of_bits) 125 int number_of_bits; 126 { 127 int return_value; 128 129 if (littlenum_pointer < littlenum_end) 130 return 0; 131 if (number_of_bits >= bits_left_in_littlenum) 132 { 133 return_value = mask[bits_left_in_littlenum] & *littlenum_pointer; 134 number_of_bits -= bits_left_in_littlenum; 135 return_value <<= number_of_bits; 136 bits_left_in_littlenum = LITTLENUM_NUMBER_OF_BITS - number_of_bits; 137 littlenum_pointer--; 138 if (littlenum_pointer >= littlenum_end) 139 return_value |= ((*littlenum_pointer) >> (bits_left_in_littlenum)) & mask[number_of_bits]; 140 } 141 else 142 { 143 bits_left_in_littlenum -= number_of_bits; 144 return_value = mask[number_of_bits] & ((*littlenum_pointer) >> bits_left_in_littlenum); 145 } 146 return (return_value); 147 } 148 149 static void 150 make_invalid_floating_point_number (words) 151 LITTLENUM_TYPE *words; 152 { 153 *words = 0x8000; /* Floating Reserved Operand Code */ 154 } 155 156 static int /* 0 means letter is OK. */ 157 what_kind_of_float (letter, precisionP, exponent_bitsP) 158 int letter; /* In: lowercase please. What kind of float? */ 159 int *precisionP; /* Number of 16-bit words in the float. */ 160 long *exponent_bitsP; /* Number of exponent bits. */ 161 { 162 int retval; /* 0: OK. */ 163 164 retval = 0; 165 switch (letter) 166 { 167 case 'f': 168 *precisionP = F_PRECISION; 169 *exponent_bitsP = 8; 170 break; 171 172 case 'd': 173 *precisionP = D_PRECISION; 174 *exponent_bitsP = 8; 175 break; 176 177 case 'g': 178 *precisionP = G_PRECISION; 179 *exponent_bitsP = 11; 180 break; 181 182 case 'h': 183 *precisionP = H_PRECISION; 184 *exponent_bitsP = 15; 185 break; 186 187 default: 188 retval = 69; 189 break; 190 } 191 return (retval); 192 } 193 194 /***********************************************************************\ 195 * * 196 * Warning: this returns 16-bit LITTLENUMs, because that is * 197 * what the VAX thinks in. It is up to the caller to figure * 198 * out any alignment problems and to conspire for the bytes/word * 199 * to be emitted in the right order. Bigendians beware! * 200 * * 201 \***********************************************************************/ 202 203 static char * /* Return pointer past text consumed. */ 204 atof_vax (str, what_kind, words) 205 char *str; /* Text to convert to binary. */ 206 int what_kind; /* 'd', 'f', 'g', 'h' */ 207 LITTLENUM_TYPE *words; /* Build the binary here. */ 208 { 209 FLONUM_TYPE f; 210 LITTLENUM_TYPE bits[MAX_PRECISION + MAX_PRECISION + GUARD]; 211 /* Extra bits for zeroed low-order bits. */ 212 /* The 1st MAX_PRECISION are zeroed, */ 213 /* the last contain flonum bits. */ 214 char *return_value; 215 int precision; /* Number of 16-bit words in the format. */ 216 long exponent_bits; 217 218 return_value = str; 219 f.low = bits + MAX_PRECISION; 220 f.high = NULL; 221 f.leader = NULL; 222 f.exponent = 0; 223 f.sign = '\0'; 224 225 if (what_kind_of_float (what_kind, &precision, &exponent_bits)) 226 { 227 return_value = NULL; /* We lost. */ 228 make_invalid_floating_point_number (words); 229 } 230 231 if (return_value) 232 { 233 memset (bits, '\0', sizeof (LITTLENUM_TYPE) * MAX_PRECISION); 234 235 /* Use more LittleNums than seems */ 236 /* necessary: the highest flonum may have */ 237 /* 15 leading 0 bits, so could be useless. */ 238 f.high = f.low + precision - 1 + GUARD; 239 240 if (atof_generic (&return_value, ".", "eE", &f)) 241 { 242 make_invalid_floating_point_number (words); 243 return_value = NULL; /* we lost */ 244 } 245 else 246 { 247 if (flonum_gen2vax (what_kind, &f, words)) 248 { 249 return_value = NULL; 250 } 251 } 252 } 253 return (return_value); 254 } /* atof_vax() */ 255 256 /* 257 * In: a flonum, a vax floating point format. 258 * Out: a vax floating-point bit pattern. 259 */ 260 261 int /* 0: OK. */ 262 flonum_gen2vax (format_letter, f, words) 263 char format_letter; /* One of 'd' 'f' 'g' 'h'. */ 264 FLONUM_TYPE *f; 265 LITTLENUM_TYPE *words; /* Deliver answer here. */ 266 { 267 LITTLENUM_TYPE *lp; 268 int precision; 269 long exponent_bits; 270 int return_value; /* 0 == OK. */ 271 272 return_value = what_kind_of_float (format_letter, &precision, &exponent_bits); 273 274 if (return_value != 0) 275 { 276 make_invalid_floating_point_number (words); 277 } 278 else 279 { 280 if (f->low > f->leader) 281 { 282 /* 0.0e0 seen. */ 283 memset (words, '\0', sizeof (LITTLENUM_TYPE) * precision); 284 } 285 else 286 { 287 long exponent_1; 288 long exponent_2; 289 long exponent_3; 290 long exponent_4; 291 int exponent_skippage; 292 LITTLENUM_TYPE word1; 293 294 /* JF: Deal with new Nan, +Inf and -Inf codes */ 295 if (f->sign != '-' && f->sign != '+') 296 { 297 make_invalid_floating_point_number (words); 298 return return_value; 299 } 300 /* 301 * All vaxen floating_point formats (so far) have: 302 * Bit 15 is sign bit. 303 * Bits 14:n are excess-whatever exponent. 304 * Bits n-1:0 (if any) are most significant bits of fraction. 305 * Bits 15:0 of the next word are the next most significant bits. 306 * And so on for each other word. 307 * 308 * All this to be compatible with a KF11?? (Which is still faster 309 * than lots of vaxen I can think of, but it also has higher 310 * maintenance costs ... sigh). 311 * 312 * So we need: number of bits of exponent, number of bits of 313 * mantissa. 314 */ 315 316 #ifdef NEVER /******* This zeroing seems redundant - Dean 3may86 **********/ 317 /* 318 * No matter how few bits we got back from the atof() 319 * routine, add enough zero littlenums so the rest of the 320 * code won't run out of "significant" bits in the mantissa. 321 */ 322 { 323 LITTLENUM_TYPE *ltp; 324 for (ltp = f->leader + 1; 325 ltp <= f->low + precision; 326 ltp++) 327 { 328 *ltp = 0; 329 } 330 } 331 #endif 332 333 bits_left_in_littlenum = LITTLENUM_NUMBER_OF_BITS; 334 littlenum_pointer = f->leader; 335 littlenum_end = f->low; 336 /* Seek (and forget) 1st significant bit */ 337 for (exponent_skippage = 0; 338 !next_bits (1); 339 exponent_skippage++);; 340 341 exponent_1 = f->exponent + f->leader + 1 - f->low; 342 /* Radix LITTLENUM_RADIX, point just higher than f->leader. */ 343 exponent_2 = exponent_1 * LITTLENUM_NUMBER_OF_BITS; 344 /* Radix 2. */ 345 exponent_3 = exponent_2 - exponent_skippage; 346 /* Forget leading zeros, forget 1st bit. */ 347 exponent_4 = exponent_3 + (1 << (exponent_bits - 1)); 348 /* Offset exponent. */ 349 350 if (exponent_4 & ~mask[exponent_bits]) 351 { 352 /* 353 * Exponent overflow. Lose immediately. 354 */ 355 356 make_invalid_floating_point_number (words); 357 358 /* 359 * We leave return_value alone: admit we read the 360 * number, but return a floating exception 361 * because we can't encode the number. 362 */ 363 } 364 else 365 { 366 lp = words; 367 368 /* Word 1. Sign, exponent and perhaps high bits. */ 369 /* Assume 2's complement integers. */ 370 word1 = (((exponent_4 & mask[exponent_bits]) << (15 - exponent_bits)) 371 | ((f->sign == '+') ? 0 : 0x8000) 372 | next_bits (15 - exponent_bits)); 373 *lp++ = word1; 374 375 /* The rest of the words are just mantissa bits. */ 376 for (; lp < words + precision; lp++) 377 { 378 *lp = next_bits (LITTLENUM_NUMBER_OF_BITS); 379 } 380 381 if (next_bits (1)) 382 { 383 /* 384 * Since the NEXT bit is a 1, round UP the mantissa. 385 * The cunning design of these hidden-1 floats permits 386 * us to let the mantissa overflow into the exponent, and 387 * it 'does the right thing'. However, we lose if the 388 * highest-order bit of the lowest-order word flips. 389 * Is that clear? 390 */ 391 392 unsigned long carry; 393 394 /* 395 #if (sizeof(carry)) < ((sizeof(bits[0]) * BITS_PER_CHAR) + 2) 396 Please allow at least 1 more bit in carry than is in a LITTLENUM. 397 We need that extra bit to hold a carry during a LITTLENUM carry 398 propagation. Another extra bit (kept 0) will assure us that we 399 don't get a sticky sign bit after shifting right, and that 400 permits us to propagate the carry without any masking of bits. 401 #endif 402 */ 403 for (carry = 1, lp--; 404 carry && (lp >= words); 405 lp--) 406 { 407 carry = *lp + carry; 408 *lp = carry; 409 carry >>= LITTLENUM_NUMBER_OF_BITS; 410 } 411 412 if ((word1 ^ *words) & (1 << (LITTLENUM_NUMBER_OF_BITS - 1))) 413 { 414 make_invalid_floating_point_number (words); 415 /* 416 * We leave return_value alone: admit we read the 417 * number, but return a floating exception 418 * because we can't encode the number. 419 */ 420 } 421 } /* if (we needed to round up) */ 422 } /* if (exponent overflow) */ 423 } /* if (0.0e0) */ 424 } /* if (float_type was OK) */ 425 return (return_value); 426 } /* flonum_gen2vax() */ 427 428 429 /* JF this used to be in vax.c but this looks like a better place for it */ 430 431 /* 432 * md_atof() 433 * 434 * In: input_line_pointer->the 1st character of a floating-point 435 * number. 436 * 1 letter denoting the type of statement that wants a 437 * binary floating point number returned. 438 * Address of where to build floating point literal. 439 * Assumed to be 'big enough'. 440 * Address of where to return size of literal (in chars). 441 * 442 * Out: Input_line_pointer->of next char after floating number. 443 * Error message, or 0. 444 * Floating point literal. 445 * Number of chars we used for the literal. 446 */ 447 448 #define MAXIMUM_NUMBER_OF_LITTLENUMS (8) /* For .hfloats. */ 449 450 char * 451 md_atof (what_statement_type, literalP, sizeP) 452 int what_statement_type; 453 char *literalP; 454 int *sizeP; 455 { 456 LITTLENUM_TYPE words[MAXIMUM_NUMBER_OF_LITTLENUMS]; 457 register char kind_of_float; 458 register int number_of_chars; 459 register LITTLENUM_TYPE *littlenumP; 460 461 switch (what_statement_type) 462 { 463 case 'F': /* .float */ 464 case 'f': /* .ffloat */ 465 kind_of_float = 'f'; 466 break; 467 468 case 'D': /* .double */ 469 case 'd': /* .dfloat */ 470 kind_of_float = 'd'; 471 break; 472 473 case 'g': /* .gfloat */ 474 kind_of_float = 'g'; 475 break; 476 477 case 'h': /* .hfloat */ 478 kind_of_float = 'h'; 479 break; 480 481 default: 482 kind_of_float = 0; 483 break; 484 }; 485 486 if (kind_of_float) 487 { 488 register LITTLENUM_TYPE *limit; 489 490 input_line_pointer = atof_vax (input_line_pointer, 491 kind_of_float, 492 words); 493 /* 494 * The atof_vax() builds up 16-bit numbers. 495 * Since the assembler may not be running on 496 * a little-endian machine, be very careful about 497 * converting words to chars. 498 */ 499 number_of_chars = atof_vax_sizeof (kind_of_float); 500 know (number_of_chars <= MAXIMUM_NUMBER_OF_LITTLENUMS * sizeof (LITTLENUM_TYPE)); 501 limit = words + (number_of_chars / sizeof (LITTLENUM_TYPE)); 502 for (littlenumP = words; littlenumP < limit; littlenumP++) 503 { 504 md_number_to_chars (literalP, *littlenumP, sizeof (LITTLENUM_TYPE)); 505 literalP += sizeof (LITTLENUM_TYPE); 506 }; 507 } 508 else 509 { 510 number_of_chars = 0; 511 }; 512 513 *sizeP = number_of_chars; 514 return kind_of_float ? 0 : "Bad call to md_atof()"; 515 } 516 517 /* end of atof-vax.c */ 518