float.c

/* float.c     floating-point constant support for the Netwide Assembler
 *
 * The Netwide Assembler is copyright (C) 1996 Simon Tatham and
 * Julian Hall. All rights reserved. The software is
 * redistributable under the licence given in the file "Licence"
 * distributed in the NASM archive.
 *
 * initial version 13/ix/96 by Simon Tatham
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <inttypes.h>

#include "nasm.h"

#define TRUE 1
#define FALSE 0

#define MANT_WORDS 6            /* 64 bits + 32 for accuracy == 96 */
#define MANT_DIGITS 28          /* 29 digits don't fit in 96 bits */

/*
 * guaranteed top bit of from is set
 * => we only have to worry about _one_ bit shift to the left
 */

static int ieee_multiply(uint16_t *to, uint16_t *from)
{
    uint32_t temp[MANT_WORDS * 2];
    int i, j;

    for (i = 0; i < MANT_WORDS * 2; i++)
        temp[i] = 0;

    for (i = 0; i < MANT_WORDS; i++)
        for (j = 0; j < MANT_WORDS; j++) {
            uint32_t n;
            n = (uint32_t)to[i] * (uint32_t)from[j];
            temp[i + j] += n >> 16;
            temp[i + j + 1] += n & 0xFFFF;
        }

    for (i = MANT_WORDS * 2; --i;) {
        temp[i - 1] += temp[i] >> 16;
        temp[i] &= 0xFFFF;
    }
    if (temp[0] & 0x8000) {
        for (i = 0; i < MANT_WORDS; i++)
            to[i] = temp[i] & 0xFFFF;
        return 0;
    } else {
        for (i = 0; i < MANT_WORDS; i++)
            to[i] = (temp[i] << 1) + !!(temp[i + 1] & 0x8000);
        return -1;
    }
}

static void ieee_flconvert(char *string, uint16_t *mant,
                           int32_t *exponent, efunc error)
{
    char digits[MANT_DIGITS];
    char *p, *q, *r;
    uint16_t mult[MANT_WORDS], bit;
    uint16_t *m;
    int32_t tenpwr, twopwr;
    int extratwos, started, seendot;

    p = digits;
    tenpwr = 0;
    started = seendot = FALSE;
    while (*string && *string != 'E' && *string != 'e') {
        if (*string == '.') {
            if (!seendot)
                seendot = TRUE;
            else {
                error(ERR_NONFATAL,
                      "too many periods in floating-point constant");
                return;
            }
        } else if (*string >= '0' && *string <= '9') {
            if (*string == '0' && !started) {
                if (seendot)
                    tenpwr--;
            } else {
                started = TRUE;
                if (p < digits + sizeof(digits))
                    *p++ = *string - '0';
                if (!seendot)
                    tenpwr++;
            }
        } else {
            error(ERR_NONFATAL,
                  "floating-point constant: `%c' is invalid character",
                  *string);
            return;
        }
        string++;
    }
    if (*string) {
        string++;               /* eat the E */
        tenpwr += atoi(string);
    }

    /*
     * 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
     */

    bit = 0x8000;
    for (m = mant; m < mant + MANT_WORDS; m++)
        *m = 0;
    m = mant;
    q = digits;
    started = FALSE;
    twopwr = 0;
    while (m < mant + MANT_WORDS) {
        uint16_t carry = 0;
        while (p > q && !p[-1])
            p--;
        if (p <= q)
            break;
        for (r = p; r-- > q;) {
            int 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 = 0x8000, m++;
            else
                bit >>= 1;
        } else
            twopwr--;
    }
    twopwr += tenpwr;

    /*
     * At this point the `mant' array contains the first six
     * fractional places of a base-2^16 real number, which when
     * multiplied by 2^twopwr and 5^tenpwr gives X. So now we
     * really do multiply by 5^tenpwr.
     */

    if (tenpwr < 0) {
        for (m = mult; m < mult + MANT_WORDS; m++)
            *m = 0xCCCC;
        extratwos = -2;
        tenpwr = -tenpwr;
    } else if (tenpwr > 0) {
        mult[0] = 0xA000;
        for (m = mult + 1; m < mult + MANT_WORDS; m++)
            *m = 0;
        extratwos = 3;
    } else
        extratwos = 0;
    while (tenpwr) {
        if (tenpwr & 1)
            twopwr += extratwos + ieee_multiply(mant, mult);
        extratwos = extratwos * 2 + ieee_multiply(mult, mult);
        tenpwr >>= 1;
    }

    /*
     * Conversion is done. The elements of `mant' contain the first
     * fractional places of a base-2^16 real number in [0.5,1)
     * which we can multiply by 2^twopwr to get X. Or, of course,
     * it contains zero.
     */
    *exponent = twopwr;
}

/*
 * Shift a mantissa to the right by i (i < 16) bits.
 */
static void ieee_shr(uint16_t *mant, int i)
{
    uint16_t n = 0, m;
    int j;

    for (j = 0; j < MANT_WORDS; j++) {
        m = (mant[j] << (16 - i)) & 0xFFFF;
        mant[j] = (mant[j] >> i) | n;
        n = m;
    }
}

/*
 * Round a mantissa off after i words.
 */
static int ieee_round(uint16_t *mant, int i)
{
    if (mant[i] & 0x8000) {
        do {
            ++mant[--i];
            mant[i] &= 0xFFFF;
        } while (i > 0 && !mant[i]);
        return !i && !mant[i];
    }
    return 0;
}

#define put(a,b) ( (*(a)=(b)), ((a)[1]=(b)>>8) )

/* 64-bit format with 52-bit mantissa and 11-bit exponent */
static int to_double(char *str, int32_t sign, uint8_t *result,
                     efunc error)
{
    uint16_t mant[MANT_WORDS];
    int32_t exponent;

    sign = (sign < 0 ? 0x8000L : 0L);

    ieee_flconvert(str, mant, &exponent, error);
    if (mant[0] & 0x8000) {
        /*
         * Non-zero.
         */
        exponent--;
        if (exponent >= -1022 && exponent <= 1024) {
            /*
             * Normalised.
             */
            exponent += 1023;
            ieee_shr(mant, 11);
            ieee_round(mant, 4);
            if (mant[0] & 0x20) /* did we scale up by one? */
                ieee_shr(mant, 1), exponent++;
            mant[0] &= 0xF;     /* remove leading one */
            put(result + 6, (exponent << 4) | mant[0] | sign);
            put(result + 4, mant[1]);
            put(result + 2, mant[2]);
            put(result + 0, mant[3]);
        } else if (exponent < -1022 && exponent >= -1074) {
            /*
             * Denormal.
             */
            int shift = -(exponent + 1011);
            int sh = shift % 16, wds = shift / 16;
            ieee_shr(mant, sh);
            if (ieee_round(mant, 4 - wds)
                || (sh > 0 && (mant[0] & (0x8000 >> (sh - 1))))) {
                ieee_shr(mant, 1);
                if (sh == 0)
                    mant[0] |= 0x8000;
                exponent++;
            }
            put(result + 6, (wds == 0 ? mant[0] : 0) | sign);
            put(result + 4, (wds <= 1 ? mant[1 - wds] : 0));
            put(result + 2, (wds <= 2 ? mant[2 - wds] : 0));
            put(result + 0, (wds <= 3 ? mant[3 - wds] : 0));
        } else {
            if (exponent > 0) {
                error(ERR_NONFATAL, "overflow in floating-point constant");
                return 0;
            } else
                memset(result, 0, 8);
        }
    } else {
        /*
         * Zero.
         */
        memset(result, 0, 8);
    }
    return 1;                   /* success */
}

/* 32-bit format with 23-bit mantissa and 8-bit exponent */
static int to_float(char *str, int32_t sign, uint8_t *result,
                    efunc error)
{
    uint16_t mant[MANT_WORDS];
    int32_t exponent;

    sign = (sign < 0 ? 0x8000L : 0L);

    ieee_flconvert(str, mant, &exponent, error);
    if (mant[0] & 0x8000) {
        /*
         * Non-zero.
         */
        exponent--;
        if (exponent >= -126 && exponent <= 128) {
            /*
             * Normalised.
             */
            exponent += 127;
            ieee_shr(mant, 8);
            ieee_round(mant, 2);
            if (mant[0] & 0x100)        /* did we scale up by one? */
                ieee_shr(mant, 1), exponent++;
            mant[0] &= 0x7F;    /* remove leading one */
            put(result + 2, (exponent << 7) | mant[0] | sign);
            put(result + 0, mant[1]);
        } else if (exponent < -126 && exponent >= -149) {
            /*
             * Denormal.
             */
            int shift = -(exponent + 118);
            int sh = shift % 16, wds = shift / 16;
            ieee_shr(mant, sh);
            if (ieee_round(mant, 2 - wds)
                || (sh > 0 && (mant[0] & (0x8000 >> (sh - 1))))) {
                ieee_shr(mant, 1);
                if (sh == 0)
                    mant[0] |= 0x8000;
                exponent++;
            }
            put(result + 2, (wds == 0 ? mant[0] : 0) | sign);
            put(result + 0, (wds <= 1 ? mant[1 - wds] : 0));
        } else {
            if (exponent > 0) {
                error(ERR_NONFATAL, "overflow in floating-point constant");
                return 0;
            } else
                memset(result, 0, 4);
        }
    } else {
        memset(result, 0, 4);
    }
    return 1;
}

/* 16-bit format with 10-bit mantissa and 5-bit exponent.
   Defined in IEEE 754r.  Used in SSE5.  See the AMD SSE5 manual, AMD
   document number 43479. */
static int to_float16(char *str, int32_t sign, uint8_t *result,
		      efunc error)
{
    uint16_t mant[MANT_WORDS];
    int32_t exponent;

    sign = (sign < 0 ? 0x8000L : 0L);

    ieee_flconvert(str, mant, &exponent, error);
    if (mant[0] & 0x8000) {
        /*
         * Non-zero.
         */
        exponent--;
        if (exponent >= -14 && exponent <= 16) {
            /*
             * Normalised.
             */
            exponent += 15;
            ieee_shr(mant, 5);
            ieee_round(mant, 1);
            if (mant[0] & 0x800)        /* did we scale up by one? */
                ieee_shr(mant, 1), exponent++;
            mant[0] &= 0x3FF;    /* remove leading one */
            put(result + 0, (exponent << 7) | mant[0] | sign);
        } else if (exponent < -14 && exponent >= -24) {
            /*
             * Denormal.
             */
            int shift = -(exponent + 8);
            int sh = shift % 16, wds = shift / 16;
            ieee_shr(mant, sh);
            if (ieee_round(mant, 1 - wds)
                || (sh > 0 && (mant[0] & (0x8000 >> (sh - 1))))) {
                ieee_shr(mant, 1);
                if (sh == 0)
                    mant[0] |= 0x8000;
                exponent++;
            }
            put(result + 0, (wds == 0 ? mant[0] : 0) | sign);
        } else {
            if (exponent > 0) {
                error(ERR_NONFATAL, "overflow in floating-point constant");
                return 0;
            } else
                memset(result, 0, 2);
        }
    } else {
        memset(result, 0, 2);
    }
    return 1;
}

/* 80-bit format with 64-bit mantissa *including an explicit integer 1*
   and 15-bit exponent. */
static int to_ldoub(char *str, int32_t sign, uint8_t *result,
                    efunc error)
{
    uint16_t mant[MANT_WORDS];
    int32_t exponent;

    sign = (sign < 0 ? 0x8000L : 0L);

    ieee_flconvert(str, mant, &exponent, error);
    if (mant[0] & 0x8000) {
        /*
         * Non-zero.
         */
        exponent--;
        if (exponent >= -16383 && exponent <= 16384) {
            /*
             * Normalised.
             */
            exponent += 16383;
            if (ieee_round(mant, 4))    /* did we scale up by one? */
                ieee_shr(mant, 1), mant[0] |= 0x8000, exponent++;
            put(result + 8, exponent | sign);
            put(result + 6, mant[0]);
            put(result + 4, mant[1]);
            put(result + 2, mant[2]);
            put(result + 0, mant[3]);
        } else if (exponent < -16383 && exponent >= -16446) {
            /*
             * Denormal.
             */
            int shift = -(exponent + 16383);
            int sh = shift % 16, wds = shift / 16;
            ieee_shr(mant, sh);
            if (ieee_round(mant, 4 - wds)
                || (sh > 0 && (mant[0] & (0x8000 >> (sh - 1))))) {
                ieee_shr(mant, 1);
                if (sh == 0)
                    mant[0] |= 0x8000;
                exponent++;
            }
            put(result + 8, sign);
            put(result + 6, (wds == 0 ? mant[0] : 0));
            put(result + 4, (wds <= 1 ? mant[1 - wds] : 0));
            put(result + 2, (wds <= 2 ? mant[2 - wds] : 0));
            put(result + 0, (wds <= 3 ? mant[3 - wds] : 0));
        } else {
            if (exponent > 0) {
                error(ERR_NONFATAL, "overflow in floating-point constant");
                return 0;
            } else
                memset(result, 0, 10);
        }
    } else {
        /*
         * Zero.
         */
        memset(result, 0, 10);
    }
    return 1;
}

int float_const(char *number, int32_t sign, uint8_t *result, int bytes,
                efunc error)
{
    switch (bytes) {
    case 2:
	return to_float16(number, sign, result, error);
    case 4:
        return to_float(number, sign, result, error);
    case 8:
        return to_double(number, sign, result, error);
    case 10:
        return to_ldoub(number, sign, result, error);
    default:
        error(ERR_PANIC, "strange value %d passed to float_const", bytes);
        return 0;
    }
}