eval.c

   1 /* ----------------------------------------------------------------------- *
   2  *
   3  *   Copyright 1996-2012 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  * eval.c    expression evaluator for the Netwide Assembler
  36  */
  37
  38 #include "compiler.h"
  39
  40 #include <stdio.h>
  41 #include <stdlib.h>
  42 #include <stddef.h>
  43 #include <string.h>
  44 #include <ctype.h>
  45 #include <inttypes.h>
  46
  47 #include "nasm.h"
  48 #include "nasmlib.h"
  49 #include "eval.h"
  50 #include "labels.h"
  51 #include "float.h"
  52
  53 #define TEMPEXPRS_DELTA 128
  54 #define TEMPEXPR_DELTA 8
  55
  56 static scanner scan;            /* Address of scanner routine */
  57 static efunc error;             /* Address of error reporting routine */
  58 static lfunc labelfunc;         /* Address of label routine */
  59
  60 static struct ofmt *outfmt;     /* Structure of addresses of output routines */
  61
  62 static expr **tempexprs = NULL;
  63 static int ntempexprs;
  64 static int tempexprs_size = 0;
  65
  66 static expr *tempexpr;
  67 static int ntempexpr;
  68 static int tempexpr_size;
  69
  70 static struct tokenval *tokval; /* The current token */
  71 static int i;                   /* The t_type of tokval */
  72
  73 static void *scpriv;
  74 static struct location *location;         /* Pointer to current line's segment,offset */
  75 static int *opflags;
  76
  77 static struct eval_hints *hint;
  78
  79 extern int in_abs_seg;          /* ABSOLUTE segment flag */
  80 extern int32_t abs_seg;         /* ABSOLUTE segment */
  81 extern int32_t abs_offset;      /* ABSOLUTE segment offset */
  82
  83 /*
  84  * Unimportant cleanup is done to avoid confusing people who are trying
  85  * to debug real memory leaks
  86  */
  87 void eval_cleanup(void)
  88 {
  89     while (ntempexprs)
  90         nasm_free(tempexprs[--ntempexprs]);
  91     nasm_free(tempexprs);
  92 }
  93
  94 /*
  95  * Construct a temporary expression.
  96  */
  97 static void begintemp(void)
  98 {
  99     tempexpr = NULL;
 100     tempexpr_size = ntempexpr = 0;
 101 }
 102
 103 static void addtotemp(int32_t type, int64_t value)
 104 {
 105     while (ntempexpr >= tempexpr_size) {
 106         tempexpr_size += TEMPEXPR_DELTA;
 107         tempexpr = nasm_realloc(tempexpr,
 108                                 tempexpr_size * sizeof(*tempexpr));
 109     }
 110     tempexpr[ntempexpr].type = type;
 111     tempexpr[ntempexpr++].value = value;
 112 }
 113
 114 static expr *finishtemp(void)
 115 {
 116     addtotemp(0L, 0L);          /* terminate */
 117     while (ntempexprs >= tempexprs_size) {
 118         tempexprs_size += TEMPEXPRS_DELTA;
 119         tempexprs = nasm_realloc(tempexprs,
 120                                  tempexprs_size * sizeof(*tempexprs));
 121     }
 122     return tempexprs[ntempexprs++] = tempexpr;
 123 }
 124
 125 /*
 126  * Add two vector datatypes. We have some bizarre behaviour on far-
 127  * absolute segment types: we preserve them during addition _only_
 128  * if one of the segments is a truly pure scalar.
 129  */
 130 static expr *add_vectors(expr * p, expr * q)
 131 {
 132     int preserve;
 133
 134     preserve = is_really_simple(p) || is_really_simple(q);
 135
 136     begintemp();
 137
 138     while (p->type && q->type &&
 139            p->type < EXPR_SEGBASE + SEG_ABS &&
 140            q->type < EXPR_SEGBASE + SEG_ABS) {
 141         int lasttype;
 142
 143         if (p->type > q->type) {
 144             addtotemp(q->type, q->value);
 145             lasttype = q++->type;
 146         } else if (p->type < q->type) {
 147             addtotemp(p->type, p->value);
 148             lasttype = p++->type;
 149         } else {                /* *p and *q have same type */
 150             int64_t sum = p->value + q->value;
 151             if (sum)
 152                 addtotemp(p->type, sum);
 153             lasttype = p->type;
 154             p++, q++;
 155         }
 156         if (lasttype == EXPR_UNKNOWN) {
 157             return finishtemp();
 158         }
 159     }
 160     while (p->type && (preserve || p->type < EXPR_SEGBASE + SEG_ABS)) {
 161         addtotemp(p->type, p->value);
 162         p++;
 163     }
 164     while (q->type && (preserve || q->type < EXPR_SEGBASE + SEG_ABS)) {
 165         addtotemp(q->type, q->value);
 166         q++;
 167     }
 168
 169     return finishtemp();
 170 }
 171
 172 /*
 173  * Multiply a vector by a scalar. Strip far-absolute segment part
 174  * if present.
 175  *
 176  * Explicit treatment of UNKNOWN is not required in this routine,
 177  * since it will silently do the Right Thing anyway.
 178  *
 179  * If `affect_hints' is set, we also change the hint type to
 180  * NOTBASE if a MAKEBASE hint points at a register being
 181  * multiplied. This allows [eax*1+ebx] to hint EBX rather than EAX
 182  * as the base register.
 183  */
 184 static expr *scalar_mult(expr * vect, int64_t scalar, int affect_hints)
 185 {
 186     expr *p = vect;
 187
 188     while (p->type && p->type < EXPR_SEGBASE + SEG_ABS) {
 189         p->value = scalar * (p->value);
 190         if (hint && hint->type == EAH_MAKEBASE &&
 191             p->type == hint->base && affect_hints)
 192             hint->type = EAH_NOTBASE;
 193         p++;
 194     }
 195     p->type = 0;
 196
 197     return vect;
 198 }
 199
 200 static expr *scalarvect(int64_t scalar)
 201 {
 202     begintemp();
 203     addtotemp(EXPR_SIMPLE, scalar);
 204     return finishtemp();
 205 }
 206
 207 static expr *unknown_expr(void)
 208 {
 209     begintemp();
 210     addtotemp(EXPR_UNKNOWN, 1L);
 211     return finishtemp();
 212 }
 213
 214 /*
 215  * The SEG operator: calculate the segment part of a relocatable
 216  * value. Return NULL, as usual, if an error occurs. Report the
 217  * error too.
 218  */
 219 static expr *segment_part(expr * e)
 220 {
 221     int32_t seg;
 222
 223     if (is_unknown(e))
 224         return unknown_expr();
 225
 226     if (!is_reloc(e)) {
 227         error(ERR_NONFATAL, "cannot apply SEG to a non-relocatable value");
 228         return NULL;
 229     }
 230
 231     seg = reloc_seg(e);
 232     if (seg == NO_SEG) {
 233         error(ERR_NONFATAL, "cannot apply SEG to a non-relocatable value");
 234         return NULL;
 235     } else if (seg & SEG_ABS) {
 236         return scalarvect(seg & ~SEG_ABS);
 237     } else if (seg & 1) {
 238         error(ERR_NONFATAL, "SEG applied to something which"
 239               " is already a segment base");
 240         return NULL;
 241     } else {
 242         int32_t base = outfmt->segbase(seg + 1);
 243
 244         begintemp();
 245         addtotemp((base == NO_SEG ? EXPR_UNKNOWN : EXPR_SEGBASE + base),
 246                   1L);
 247         return finishtemp();
 248     }
 249 }
 250
 251 /*
 252  * Recursive-descent parser. Called with a single boolean operand,
 253  * which is true if the evaluation is critical (i.e. unresolved
 254  * symbols are an error condition). Must update the global `i' to
 255  * reflect the token after the parsed string. May return NULL.
 256  *
 257  * evaluate() should report its own errors: on return it is assumed
 258  * that if NULL has been returned, the error has already been
 259  * reported.
 260  */
 261
 262 /*
 263  * Grammar parsed is:
 264  *
 265  * expr  : bexpr [ WRT expr6 ]
 266  * bexpr : rexp0 or expr0 depending on relative-mode setting
 267  * rexp0 : rexp1 [ {||} rexp1...]
 268  * rexp1 : rexp2 [ {^^} rexp2...]
 269  * rexp2 : rexp3 [ {&&} rexp3...]
 270  * rexp3 : expr0 [ {=,==,<>,!=,<,>,<=,>=} expr0 ]
 271  * expr0 : expr1 [ {|} expr1...]
 272  * expr1 : expr2 [ {^} expr2...]
 273  * expr2 : expr3 [ {&} expr3...]
 274  * expr3 : expr4 [ {<<,>>} expr4...]
 275  * expr4 : expr5 [ {+,-} expr5...]
 276  * expr5 : expr6 [ {*,/,%,//,%%} expr6...]
 277  * expr6 : { ~,+,-,IFUNC,SEG } expr6
 278  *       | (bexpr)
 279  *       | symbol
 280  *       | $
 281  *       | number
 282  */
 283
 284 static expr *rexp0(int), *rexp1(int), *rexp2(int), *rexp3(int);
 285
 286 static expr *expr0(int), *expr1(int), *expr2(int), *expr3(int);
 287 static expr *expr4(int), *expr5(int), *expr6(int);
 288
 289 static expr *(*bexpr) (int);
 290
 291 static expr *rexp0(int critical)
 292 {
 293     expr *e, *f;
 294
 295     e = rexp1(critical);
 296     if (!e)
 297         return NULL;
 298
 299     while (i == TOKEN_DBL_OR) {
 300         i = scan(scpriv, tokval);
 301         f = rexp1(critical);
 302         if (!f)
 303             return NULL;
 304         if (!(is_simple(e) || is_just_unknown(e)) ||
 305             !(is_simple(f) || is_just_unknown(f))) {
 306             error(ERR_NONFATAL, "`|' operator may only be applied to"
 307                   " scalar values");
 308         }
 309
 310         if (is_just_unknown(e) || is_just_unknown(f))
 311             e = unknown_expr();
 312         else
 313             e = scalarvect((int64_t)(reloc_value(e) || reloc_value(f)));
 314     }
 315     return e;
 316 }
 317
 318 static expr *rexp1(int critical)
 319 {
 320     expr *e, *f;
 321
 322     e = rexp2(critical);
 323     if (!e)
 324         return NULL;
 325
 326     while (i == TOKEN_DBL_XOR) {
 327         i = scan(scpriv, tokval);
 328         f = rexp2(critical);
 329         if (!f)
 330             return NULL;
 331         if (!(is_simple(e) || is_just_unknown(e)) ||
 332             !(is_simple(f) || is_just_unknown(f))) {
 333             error(ERR_NONFATAL, "`^' operator may only be applied to"
 334                   " scalar values");
 335         }
 336
 337         if (is_just_unknown(e) || is_just_unknown(f))
 338             e = unknown_expr();
 339         else
 340             e = scalarvect((int64_t)(!reloc_value(e) ^ !reloc_value(f)));
 341     }
 342     return e;
 343 }
 344
 345 static expr *rexp2(int critical)
 346 {
 347     expr *e, *f;
 348
 349     e = rexp3(critical);
 350     if (!e)
 351         return NULL;
 352     while (i == TOKEN_DBL_AND) {
 353         i = scan(scpriv, tokval);
 354         f = rexp3(critical);
 355         if (!f)
 356             return NULL;
 357         if (!(is_simple(e) || is_just_unknown(e)) ||
 358             !(is_simple(f) || is_just_unknown(f))) {
 359             error(ERR_NONFATAL, "`&' operator may only be applied to"
 360                   " scalar values");
 361         }
 362         if (is_just_unknown(e) || is_just_unknown(f))
 363             e = unknown_expr();
 364         else
 365             e = scalarvect((int64_t)(reloc_value(e) && reloc_value(f)));
 366     }
 367     return e;
 368 }
 369
 370 static expr *rexp3(int critical)
 371 {
 372     expr *e, *f;
 373     int64_t v;
 374
 375     e = expr0(critical);
 376     if (!e)
 377         return NULL;
 378
 379     while (i == TOKEN_EQ || i == TOKEN_LT || i == TOKEN_GT ||
 380            i == TOKEN_NE || i == TOKEN_LE || i == TOKEN_GE) {
 381         int j = i;
 382         i = scan(scpriv, tokval);
 383         f = expr0(critical);
 384         if (!f)
 385             return NULL;
 386
 387         e = add_vectors(e, scalar_mult(f, -1L, false));
 388
 389         switch (j) {
 390         case TOKEN_EQ:
 391         case TOKEN_NE:
 392             if (is_unknown(e))
 393                 v = -1;         /* means unknown */
 394             else if (!is_really_simple(e) || reloc_value(e) != 0)
 395                 v = (j == TOKEN_NE);    /* unequal, so return true if NE */
 396             else
 397                 v = (j == TOKEN_EQ);    /* equal, so return true if EQ */
 398             break;
 399         default:
 400             if (is_unknown(e))
 401                 v = -1;         /* means unknown */
 402             else if (!is_really_simple(e)) {
 403                 error(ERR_NONFATAL,
 404                       "`%s': operands differ by a non-scalar",
 405                       (j == TOKEN_LE ? "<=" : j == TOKEN_LT ? "<" : j ==
 406                        TOKEN_GE ? ">=" : ">"));
 407                 v = 0;          /* must set it to _something_ */
 408             } else {
 409                 int64_t vv = reloc_value(e);
 410                 if (vv == 0)
 411                     v = (j == TOKEN_LE || j == TOKEN_GE);
 412                 else if (vv > 0)
 413                     v = (j == TOKEN_GE || j == TOKEN_GT);
 414                 else            /* vv < 0 */
 415                     v = (j == TOKEN_LE || j == TOKEN_LT);
 416             }
 417             break;
 418         }
 419
 420         if (v == -1)
 421             e = unknown_expr();
 422         else
 423             e = scalarvect(v);
 424     }
 425     return e;
 426 }
 427
 428 static expr *expr0(int critical)
 429 {
 430     expr *e, *f;
 431
 432     e = expr1(critical);
 433     if (!e)
 434         return NULL;
 435
 436     while (i == '|') {
 437         i = scan(scpriv, tokval);
 438         f = expr1(critical);
 439         if (!f)
 440             return NULL;
 441         if (!(is_simple(e) || is_just_unknown(e)) ||
 442             !(is_simple(f) || is_just_unknown(f))) {
 443             error(ERR_NONFATAL, "`|' operator may only be applied to"
 444                   " scalar values");
 445         }
 446         if (is_just_unknown(e) || is_just_unknown(f))
 447             e = unknown_expr();
 448         else
 449             e = scalarvect(reloc_value(e) | reloc_value(f));
 450     }
 451     return e;
 452 }
 453
 454 static expr *expr1(int critical)
 455 {
 456     expr *e, *f;
 457
 458     e = expr2(critical);
 459     if (!e)
 460         return NULL;
 461
 462     while (i == '^') {
 463         i = scan(scpriv, tokval);
 464         f = expr2(critical);
 465         if (!f)
 466             return NULL;
 467         if (!(is_simple(e) || is_just_unknown(e)) ||
 468             !(is_simple(f) || is_just_unknown(f))) {
 469             error(ERR_NONFATAL, "`^' operator may only be applied to"
 470                   " scalar values");
 471         }
 472         if (is_just_unknown(e) || is_just_unknown(f))
 473             e = unknown_expr();
 474         else
 475             e = scalarvect(reloc_value(e) ^ reloc_value(f));
 476     }
 477     return e;
 478 }
 479
 480 static expr *expr2(int critical)
 481 {
 482     expr *e, *f;
 483
 484     e = expr3(critical);
 485     if (!e)
 486         return NULL;
 487
 488     while (i == '&') {
 489         i = scan(scpriv, tokval);
 490         f = expr3(critical);
 491         if (!f)
 492             return NULL;
 493         if (!(is_simple(e) || is_just_unknown(e)) ||
 494             !(is_simple(f) || is_just_unknown(f))) {
 495             error(ERR_NONFATAL, "`&' operator may only be applied to"
 496                   " scalar values");
 497         }
 498         if (is_just_unknown(e) || is_just_unknown(f))
 499             e = unknown_expr();
 500         else
 501             e = scalarvect(reloc_value(e) & reloc_value(f));
 502     }
 503     return e;
 504 }
 505
 506 static expr *expr3(int critical)
 507 {
 508     expr *e, *f;
 509
 510     e = expr4(critical);
 511     if (!e)
 512         return NULL;
 513
 514     while (i == TOKEN_SHL || i == TOKEN_SHR) {
 515         int j = i;
 516         i = scan(scpriv, tokval);
 517         f = expr4(critical);
 518         if (!f)
 519             return NULL;
 520         if (!(is_simple(e) || is_just_unknown(e)) ||
 521             !(is_simple(f) || is_just_unknown(f))) {
 522             error(ERR_NONFATAL, "shift operator may only be applied to"
 523                   " scalar values");
 524         } else if (is_just_unknown(e) || is_just_unknown(f)) {
 525             e = unknown_expr();
 526         } else
 527             switch (j) {
 528             case TOKEN_SHL:
 529                 e = scalarvect(reloc_value(e) << reloc_value(f));
 530                 break;
 531             case TOKEN_SHR:
 532                 e = scalarvect(((uint64_t)reloc_value(e)) >>
 533                                reloc_value(f));
 534                 break;
 535             }
 536     }
 537     return e;
 538 }
 539
 540 static expr *expr4(int critical)
 541 {
 542     expr *e, *f;
 543
 544     e = expr5(critical);
 545     if (!e)
 546         return NULL;
 547     while (i == '+' || i == '-') {
 548         int j = i;
 549         i = scan(scpriv, tokval);
 550         f = expr5(critical);
 551         if (!f)
 552             return NULL;
 553         switch (j) {
 554         case '+':
 555             e = add_vectors(e, f);
 556             break;
 557         case '-':
 558             e = add_vectors(e, scalar_mult(f, -1L, false));
 559             break;
 560         }
 561     }
 562     return e;
 563 }
 564
 565 static expr *expr5(int critical)
 566 {
 567     expr *e, *f;
 568
 569     e = expr6(critical);
 570     if (!e)
 571         return NULL;
 572     while (i == '*' || i == '/' || i == '%' ||
 573            i == TOKEN_SDIV || i == TOKEN_SMOD) {
 574         int j = i;
 575         i = scan(scpriv, tokval);
 576         f = expr6(critical);
 577         if (!f)
 578             return NULL;
 579         if (j != '*' && (!(is_simple(e) || is_just_unknown(e)) ||
 580                          !(is_simple(f) || is_just_unknown(f)))) {
 581             error(ERR_NONFATAL, "division operator may only be applied to"
 582                   " scalar values");
 583             return NULL;
 584         }
 585         if (j != '*' && !is_unknown(f) && reloc_value(f) == 0) {
 586             error(ERR_NONFATAL, "division by zero");
 587             return NULL;
 588         }
 589         switch (j) {
 590         case '*':
 591             if (is_simple(e))
 592                 e = scalar_mult(f, reloc_value(e), true);
 593             else if (is_simple(f))
 594                 e = scalar_mult(e, reloc_value(f), true);
 595             else if (is_just_unknown(e) && is_just_unknown(f))
 596                 e = unknown_expr();
 597             else {
 598                 error(ERR_NONFATAL, "unable to multiply two "
 599                       "non-scalar objects");
 600                 return NULL;
 601             }
 602             break;
 603         case '/':
 604             if (is_just_unknown(e) || is_just_unknown(f))
 605                 e = unknown_expr();
 606             else
 607                 e = scalarvect(((uint64_t)reloc_value(e)) /
 608                                ((uint64_t)reloc_value(f)));
 609             break;
 610         case '%':
 611             if (is_just_unknown(e) || is_just_unknown(f))
 612                 e = unknown_expr();
 613             else
 614                 e = scalarvect(((uint64_t)reloc_value(e)) %
 615                                ((uint64_t)reloc_value(f)));
 616             break;
 617         case TOKEN_SDIV:
 618             if (is_just_unknown(e) || is_just_unknown(f))
 619                 e = unknown_expr();
 620             else
 621                 e = scalarvect(((int64_t)reloc_value(e)) /
 622                                ((int64_t)reloc_value(f)));
 623             break;
 624         case TOKEN_SMOD:
 625             if (is_just_unknown(e) || is_just_unknown(f))
 626                 e = unknown_expr();
 627             else
 628                 e = scalarvect(((int64_t)reloc_value(e)) %
 629                                ((int64_t)reloc_value(f)));
 630             break;
 631         }
 632     }
 633     return e;
 634 }
 635
 636 static expr *eval_floatize(enum floatize type)
 637 {
 638     uint8_t result[16], *p;     /* Up to 128 bits */
 639     static const struct {
 640         int bytes, start, len;
 641     } formats[] = {
 642         {  1, 0, 1 },           /* FLOAT_8 */
 643         {  2, 0, 2 },           /* FLOAT_16 */
 644         {  4, 0, 4 },           /* FLOAT_32 */
 645         {  8, 0, 8 },           /* FLOAT_64 */
 646         { 10, 0, 8 },           /* FLOAT_80M */
 647         { 10, 8, 2 },           /* FLOAT_80E */
 648         { 16, 0, 8 },           /* FLOAT_128L */
 649         { 16, 8, 8 },           /* FLOAT_128H */
 650     };
 651     int sign = 1;
 652     int64_t val;
 653     int j;
 654
 655     i = scan(scpriv, tokval);
 656     if (i != '(') {
 657         error(ERR_NONFATAL, "expecting `('");
 658         return NULL;
 659     }
 660     i = scan(scpriv, tokval);
 661     if (i == '-' || i == '+') {
 662         sign = (i == '-') ? -1 : 1;
 663         i = scan(scpriv, tokval);
 664     }
 665     if (i != TOKEN_FLOAT) {
 666         error(ERR_NONFATAL, "expecting floating-point number");
 667         return NULL;
 668     }
 669     if (!float_const(tokval->t_charptr, sign, result,
 670                      formats[type].bytes, error))
 671         return NULL;
 672     i = scan(scpriv, tokval);
 673     if (i != ')') {
 674         error(ERR_NONFATAL, "expecting `)'");
 675         return NULL;
 676     }
 677
 678     p = result+formats[type].start+formats[type].len;
 679     val = 0;
 680     for (j = formats[type].len; j; j--) {
 681         p--;
 682         val = (val << 8) + *p;
 683     }
 684
 685     begintemp();
 686     addtotemp(EXPR_SIMPLE, val);
 687
 688     i = scan(scpriv, tokval);
 689     return finishtemp();
 690 }
 691
 692 static expr *eval_strfunc(enum strfunc type)
 693 {
 694     char *string;
 695     size_t string_len;
 696     int64_t val;
 697     bool parens, rn_warn;
 698
 699     parens = false;
 700     i = scan(scpriv, tokval);
 701     if (i == '(') {
 702         parens = true;
 703         i = scan(scpriv, tokval);
 704     }
 705     if (i != TOKEN_STR) {
 706         error(ERR_NONFATAL, "expecting string");
 707         return NULL;
 708     }
 709     string_len = string_transform(tokval->t_charptr, tokval->t_inttwo,
 710                                   &string, type);
 711     if (string_len == (size_t)-1) {
 712         error(ERR_NONFATAL, "invalid string for transform");
 713         return NULL;
 714     }
 715
 716     val = readstrnum(string, string_len, &rn_warn);
 717     if (parens) {
 718         i = scan(scpriv, tokval);
 719         if (i != ')') {
 720             error(ERR_NONFATAL, "expecting `)'");
 721             return NULL;
 722         }
 723     }
 724
 725     if (rn_warn)
 726         error(ERR_WARNING|ERR_PASS1, "character constant too long");
 727
 728     begintemp();
 729     addtotemp(EXPR_SIMPLE, val);
 730
 731     i = scan(scpriv, tokval);
 732     return finishtemp();
 733 }
 734
 735 static int64_t eval_ifunc(int64_t val, enum ifunc func)
 736 {
 737     int errtype;
 738     uint64_t uval = (uint64_t)val;
 739     int64_t rv;
 740
 741     switch (func) {
 742     case IFUNC_ILOG2E:
 743     case IFUNC_ILOG2W:
 744         errtype = (func == IFUNC_ILOG2E) ? ERR_NONFATAL : ERR_WARNING;
 745
 746         if (!is_power2(uval))
 747             error(errtype, "ilog2 argument is not a power of two");
 748         /* fall through */
 749     case IFUNC_ILOG2F:
 750         rv = ilog2_64(uval);
 751         break;
 752
 753     case IFUNC_ILOG2C:
 754         rv = (uval < 2) ? 0 : ilog2_64(uval-1) + 1;
 755         break;
 756
 757     default:
 758         error(ERR_PANIC, "invalid IFUNC token %d", func);
 759         rv = 0;
 760         break;
 761     }
 762
 763     return rv;
 764 }
 765
 766 static expr *expr6(int critical)
 767 {
 768     int32_t type;
 769     expr *e;
 770     int32_t label_seg;
 771     int64_t label_ofs;
 772     int64_t tmpval;
 773     bool rn_warn;
 774     char *scope;
 775
 776     switch (i) {
 777     case '-':
 778         i = scan(scpriv, tokval);
 779         e = expr6(critical);
 780         if (!e)
 781             return NULL;
 782         return scalar_mult(e, -1L, false);
 783
 784     case '+':
 785         i = scan(scpriv, tokval);
 786         return expr6(critical);
 787
 788     case '~':
 789         i = scan(scpriv, tokval);
 790         e = expr6(critical);
 791         if (!e)
 792             return NULL;
 793         if (is_just_unknown(e))
 794             return unknown_expr();
 795         else if (!is_simple(e)) {
 796             error(ERR_NONFATAL, "`~' operator may only be applied to"
 797                   " scalar values");
 798             return NULL;
 799         }
 800         return scalarvect(~reloc_value(e));
 801
 802     case '!':
 803         i = scan(scpriv, tokval);
 804         e = expr6(critical);
 805         if (!e)
 806             return NULL;
 807         if (is_just_unknown(e))
 808             return unknown_expr();
 809         else if (!is_simple(e)) {
 810             error(ERR_NONFATAL, "`!' operator may only be applied to"
 811                   " scalar values");
 812             return NULL;
 813         }
 814         return scalarvect(!reloc_value(e));
 815
 816     case TOKEN_IFUNC:
 817     {
 818         enum ifunc func = tokval->t_integer;
 819         i = scan(scpriv, tokval);
 820         e = expr6(critical);
 821         if (!e)
 822             return NULL;
 823         if (is_just_unknown(e))
 824             return unknown_expr();
 825         else if (!is_simple(e)) {
 826             error(ERR_NONFATAL, "function may only be applied to"
 827                   " scalar values");
 828             return NULL;
 829         }
 830         return scalarvect(eval_ifunc(reloc_value(e), func));
 831     }
 832
 833     case TOKEN_SEG:
 834         i = scan(scpriv, tokval);
 835         e = expr6(critical);
 836         if (!e)
 837             return NULL;
 838         e = segment_part(e);
 839         if (!e)
 840             return NULL;
 841         if (is_unknown(e) && critical) {
 842             error(ERR_NONFATAL, "unable to determine segment base");
 843             return NULL;
 844         }
 845         return e;
 846
 847     case TOKEN_FLOATIZE:
 848         return eval_floatize(tokval->t_integer);
 849
 850     case TOKEN_STRFUNC:
 851         return eval_strfunc(tokval->t_integer);
 852
 853     case '(':
 854         i = scan(scpriv, tokval);
 855         e = bexpr(critical);
 856         if (!e)
 857             return NULL;
 858         if (i != ')') {
 859             error(ERR_NONFATAL, "expecting `)'");
 860             return NULL;
 861         }
 862         i = scan(scpriv, tokval);
 863         return e;
 864
 865     case TOKEN_NUM:
 866     case TOKEN_STR:
 867     case TOKEN_REG:
 868     case TOKEN_ID:
 869     case TOKEN_INSN:            /* Opcodes that occur here are really labels */
 870     case TOKEN_HERE:
 871     case TOKEN_BASE:
 872     case TOKEN_DECORATOR:
 873         begintemp();
 874         switch (i) {
 875         case TOKEN_NUM:
 876             addtotemp(EXPR_SIMPLE, tokval->t_integer);
 877             break;
 878         case TOKEN_STR:
 879             tmpval = readstrnum(tokval->t_charptr, tokval->t_inttwo, &rn_warn);
 880             if (rn_warn)
 881                 error(ERR_WARNING|ERR_PASS1, "character constant too long");
 882             addtotemp(EXPR_SIMPLE, tmpval);
 883             break;
 884         case TOKEN_REG:
 885             addtotemp(tokval->t_integer, 1L);
 886             if (hint && hint->type == EAH_NOHINT)
 887                 hint->base = tokval->t_integer, hint->type = EAH_MAKEBASE;
 888             break;
 889         case TOKEN_ID:
 890         case TOKEN_INSN:
 891         case TOKEN_HERE:
 892         case TOKEN_BASE:
 893             /*
 894              * If !location->known, this indicates that no
 895              * symbol, Here or Base references are valid because we
 896              * are in preprocess-only mode.
 897              */
 898             if (!location->known) {
 899                 error(ERR_NONFATAL,
 900                       "%s not supported in preprocess-only mode",
 901                       (i == TOKEN_HERE ? "`$'" :
 902                        i == TOKEN_BASE ? "`$$'" :
 903                        "symbol references"));
 904                 addtotemp(EXPR_UNKNOWN, 1L);
 905                 break;
 906             }
 907
 908             type = EXPR_SIMPLE; /* might get overridden by UNKNOWN */
 909             if (i == TOKEN_BASE) {
 910                 label_seg = in_abs_seg ? abs_seg : location->segment;
 911                 label_ofs = 0;
 912             } else if (i == TOKEN_HERE) {
 913                 label_seg = in_abs_seg ? abs_seg : location->segment;
 914                 label_ofs = in_abs_seg ? abs_offset : location->offset;
 915             } else {
 916                 if (!labelfunc(tokval->t_charptr, &label_seg, &label_ofs)) {
 917                     scope = local_scope(tokval->t_charptr);
 918                     if (critical == 2) {
 919                         error(ERR_NONFATAL, "symbol `%s%s' undefined",
 920                               scope,tokval->t_charptr);
 921                         return NULL;
 922                     } else if (critical == 1) {
 923                         error(ERR_NONFATAL,
 924                               "symbol `%s%s' not defined before use",
 925                               scope,tokval->t_charptr);
 926                         return NULL;
 927                     } else {
 928                         if (opflags)
 929                             *opflags |= OPFLAG_FORWARD;
 930                         type = EXPR_UNKNOWN;
 931                         label_seg = NO_SEG;
 932                         label_ofs = 1;
 933                     }
 934                 }
 935                 if (opflags && is_extern(tokval->t_charptr))
 936                     *opflags |= OPFLAG_EXTERN;
 937             }
 938             addtotemp(type, label_ofs);
 939             if (label_seg != NO_SEG)
 940                 addtotemp(EXPR_SEGBASE + label_seg, 1L);
 941             break;
 942         case TOKEN_DECORATOR:
 943             addtotemp(EXPR_RDSAE, tokval->t_integer);
 944             break;
 945         }
 946         i = scan(scpriv, tokval);
 947         return finishtemp();
 948
 949     default:
 950         error(ERR_NONFATAL, "expression syntax error");
 951         return NULL;
 952     }
 953 }
 954
 955 void eval_global_info(struct ofmt *output, lfunc lookup_label,
 956                       struct location * locp)
 957 {
 958     outfmt = output;
 959     labelfunc = lookup_label;
 960     location = locp;
 961 }
 962
 963 expr *evaluate(scanner sc, void *scprivate, struct tokenval *tv,
 964                int *fwref, int critical, efunc report_error,
 965                struct eval_hints *hints)
 966 {
 967     expr *e;
 968     expr *f = NULL;
 969
 970     hint = hints;
 971     if (hint)
 972         hint->type = EAH_NOHINT;
 973
 974     if (critical & CRITICAL) {
 975         critical &= ~CRITICAL;
 976         bexpr = rexp0;
 977     } else
 978         bexpr = expr0;
 979
 980     scan = sc;
 981     scpriv = scprivate;
 982     tokval = tv;
 983     error = report_error;
 984     opflags = fwref;
 985
 986     if (tokval->t_type == TOKEN_INVALID)
 987         i = scan(scpriv, tokval);
 988     else
 989         i = tokval->t_type;
 990
 991     while (ntempexprs)          /* initialize temporary storage */
 992         nasm_free(tempexprs[--ntempexprs]);
 993
 994     e = bexpr(critical);
 995     if (!e)
 996         return NULL;
 997
 998     if (i == TOKEN_WRT) {
 999         i = scan(scpriv, tokval);       /* eat the WRT */
1000         f = expr6(critical);
1001         if (!f)
1002             return NULL;
1003     }
1004     e = scalar_mult(e, 1L, false);      /* strip far-absolute segment part */
1005     if (f) {
1006         expr *g;
1007         if (is_just_unknown(f))
1008             g = unknown_expr();
1009         else {
1010             int64_t value;
1011             begintemp();
1012             if (!is_reloc(f)) {
1013                 error(ERR_NONFATAL, "invalid right-hand operand to WRT");
1014                 return NULL;
1015             }
1016             value = reloc_seg(f);
1017             if (value == NO_SEG)
1018                 value = reloc_value(f) | SEG_ABS;
1019             else if (!(value & SEG_ABS) && !(value % 2) && critical) {
1020                 error(ERR_NONFATAL, "invalid right-hand operand to WRT");
1021                 return NULL;
1022             }
1023             addtotemp(EXPR_WRT, value);
1024             g = finishtemp();
1025         }
1026         e = add_vectors(e, g);
1027     }
1028     return e;
1029 }