eval.c

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