mirror of
https://github.com/netwide-assembler/nasm.git
synced 2024-12-09 08:51:18 +08:00
744100dc14
* nasm-2.14.xx: Fix undefined behavior when shifting left by 32 bits BR 3392529: if the default output name is the same as input -> nasm.out
951 lines
28 KiB
C
951 lines
28 KiB
C
/* ----------------------------------------------------------------------- *
|
|
*
|
|
* Copyright 1996-2017 The NASM Authors - All Rights Reserved
|
|
* See the file AUTHORS included with the NASM distribution for
|
|
* the specific copyright holders.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following
|
|
* conditions are met:
|
|
*
|
|
* * Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above
|
|
* copyright notice, this list of conditions and the following
|
|
* disclaimer in the documentation and/or other materials provided
|
|
* with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
|
|
* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
|
|
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
|
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
|
|
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
|
|
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
|
|
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
* ----------------------------------------------------------------------- */
|
|
|
|
/*
|
|
* float.c floating-point constant support for the Netwide Assembler
|
|
*/
|
|
|
|
#include "compiler.h"
|
|
|
|
#include <ctype.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include "nasm.h"
|
|
#include "float.h"
|
|
#include "error.h"
|
|
|
|
/*
|
|
* -----------------
|
|
* local variables
|
|
* -----------------
|
|
*/
|
|
static bool daz = false; /* denormals as zero */
|
|
static enum float_round rc = FLOAT_RC_NEAR; /* rounding control */
|
|
|
|
/*
|
|
* -----------
|
|
* constants
|
|
* -----------
|
|
*/
|
|
|
|
/* "A limb is like a digit but bigger */
|
|
typedef uint32_t fp_limb;
|
|
typedef uint64_t fp_2limb;
|
|
|
|
#define LIMB_BITS 32
|
|
#define LIMB_BYTES (LIMB_BITS/8)
|
|
#define LIMB_TOP_BIT ((fp_limb)1 << (LIMB_BITS-1))
|
|
#define LIMB_MASK ((fp_limb)(~0))
|
|
#define LIMB_ALL_BYTES ((fp_limb)0x01010101)
|
|
#define LIMB_BYTE(x) ((x)*LIMB_ALL_BYTES)
|
|
|
|
/* 112 bits + 64 bits for accuracy + 16 bits for rounding */
|
|
#define MANT_LIMBS 6
|
|
|
|
/* 52 digits fit in 176 bits because 10^53 > 2^176 > 10^52 */
|
|
#define MANT_DIGITS 52
|
|
|
|
/* the format and the argument list depend on MANT_LIMBS */
|
|
#define MANT_FMT "%08x_%08x_%08x_%08x_%08x_%08x"
|
|
#define MANT_ARG SOME_ARG(mant, 0)
|
|
|
|
#define SOME_ARG(a,i) (a)[(i)+0], (a)[(i)+1], (a)[(i)+2], \
|
|
(a)[(i)+3], (a)[(i)+4], (a)[(i)+5]
|
|
|
|
/*
|
|
* ---------------------------------------------------------------------------
|
|
* emit a printf()-like debug message... but only if DEBUG_FLOAT was defined
|
|
* ---------------------------------------------------------------------------
|
|
*/
|
|
|
|
#ifdef DEBUG_FLOAT
|
|
#define dprintf(x) printf x
|
|
#else
|
|
#define dprintf(x) do { } while (0)
|
|
#endif
|
|
|
|
/*
|
|
* ---------------------------------------------------------------------------
|
|
* multiply
|
|
* ---------------------------------------------------------------------------
|
|
*/
|
|
static int float_multiply(fp_limb *to, fp_limb *from)
|
|
{
|
|
fp_2limb temp[MANT_LIMBS * 2];
|
|
int i, j;
|
|
|
|
/*
|
|
* guaranteed that top bit of 'from' is set -- so we only have
|
|
* to worry about _one_ bit shift to the left
|
|
*/
|
|
dprintf(("%s=" MANT_FMT "\n", "mul1", SOME_ARG(to, 0)));
|
|
dprintf(("%s=" MANT_FMT "\n", "mul2", SOME_ARG(from, 0)));
|
|
|
|
memset(temp, 0, sizeof temp);
|
|
|
|
for (i = 0; i < MANT_LIMBS; i++) {
|
|
for (j = 0; j < MANT_LIMBS; j++) {
|
|
fp_2limb n;
|
|
n = (fp_2limb) to[i] * (fp_2limb) from[j];
|
|
temp[i + j] += n >> LIMB_BITS;
|
|
temp[i + j + 1] += (fp_limb)n;
|
|
}
|
|
}
|
|
|
|
for (i = MANT_LIMBS * 2; --i;) {
|
|
temp[i - 1] += temp[i] >> LIMB_BITS;
|
|
temp[i] &= LIMB_MASK;
|
|
}
|
|
|
|
dprintf(("%s=" MANT_FMT "_" MANT_FMT "\n", "temp", SOME_ARG(temp, 0),
|
|
SOME_ARG(temp, MANT_LIMBS)));
|
|
|
|
if (temp[0] & LIMB_TOP_BIT) {
|
|
for (i = 0; i < MANT_LIMBS; i++) {
|
|
to[i] = temp[i] & LIMB_MASK;
|
|
}
|
|
dprintf(("%s=" MANT_FMT " (%i)\n", "prod", SOME_ARG(to, 0), 0));
|
|
return 0;
|
|
} else {
|
|
for (i = 0; i < MANT_LIMBS; i++) {
|
|
to[i] = (temp[i] << 1) + !!(temp[i + 1] & LIMB_TOP_BIT);
|
|
}
|
|
dprintf(("%s=" MANT_FMT " (%i)\n", "prod", SOME_ARG(to, 0), -1));
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* ---------------------------------------------------------------------------
|
|
* read an exponent; returns INT32_MAX on error
|
|
* ---------------------------------------------------------------------------
|
|
*/
|
|
static int32_t read_exponent(const char *string, int32_t max)
|
|
{
|
|
int32_t i = 0;
|
|
bool neg = false;
|
|
|
|
if (*string == '+') {
|
|
string++;
|
|
} else if (*string == '-') {
|
|
neg = true;
|
|
string++;
|
|
}
|
|
while (*string) {
|
|
if (*string >= '0' && *string <= '9') {
|
|
i = (i * 10) + (*string - '0');
|
|
|
|
/*
|
|
* To ensure that underflows and overflows are
|
|
* handled properly we must avoid wraparounds of
|
|
* the signed integer value that is used to hold
|
|
* the exponent. Therefore we cap the exponent at
|
|
* +/-5000, which is slightly more/less than
|
|
* what's required for normal and denormal numbers
|
|
* in single, double, and extended precision, but
|
|
* sufficient to avoid signed integer wraparound.
|
|
*/
|
|
if (i > max)
|
|
i = max;
|
|
} else if (*string == '_') {
|
|
/* do nothing */
|
|
} else {
|
|
nasm_error(ERR_NONFATAL,
|
|
"invalid character in floating-point constant %s: '%c'",
|
|
"exponent", *string);
|
|
return INT32_MAX;
|
|
}
|
|
string++;
|
|
}
|
|
|
|
return neg ? -i : i;
|
|
}
|
|
|
|
/*
|
|
* ---------------------------------------------------------------------------
|
|
* convert
|
|
* ---------------------------------------------------------------------------
|
|
*/
|
|
static bool ieee_flconvert(const char *string, fp_limb *mant,
|
|
int32_t * exponent)
|
|
{
|
|
char digits[MANT_DIGITS];
|
|
char *p, *q, *r;
|
|
fp_limb mult[MANT_LIMBS], bit;
|
|
fp_limb *m;
|
|
int32_t tenpwr, twopwr;
|
|
int32_t extratwos;
|
|
bool started, seendot, warned;
|
|
|
|
warned = false;
|
|
p = digits;
|
|
tenpwr = 0;
|
|
started = seendot = false;
|
|
|
|
while (*string && *string != 'E' && *string != 'e') {
|
|
if (*string == '.') {
|
|
if (!seendot) {
|
|
seendot = true;
|
|
} else {
|
|
nasm_error(ERR_NONFATAL,
|
|
"too many periods in floating-point constant");
|
|
return false;
|
|
}
|
|
} else if (*string >= '0' && *string <= '9') {
|
|
if (*string == '0' && !started) {
|
|
if (seendot) {
|
|
tenpwr--;
|
|
}
|
|
} else {
|
|
started = true;
|
|
if (p < digits + sizeof(digits)) {
|
|
*p++ = *string - '0';
|
|
} else {
|
|
if (!warned) {
|
|
nasm_error(ERR_WARNING|ERR_WARN_FL_TOOLONG|ERR_PASS2,
|
|
"floating-point constant significand contains "
|
|
"more than %i digits", MANT_DIGITS);
|
|
warned = true;
|
|
}
|
|
}
|
|
if (!seendot) {
|
|
tenpwr++;
|
|
}
|
|
}
|
|
} else if (*string == '_') {
|
|
/* do nothing */
|
|
} else {
|
|
nasm_error(ERR_NONFATAL|ERR_PASS2,
|
|
"invalid character in floating-point constant %s: '%c'",
|
|
"significand", *string);
|
|
return false;
|
|
}
|
|
string++;
|
|
}
|
|
|
|
if (*string) {
|
|
int32_t e;
|
|
|
|
string++; /* eat the E */
|
|
e = read_exponent(string, 5000);
|
|
if (e == INT32_MAX)
|
|
return false;
|
|
tenpwr += e;
|
|
}
|
|
|
|
/*
|
|
* At this point, the memory interval [digits,p) contains a
|
|
* series of decimal digits zzzzzzz, such that our number X
|
|
* satisfies X = 0.zzzzzzz * 10^tenpwr.
|
|
*/
|
|
q = digits;
|
|
dprintf(("X = 0."));
|
|
while (q < p) {
|
|
dprintf(("%c", *q + '0'));
|
|
q++;
|
|
}
|
|
dprintf((" * 10^%i\n", tenpwr));
|
|
|
|
/*
|
|
* Now convert [digits,p) to our internal representation.
|
|
*/
|
|
bit = LIMB_TOP_BIT;
|
|
for (m = mant; m < mant + MANT_LIMBS; m++) {
|
|
*m = 0;
|
|
}
|
|
m = mant;
|
|
q = digits;
|
|
started = false;
|
|
twopwr = 0;
|
|
while (m < mant + MANT_LIMBS) {
|
|
fp_limb carry = 0;
|
|
while (p > q && !p[-1]) {
|
|
p--;
|
|
}
|
|
if (p <= q) {
|
|
break;
|
|
}
|
|
for (r = p; r-- > q;) {
|
|
int32_t i;
|
|
i = 2 * *r + carry;
|
|
if (i >= 10) {
|
|
carry = 1;
|
|
i -= 10;
|
|
} else {
|
|
carry = 0;
|
|
}
|
|
*r = i;
|
|
}
|
|
if (carry) {
|
|
*m |= bit;
|
|
started = true;
|
|
}
|
|
if (started) {
|
|
if (bit == 1) {
|
|
bit = LIMB_TOP_BIT;
|
|
m++;
|
|
} else {
|
|
bit >>= 1;
|
|
}
|
|
} else {
|
|
twopwr--;
|
|
}
|
|
}
|
|
twopwr += tenpwr;
|
|
|
|
/*
|
|
* At this point, the 'mant' array contains the first frac-
|
|
* tional places of a base-2^16 real number which when mul-
|
|
* tiplied by 2^twopwr and 5^tenpwr gives X.
|
|
*/
|
|
dprintf(("X = " MANT_FMT " * 2^%i * 5^%i\n", MANT_ARG, twopwr,
|
|
tenpwr));
|
|
|
|
/*
|
|
* Now multiply 'mant' by 5^tenpwr.
|
|
*/
|
|
if (tenpwr < 0) { /* mult = 5^-1 = 0.2 */
|
|
for (m = mult; m < mult + MANT_LIMBS - 1; m++) {
|
|
*m = LIMB_BYTE(0xcc);
|
|
}
|
|
mult[MANT_LIMBS - 1] = LIMB_BYTE(0xcc)+1;
|
|
extratwos = -2;
|
|
tenpwr = -tenpwr;
|
|
|
|
/*
|
|
* If tenpwr was 1000...000b, then it becomes 1000...000b. See
|
|
* the "ANSI C" comment below for more details on that case.
|
|
*
|
|
* Because we already truncated tenpwr to +5000...-5000 inside
|
|
* the exponent parsing code, this shouldn't happen though.
|
|
*/
|
|
} else if (tenpwr > 0) { /* mult = 5^+1 = 5.0 */
|
|
mult[0] = (fp_limb)5 << (LIMB_BITS-3); /* 0xA000... */
|
|
for (m = mult + 1; m < mult + MANT_LIMBS; m++) {
|
|
*m = 0;
|
|
}
|
|
extratwos = 3;
|
|
} else {
|
|
extratwos = 0;
|
|
}
|
|
while (tenpwr) {
|
|
dprintf(("loop=" MANT_FMT " * 2^%i * 5^%i (%i)\n", MANT_ARG,
|
|
twopwr, tenpwr, extratwos));
|
|
if (tenpwr & 1) {
|
|
dprintf(("mant*mult\n"));
|
|
twopwr += extratwos + float_multiply(mant, mult);
|
|
}
|
|
dprintf(("mult*mult\n"));
|
|
extratwos = extratwos * 2 + float_multiply(mult, mult);
|
|
tenpwr >>= 1;
|
|
|
|
/*
|
|
* In ANSI C, the result of right-shifting a signed integer is
|
|
* considered implementation-specific. To ensure that the loop
|
|
* terminates even if tenpwr was 1000...000b to begin with, we
|
|
* manually clear the MSB, in case a 1 was shifted in.
|
|
*
|
|
* Because we already truncated tenpwr to +5000...-5000 inside
|
|
* the exponent parsing code, this shouldn't matter; neverthe-
|
|
* less it is the right thing to do here.
|
|
*/
|
|
tenpwr &= (uint32_t) - 1 >> 1;
|
|
}
|
|
|
|
/*
|
|
* At this point, the 'mant' array contains the first frac-
|
|
* tional places of a base-2^16 real number in [0.5,1) that
|
|
* when multiplied by 2^twopwr gives X. Or it contains zero
|
|
* of course. We are done.
|
|
*/
|
|
*exponent = twopwr;
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
* ---------------------------------------------------------------------------
|
|
* operations of specific bits
|
|
* ---------------------------------------------------------------------------
|
|
*/
|
|
|
|
/* Set a bit, using *bigendian* bit numbering (0 = MSB) */
|
|
static void set_bit(fp_limb *mant, int bit)
|
|
{
|
|
mant[bit/LIMB_BITS] |= LIMB_TOP_BIT >> (bit & (LIMB_BITS-1));
|
|
}
|
|
|
|
/* Test a single bit */
|
|
static int test_bit(const fp_limb *mant, int bit)
|
|
{
|
|
return (mant[bit/LIMB_BITS] >> (~bit & (LIMB_BITS-1))) & 1;
|
|
}
|
|
|
|
/* Report if the mantissa value is all zero */
|
|
static bool is_zero(const fp_limb *mant)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < MANT_LIMBS; i++)
|
|
if (mant[i])
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
* ---------------------------------------------------------------------------
|
|
* round a mantissa off after i words
|
|
* ---------------------------------------------------------------------------
|
|
*/
|
|
|
|
#define ROUND_COLLECT_BITS \
|
|
do { \
|
|
m = mant[i] & (2*bit-1); \
|
|
for (j = i+1; j < MANT_LIMBS; j++) \
|
|
m = m | mant[j]; \
|
|
} while (0)
|
|
|
|
#define ROUND_ABS_DOWN \
|
|
do { \
|
|
mant[i] &= ~(bit-1); \
|
|
for (j = i+1; j < MANT_LIMBS; j++) \
|
|
mant[j] = 0; \
|
|
return false; \
|
|
} while (0)
|
|
|
|
#define ROUND_ABS_UP \
|
|
do { \
|
|
mant[i] = (mant[i] & ~(bit-1)) + bit; \
|
|
for (j = i+1; j < MANT_LIMBS; j++) \
|
|
mant[j] = 0; \
|
|
while (i > 0 && !mant[i]) \
|
|
++mant[--i]; \
|
|
return !mant[0]; \
|
|
} while (0)
|
|
|
|
static bool ieee_round(bool minus, fp_limb *mant, int bits)
|
|
{
|
|
fp_limb m = 0;
|
|
int32_t j;
|
|
int i = bits / LIMB_BITS;
|
|
int p = bits % LIMB_BITS;
|
|
fp_limb bit = LIMB_TOP_BIT >> p;
|
|
|
|
if (rc == FLOAT_RC_NEAR) {
|
|
if (mant[i] & bit) {
|
|
mant[i] &= ~bit;
|
|
ROUND_COLLECT_BITS;
|
|
mant[i] |= bit;
|
|
if (m) {
|
|
ROUND_ABS_UP;
|
|
} else {
|
|
if (test_bit(mant, bits-1)) {
|
|
ROUND_ABS_UP;
|
|
} else {
|
|
ROUND_ABS_DOWN;
|
|
}
|
|
}
|
|
} else {
|
|
ROUND_ABS_DOWN;
|
|
}
|
|
} else if (rc == FLOAT_RC_ZERO ||
|
|
rc == (minus ? FLOAT_RC_UP : FLOAT_RC_DOWN)) {
|
|
ROUND_ABS_DOWN;
|
|
} else {
|
|
/* rc == (minus ? FLOAT_RC_DOWN : FLOAT_RC_UP) */
|
|
/* Round toward +/- infinity */
|
|
ROUND_COLLECT_BITS;
|
|
if (m) {
|
|
ROUND_ABS_UP;
|
|
} else {
|
|
ROUND_ABS_DOWN;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/* Returns a value >= 16 if not a valid hex digit */
|
|
static unsigned int hexval(char c)
|
|
{
|
|
unsigned int v = (unsigned char) c;
|
|
|
|
if (v >= '0' && v <= '9')
|
|
return v - '0';
|
|
else
|
|
return (v|0x20) - 'a' + 10;
|
|
}
|
|
|
|
/* Handle floating-point numbers with radix 2^bits and binary exponent */
|
|
static bool ieee_flconvert_bin(const char *string, int bits,
|
|
fp_limb *mant, int32_t *exponent)
|
|
{
|
|
static const int log2tbl[16] =
|
|
{ -1, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3 };
|
|
fp_limb mult[MANT_LIMBS + 1], *mp;
|
|
int ms;
|
|
int32_t twopwr;
|
|
bool seendot, seendigit;
|
|
unsigned char c;
|
|
const int radix = 1 << bits;
|
|
fp_limb v;
|
|
|
|
twopwr = 0;
|
|
seendot = seendigit = false;
|
|
ms = 0;
|
|
mp = NULL;
|
|
|
|
memset(mult, 0, sizeof mult);
|
|
|
|
while ((c = *string++) != '\0') {
|
|
if (c == '.') {
|
|
if (!seendot)
|
|
seendot = true;
|
|
else {
|
|
nasm_error(ERR_NONFATAL,
|
|
"too many periods in floating-point constant");
|
|
return false;
|
|
}
|
|
} else if ((v = hexval(c)) < (unsigned int)radix) {
|
|
if (!seendigit && v) {
|
|
int l = log2tbl[v];
|
|
|
|
seendigit = true;
|
|
mp = mult;
|
|
ms = (LIMB_BITS-1)-l;
|
|
|
|
twopwr += l+1-bits;
|
|
}
|
|
|
|
if (seendigit) {
|
|
if (ms <= 0) {
|
|
*mp |= v >> -ms;
|
|
mp++;
|
|
if (mp > &mult[MANT_LIMBS])
|
|
mp = &mult[MANT_LIMBS]; /* Guard slot */
|
|
ms += LIMB_BITS;
|
|
}
|
|
*mp |= v << (ms % (sizeof(fp_limb) * CHAR_BIT));
|
|
ms -= bits;
|
|
|
|
if (!seendot)
|
|
twopwr += bits;
|
|
} else {
|
|
if (seendot)
|
|
twopwr -= bits;
|
|
}
|
|
} else if (c == 'p' || c == 'P') {
|
|
int32_t e;
|
|
e = read_exponent(string, 20000);
|
|
if (e == INT32_MAX)
|
|
return false;
|
|
twopwr += e;
|
|
break;
|
|
} else if (c == '_') {
|
|
/* ignore */
|
|
} else {
|
|
nasm_error(ERR_NONFATAL,
|
|
"floating-point constant: `%c' is invalid character", c);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (!seendigit) {
|
|
memset(mant, 0, MANT_LIMBS*sizeof(fp_limb)); /* Zero */
|
|
*exponent = 0;
|
|
} else {
|
|
memcpy(mant, mult, MANT_LIMBS*sizeof(fp_limb));
|
|
*exponent = twopwr;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
* Shift a mantissa to the right by i bits.
|
|
*/
|
|
static void ieee_shr(fp_limb *mant, int i)
|
|
{
|
|
fp_limb n, m;
|
|
int j = 0;
|
|
int sr, sl, offs;
|
|
|
|
sr = i % LIMB_BITS; sl = LIMB_BITS-sr;
|
|
offs = i/LIMB_BITS;
|
|
|
|
if (sr == 0) {
|
|
if (offs)
|
|
for (j = MANT_LIMBS-1; j >= offs; j--)
|
|
mant[j] = mant[j-offs];
|
|
} else if (MANT_LIMBS-1-offs < 0) {
|
|
j = MANT_LIMBS-1;
|
|
} else {
|
|
n = mant[MANT_LIMBS-1-offs] >> sr;
|
|
for (j = MANT_LIMBS-1; j > offs; j--) {
|
|
m = mant[j-offs-1];
|
|
mant[j] = (m << sl) | n;
|
|
n = m >> sr;
|
|
}
|
|
mant[j--] = n;
|
|
}
|
|
while (j >= 0)
|
|
mant[j--] = 0;
|
|
}
|
|
|
|
/* Produce standard IEEE formats, with implicit or explicit integer
|
|
bit; this makes the following assumptions:
|
|
|
|
- the sign bit is the MSB, followed by the exponent,
|
|
followed by the integer bit if present.
|
|
- the sign bit plus exponent fit in 16 bits.
|
|
- the exponent bias is 2^(n-1)-1 for an n-bit exponent */
|
|
|
|
struct ieee_format {
|
|
int bytes;
|
|
int mantissa; /* Fractional bits in the mantissa */
|
|
int explicit; /* Explicit integer */
|
|
int exponent; /* Bits in the exponent */
|
|
};
|
|
|
|
/*
|
|
* The 16- and 128-bit formats are expected to be in IEEE 754r.
|
|
* AMD SSE5 uses the 16-bit format.
|
|
*
|
|
* The 32- and 64-bit formats are the original IEEE 754 formats.
|
|
*
|
|
* The 80-bit format is x87-specific, but widely used.
|
|
*
|
|
* The 8-bit format appears to be the consensus 8-bit floating-point
|
|
* format. It is apparently used in graphics applications.
|
|
*/
|
|
static const struct ieee_format ieee_8 = { 1, 3, 0, 4 };
|
|
static const struct ieee_format ieee_16 = { 2, 10, 0, 5 };
|
|
static const struct ieee_format ieee_32 = { 4, 23, 0, 8 };
|
|
static const struct ieee_format ieee_64 = { 8, 52, 0, 11 };
|
|
static const struct ieee_format ieee_80 = { 10, 63, 1, 15 };
|
|
static const struct ieee_format ieee_128 = { 16, 112, 0, 15 };
|
|
|
|
/* Types of values we can generate */
|
|
enum floats {
|
|
FL_ZERO,
|
|
FL_DENORMAL,
|
|
FL_NORMAL,
|
|
FL_INFINITY,
|
|
FL_QNAN,
|
|
FL_SNAN
|
|
};
|
|
|
|
static int to_packed_bcd(const char *str, const char *p,
|
|
int s, uint8_t *result,
|
|
const struct ieee_format *fmt)
|
|
{
|
|
int n = 0;
|
|
char c;
|
|
int tv = -1;
|
|
|
|
if (fmt != &ieee_80) {
|
|
nasm_error(ERR_NONFATAL,
|
|
"packed BCD requires an 80-bit format");
|
|
return 0;
|
|
}
|
|
|
|
while (p >= str) {
|
|
c = *p--;
|
|
if (c >= '0' && c <= '9') {
|
|
if (tv < 0) {
|
|
if (n == 9) {
|
|
nasm_error(ERR_WARNING|ERR_PASS2,
|
|
"packed BCD truncated to 18 digits");
|
|
}
|
|
tv = c-'0';
|
|
} else {
|
|
if (n < 9)
|
|
*result++ = tv + ((c-'0') << 4);
|
|
n++;
|
|
tv = -1;
|
|
}
|
|
} else if (c == '_') {
|
|
/* do nothing */
|
|
} else {
|
|
nasm_error(ERR_NONFATAL,
|
|
"invalid character `%c' in packed BCD constant", c);
|
|
return 0;
|
|
}
|
|
}
|
|
if (tv >= 0) {
|
|
if (n < 9)
|
|
*result++ = tv;
|
|
n++;
|
|
}
|
|
while (n < 9) {
|
|
*result++ = 0;
|
|
n++;
|
|
}
|
|
*result = (s < 0) ? 0x80 : 0;
|
|
|
|
return 1; /* success */
|
|
}
|
|
|
|
static int to_float(const char *str, int s, uint8_t *result,
|
|
const struct ieee_format *fmt)
|
|
{
|
|
fp_limb mant[MANT_LIMBS];
|
|
int32_t exponent = 0;
|
|
const int32_t expmax = 1 << (fmt->exponent - 1);
|
|
fp_limb one_mask = LIMB_TOP_BIT >>
|
|
((fmt->exponent+fmt->explicit) % LIMB_BITS);
|
|
const int one_pos = (fmt->exponent+fmt->explicit)/LIMB_BITS;
|
|
int i;
|
|
int shift;
|
|
enum floats type;
|
|
bool ok;
|
|
const bool minus = s < 0;
|
|
const int bits = fmt->bytes * 8;
|
|
const char *strend;
|
|
|
|
nasm_assert(str[0]);
|
|
|
|
strend = strchr(str, '\0');
|
|
if (strend[-1] == 'P' || strend[-1] == 'p')
|
|
return to_packed_bcd(str, strend-2, s, result, fmt);
|
|
|
|
if (str[0] == '_') {
|
|
/* Special tokens */
|
|
|
|
switch (str[2]) {
|
|
case 'n': /* __nan__ */
|
|
case 'N':
|
|
case 'q': /* __qnan__ */
|
|
case 'Q':
|
|
type = FL_QNAN;
|
|
break;
|
|
case 's': /* __snan__ */
|
|
case 'S':
|
|
type = FL_SNAN;
|
|
break;
|
|
case 'i': /* __infinity__ */
|
|
case 'I':
|
|
type = FL_INFINITY;
|
|
break;
|
|
default:
|
|
nasm_error(ERR_NONFATAL,
|
|
"internal error: unknown FP constant token `%s'\n", str);
|
|
type = FL_QNAN;
|
|
break;
|
|
}
|
|
} else {
|
|
if (str[0] == '0') {
|
|
switch (str[1]) {
|
|
case 'x': case 'X':
|
|
case 'h': case 'H':
|
|
ok = ieee_flconvert_bin(str+2, 4, mant, &exponent);
|
|
break;
|
|
case 'o': case 'O':
|
|
case 'q': case 'Q':
|
|
ok = ieee_flconvert_bin(str+2, 3, mant, &exponent);
|
|
break;
|
|
case 'b': case 'B':
|
|
case 'y': case 'Y':
|
|
ok = ieee_flconvert_bin(str+2, 1, mant, &exponent);
|
|
break;
|
|
case 'd': case 'D':
|
|
case 't': case 'T':
|
|
ok = ieee_flconvert(str+2, mant, &exponent);
|
|
break;
|
|
case 'p': case 'P':
|
|
return to_packed_bcd(str+2, strend-1, s, result, fmt);
|
|
default:
|
|
/* Leading zero was just a zero? */
|
|
ok = ieee_flconvert(str, mant, &exponent);
|
|
break;
|
|
}
|
|
} else if (str[0] == '$') {
|
|
ok = ieee_flconvert_bin(str+1, 4, mant, &exponent);
|
|
} else {
|
|
ok = ieee_flconvert(str, mant, &exponent);
|
|
}
|
|
|
|
if (!ok) {
|
|
type = FL_QNAN;
|
|
} else if (mant[0] & LIMB_TOP_BIT) {
|
|
/*
|
|
* Non-zero.
|
|
*/
|
|
exponent--;
|
|
if (exponent >= 2 - expmax && exponent <= expmax) {
|
|
type = FL_NORMAL;
|
|
} else if (exponent > 0) {
|
|
if (pass0 == 1)
|
|
nasm_error(ERR_WARNING|ERR_WARN_FL_OVERFLOW|ERR_PASS2,
|
|
"overflow in floating-point constant");
|
|
type = FL_INFINITY;
|
|
} else {
|
|
/* underflow or denormal; the denormal code handles
|
|
actual underflow. */
|
|
type = FL_DENORMAL;
|
|
}
|
|
} else {
|
|
/* Zero */
|
|
type = FL_ZERO;
|
|
}
|
|
}
|
|
|
|
switch (type) {
|
|
case FL_ZERO:
|
|
zero:
|
|
memset(mant, 0, sizeof mant);
|
|
break;
|
|
|
|
case FL_DENORMAL:
|
|
{
|
|
shift = -(exponent + expmax - 2 - fmt->exponent)
|
|
+ fmt->explicit;
|
|
ieee_shr(mant, shift);
|
|
ieee_round(minus, mant, bits);
|
|
if (mant[one_pos] & one_mask) {
|
|
/* One's position is set, we rounded up into normal range */
|
|
exponent = 1;
|
|
if (!fmt->explicit)
|
|
mant[one_pos] &= ~one_mask; /* remove explicit one */
|
|
mant[0] |= exponent << (LIMB_BITS-1 - fmt->exponent);
|
|
} else {
|
|
if (daz || is_zero(mant)) {
|
|
/* Flush denormals to zero */
|
|
nasm_error(ERR_WARNING|ERR_WARN_FL_UNDERFLOW|ERR_PASS2,
|
|
"underflow in floating-point constant");
|
|
goto zero;
|
|
} else {
|
|
nasm_error(ERR_WARNING|ERR_WARN_FL_DENORM|ERR_PASS2,
|
|
"denormal floating-point constant");
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
case FL_NORMAL:
|
|
exponent += expmax - 1;
|
|
ieee_shr(mant, fmt->exponent+fmt->explicit);
|
|
ieee_round(minus, mant, bits);
|
|
/* did we scale up by one? */
|
|
if (test_bit(mant, fmt->exponent+fmt->explicit-1)) {
|
|
ieee_shr(mant, 1);
|
|
exponent++;
|
|
if (exponent >= (expmax << 1)-1) {
|
|
nasm_error(ERR_WARNING|ERR_WARN_FL_OVERFLOW|ERR_PASS2,
|
|
"overflow in floating-point constant");
|
|
type = FL_INFINITY;
|
|
goto overflow;
|
|
}
|
|
}
|
|
|
|
if (!fmt->explicit)
|
|
mant[one_pos] &= ~one_mask; /* remove explicit one */
|
|
mant[0] |= exponent << (LIMB_BITS-1 - fmt->exponent);
|
|
break;
|
|
|
|
case FL_INFINITY:
|
|
case FL_QNAN:
|
|
case FL_SNAN:
|
|
overflow:
|
|
memset(mant, 0, sizeof mant);
|
|
mant[0] = (((fp_limb)1 << fmt->exponent)-1)
|
|
<< (LIMB_BITS-1 - fmt->exponent);
|
|
if (fmt->explicit)
|
|
mant[one_pos] |= one_mask;
|
|
if (type == FL_QNAN)
|
|
set_bit(mant, fmt->exponent+fmt->explicit+1);
|
|
else if (type == FL_SNAN)
|
|
set_bit(mant, fmt->exponent+fmt->explicit+fmt->mantissa);
|
|
break;
|
|
}
|
|
|
|
mant[0] |= minus ? LIMB_TOP_BIT : 0;
|
|
|
|
for (i = fmt->bytes - 1; i >= 0; i--)
|
|
*result++ = mant[i/LIMB_BYTES] >> (((LIMB_BYTES-1)-(i%LIMB_BYTES))*8);
|
|
|
|
return 1; /* success */
|
|
}
|
|
|
|
int float_const(const char *number, int sign, uint8_t *result, int bytes)
|
|
{
|
|
switch (bytes) {
|
|
case 1:
|
|
return to_float(number, sign, result, &ieee_8);
|
|
case 2:
|
|
return to_float(number, sign, result, &ieee_16);
|
|
case 4:
|
|
return to_float(number, sign, result, &ieee_32);
|
|
case 8:
|
|
return to_float(number, sign, result, &ieee_64);
|
|
case 10:
|
|
return to_float(number, sign, result, &ieee_80);
|
|
case 16:
|
|
return to_float(number, sign, result, &ieee_128);
|
|
default:
|
|
nasm_panic("strange value %d passed to float_const", bytes);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/* Set floating-point options */
|
|
int float_option(const char *option)
|
|
{
|
|
if (!nasm_stricmp(option, "daz")) {
|
|
daz = true;
|
|
return 0;
|
|
} else if (!nasm_stricmp(option, "nodaz")) {
|
|
daz = false;
|
|
return 0;
|
|
} else if (!nasm_stricmp(option, "near")) {
|
|
rc = FLOAT_RC_NEAR;
|
|
return 0;
|
|
} else if (!nasm_stricmp(option, "down")) {
|
|
rc = FLOAT_RC_DOWN;
|
|
return 0;
|
|
} else if (!nasm_stricmp(option, "up")) {
|
|
rc = FLOAT_RC_UP;
|
|
return 0;
|
|
} else if (!nasm_stricmp(option, "zero")) {
|
|
rc = FLOAT_RC_ZERO;
|
|
return 0;
|
|
} else if (!nasm_stricmp(option, "default")) {
|
|
rc = FLOAT_RC_NEAR;
|
|
daz = false;
|
|
return 0;
|
|
} else {
|
|
return -1; /* Unknown option */
|
|
}
|
|
}
|