asm/float.c

   1 /* ----------------------------------------------------------------------- *
   2  *
   3  *   Copyright 1996-2017 The NASM Authors - All Rights Reserved
   4  *   See the file AUTHORS included with the NASM distribution for
   5  *   the specific copyright holders.
   6  *
   7  *   Redistribution and use in source and binary forms, with or without
   8  *   modification, are permitted provided that the following
   9  *   conditions are met:
  10  *
  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.
  17  *
  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.
  31  *
  32  * ----------------------------------------------------------------------- */
  33
  34 /*
  35  * float.c     floating-point constant support for the Netwide Assembler
  36  */
  37
  38 #include "compiler.h"
  39
  40 #include <ctype.h>
  41 #include <stdio.h>
  42 #include <stdlib.h>
  43 #include <string.h>
  44
  45 #include "nasm.h"
  46 #include "float.h"
  47 #include "error.h"
  48
  49 /*
  50  * -----------------
  51  *  local variables
  52  * -----------------
  53  */
  54 static bool daz = false;        /* denormals as zero */
  55 static enum float_round rc = FLOAT_RC_NEAR;     /* rounding control */
  56
  57 /*
  58  * -----------
  59  *  constants
  60  * -----------
  61  */
  62
  63 /* "A limb is like a digit but bigger */
  64 typedef uint32_t fp_limb;
  65 typedef uint64_t fp_2limb;
  66
  67 #define LIMB_BITS       32
  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)
  73
  74 /* 112 bits + 64 bits for accuracy + 16 bits for rounding */
  75 #define MANT_LIMBS 6
  76
  77 /* 52 digits fit in 176 bits because 10^53 > 2^176 > 10^52 */
  78 #define MANT_DIGITS 52
  79
  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)
  83
  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]
  86
  87 /*
  88  * ---------------------------------------------------------------------------
  89  *  emit a printf()-like debug message... but only if DEBUG_FLOAT was defined
  90  * ---------------------------------------------------------------------------
  91  */
  92
  93 #ifdef DEBUG_FLOAT
  94 #define dprintf(x) printf x
  95 #else
  96 #define dprintf(x) do { } while (0)
  97 #endif
  98
  99 /*
 100  * ---------------------------------------------------------------------------
 101  *  multiply
 102  * ---------------------------------------------------------------------------
 103  */
 104 static int float_multiply(fp_limb *to, fp_limb *from)
 105 {
 106     fp_2limb temp[MANT_LIMBS * 2];
 107     int i, j;
 108
 109     /*
 110      * guaranteed that top bit of 'from' is set -- so we only have
 111      * to worry about _one_ bit shift to the left
 112      */
 113     dprintf(("%s=" MANT_FMT "\n", "mul1", SOME_ARG(to, 0)));
 114     dprintf(("%s=" MANT_FMT "\n", "mul2", SOME_ARG(from, 0)));
 115
 116     memset(temp, 0, sizeof temp);
 117
 118     for (i = 0; i < MANT_LIMBS; i++) {
 119         for (j = 0; j < MANT_LIMBS; j++) {
 120             fp_2limb n;
 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;
 124         }
 125     }
 126
 127     for (i = MANT_LIMBS * 2; --i;) {
 128         temp[i - 1] += temp[i] >> LIMB_BITS;
 129         temp[i] &= LIMB_MASK;
 130     }
 131
 132     dprintf(("%s=" MANT_FMT "_" MANT_FMT "\n", "temp", SOME_ARG(temp, 0),
 133              SOME_ARG(temp, MANT_LIMBS)));
 134
 135     if (temp[0] & LIMB_TOP_BIT) {
 136         for (i = 0; i < MANT_LIMBS; i++) {
 137             to[i] = temp[i] & LIMB_MASK;
 138         }
 139         dprintf(("%s=" MANT_FMT " (%i)\n", "prod", SOME_ARG(to, 0), 0));
 140         return 0;
 141     } else {
 142         for (i = 0; i < MANT_LIMBS; i++) {
 143             to[i] = (temp[i] << 1) + !!(temp[i + 1] & LIMB_TOP_BIT);
 144         }
 145         dprintf(("%s=" MANT_FMT " (%i)\n", "prod", SOME_ARG(to, 0), -1));
 146         return -1;
 147     }
 148 }
 149
 150 /*
 151  * ---------------------------------------------------------------------------
 152  *  read an exponent; returns INT32_MAX on error
 153  * ---------------------------------------------------------------------------
 154  */
 155 static int32_t read_exponent(const char *string, int32_t max)
 156 {
 157     int32_t i = 0;
 158     bool neg = false;
 159
 160     if (*string == '+') {
 161         string++;
 162     } else if (*string == '-') {
 163         neg = true;
 164         string++;
 165     }
 166     while (*string) {
 167         if (*string >= '0' && *string <= '9') {
 168             i = (i * 10) + (*string - '0');
 169
 170             /*
 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.
 179              */
 180             if (i > max)
 181                 i = max;
 182         } else if (*string == '_') {
 183             /* do nothing */
 184         } else {
 185             nasm_error(ERR_NONFATAL,
 186                   "invalid character in floating-point constant %s: '%c'",
 187                   "exponent", *string);
 188             return INT32_MAX;
 189         }
 190         string++;
 191     }
 192
 193     return neg ? -i : i;
 194 }
 195
 196 /*
 197  * ---------------------------------------------------------------------------
 198  *  convert
 199  * ---------------------------------------------------------------------------
 200  */
 201 static bool ieee_flconvert(const char *string, fp_limb *mant,
 202                            int32_t * exponent)
 203 {
 204     char digits[MANT_DIGITS];
 205     char *p, *q, *r;
 206     fp_limb mult[MANT_LIMBS], bit;
 207     fp_limb *m;
 208     int32_t tenpwr, twopwr;
 209     int32_t extratwos;
 210     bool started, seendot, warned;
 211
 212     warned = false;
 213     p = digits;
 214     tenpwr = 0;
 215     started = seendot = false;
 216
 217     while (*string && *string != 'E' && *string != 'e') {
 218         if (*string == '.') {
 219             if (!seendot) {
 220                 seendot = true;
 221             } else {
 222                 nasm_error(ERR_NONFATAL,
 223                       "too many periods in floating-point constant");
 224                 return false;
 225             }
 226         } else if (*string >= '0' && *string <= '9') {
 227             if (*string == '0' && !started) {
 228                 if (seendot) {
 229                     tenpwr--;
 230                 }
 231             } else {
 232                 started = true;
 233                 if (p < digits + sizeof(digits)) {
 234                     *p++ = *string - '0';
 235                 } else {
 236                     if (!warned) {
 237                         nasm_error(ERR_WARNING|ERR_WARN_FL_TOOLONG|ERR_PASS2,
 238                               "floating-point constant significand contains "
 239                               "more than %i digits", MANT_DIGITS);
 240                         warned = true;
 241                     }
 242                 }
 243                 if (!seendot) {
 244                     tenpwr++;
 245                 }
 246             }
 247         } else if (*string == '_') {
 248             /* do nothing */
 249         } else {
 250             nasm_error(ERR_NONFATAL|ERR_PASS2,
 251                   "invalid character in floating-point constant %s: '%c'",
 252                   "significand", *string);
 253             return false;
 254         }
 255         string++;
 256     }
 257
 258     if (*string) {
 259         int32_t e;
 260
 261         string++;               /* eat the E */
 262         e = read_exponent(string, 5000);
 263         if (e == INT32_MAX)
 264             return false;
 265         tenpwr += e;
 266     }
 267
 268     /*
 269      * At this point, the memory interval [digits,p) contains a
 270      * series of decimal digits zzzzzzz, such that our number X
 271      * satisfies X = 0.zzzzzzz * 10^tenpwr.
 272      */
 273     q = digits;
 274     dprintf(("X = 0."));
 275     while (q < p) {
 276         dprintf(("%c", *q + '0'));
 277         q++;
 278     }
 279     dprintf((" * 10^%i\n", tenpwr));
 280
 281     /*
 282      * Now convert [digits,p) to our internal representation.
 283      */
 284     bit = LIMB_TOP_BIT;
 285     for (m = mant; m < mant + MANT_LIMBS; m++) {
 286         *m = 0;
 287     }
 288     m = mant;
 289     q = digits;
 290     started = false;
 291     twopwr = 0;
 292     while (m < mant + MANT_LIMBS) {
 293         fp_limb carry = 0;
 294         while (p > q && !p[-1]) {
 295             p--;
 296         }
 297         if (p <= q) {
 298             break;
 299         }
 300         for (r = p; r-- > q;) {
 301             int32_t i;
 302             i = 2 * *r + carry;
 303             if (i >= 10) {
 304                 carry = 1;
 305                 i -= 10;
 306             } else {
 307                 carry = 0;
 308             }
 309             *r = i;
 310         }
 311         if (carry) {
 312             *m |= bit;
 313             started = true;
 314         }
 315         if (started) {
 316             if (bit == 1) {
 317                 bit = LIMB_TOP_BIT;
 318                 m++;
 319             } else {
 320                 bit >>= 1;
 321             }
 322         } else {
 323             twopwr--;
 324         }
 325     }
 326     twopwr += tenpwr;
 327
 328     /*
 329      * At this point, the 'mant' array contains the first frac-
 330      * tional places of a base-2^16 real number which when mul-
 331      * tiplied by 2^twopwr and 5^tenpwr gives X.
 332      */
 333     dprintf(("X = " MANT_FMT " * 2^%i * 5^%i\n", MANT_ARG, twopwr,
 334              tenpwr));
 335
 336     /*
 337      * Now multiply 'mant' by 5^tenpwr.
 338      */
 339     if (tenpwr < 0) {           /* mult = 5^-1 = 0.2 */
 340         for (m = mult; m < mult + MANT_LIMBS - 1; m++) {
 341             *m = LIMB_BYTE(0xcc);
 342         }
 343         mult[MANT_LIMBS - 1] = LIMB_BYTE(0xcc)+1;
 344         extratwos = -2;
 345         tenpwr = -tenpwr;
 346
 347         /*
 348          * If tenpwr was 1000...000b, then it becomes 1000...000b. See
 349          * the "ANSI C" comment below for more details on that case.
 350          *
 351          * Because we already truncated tenpwr to +5000...-5000 inside
 352          * the exponent parsing code, this shouldn't happen though.
 353          */
 354     } else if (tenpwr > 0) {    /* mult = 5^+1 = 5.0 */
 355         mult[0] = (fp_limb)5 << (LIMB_BITS-3); /* 0xA000... */
 356         for (m = mult + 1; m < mult + MANT_LIMBS; m++) {
 357             *m = 0;
 358         }
 359         extratwos = 3;
 360     } else {
 361         extratwos = 0;
 362     }
 363     while (tenpwr) {
 364         dprintf(("loop=" MANT_FMT " * 2^%i * 5^%i (%i)\n", MANT_ARG,
 365                  twopwr, tenpwr, extratwos));
 366         if (tenpwr & 1) {
 367             dprintf(("mant*mult\n"));
 368             twopwr += extratwos + float_multiply(mant, mult);
 369         }
 370         dprintf(("mult*mult\n"));
 371         extratwos = extratwos * 2 + float_multiply(mult, mult);
 372         tenpwr >>= 1;
 373
 374         /*
 375          * In ANSI C, the result of right-shifting a signed integer is
 376          * considered implementation-specific. To ensure that the loop
 377          * terminates even if tenpwr was 1000...000b to begin with, we
 378          * manually clear the MSB, in case a 1 was shifted in.
 379          *
 380          * Because we already truncated tenpwr to +5000...-5000 inside
 381          * the exponent parsing code, this shouldn't matter; neverthe-
 382          * less it is the right thing to do here.
 383          */
 384         tenpwr &= (uint32_t) - 1 >> 1;
 385     }
 386
 387     /*
 388      * At this point, the 'mant' array contains the first frac-
 389      * tional places of a base-2^16 real number in [0.5,1) that
 390      * when multiplied by 2^twopwr gives X. Or it contains zero
 391      * of course. We are done.
 392      */
 393     *exponent = twopwr;
 394     return true;
 395 }
 396
 397 /*
 398  * ---------------------------------------------------------------------------
 399  *  operations of specific bits
 400  * ---------------------------------------------------------------------------
 401  */
 402
 403 /* Set a bit, using *bigendian* bit numbering (0 = MSB) */
 404 static void set_bit(fp_limb *mant, int bit)
 405 {
 406     mant[bit/LIMB_BITS] |= LIMB_TOP_BIT >> (bit & (LIMB_BITS-1));
 407 }
 408
 409 /* Test a single bit */
 410 static int test_bit(const fp_limb *mant, int bit)
 411 {
 412     return (mant[bit/LIMB_BITS] >> (~bit & (LIMB_BITS-1))) & 1;
 413 }
 414
 415 /* Report if the mantissa value is all zero */
 416 static bool is_zero(const fp_limb *mant)
 417 {
 418     int i;
 419
 420     for (i = 0; i < MANT_LIMBS; i++)
 421         if (mant[i])
 422             return false;
 423
 424     return true;
 425 }
 426
 427 /*
 428  * ---------------------------------------------------------------------------
 429  *  round a mantissa off after i words
 430  * ---------------------------------------------------------------------------
 431  */
 432
 433 #define ROUND_COLLECT_BITS                      \
 434     do {                                        \
 435         m = mant[i] & (2*bit-1);                \
 436         for (j = i+1; j < MANT_LIMBS; j++)      \
 437             m = m | mant[j];                    \
 438     } while (0)
 439
 440 #define ROUND_ABS_DOWN                          \
 441     do {                                        \
 442         mant[i] &= ~(bit-1);                    \
 443         for (j = i+1; j < MANT_LIMBS; j++)      \
 444             mant[j] = 0;                        \
 445         return false;                           \
 446     } while (0)
 447
 448 #define ROUND_ABS_UP                            \
 449     do {                                        \
 450         mant[i] = (mant[i] & ~(bit-1)) + bit;   \
 451         for (j = i+1; j < MANT_LIMBS; j++)      \
 452             mant[j] = 0;                        \
 453         while (i > 0 && !mant[i])               \
 454             ++mant[--i];                        \
 455         return !mant[0];                        \
 456     } while (0)
 457
 458 static bool ieee_round(bool minus, fp_limb *mant, int bits)
 459 {
 460     fp_limb m = 0;
 461     int32_t j;
 462     int i = bits / LIMB_BITS;
 463     int p = bits % LIMB_BITS;
 464     fp_limb bit = LIMB_TOP_BIT >> p;
 465
 466     if (rc == FLOAT_RC_NEAR) {
 467         if (mant[i] & bit) {
 468             mant[i] &= ~bit;
 469             ROUND_COLLECT_BITS;
 470             mant[i] |= bit;
 471             if (m) {
 472                 ROUND_ABS_UP;
 473             } else {
 474                 if (test_bit(mant, bits-1)) {
 475                     ROUND_ABS_UP;
 476                 } else {
 477                     ROUND_ABS_DOWN;
 478                 }
 479             }
 480         } else {
 481             ROUND_ABS_DOWN;
 482         }
 483     } else if (rc == FLOAT_RC_ZERO ||
 484                rc == (minus ? FLOAT_RC_UP : FLOAT_RC_DOWN)) {
 485         ROUND_ABS_DOWN;
 486     } else {
 487         /* rc == (minus ? FLOAT_RC_DOWN : FLOAT_RC_UP) */
 488         /* Round toward +/- infinity */
 489         ROUND_COLLECT_BITS;
 490         if (m) {
 491             ROUND_ABS_UP;
 492         } else {
 493             ROUND_ABS_DOWN;
 494         }
 495     }
 496     return false;
 497 }
 498
 499 /* Returns a value >= 16 if not a valid hex digit */
 500 static unsigned int hexval(char c)
 501 {
 502     unsigned int v = (unsigned char) c;
 503
 504     if (v >= '0' && v <= '9')
 505         return v - '0';
 506     else
 507         return (v|0x20) - 'a' + 10;
 508 }
 509
 510 /* Handle floating-point numbers with radix 2^bits and binary exponent */
 511 static bool ieee_flconvert_bin(const char *string, int bits,
 512                                fp_limb *mant, int32_t *exponent)
 513 {
 514     static const int log2tbl[16] =
 515         { -1, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3 };
 516     fp_limb mult[MANT_LIMBS + 1], *mp;
 517     int ms;
 518     int32_t twopwr;
 519     bool seendot, seendigit;
 520     unsigned char c;
 521     const int radix = 1 << bits;
 522     fp_limb v;
 523
 524     twopwr = 0;
 525     seendot = seendigit = false;
 526     ms = 0;
 527     mp = NULL;
 528
 529     memset(mult, 0, sizeof mult);
 530
 531     while ((c = *string++) != '\0') {
 532         if (c == '.') {
 533             if (!seendot)
 534                 seendot = true;
 535             else {
 536                 nasm_error(ERR_NONFATAL,
 537                       "too many periods in floating-point constant");
 538                 return false;
 539             }
 540         } else if ((v = hexval(c)) < (unsigned int)radix) {
 541             if (!seendigit && v) {
 542                 int l = log2tbl[v];
 543
 544                 seendigit = true;
 545                 mp = mult;
 546                 ms = (LIMB_BITS-1)-l;
 547
 548                 twopwr += l+1-bits;
 549             }
 550
 551             if (seendigit) {
 552                 if (ms <= 0) {
 553                     *mp |= v >> -ms;
 554                     mp++;
 555                     if (mp > &mult[MANT_LIMBS])
 556                         mp = &mult[MANT_LIMBS]; /* Guard slot */
 557                     ms += LIMB_BITS;
 558                 }
 559                 *mp |= v << ms;
 560                 ms -= bits;
 561
 562                 if (!seendot)
 563                     twopwr += bits;
 564             } else {
 565                 if (seendot)
 566                     twopwr -= bits;
 567             }
 568         } else if (c == 'p' || c == 'P') {
 569             int32_t e;
 570             e = read_exponent(string, 20000);
 571             if (e == INT32_MAX)
 572                 return false;
 573             twopwr += e;
 574             break;
 575         } else if (c == '_') {
 576             /* ignore */
 577         } else {
 578             nasm_error(ERR_NONFATAL,
 579                   "floating-point constant: `%c' is invalid character", c);
 580             return false;
 581         }
 582     }
 583
 584     if (!seendigit) {
 585         memset(mant, 0, MANT_LIMBS*sizeof(fp_limb)); /* Zero */
 586         *exponent = 0;
 587     } else {
 588         memcpy(mant, mult, MANT_LIMBS*sizeof(fp_limb));
 589         *exponent = twopwr;
 590     }
 591
 592     return true;
 593 }
 594
 595 /*
 596  * Shift a mantissa to the right by i bits.
 597  */
 598 static void ieee_shr(fp_limb *mant, int i)
 599 {
 600     fp_limb n, m;
 601     int j = 0;
 602     int sr, sl, offs;
 603
 604     sr = i % LIMB_BITS; sl = LIMB_BITS-sr;
 605     offs = i/LIMB_BITS;
 606
 607     if (sr == 0) {
 608         if (offs)
 609             for (j = MANT_LIMBS-1; j >= offs; j--)
 610                 mant[j] = mant[j-offs];
 611     } else if (MANT_LIMBS-1-offs < 0) {
 612         j = MANT_LIMBS-1;
 613     } else {
 614         n = mant[MANT_LIMBS-1-offs] >> sr;
 615         for (j = MANT_LIMBS-1; j > offs; j--) {
 616             m = mant[j-offs-1];
 617             mant[j] = (m << sl) | n;
 618             n = m >> sr;
 619         }
 620         mant[j--] = n;
 621     }
 622     while (j >= 0)
 623         mant[j--] = 0;
 624 }
 625
 626 /* Produce standard IEEE formats, with implicit or explicit integer
 627    bit; this makes the following assumptions:
 628
 629    - the sign bit is the MSB, followed by the exponent,
 630      followed by the integer bit if present.
 631    - the sign bit plus exponent fit in 16 bits.
 632    - the exponent bias is 2^(n-1)-1 for an n-bit exponent */
 633
 634 struct ieee_format {
 635     int bytes;
 636     int mantissa;               /* Fractional bits in the mantissa */
 637     int explicit;               /* Explicit integer */
 638     int exponent;               /* Bits in the exponent */
 639 };
 640
 641 /*
 642  * The 16- and 128-bit formats are expected to be in IEEE 754r.
 643  * AMD SSE5 uses the 16-bit format.
 644  *
 645  * The 32- and 64-bit formats are the original IEEE 754 formats.
 646  *
 647  * The 80-bit format is x87-specific, but widely used.
 648  *
 649  * The 8-bit format appears to be the consensus 8-bit floating-point
 650  * format.  It is apparently used in graphics applications.
 651  */
 652 static const struct ieee_format ieee_8   = {  1,   3, 0,  4 };
 653 static const struct ieee_format ieee_16  = {  2,  10, 0,  5 };
 654 static const struct ieee_format ieee_32  = {  4,  23, 0,  8 };
 655 static const struct ieee_format ieee_64  = {  8,  52, 0, 11 };
 656 static const struct ieee_format ieee_80  = { 10,  63, 1, 15 };
 657 static const struct ieee_format ieee_128 = { 16, 112, 0, 15 };
 658
 659 /* Types of values we can generate */
 660 enum floats {
 661     FL_ZERO,
 662     FL_DENORMAL,
 663     FL_NORMAL,
 664     FL_INFINITY,
 665     FL_QNAN,
 666     FL_SNAN
 667 };
 668
 669 static int to_packed_bcd(const char *str, const char *p,
 670                          int s, uint8_t *result,
 671                          const struct ieee_format *fmt)
 672 {
 673     int n = 0;
 674     char c;
 675     int tv = -1;
 676
 677     if (fmt != &ieee_80) {
 678         nasm_error(ERR_NONFATAL,
 679               "packed BCD requires an 80-bit format");
 680         return 0;
 681     }
 682
 683     while (p >= str) {
 684         c = *p--;
 685         if (c >= '0' && c <= '9') {
 686             if (tv < 0) {
 687                 if (n == 9) {
 688                     nasm_error(ERR_WARNING|ERR_PASS2,
 689                           "packed BCD truncated to 18 digits");
 690                 }
 691                 tv = c-'0';
 692             } else {
 693                 if (n < 9)
 694                     *result++ = tv + ((c-'0') << 4);
 695                 n++;
 696                 tv = -1;
 697             }
 698         } else if (c == '_') {
 699             /* do nothing */
 700         } else {
 701             nasm_error(ERR_NONFATAL,
 702                   "invalid character `%c' in packed BCD constant", c);
 703             return 0;
 704         }
 705     }
 706     if (tv >= 0) {
 707         if (n < 9)
 708             *result++ = tv;
 709         n++;
 710     }
 711     while (n < 9) {
 712         *result++ = 0;
 713         n++;
 714     }
 715     *result = (s < 0) ? 0x80 : 0;
 716
 717     return 1;                   /* success */
 718 }
 719
 720 static int to_float(const char *str, int s, uint8_t *result,
 721                     const struct ieee_format *fmt)
 722 {
 723     fp_limb mant[MANT_LIMBS];
 724     int32_t exponent = 0;
 725     const int32_t expmax = 1 << (fmt->exponent - 1);
 726     fp_limb one_mask = LIMB_TOP_BIT >>
 727         ((fmt->exponent+fmt->explicit) % LIMB_BITS);
 728     const int one_pos = (fmt->exponent+fmt->explicit)/LIMB_BITS;
 729     int i;
 730     int shift;
 731     enum floats type;
 732     bool ok;
 733     const bool minus = s < 0;
 734     const int bits = fmt->bytes * 8;
 735     const char *strend;
 736
 737     nasm_assert(str[0]);
 738
 739     strend = strchr(str, '\0');
 740     if (strend[-1] == 'P' || strend[-1] == 'p')
 741         return to_packed_bcd(str, strend-2, s, result, fmt);
 742
 743     if (str[0] == '_') {
 744         /* Special tokens */
 745
 746         switch (str[2]) {
 747         case 'n':              /* __nan__ */
 748         case 'N':
 749         case 'q':              /* __qnan__ */
 750         case 'Q':
 751             type = FL_QNAN;
 752             break;
 753         case 's':              /* __snan__ */
 754         case 'S':
 755             type = FL_SNAN;
 756             break;
 757         case 'i':              /* __infinity__ */
 758         case 'I':
 759             type = FL_INFINITY;
 760             break;
 761         default:
 762             nasm_error(ERR_NONFATAL,
 763                   "internal error: unknown FP constant token `%s'\n", str);
 764             type = FL_QNAN;
 765             break;
 766         }
 767     } else {
 768         if (str[0] == '0') {
 769             switch (str[1]) {
 770             case 'x': case 'X':
 771             case 'h': case 'H':
 772                 ok = ieee_flconvert_bin(str+2, 4, mant, &exponent);
 773                 break;
 774             case 'o': case 'O':
 775             case 'q': case 'Q':
 776                 ok = ieee_flconvert_bin(str+2, 3, mant, &exponent);
 777                 break;
 778             case 'b': case 'B':
 779             case 'y': case 'Y':
 780                 ok = ieee_flconvert_bin(str+2, 1, mant, &exponent);
 781                 break;
 782             case 'd': case 'D':
 783             case 't': case 'T':
 784                 ok = ieee_flconvert(str+2, mant, &exponent);
 785                 break;
 786             case 'p': case 'P':
 787                 return to_packed_bcd(str+2, strend-1, s, result, fmt);
 788             default:
 789                 /* Leading zero was just a zero? */
 790                 ok = ieee_flconvert(str, mant, &exponent);
 791                 break;
 792             }
 793         } else if (str[0] == '$') {
 794             ok = ieee_flconvert_bin(str+1, 4, mant, &exponent);
 795         } else {
 796             ok = ieee_flconvert(str, mant, &exponent);
 797         }
 798
 799         if (!ok) {
 800             type = FL_QNAN;
 801         } else if (mant[0] & LIMB_TOP_BIT) {
 802             /*
 803              * Non-zero.
 804              */
 805             exponent--;
 806             if (exponent >= 2 - expmax && exponent <= expmax) {
 807                 type = FL_NORMAL;
 808             } else if (exponent > 0) {
 809                 if (pass0 == 1)
 810                     nasm_error(ERR_WARNING|ERR_WARN_FL_OVERFLOW|ERR_PASS2,
 811                           "overflow in floating-point constant");
 812                 type = FL_INFINITY;
 813             } else {
 814                 /* underflow or denormal; the denormal code handles
 815                    actual underflow. */
 816                 type = FL_DENORMAL;
 817             }
 818         } else {
 819             /* Zero */
 820             type = FL_ZERO;
 821         }
 822     }
 823
 824     switch (type) {
 825     case FL_ZERO:
 826     zero:
 827         memset(mant, 0, sizeof mant);
 828         break;
 829
 830     case FL_DENORMAL:
 831     {
 832         shift = -(exponent + expmax - 2 - fmt->exponent)
 833             + fmt->explicit;
 834         ieee_shr(mant, shift);
 835         ieee_round(minus, mant, bits);
 836         if (mant[one_pos] & one_mask) {
 837             /* One's position is set, we rounded up into normal range */
 838             exponent = 1;
 839             if (!fmt->explicit)
 840                 mant[one_pos] &= ~one_mask;     /* remove explicit one */
 841             mant[0] |= exponent << (LIMB_BITS-1 - fmt->exponent);
 842         } else {
 843             if (daz || is_zero(mant)) {
 844                 /* Flush denormals to zero */
 845                 nasm_error(ERR_WARNING|ERR_WARN_FL_UNDERFLOW|ERR_PASS2,
 846                       "underflow in floating-point constant");
 847                 goto zero;
 848             } else {
 849                 nasm_error(ERR_WARNING|ERR_WARN_FL_DENORM|ERR_PASS2,
 850                       "denormal floating-point constant");
 851             }
 852         }
 853         break;
 854     }
 855
 856     case FL_NORMAL:
 857         exponent += expmax - 1;
 858         ieee_shr(mant, fmt->exponent+fmt->explicit);
 859         ieee_round(minus, mant, bits);
 860         /* did we scale up by one? */
 861         if (test_bit(mant, fmt->exponent+fmt->explicit-1)) {
 862             ieee_shr(mant, 1);
 863             exponent++;
 864             if (exponent >= (expmax << 1)-1) {
 865                     nasm_error(ERR_WARNING|ERR_WARN_FL_OVERFLOW|ERR_PASS2,
 866                           "overflow in floating-point constant");
 867                 type = FL_INFINITY;
 868                 goto overflow;
 869             }
 870         }
 871
 872         if (!fmt->explicit)
 873             mant[one_pos] &= ~one_mask; /* remove explicit one */
 874         mant[0] |= exponent << (LIMB_BITS-1 - fmt->exponent);
 875         break;
 876
 877     case FL_INFINITY:
 878     case FL_QNAN:
 879     case FL_SNAN:
 880     overflow:
 881         memset(mant, 0, sizeof mant);
 882         mant[0] = (((fp_limb)1 << fmt->exponent)-1)
 883             << (LIMB_BITS-1 - fmt->exponent);
 884         if (fmt->explicit)
 885             mant[one_pos] |= one_mask;
 886         if (type == FL_QNAN)
 887             set_bit(mant, fmt->exponent+fmt->explicit+1);
 888         else if (type == FL_SNAN)
 889             set_bit(mant, fmt->exponent+fmt->explicit+fmt->mantissa);
 890         break;
 891     }
 892
 893     mant[0] |= minus ? LIMB_TOP_BIT : 0;
 894
 895     for (i = fmt->bytes - 1; i >= 0; i--)
 896         *result++ = mant[i/LIMB_BYTES] >> (((LIMB_BYTES-1)-(i%LIMB_BYTES))*8);
 897
 898     return 1;                   /* success */
 899 }
 900
 901 int float_const(const char *number, int sign, uint8_t *result, int bytes)
 902 {
 903     switch (bytes) {
 904     case 1:
 905         return to_float(number, sign, result, &ieee_8);
 906     case 2:
 907         return to_float(number, sign, result, &ieee_16);
 908     case 4:
 909         return to_float(number, sign, result, &ieee_32);
 910     case 8:
 911         return to_float(number, sign, result, &ieee_64);
 912     case 10:
 913         return to_float(number, sign, result, &ieee_80);
 914     case 16:
 915         return to_float(number, sign, result, &ieee_128);
 916     default:
 917         nasm_panic("strange value %d passed to float_const", bytes);
 918         return 0;
 919     }
 920 }
 921
 922 /* Set floating-point options */
 923 int float_option(const char *option)
 924 {
 925     if (!nasm_stricmp(option, "daz")) {
 926         daz = true;
 927         return 0;
 928     } else if (!nasm_stricmp(option, "nodaz")) {
 929         daz = false;
 930         return 0;
 931     } else if (!nasm_stricmp(option, "near")) {
 932         rc = FLOAT_RC_NEAR;
 933         return 0;
 934     } else if (!nasm_stricmp(option, "down")) {
 935         rc = FLOAT_RC_DOWN;
 936         return 0;
 937     } else if (!nasm_stricmp(option, "up")) {
 938         rc = FLOAT_RC_UP;
 939         return 0;
 940     } else if (!nasm_stricmp(option, "zero")) {
 941         rc = FLOAT_RC_ZERO;
 942         return 0;
 943     } else if (!nasm_stricmp(option, "default")) {
 944         rc = FLOAT_RC_NEAR;
 945         daz = false;
 946         return 0;
 947     } else {
 948         return -1;              /* Unknown option */
 949     }
 950 }