1 /* ----------------------------------------------------------------------- *
3 * Copyright 1996-2018 The NASM Authors - All Rights Reserved
4 * See the file AUTHORS included with the NASM distribution for
5 * the specific copyright holders.
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following
11 * * Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * * Redistributions in binary form must reproduce the above
14 * copyright notice, this list of conditions and the following
15 * disclaimer in the documentation and/or other materials provided
16 * with the distribution.
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
19 * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
20 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
21 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
22 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
23 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
25 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
26 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
29 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
30 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 * ----------------------------------------------------------------------- */
35 * float.c floating-point constant support for the Netwide Assembler
54 static bool daz
= false; /* denormals as zero */
55 static enum float_round rc
= FLOAT_RC_NEAR
; /* rounding control */
63 /* "A limb is like a digit but bigger */
64 typedef uint32_t fp_limb
;
65 typedef uint64_t fp_2limb
;
68 #define LIMB_BYTES (LIMB_BITS/8)
69 #define LIMB_TOP_BIT ((fp_limb)1 << (LIMB_BITS-1))
70 #define LIMB_MASK ((fp_limb)(~0))
71 #define LIMB_ALL_BYTES ((fp_limb)0x01010101)
72 #define LIMB_BYTE(x) ((x)*LIMB_ALL_BYTES)
74 /* 112 bits + 64 bits for accuracy + 16 bits for rounding */
77 /* 52 digits fit in 176 bits because 10^53 > 2^176 > 10^52 */
78 #define MANT_DIGITS 52
80 /* the format and the argument list depend on MANT_LIMBS */
81 #define MANT_FMT "%08x_%08x_%08x_%08x_%08x_%08x"
82 #define MANT_ARG SOME_ARG(mant, 0)
84 #define SOME_ARG(a,i) (a)[(i)+0], (a)[(i)+1], (a)[(i)+2], \
85 (a)[(i)+3], (a)[(i)+4], (a)[(i)+5]
88 * ---------------------------------------------------------------------------
89 * emit a printf()-like debug message... but only if DEBUG_FLOAT was defined
90 * ---------------------------------------------------------------------------
94 #define dprintf(x) printf x
96 #define dprintf(x) do { } while (0)
100 * ---------------------------------------------------------------------------
102 * ---------------------------------------------------------------------------
104 static int float_multiply(fp_limb
*to
, fp_limb
*from
)
106 fp_2limb temp
[MANT_LIMBS
* 2];
110 * guaranteed that top bit of 'from' is set -- so we only have
111 * to worry about _one_ bit shift to the left
113 dprintf(("%s=" MANT_FMT
"\n", "mul1", SOME_ARG(to
, 0)));
114 dprintf(("%s=" MANT_FMT
"\n", "mul2", SOME_ARG(from
, 0)));
116 memset(temp
, 0, sizeof temp
);
118 for (i
= 0; i
< MANT_LIMBS
; i
++) {
119 for (j
= 0; j
< MANT_LIMBS
; j
++) {
121 n
= (fp_2limb
) to
[i
] * (fp_2limb
) from
[j
];
122 temp
[i
+ j
] += n
>> LIMB_BITS
;
123 temp
[i
+ j
+ 1] += (fp_limb
)n
;
127 for (i
= MANT_LIMBS
* 2; --i
;) {
128 temp
[i
- 1] += temp
[i
] >> LIMB_BITS
;
129 temp
[i
] &= LIMB_MASK
;
132 dprintf(("%s=" MANT_FMT
"_" MANT_FMT
"\n", "temp", SOME_ARG(temp
, 0),
133 SOME_ARG(temp
, MANT_LIMBS
)));
135 if (temp
[0] & LIMB_TOP_BIT
) {
136 for (i
= 0; i
< MANT_LIMBS
; i
++) {
137 to
[i
] = temp
[i
] & LIMB_MASK
;
139 dprintf(("%s=" MANT_FMT
" (%i)\n", "prod", SOME_ARG(to
, 0), 0));
142 for (i
= 0; i
< MANT_LIMBS
; i
++) {
143 to
[i
] = (temp
[i
] << 1) + !!(temp
[i
+ 1] & LIMB_TOP_BIT
);
145 dprintf(("%s=" MANT_FMT
" (%i)\n", "prod", SOME_ARG(to
, 0), -1));
151 * ---------------------------------------------------------------------------
152 * read an exponent; returns INT32_MAX on error
153 * ---------------------------------------------------------------------------
155 static int32_t read_exponent(const char *string
, int32_t max
)
160 if (*string
== '+') {
162 } else if (*string
== '-') {
167 if (*string
>= '0' && *string
<= '9') {
168 i
= (i
* 10) + (*string
- '0');
171 * To ensure that underflows and overflows are
172 * handled properly we must avoid wraparounds of
173 * the signed integer value that is used to hold
174 * the exponent. Therefore we cap the exponent at
175 * +/-5000, which is slightly more/less than
176 * what's required for normal and denormal numbers
177 * in single, double, and extended precision, but
178 * sufficient to avoid signed integer wraparound.
182 } else if (*string
== '_') {
185 nasm_nonfatal("invalid character in floating-point constant %s: '%c'",
186 "exponent", *string
);
196 * ---------------------------------------------------------------------------
198 * ---------------------------------------------------------------------------
200 static bool ieee_flconvert(const char *string
, fp_limb
*mant
,
203 char digits
[MANT_DIGITS
];
205 fp_limb mult
[MANT_LIMBS
], bit
;
207 int32_t tenpwr
, twopwr
;
209 bool started
, seendot
, warned
;
214 started
= seendot
= false;
216 while (*string
&& *string
!= 'E' && *string
!= 'e') {
217 if (*string
== '.') {
221 nasm_nonfatal("too many periods in floating-point constant");
224 } else if (*string
>= '0' && *string
<= '9') {
225 if (*string
== '0' && !started
) {
231 if (p
< digits
+ sizeof(digits
)) {
232 *p
++ = *string
- '0';
236 *!float-toolong [on] too many digits in floating-point number
237 *! warns about too many digits in floating-point numbers.
239 nasm_warn(WARN_FLOAT_TOOLONG
|ERR_PASS2
,
240 "floating-point constant significand contains "
241 "more than %i digits", MANT_DIGITS
);
249 } else if (*string
== '_') {
252 nasm_nonfatalf(ERR_PASS2
,
253 "invalid character in floating-point constant %s: '%c'",
254 "significand", *string
);
263 string
++; /* eat the E */
264 e
= read_exponent(string
, 5000);
271 * At this point, the memory interval [digits,p) contains a
272 * series of decimal digits zzzzzzz, such that our number X
273 * satisfies X = 0.zzzzzzz * 10^tenpwr.
278 dprintf(("%c", *q
+ '0'));
281 dprintf((" * 10^%i\n", tenpwr
));
284 * Now convert [digits,p) to our internal representation.
287 for (m
= mant
; m
< mant
+ MANT_LIMBS
; m
++) {
294 while (m
< mant
+ MANT_LIMBS
) {
296 while (p
> q
&& !p
[-1]) {
302 for (r
= p
; r
-- > q
;) {
331 * At this point, the 'mant' array contains the first frac-
332 * tional places of a base-2^16 real number which when mul-
333 * tiplied by 2^twopwr and 5^tenpwr gives X.
335 dprintf(("X = " MANT_FMT
" * 2^%i * 5^%i\n", MANT_ARG
, twopwr
,
339 * Now multiply 'mant' by 5^tenpwr.
341 if (tenpwr
< 0) { /* mult = 5^-1 = 0.2 */
342 for (m
= mult
; m
< mult
+ MANT_LIMBS
- 1; m
++) {
343 *m
= LIMB_BYTE(0xcc);
345 mult
[MANT_LIMBS
- 1] = LIMB_BYTE(0xcc)+1;
350 * If tenpwr was 1000...000b, then it becomes 1000...000b. See
351 * the "ANSI C" comment below for more details on that case.
353 * Because we already truncated tenpwr to +5000...-5000 inside
354 * the exponent parsing code, this shouldn't happen though.
356 } else if (tenpwr
> 0) { /* mult = 5^+1 = 5.0 */
357 mult
[0] = (fp_limb
)5 << (LIMB_BITS
-3); /* 0xA000... */
358 for (m
= mult
+ 1; m
< mult
+ MANT_LIMBS
; m
++) {
366 dprintf(("loop=" MANT_FMT
" * 2^%i * 5^%i (%i)\n", MANT_ARG
,
367 twopwr
, tenpwr
, extratwos
));
369 dprintf(("mant*mult\n"));
370 twopwr
+= extratwos
+ float_multiply(mant
, mult
);
372 dprintf(("mult*mult\n"));
373 extratwos
= extratwos
* 2 + float_multiply(mult
, mult
);
377 * In ANSI C, the result of right-shifting a signed integer is
378 * considered implementation-specific. To ensure that the loop
379 * terminates even if tenpwr was 1000...000b to begin with, we
380 * manually clear the MSB, in case a 1 was shifted in.
382 * Because we already truncated tenpwr to +5000...-5000 inside
383 * the exponent parsing code, this shouldn't matter; neverthe-
384 * less it is the right thing to do here.
386 tenpwr
&= (uint32_t) - 1 >> 1;
390 * At this point, the 'mant' array contains the first frac-
391 * tional places of a base-2^16 real number in [0.5,1) that
392 * when multiplied by 2^twopwr gives X. Or it contains zero
393 * of course. We are done.
400 * ---------------------------------------------------------------------------
401 * operations of specific bits
402 * ---------------------------------------------------------------------------
405 /* Set a bit, using *bigendian* bit numbering (0 = MSB) */
406 static void set_bit(fp_limb
*mant
, int bit
)
408 mant
[bit
/LIMB_BITS
] |= LIMB_TOP_BIT
>> (bit
& (LIMB_BITS
-1));
411 /* Test a single bit */
412 static int test_bit(const fp_limb
*mant
, int bit
)
414 return (mant
[bit
/LIMB_BITS
] >> (~bit
& (LIMB_BITS
-1))) & 1;
417 /* Report if the mantissa value is all zero */
418 static bool is_zero(const fp_limb
*mant
)
422 for (i
= 0; i
< MANT_LIMBS
; i
++)
430 * ---------------------------------------------------------------------------
431 * round a mantissa off after i words
432 * ---------------------------------------------------------------------------
435 #define ROUND_COLLECT_BITS \
437 m = mant[i] & (2*bit-1); \
438 for (j = i+1; j < MANT_LIMBS; j++) \
442 #define ROUND_ABS_DOWN \
444 mant[i] &= ~(bit-1); \
445 for (j = i+1; j < MANT_LIMBS; j++) \
450 #define ROUND_ABS_UP \
452 mant[i] = (mant[i] & ~(bit-1)) + bit; \
453 for (j = i+1; j < MANT_LIMBS; j++) \
455 while (i > 0 && !mant[i]) \
460 static bool ieee_round(bool minus
, fp_limb
*mant
, int bits
)
464 int i
= bits
/ LIMB_BITS
;
465 int p
= bits
% LIMB_BITS
;
466 fp_limb bit
= LIMB_TOP_BIT
>> p
;
468 if (rc
== FLOAT_RC_NEAR
) {
476 if (test_bit(mant
, bits
-1)) {
485 } else if (rc
== FLOAT_RC_ZERO
||
486 rc
== (minus
? FLOAT_RC_UP
: FLOAT_RC_DOWN
)) {
489 /* rc == (minus ? FLOAT_RC_DOWN : FLOAT_RC_UP) */
490 /* Round toward +/- infinity */
501 /* Returns a value >= 16 if not a valid hex digit */
502 static unsigned int hexval(char c
)
504 unsigned int v
= (unsigned char) c
;
506 if (v
>= '0' && v
<= '9')
509 return (v
|0x20) - 'a' + 10;
512 /* Handle floating-point numbers with radix 2^bits and binary exponent */
513 static bool ieee_flconvert_bin(const char *string
, int bits
,
514 fp_limb
*mant
, int32_t *exponent
)
516 static const int log2tbl
[16] =
517 { -1, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3 };
518 fp_limb mult
[MANT_LIMBS
+ 1], *mp
;
521 bool seendot
, seendigit
;
523 const int radix
= 1 << bits
;
527 seendot
= seendigit
= false;
531 memset(mult
, 0, sizeof mult
);
533 while ((c
= *string
++) != '\0') {
538 nasm_nonfatal("too many periods in floating-point constant");
541 } else if ((v
= hexval(c
)) < (unsigned int)radix
) {
542 if (!seendigit
&& v
) {
547 ms
= (LIMB_BITS
-1)-l
;
554 /* Cast to fp_2limb as ms == -LIMB_BITS is possible. */
555 *mp
|= (fp_2limb
)v
>> -ms
;
557 if (mp
> &mult
[MANT_LIMBS
])
558 mp
= &mult
[MANT_LIMBS
]; /* Guard slot */
570 } else if (c
== 'p' || c
== 'P') {
572 e
= read_exponent(string
, 20000);
577 } else if (c
== '_') {
580 nasm_nonfatal("floating-point constant: `%c' is invalid character", c
);
586 memset(mant
, 0, MANT_LIMBS
*sizeof(fp_limb
)); /* Zero */
589 memcpy(mant
, mult
, MANT_LIMBS
*sizeof(fp_limb
));
597 * Shift a mantissa to the right by i bits.
599 static void ieee_shr(fp_limb
*mant
, int i
)
605 sr
= i
% LIMB_BITS
; sl
= LIMB_BITS
-sr
;
610 for (j
= MANT_LIMBS
-1; j
>= offs
; j
--)
611 mant
[j
] = mant
[j
-offs
];
612 } else if (MANT_LIMBS
-1-offs
< 0) {
615 n
= mant
[MANT_LIMBS
-1-offs
] >> sr
;
616 for (j
= MANT_LIMBS
-1; j
> offs
; j
--) {
618 mant
[j
] = (m
<< sl
) | n
;
627 /* Produce standard IEEE formats, with implicit or explicit integer
628 bit; this makes the following assumptions:
630 - the sign bit is the MSB, followed by the exponent,
631 followed by the integer bit if present.
632 - the sign bit plus exponent fit in 16 bits.
633 - the exponent bias is 2^(n-1)-1 for an n-bit exponent */
637 int mantissa
; /* Fractional bits in the mantissa */
638 int explicit; /* Explicit integer */
639 int exponent
; /* Bits in the exponent */
643 * The 16- and 128-bit formats are expected to be in IEEE 754r.
644 * AMD SSE5 uses the 16-bit format.
646 * The 32- and 64-bit formats are the original IEEE 754 formats.
648 * The 80-bit format is x87-specific, but widely used.
650 * The 8-bit format appears to be the consensus 8-bit floating-point
651 * format. It is apparently used in graphics applications.
653 static const struct ieee_format ieee_8
= { 1, 3, 0, 4 };
654 static const struct ieee_format ieee_16
= { 2, 10, 0, 5 };
655 static const struct ieee_format ieee_32
= { 4, 23, 0, 8 };
656 static const struct ieee_format ieee_64
= { 8, 52, 0, 11 };
657 static const struct ieee_format ieee_80
= { 10, 63, 1, 15 };
658 static const struct ieee_format ieee_128
= { 16, 112, 0, 15 };
660 /* Types of values we can generate */
670 static int to_packed_bcd(const char *str
, const char *p
,
671 int s
, uint8_t *result
,
672 const struct ieee_format
*fmt
)
678 if (fmt
!= &ieee_80
) {
679 nasm_nonfatal("packed BCD requires an 80-bit format");
685 if (c
>= '0' && c
<= '9') {
688 nasm_warn(WARN_OTHER
|ERR_PASS2
, "packed BCD truncated to 18 digits");
692 *result
++ = tv
+ ((c
-'0') << 4);
696 } else if (c
== '_') {
699 nasm_nonfatal("invalid character `%c' in packed BCD constant", c
);
712 *result
= (s
< 0) ? 0x80 : 0;
714 return 1; /* success */
717 static int to_float(const char *str
, int s
, uint8_t *result
,
718 const struct ieee_format
*fmt
)
720 fp_limb mant
[MANT_LIMBS
];
721 int32_t exponent
= 0;
722 const int32_t expmax
= 1 << (fmt
->exponent
- 1);
723 fp_limb one_mask
= LIMB_TOP_BIT
>>
724 ((fmt
->exponent
+fmt
->explicit) % LIMB_BITS
);
725 const int one_pos
= (fmt
->exponent
+fmt
->explicit)/LIMB_BITS
;
730 const bool minus
= s
< 0;
731 const int bits
= fmt
->bytes
* 8;
736 strend
= strchr(str
, '\0');
737 if (strend
[-1] == 'P' || strend
[-1] == 'p')
738 return to_packed_bcd(str
, strend
-2, s
, result
, fmt
);
744 case 'n': /* __nan__ */
746 case 'q': /* __qnan__ */
750 case 's': /* __snan__ */
754 case 'i': /* __infinity__ */
759 nasm_nonfatal("internal error: unknown FP constant token `%s'", str
);
768 ok
= ieee_flconvert_bin(str
+2, 4, mant
, &exponent
);
772 ok
= ieee_flconvert_bin(str
+2, 3, mant
, &exponent
);
776 ok
= ieee_flconvert_bin(str
+2, 1, mant
, &exponent
);
780 ok
= ieee_flconvert(str
+2, mant
, &exponent
);
783 return to_packed_bcd(str
+2, strend
-1, s
, result
, fmt
);
785 /* Leading zero was just a zero? */
786 ok
= ieee_flconvert(str
, mant
, &exponent
);
789 } else if (str
[0] == '$') {
790 ok
= ieee_flconvert_bin(str
+1, 4, mant
, &exponent
);
792 ok
= ieee_flconvert(str
, mant
, &exponent
);
797 } else if (mant
[0] & LIMB_TOP_BIT
) {
802 if (exponent
>= 2 - expmax
&& exponent
<= expmax
) {
804 } else if (exponent
> 0) {
805 nasm_warn(WARN_FLOAT_OVERFLOW
|ERR_PASS2
,
806 "overflow in floating-point constant");
809 /* underflow or denormal; the denormal code handles
822 memset(mant
, 0, sizeof mant
);
827 shift
= -(exponent
+ expmax
- 2 - fmt
->exponent
)
829 ieee_shr(mant
, shift
);
830 ieee_round(minus
, mant
, bits
);
831 if (mant
[one_pos
] & one_mask
) {
832 /* One's position is set, we rounded up into normal range */
835 mant
[one_pos
] &= ~one_mask
; /* remove explicit one */
836 mant
[0] |= exponent
<< (LIMB_BITS
-1 - fmt
->exponent
);
838 if (daz
|| is_zero(mant
)) {
840 *!float-underflow [off] floating point underflow
841 *! warns about floating point underflow (a nonzero
842 *! constant rounded to zero.)
844 nasm_warn(WARN_FLOAT_UNDERFLOW
|ERR_PASS2
,
845 "underflow in floating-point constant");
849 *!float-denorm [off] floating point denormal
850 *! warns about denormal floating point constants.
852 nasm_warn(WARN_FLOAT_DENORM
|ERR_PASS2
,
853 "denormal floating-point constant");
860 exponent
+= expmax
- 1;
861 ieee_shr(mant
, fmt
->exponent
+fmt
->explicit);
862 ieee_round(minus
, mant
, bits
);
863 /* did we scale up by one? */
864 if (test_bit(mant
, fmt
->exponent
+fmt
->explicit-1)) {
867 if (exponent
>= (expmax
<< 1)-1) {
869 *!float-overflow [on] floating point overflow
870 *! warns about floating point underflow.
872 nasm_warn(WARN_FLOAT_OVERFLOW
|ERR_PASS2
,
873 "overflow in floating-point constant");
880 mant
[one_pos
] &= ~one_mask
; /* remove explicit one */
881 mant
[0] |= exponent
<< (LIMB_BITS
-1 - fmt
->exponent
);
888 memset(mant
, 0, sizeof mant
);
889 mant
[0] = (((fp_limb
)1 << fmt
->exponent
)-1)
890 << (LIMB_BITS
-1 - fmt
->exponent
);
892 mant
[one_pos
] |= one_mask
;
894 set_bit(mant
, fmt
->exponent
+fmt
->explicit+1);
895 else if (type
== FL_SNAN
)
896 set_bit(mant
, fmt
->exponent
+fmt
->explicit+fmt
->mantissa
);
900 mant
[0] |= minus
? LIMB_TOP_BIT
: 0;
902 for (i
= fmt
->bytes
- 1; i
>= 0; i
--)
903 *result
++ = mant
[i
/LIMB_BYTES
] >> (((LIMB_BYTES
-1)-(i
%LIMB_BYTES
))*8);
905 return 1; /* success */
908 int float_const(const char *number
, int sign
, uint8_t *result
, int bytes
)
912 return to_float(number
, sign
, result
, &ieee_8
);
914 return to_float(number
, sign
, result
, &ieee_16
);
916 return to_float(number
, sign
, result
, &ieee_32
);
918 return to_float(number
, sign
, result
, &ieee_64
);
920 return to_float(number
, sign
, result
, &ieee_80
);
922 return to_float(number
, sign
, result
, &ieee_128
);
924 nasm_panic("strange value %d passed to float_const", bytes
);
929 /* Set floating-point options */
930 int float_option(const char *option
)
932 if (!nasm_stricmp(option
, "daz")) {
935 } else if (!nasm_stricmp(option
, "nodaz")) {
938 } else if (!nasm_stricmp(option
, "near")) {
941 } else if (!nasm_stricmp(option
, "down")) {
944 } else if (!nasm_stricmp(option
, "up")) {
947 } else if (!nasm_stricmp(option
, "zero")) {
950 } else if (!nasm_stricmp(option
, "default")) {
955 return -1; /* Unknown option */