asm/float.c

   1 /* ----------------------------------------------------------------------- *
   2  *
   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.
   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|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                     /* Cast to fp_2limb as ms == -LIMB_BITS is possible. */
 554                     *mp |= (fp_2limb)v >> -ms;
 555                     mp++;
 556                     if (mp > &mult[MANT_LIMBS])
 557                         mp = &mult[MANT_LIMBS]; /* Guard slot */
 558                     ms += LIMB_BITS;
 559                 }
 560                 *mp |= v << ms;
 561                 ms -= bits;
 562
 563                 if (!seendot)
 564                     twopwr += bits;
 565             } else {
 566                 if (seendot)
 567                     twopwr -= bits;
 568             }
 569         } else if (c == 'p' || c == 'P') {
 570             int32_t e;
 571             e = read_exponent(string, 20000);
 572             if (e == INT32_MAX)
 573                 return false;
 574             twopwr += e;
 575             break;
 576         } else if (c == '_') {
 577             /* ignore */
 578         } else {
 579             nasm_error(ERR_NONFATAL,
 580                   "floating-point constant: `%c' is invalid character", c);
 581             return false;
 582         }
 583     }
 584
 585     if (!seendigit) {
 586         memset(mant, 0, MANT_LIMBS*sizeof(fp_limb)); /* Zero */
 587         *exponent = 0;
 588     } else {
 589         memcpy(mant, mult, MANT_LIMBS*sizeof(fp_limb));
 590         *exponent = twopwr;
 591     }
 592
 593     return true;
 594 }
 595
 596 /*
 597  * Shift a mantissa to the right by i bits.
 598  */
 599 static void ieee_shr(fp_limb *mant, int i)
 600 {
 601     fp_limb n, m;
 602     int j = 0;
 603     int sr, sl, offs;
 604
 605     sr = i % LIMB_BITS; sl = LIMB_BITS-sr;
 606     offs = i/LIMB_BITS;
 607
 608     if (sr == 0) {
 609         if (offs)
 610             for (j = MANT_LIMBS-1; j >= offs; j--)
 611                 mant[j] = mant[j-offs];
 612     } else if (MANT_LIMBS-1-offs < 0) {
 613         j = MANT_LIMBS-1;
 614     } else {
 615         n = mant[MANT_LIMBS-1-offs] >> sr;
 616         for (j = MANT_LIMBS-1; j > offs; j--) {
 617             m = mant[j-offs-1];
 618             mant[j] = (m << sl) | n;
 619             n = m >> sr;
 620         }
 621         mant[j--] = n;
 622     }
 623     while (j >= 0)
 624         mant[j--] = 0;
 625 }
 626
 627 /* Produce standard IEEE formats, with implicit or explicit integer
 628    bit; this makes the following assumptions:
 629
 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 */
 634
 635 struct ieee_format {
 636     int bytes;
 637     int mantissa;               /* Fractional bits in the mantissa */
 638     int explicit;               /* Explicit integer */
 639     int exponent;               /* Bits in the exponent */
 640 };
 641
 642 /*
 643  * The 16- and 128-bit formats are expected to be in IEEE 754r.
 644  * AMD SSE5 uses the 16-bit format.
 645  *
 646  * The 32- and 64-bit formats are the original IEEE 754 formats.
 647  *
 648  * The 80-bit format is x87-specific, but widely used.
 649  *
 650  * The 8-bit format appears to be the consensus 8-bit floating-point
 651  * format.  It is apparently used in graphics applications.
 652  */
 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 };
 659
 660 /* Types of values we can generate */
 661 enum floats {
 662     FL_ZERO,
 663     FL_DENORMAL,
 664     FL_NORMAL,
 665     FL_INFINITY,
 666     FL_QNAN,
 667     FL_SNAN
 668 };
 669
 670 static int to_packed_bcd(const char *str, const char *p,
 671                          int s, uint8_t *result,
 672                          const struct ieee_format *fmt)
 673 {
 674     int n = 0;
 675     char c;
 676     int tv = -1;
 677
 678     if (fmt != &ieee_80) {
 679         nasm_error(ERR_NONFATAL,
 680               "packed BCD requires an 80-bit format");
 681         return 0;
 682     }
 683
 684     while (p >= str) {
 685         c = *p--;
 686         if (c >= '0' && c <= '9') {
 687             if (tv < 0) {
 688                 if (n == 9) {
 689                     nasm_error(ERR_WARNING|ERR_PASS2,
 690                           "packed BCD truncated to 18 digits");
 691                 }
 692                 tv = c-'0';
 693             } else {
 694                 if (n < 9)
 695                     *result++ = tv + ((c-'0') << 4);
 696                 n++;
 697                 tv = -1;
 698             }
 699         } else if (c == '_') {
 700             /* do nothing */
 701         } else {
 702             nasm_error(ERR_NONFATAL,
 703                   "invalid character `%c' in packed BCD constant", c);
 704             return 0;
 705         }
 706     }
 707     if (tv >= 0) {
 708         if (n < 9)
 709             *result++ = tv;
 710         n++;
 711     }
 712     while (n < 9) {
 713         *result++ = 0;
 714         n++;
 715     }
 716     *result = (s < 0) ? 0x80 : 0;
 717
 718     return 1;                   /* success */
 719 }
 720
 721 static int to_float(const char *str, int s, uint8_t *result,
 722                     const struct ieee_format *fmt)
 723 {
 724     fp_limb mant[MANT_LIMBS];
 725     int32_t exponent = 0;
 726     const int32_t expmax = 1 << (fmt->exponent - 1);
 727     fp_limb one_mask = LIMB_TOP_BIT >>
 728         ((fmt->exponent+fmt->explicit) % LIMB_BITS);
 729     const int one_pos = (fmt->exponent+fmt->explicit)/LIMB_BITS;
 730     int i;
 731     int shift;
 732     enum floats type;
 733     bool ok;
 734     const bool minus = s < 0;
 735     const int bits = fmt->bytes * 8;
 736     const char *strend;
 737
 738     if (!str[0]) {
 739         nasm_panic(0,
 740               "internal errror: empty string passed to float_const");
 741         return 0;
 742     }
 743
 744     strend = strchr(str, '\0');
 745     if (strend[-1] == 'P' || strend[-1] == 'p')
 746         return to_packed_bcd(str, strend-2, s, result, fmt);
 747
 748     if (str[0] == '_') {
 749         /* Special tokens */
 750
 751         switch (str[2]) {
 752         case 'n':              /* __nan__ */
 753         case 'N':
 754         case 'q':              /* __qnan__ */
 755         case 'Q':
 756             type = FL_QNAN;
 757             break;
 758         case 's':              /* __snan__ */
 759         case 'S':
 760             type = FL_SNAN;
 761             break;
 762         case 'i':              /* __infinity__ */
 763         case 'I':
 764             type = FL_INFINITY;
 765             break;
 766         default:
 767             nasm_error(ERR_NONFATAL,
 768                   "internal error: unknown FP constant token `%s'\n", str);
 769             type = FL_QNAN;
 770             break;
 771         }
 772     } else {
 773         if (str[0] == '0') {
 774             switch (str[1]) {
 775             case 'x': case 'X':
 776             case 'h': case 'H':
 777                 ok = ieee_flconvert_bin(str+2, 4, mant, &exponent);
 778                 break;
 779             case 'o': case 'O':
 780             case 'q': case 'Q':
 781                 ok = ieee_flconvert_bin(str+2, 3, mant, &exponent);
 782                 break;
 783             case 'b': case 'B':
 784             case 'y': case 'Y':
 785                 ok = ieee_flconvert_bin(str+2, 1, mant, &exponent);
 786                 break;
 787             case 'd': case 'D':
 788             case 't': case 'T':
 789                 ok = ieee_flconvert(str+2, mant, &exponent);
 790                 break;
 791             case 'p': case 'P':
 792                 return to_packed_bcd(str+2, strend-1, s, result, fmt);
 793             default:
 794                 /* Leading zero was just a zero? */
 795                 ok = ieee_flconvert(str, mant, &exponent);
 796                 break;
 797             }
 798         } else if (str[0] == '$') {
 799             ok = ieee_flconvert_bin(str+1, 4, mant, &exponent);
 800         } else {
 801             ok = ieee_flconvert(str, mant, &exponent);
 802         }
 803
 804         if (!ok) {
 805             type = FL_QNAN;
 806         } else if (mant[0] & LIMB_TOP_BIT) {
 807             /*
 808              * Non-zero.
 809              */
 810             exponent--;
 811             if (exponent >= 2 - expmax && exponent <= expmax) {
 812                 type = FL_NORMAL;
 813             } else if (exponent > 0) {
 814                 if (pass0 == 1)
 815                     nasm_error(ERR_WARNING|WARN_FL_OVERFLOW|ERR_PASS2,
 816                           "overflow in floating-point constant");
 817                 type = FL_INFINITY;
 818             } else {
 819                 /* underflow or denormal; the denormal code handles
 820                    actual underflow. */
 821                 type = FL_DENORMAL;
 822             }
 823         } else {
 824             /* Zero */
 825             type = FL_ZERO;
 826         }
 827     }
 828
 829     switch (type) {
 830     case FL_ZERO:
 831     zero:
 832         memset(mant, 0, sizeof mant);
 833         break;
 834
 835     case FL_DENORMAL:
 836     {
 837         shift = -(exponent + expmax - 2 - fmt->exponent)
 838             + fmt->explicit;
 839         ieee_shr(mant, shift);
 840         ieee_round(minus, mant, bits);
 841         if (mant[one_pos] & one_mask) {
 842             /* One's position is set, we rounded up into normal range */
 843             exponent = 1;
 844             if (!fmt->explicit)
 845                 mant[one_pos] &= ~one_mask;     /* remove explicit one */
 846             mant[0] |= exponent << (LIMB_BITS-1 - fmt->exponent);
 847         } else {
 848             if (daz || is_zero(mant)) {
 849                 /* Flush denormals to zero */
 850                 nasm_error(ERR_WARNING|WARN_FL_UNDERFLOW|ERR_PASS2,
 851                       "underflow in floating-point constant");
 852                 goto zero;
 853             } else {
 854                 nasm_error(ERR_WARNING|WARN_FL_DENORM|ERR_PASS2,
 855                       "denormal floating-point constant");
 856             }
 857         }
 858         break;
 859     }
 860
 861     case FL_NORMAL:
 862         exponent += expmax - 1;
 863         ieee_shr(mant, fmt->exponent+fmt->explicit);
 864         ieee_round(minus, mant, bits);
 865         /* did we scale up by one? */
 866         if (test_bit(mant, fmt->exponent+fmt->explicit-1)) {
 867             ieee_shr(mant, 1);
 868             exponent++;
 869             if (exponent >= (expmax << 1)-1) {
 870                     nasm_error(ERR_WARNING|WARN_FL_OVERFLOW|ERR_PASS2,
 871                           "overflow in floating-point constant");
 872                 type = FL_INFINITY;
 873                 goto overflow;
 874             }
 875         }
 876
 877         if (!fmt->explicit)
 878             mant[one_pos] &= ~one_mask; /* remove explicit one */
 879         mant[0] |= exponent << (LIMB_BITS-1 - fmt->exponent);
 880         break;
 881
 882     case FL_INFINITY:
 883     case FL_QNAN:
 884     case FL_SNAN:
 885     overflow:
 886         memset(mant, 0, sizeof mant);
 887         mant[0] = (((fp_limb)1 << fmt->exponent)-1)
 888             << (LIMB_BITS-1 - fmt->exponent);
 889         if (fmt->explicit)
 890             mant[one_pos] |= one_mask;
 891         if (type == FL_QNAN)
 892             set_bit(mant, fmt->exponent+fmt->explicit+1);
 893         else if (type == FL_SNAN)
 894             set_bit(mant, fmt->exponent+fmt->explicit+fmt->mantissa);
 895         break;
 896     }
 897
 898     mant[0] |= minus ? LIMB_TOP_BIT : 0;
 899
 900     for (i = fmt->bytes - 1; i >= 0; i--)
 901         *result++ = mant[i/LIMB_BYTES] >> (((LIMB_BYTES-1)-(i%LIMB_BYTES))*8);
 902
 903     return 1;                   /* success */
 904 }
 905
 906 int float_const(const char *number, int sign, uint8_t *result, int bytes)
 907 {
 908     switch (bytes) {
 909     case 1:
 910         return to_float(number, sign, result, &ieee_8);
 911     case 2:
 912         return to_float(number, sign, result, &ieee_16);
 913     case 4:
 914         return to_float(number, sign, result, &ieee_32);
 915     case 8:
 916         return to_float(number, sign, result, &ieee_64);
 917     case 10:
 918         return to_float(number, sign, result, &ieee_80);
 919     case 16:
 920         return to_float(number, sign, result, &ieee_128);
 921     default:
 922         nasm_panic(0, "strange value %d passed to float_const", bytes);
 923         return 0;
 924     }
 925 }
 926
 927 /* Set floating-point options */
 928 int float_option(const char *option)
 929 {
 930     if (!nasm_stricmp(option, "daz")) {
 931         daz = true;
 932         return 0;
 933     } else if (!nasm_stricmp(option, "nodaz")) {
 934         daz = false;
 935         return 0;
 936     } else if (!nasm_stricmp(option, "near")) {
 937         rc = FLOAT_RC_NEAR;
 938         return 0;
 939     } else if (!nasm_stricmp(option, "down")) {
 940         rc = FLOAT_RC_DOWN;
 941         return 0;
 942     } else if (!nasm_stricmp(option, "up")) {
 943         rc = FLOAT_RC_UP;
 944         return 0;
 945     } else if (!nasm_stricmp(option, "zero")) {
 946         rc = FLOAT_RC_ZERO;
 947         return 0;
 948     } else if (!nasm_stricmp(option, "default")) {
 949         rc = FLOAT_RC_NEAR;
 950         daz = false;
 951         return 0;
 952     } else {
 953         return -1;              /* Unknown option */
 954     }
 955 }