1 /* float.c floating-point constant support for the Netwide Assembler
3 * The Netwide Assembler is copyright (C) 1996 Simon Tatham and
4 * Julian Hall. All rights reserved. The software is
5 * redistributable under the licence given in the file "Licence"
6 * distributed in the NASM archive.
8 * initial version 13/ix/96 by Simon Tatham
28 static bool daz = false; /* denormals as zero */
29 static enum float_round rc = FLOAT_RC_NEAR; /* rounding control */
37 /* 112 bits + 64 bits for accuracy + 16 bits for rounding */
40 /* 52 digits fit in 176 bits because 10^53 > 2^176 > 10^52 */
41 #define MANT_DIGITS 52
43 /* the format and the argument list depend on MANT_WORDS */
44 #define MANT_FMT "%04x%04x_%04x%04x_%04x%04x_%04x%04x_%04x%04x_%04x%04x"
45 #define MANT_ARG SOME_ARG(mant, 0)
47 #define SOME_ARG(a,i) (a)[(i)+0], (a)[(i)+1], (a)[(i)+2], (a)[(i)+3], \
48 (a)[(i)+4], (a)[(i)+5], (a)[(i)+6], (a)[(i)+7], (a)[(i)+8], \
49 (a)[(i)+9], (a)[(i)+10], (a)[(i)+11]
52 * ---------------------------------------------------------------------------
53 * emit a printf()-like debug message... but only if DEBUG_FLOAT was defined
54 * ---------------------------------------------------------------------------
58 #define dprintf(x) printf x
60 #define dprintf(x) do { } while (0)
64 * ---------------------------------------------------------------------------
66 * ---------------------------------------------------------------------------
68 static int float_multiply(uint16_t * to, uint16_t * from)
70 uint32_t temp[MANT_WORDS * 2];
74 * guaranteed that top bit of 'from' is set -- so we only have
75 * to worry about _one_ bit shift to the left
77 dprintf(("%s=" MANT_FMT "\n", "mul1", SOME_ARG(to, 0)));
78 dprintf(("%s=" MANT_FMT "\n", "mul2", SOME_ARG(from, 0)));
80 memset(temp, 0, sizeof temp);
82 for (i = 0; i < MANT_WORDS; i++) {
83 for (j = 0; j < MANT_WORDS; j++) {
85 n = (uint32_t) to[i] * (uint32_t) from[j];
86 temp[i + j] += n >> 16;
87 temp[i + j + 1] += n & 0xFFFF;
91 for (i = MANT_WORDS * 2; --i;) {
92 temp[i - 1] += temp[i] >> 16;
96 dprintf(("%s=" MANT_FMT "_" MANT_FMT "\n", "temp", SOME_ARG(temp, 0),
97 SOME_ARG(temp, MANT_WORDS)));
99 if (temp[0] & 0x8000) {
100 for (i = 0; i < MANT_WORDS; i++) {
101 to[i] = temp[i] & 0xFFFF;
103 dprintf(("%s=" MANT_FMT " (%i)\n", "prod", SOME_ARG(to, 0), 0));
106 for (i = 0; i < MANT_WORDS; i++) {
107 to[i] = (temp[i] << 1) + !!(temp[i + 1] & 0x8000);
109 dprintf(("%s=" MANT_FMT " (%i)\n", "prod", SOME_ARG(to, 0), -1));
115 * ---------------------------------------------------------------------------
116 * read an exponent; returns INT32_MAX on error
117 * ---------------------------------------------------------------------------
119 static int32_t read_exponent(const char *string, int32_t max)
124 if (*string == '+') {
126 } else if (*string == '-') {
131 if (*string >= '0' && *string <= '9') {
132 i = (i * 10) + (*string - '0');
135 * To ensure that underflows and overflows are
136 * handled properly we must avoid wraparounds of
137 * the signed integer value that is used to hold
138 * the exponent. Therefore we cap the exponent at
139 * +/-5000, which is slightly more/less than
140 * what's required for normal and denormal numbers
141 * in single, double, and extended precision, but
142 * sufficient to avoid signed integer wraparound.
147 } else if (*string == '_') {
151 "invalid character in floating-point constant %s: '%c'",
152 "exponent", *string);
162 * ---------------------------------------------------------------------------
164 * ---------------------------------------------------------------------------
166 static bool ieee_flconvert(const char *string, uint16_t * mant,
169 char digits[MANT_DIGITS];
171 uint16_t mult[MANT_WORDS], bit;
173 int32_t tenpwr, twopwr;
175 bool started, seendot, warned;
178 started = seendot = false;
179 warned = (pass0 != 1);
180 while (*string && *string != 'E' && *string != 'e') {
181 if (*string == '.') {
186 "too many periods in floating-point constant");
189 } else if (*string >= '0' && *string <= '9') {
190 if (*string == '0' && !started) {
196 if (p < digits + sizeof(digits)) {
197 *p++ = *string - '0';
200 error(ERR_WARNING|ERR_WARN_FL_TOOLONG,
201 "floating-point constant significand contains "
202 "more than %i digits", MANT_DIGITS);
210 } else if (*string == '_') {
214 "invalid character in floating-point constant %s: '%c'",
215 "significand", *string);
224 string++; /* eat the E */
225 e = read_exponent(string, 5000);
232 * At this point, the memory interval [digits,p) contains a
233 * series of decimal digits zzzzzzz, such that our number X
234 * satisfies X = 0.zzzzzzz * 10^tenpwr.
239 dprintf(("%c", *q + '0'));
242 dprintf((" * 10^%i\n", tenpwr));
245 * Now convert [digits,p) to our internal representation.
248 for (m = mant; m < mant + MANT_WORDS; m++) {
255 while (m < mant + MANT_WORDS) {
257 while (p > q && !p[-1]) {
263 for (r = p; r-- > q;) {
292 * At this point, the 'mant' array contains the first frac-
293 * tional places of a base-2^16 real number which when mul-
294 * tiplied by 2^twopwr and 5^tenpwr gives X.
296 dprintf(("X = " MANT_FMT " * 2^%i * 5^%i\n", MANT_ARG, twopwr,
300 * Now multiply 'mant' by 5^tenpwr.
302 if (tenpwr < 0) { /* mult = 5^-1 = 0.2 */
303 for (m = mult; m < mult + MANT_WORDS - 1; m++) {
306 mult[MANT_WORDS - 1] = 0xCCCD;
311 * If tenpwr was 1000...000b, then it becomes 1000...000b. See
312 * the "ANSI C" comment below for more details on that case.
314 * Because we already truncated tenpwr to +5000...-5000 inside
315 * the exponent parsing code, this shouldn't happen though.
317 } else if (tenpwr > 0) { /* mult = 5^+1 = 5.0 */
319 for (m = mult + 1; m < mult + MANT_WORDS; m++) {
327 dprintf(("loop=" MANT_FMT " * 2^%i * 5^%i (%i)\n", MANT_ARG,
328 twopwr, tenpwr, extratwos));
330 dprintf(("mant*mult\n"));
331 twopwr += extratwos + float_multiply(mant, mult);
333 dprintf(("mult*mult\n"));
334 extratwos = extratwos * 2 + float_multiply(mult, mult);
338 * In ANSI C, the result of right-shifting a signed integer is
339 * considered implementation-specific. To ensure that the loop
340 * terminates even if tenpwr was 1000...000b to begin with, we
341 * manually clear the MSB, in case a 1 was shifted in.
343 * Because we already truncated tenpwr to +5000...-5000 inside
344 * the exponent parsing code, this shouldn't matter; neverthe-
345 * less it is the right thing to do here.
347 tenpwr &= (uint32_t) - 1 >> 1;
351 * At this point, the 'mant' array contains the first frac-
352 * tional places of a base-2^16 real number in [0.5,1) that
353 * when multiplied by 2^twopwr gives X. Or it contains zero
354 * of course. We are done.
361 * ---------------------------------------------------------------------------
362 * round a mantissa off after i words
363 * ---------------------------------------------------------------------------
366 #define ROUND_COLLECT_BITS \
367 for (j = i; j < MANT_WORDS; j++) { \
371 #define ROUND_ABS_DOWN \
372 for (j = i; j < MANT_WORDS; j++) { \
376 #define ROUND_ABS_UP \
380 } while (i > 0 && !mant[i]); \
381 return (!i && !mant[i]);
383 static bool ieee_round(int sign, uint16_t * mant, int32_t i)
387 if ((sign == 0x0000) || (sign == 0x8000)) {
388 if (rc == FLOAT_RC_NEAR) {
389 if (mant[i] & 0x8000) {
396 if (mant[i - 1] & 1) {
405 } else if (((sign == 0x0000) && (rc == FLOAT_RC_DOWN))
406 || ((sign == 0x8000) && (rc == FLOAT_RC_UP))) {
411 } else if (((sign == 0x0000) && (rc == FLOAT_RC_UP))
412 || ((sign == 0x8000) && (rc == FLOAT_RC_DOWN))) {
417 } else if (rc == FLOAT_RC_ZERO) {
420 error(ERR_PANIC, "float_round() can't handle rc=%i", rc);
423 error(ERR_PANIC, "float_round() can't handle sign=%i", sign);
428 static int hexval(char c)
430 if (c >= '0' && c <= '9')
432 else if (c >= 'a' && c <= 'f')
438 static bool ieee_flconvert_hex(const char *string, uint16_t * mant,
441 static const int log2tbl[16] =
442 { -1, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3 };
443 uint16_t mult[MANT_WORDS + 1], *mp;
446 int seendot, seendigit;
450 seendot = seendigit = 0;
454 memset(mult, 0, sizeof mult);
456 while ((c = *string++) != '\0') {
462 "too many periods in floating-point constant");
465 } else if (isxdigit(c)) {
468 if (!seendigit && v) {
475 twopwr = seendot ? twopwr - 4 + l : l - 3;
482 if (mp > &mult[MANT_WORDS])
483 mp = &mult[MANT_WORDS]; /* Guard slot */
495 } else if (c == 'p' || c == 'P') {
497 e = read_exponent(string, 16384);
502 } else if (c == '_') {
506 "floating-point constant: `%c' is invalid character", c);
512 memset(mant, 0, 2 * MANT_WORDS); /* Zero */
515 memcpy(mant, mult, 2 * MANT_WORDS);
523 * Shift a mantissa to the right by i bits.
525 static void ieee_shr(uint16_t * mant, int i)
531 sr = i%16; sl = 16-sr;
536 for (j = MANT_WORDS-1; j >= offs; j--)
537 mant[j] = mant[j-offs];
539 n = mant[MANT_WORDS-1-offs] >> sr;
540 for (j = MANT_WORDS-1; j > offs; j--) {
542 mant[j] = (m << sl) | n;
551 #if defined(__i386__) || defined(__x86_64__)
552 #define put(a,b) (*(uint16_t *)(a) = (b))
554 #define put(a,b) (((a)[0] = (b)), ((a)[1] = (b) >> 8))
557 /* Set a bit, using *bigendian* bit numbering (0 = MSB) */
558 static void set_bit(uint16_t *mant, int bit)
560 mant[bit >> 4] |= 1 << (~bit & 15);
563 /* Test a single bit */
564 static int test_bit(const uint16_t *mant, int bit)
566 return (mant[bit >> 4] >> (~bit & 15)) & 1;
569 /* Report if the mantissa value is all zero */
570 static bool is_zero(const uint16_t *mant)
574 for (i = 0; i < MANT_WORDS; i++)
581 /* Produce standard IEEE formats, with implicit or explicit integer
582 bit; this makes the following assumptions:
584 - the sign bit is the MSB, followed by the exponent,
585 followed by the integer bit if present.
586 - the sign bit plus exponent fit in 16 bits.
587 - the exponent bias is 2^(n-1)-1 for an n-bit exponent */
591 int mantissa; /* Fractional bits in the mantissa */
592 int explicit; /* Explicit integer */
593 int exponent; /* Bits in the exponent */
597 * The 16- and 128-bit formats are expected to be in IEEE 754r.
598 * AMD SSE5 uses the 16-bit format.
600 * The 32- and 64-bit formats are the original IEEE 754 formats.
602 * The 80-bit format is x87-specific, but widely used.
604 static const struct ieee_format ieee_16 = { 1, 10, 0, 5 };
605 static const struct ieee_format ieee_32 = { 2, 23, 0, 8 };
606 static const struct ieee_format ieee_64 = { 4, 52, 0, 11 };
607 static const struct ieee_format ieee_80 = { 5, 63, 1, 15 };
608 static const struct ieee_format ieee_128 = { 8, 112, 0, 15 };
610 /* Types of values we can generate */
620 static int to_float(const char *str, int sign, uint8_t * result,
621 const struct ieee_format *fmt)
623 uint16_t mant[MANT_WORDS], *mp;
624 int32_t exponent = 0;
625 int32_t expmax = 1 << (fmt->exponent - 1);
626 uint16_t one_mask = 0x8000 >> ((fmt->exponent+fmt->explicit) % 16);
627 int one_pos = (fmt->exponent+fmt->explicit)/16;
633 sign = (sign < 0 ? 0x8000 : 0);
639 case 'n': /* __nan__ */
641 case 'q': /* __qnan__ */
645 case 's': /* __snan__ */
649 case 'i': /* __infinity__ */
655 "internal error: unknown FP constant token `%s'\n", str);
660 if (str[0] == '0' && (str[1] == 'x' || str[1] == 'X'))
661 ok = ieee_flconvert_hex(str + 2, mant, &exponent);
662 else if (str[0] == '$')
663 ok = ieee_flconvert_hex(str + 1, mant, &exponent);
665 ok = ieee_flconvert(str, mant, &exponent);
669 } else if (mant[0] & 0x8000) {
674 if (exponent >= 2 - expmax && exponent <= expmax) {
676 } else if (exponent < 2 - expmax &&
677 exponent >= 2 - expmax - fmt->mantissa) {
679 } else if (exponent > 0) {
681 error(ERR_WARNING|ERR_WARN_FL_OVERFLOW,
682 "overflow in floating-point constant");
687 error(ERR_WARNING|ERR_WARN_FL_UNDERFLOW,
688 "underflow in floating-point constant");
700 memset(mant, 0, sizeof mant);
705 shift = -(exponent + expmax - 2 - fmt->exponent)
707 ieee_shr(mant, shift);
708 ieee_round(sign, mant, fmt->words);
709 if (mant[one_pos] & one_mask) {
710 /* One's position is set, we rounded up into normal range */
713 mant[one_pos] &= ~one_mask; /* remove explicit one */
714 mant[0] |= exponent << (15 - fmt->exponent);
716 if (daz || is_zero(mant)) {
717 /* Flush denormals to zero */
719 error(ERR_WARNING|ERR_WARN_FL_UNDERFLOW,
720 "underflow in floating-point constant");
724 error(ERR_WARNING|ERR_WARN_FL_DENORM,
725 "denormal floating-point constant");
732 exponent += expmax - 1;
733 ieee_shr(mant, fmt->exponent+fmt->explicit);
734 ieee_round(sign, mant, fmt->words);
735 /* did we scale up by one? */
736 if (test_bit(mant, fmt->exponent+fmt->explicit-1)) {
739 if (exponent >= (expmax << 1)-1) {
741 error(ERR_WARNING|ERR_WARN_FL_OVERFLOW,
742 "overflow in floating-point constant");
749 mant[one_pos] &= ~one_mask; /* remove explicit one */
750 mant[0] |= exponent << (15 - fmt->exponent);
757 memset(mant, 0, sizeof mant);
758 mant[0] = ((1 << fmt->exponent)-1) << (15 - fmt->exponent);
760 mant[one_pos] |= one_mask;
762 set_bit(mant, fmt->exponent+fmt->explicit+1);
763 else if (type == FL_SNAN)
764 set_bit(mant, fmt->exponent+fmt->explicit+fmt->mantissa);
770 for (mp = &mant[fmt->words], i = 0; i < fmt->words; i++) {
776 return 1; /* success */
779 int float_const(const char *number, int32_t sign, uint8_t * result,
780 int bytes, efunc err)
786 return to_float(number, sign, result, &ieee_16);
788 return to_float(number, sign, result, &ieee_32);
790 return to_float(number, sign, result, &ieee_64);
792 return to_float(number, sign, result, &ieee_80);
794 return to_float(number, sign, result, &ieee_128);
796 error(ERR_PANIC, "strange value %d passed to float_const", bytes);
801 /* Set floating-point options */
802 int float_option(const char *option)
804 if (!nasm_stricmp(option, "daz")) {
807 } else if (!nasm_stricmp(option, "nodaz")) {
810 } else if (!nasm_stricmp(option, "near")) {
813 } else if (!nasm_stricmp(option, "down")) {
816 } else if (!nasm_stricmp(option, "up")) {
819 } else if (!nasm_stricmp(option, "zero")) {
822 } else if (!nasm_stricmp(option, "default")) {
827 return -1; /* Unknown option */