BR 3392218: Disassemble 82h opcodes
[nasm/nasm.git] / eval.c
blobd7cf844edbe8381ab08ad13c07197457c5832990
1 /* ----------------------------------------------------------------------- *
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.
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following
9 * conditions are met:
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.
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.
32 * ----------------------------------------------------------------------- */
35 * eval.c expression evaluator for the Netwide Assembler
38 #include "compiler.h"
40 #include <stdio.h>
41 #include <stdlib.h>
42 #include <stddef.h>
43 #include <string.h>
44 #include <ctype.h>
45 #include <inttypes.h>
47 #include "nasm.h"
48 #include "nasmlib.h"
49 #include "eval.h"
50 #include "labels.h"
51 #include "float.h"
53 #define TEMPEXPRS_DELTA 128
54 #define TEMPEXPR_DELTA 8
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 */
60 static struct ofmt *outfmt; /* Structure of addresses of output routines */
62 static expr **tempexprs = NULL;
63 static int ntempexprs;
64 static int tempexprs_size = 0;
66 static expr *tempexpr;
67 static int ntempexpr;
68 static int tempexpr_size;
70 static struct tokenval *tokval; /* The current token */
71 static int i; /* The t_type of tokval */
73 static void *scpriv;
74 static struct location *location; /* Pointer to current line's segment,offset */
75 static int *opflags;
77 static struct eval_hints *hint;
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 */
84 * Unimportant cleanup is done to avoid confusing people who are trying
85 * to debug real memory leaks
87 void eval_cleanup(void)
89 while (ntempexprs)
90 nasm_free(tempexprs[--ntempexprs]);
91 nasm_free(tempexprs);
95 * Construct a temporary expression.
97 static void begintemp(void)
99 tempexpr = NULL;
100 tempexpr_size = ntempexpr = 0;
103 static void addtotemp(int32_t type, int64_t value)
105 while (ntempexpr >= tempexpr_size) {
106 tempexpr_size += TEMPEXPR_DELTA;
107 tempexpr = nasm_realloc(tempexpr,
108 tempexpr_size * sizeof(*tempexpr));
110 tempexpr[ntempexpr].type = type;
111 tempexpr[ntempexpr++].value = value;
114 static expr *finishtemp(void)
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));
122 return tempexprs[ntempexprs++] = tempexpr;
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.
130 static expr *add_vectors(expr * p, expr * q)
132 int preserve;
134 preserve = is_really_simple(p) || is_really_simple(q);
136 begintemp();
138 while (p->type && q->type &&
139 p->type < EXPR_SEGBASE + SEG_ABS &&
140 q->type < EXPR_SEGBASE + SEG_ABS) {
141 int lasttype;
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++;
156 if (lasttype == EXPR_UNKNOWN) {
157 return finishtemp();
160 while (p->type && (preserve || p->type < EXPR_SEGBASE + SEG_ABS)) {
161 addtotemp(p->type, p->value);
162 p++;
164 while (q->type && (preserve || q->type < EXPR_SEGBASE + SEG_ABS)) {
165 addtotemp(q->type, q->value);
166 q++;
169 return finishtemp();
173 * Multiply a vector by a scalar. Strip far-absolute segment part
174 * if present.
176 * Explicit treatment of UNKNOWN is not required in this routine,
177 * since it will silently do the Right Thing anyway.
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.
184 static expr *scalar_mult(expr * vect, int64_t scalar, int affect_hints)
186 expr *p = vect;
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++;
195 p->type = 0;
197 return vect;
200 static expr *scalarvect(int64_t scalar)
202 begintemp();
203 addtotemp(EXPR_SIMPLE, scalar);
204 return finishtemp();
207 static expr *unknown_expr(void)
209 begintemp();
210 addtotemp(EXPR_UNKNOWN, 1L);
211 return finishtemp();
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.
219 static expr *segment_part(expr * e)
221 int32_t seg;
223 if (is_unknown(e))
224 return unknown_expr();
226 if (!is_reloc(e)) {
227 error(ERR_NONFATAL, "cannot apply SEG to a non-relocatable value");
228 return NULL;
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);
244 begintemp();
245 addtotemp((base == NO_SEG ? EXPR_UNKNOWN : EXPR_SEGBASE + base),
246 1L);
247 return finishtemp();
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.
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.
263 * Grammar parsed is:
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
284 static expr *rexp0(int), *rexp1(int), *rexp2(int), *rexp3(int);
286 static expr *expr0(int), *expr1(int), *expr2(int), *expr3(int);
287 static expr *expr4(int), *expr5(int), *expr6(int);
289 static expr *(*bexpr) (int);
291 static expr *rexp0(int critical)
293 expr *e, *f;
295 e = rexp1(critical);
296 if (!e)
297 return NULL;
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");
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)));
315 return e;
318 static expr *rexp1(int critical)
320 expr *e, *f;
322 e = rexp2(critical);
323 if (!e)
324 return NULL;
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");
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)));
342 return e;
345 static expr *rexp2(int critical)
347 expr *e, *f;
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");
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)));
367 return e;
370 static expr *rexp3(int critical)
372 expr *e, *f;
373 int64_t v;
375 e = expr0(critical);
376 if (!e)
377 return NULL;
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;
387 e = add_vectors(e, scalar_mult(f, -1L, false));
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);
417 break;
420 if (v == -1)
421 e = unknown_expr();
422 else
423 e = scalarvect(v);
425 return e;
428 static expr *expr0(int critical)
430 expr *e, *f;
432 e = expr1(critical);
433 if (!e)
434 return NULL;
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");
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));
451 return e;
454 static expr *expr1(int critical)
456 expr *e, *f;
458 e = expr2(critical);
459 if (!e)
460 return NULL;
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");
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));
477 return e;
480 static expr *expr2(int critical)
482 expr *e, *f;
484 e = expr3(critical);
485 if (!e)
486 return NULL;
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");
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));
503 return e;
506 static expr *expr3(int critical)
508 expr *e, *f;
510 e = expr4(critical);
511 if (!e)
512 return NULL;
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;
537 return e;
540 static expr *expr4(int critical)
542 expr *e, *f;
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;
562 return e;
565 static expr *expr5(int critical)
567 expr *e, *f;
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;
585 if (j != '*' && !is_unknown(f) && reloc_value(f) == 0) {
586 error(ERR_NONFATAL, "division by zero");
587 return NULL;
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;
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;
633 return e;
636 static expr *eval_floatize(enum floatize type)
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 */
651 int sign = 1;
652 int64_t val;
653 int j;
655 i = scan(scpriv, tokval);
656 if (i != '(') {
657 error(ERR_NONFATAL, "expecting `('");
658 return NULL;
660 i = scan(scpriv, tokval);
661 if (i == '-' || i == '+') {
662 sign = (i == '-') ? -1 : 1;
663 i = scan(scpriv, tokval);
665 if (i != TOKEN_FLOAT) {
666 error(ERR_NONFATAL, "expecting floating-point number");
667 return NULL;
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;
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;
685 begintemp();
686 addtotemp(EXPR_SIMPLE, val);
688 i = scan(scpriv, tokval);
689 return finishtemp();
692 static expr *eval_strfunc(enum strfunc type)
694 char *string;
695 size_t string_len;
696 int64_t val;
697 bool parens, rn_warn;
699 parens = false;
700 i = scan(scpriv, tokval);
701 if (i == '(') {
702 parens = true;
703 i = scan(scpriv, tokval);
705 if (i != TOKEN_STR) {
706 error(ERR_NONFATAL, "expecting string");
707 return NULL;
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;
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;
725 if (rn_warn)
726 error(ERR_WARNING|ERR_PASS1, "character constant too long");
728 begintemp();
729 addtotemp(EXPR_SIMPLE, val);
731 i = scan(scpriv, tokval);
732 return finishtemp();
735 static int64_t eval_ifunc(int64_t val, enum ifunc func)
737 int errtype;
738 uint64_t uval = (uint64_t)val;
739 int64_t rv;
741 switch (func) {
742 case IFUNC_ILOG2E:
743 case IFUNC_ILOG2W:
744 errtype = (func == IFUNC_ILOG2E) ? ERR_NONFATAL : ERR_WARNING;
746 if ((!uval) | (uval & (uval-1)))
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;
753 case IFUNC_ILOG2C:
754 rv = (uval < 2) ? 0 : ilog2_64(uval-1) + 1;
755 break;
757 default:
758 error(ERR_PANIC, "invalid IFUNC token %d", func);
759 rv = 0;
760 break;
763 return rv;
766 static expr *expr6(int critical)
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;
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);
784 case '+':
785 i = scan(scpriv, tokval);
786 return expr6(critical);
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;
800 return scalarvect(~reloc_value(e));
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;
814 return scalarvect(!reloc_value(e));
816 case TOKEN_IFUNC:
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;
830 return scalarvect(eval_ifunc(reloc_value(e), func));
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;
845 return e;
847 case TOKEN_FLOATIZE:
848 return eval_floatize(tokval->t_integer);
850 case TOKEN_STRFUNC:
851 return eval_strfunc(tokval->t_integer);
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;
862 i = scan(scpriv, tokval);
863 return e;
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 begintemp();
873 switch (i) {
874 case TOKEN_NUM:
875 addtotemp(EXPR_SIMPLE, tokval->t_integer);
876 break;
877 case TOKEN_STR:
878 tmpval = readstrnum(tokval->t_charptr, tokval->t_inttwo, &rn_warn);
879 if (rn_warn)
880 error(ERR_WARNING|ERR_PASS1, "character constant too long");
881 addtotemp(EXPR_SIMPLE, tmpval);
882 break;
883 case TOKEN_REG:
884 addtotemp(tokval->t_integer, 1L);
885 if (hint && hint->type == EAH_NOHINT)
886 hint->base = tokval->t_integer, hint->type = EAH_MAKEBASE;
887 break;
888 case TOKEN_ID:
889 case TOKEN_INSN:
890 case TOKEN_HERE:
891 case TOKEN_BASE:
893 * If !location->known, this indicates that no
894 * symbol, Here or Base references are valid because we
895 * are in preprocess-only mode.
897 if (!location->known) {
898 error(ERR_NONFATAL,
899 "%s not supported in preprocess-only mode",
900 (i == TOKEN_HERE ? "`$'" :
901 i == TOKEN_BASE ? "`$$'" :
902 "symbol references"));
903 addtotemp(EXPR_UNKNOWN, 1L);
904 break;
907 type = EXPR_SIMPLE; /* might get overridden by UNKNOWN */
908 if (i == TOKEN_BASE) {
909 label_seg = in_abs_seg ? abs_seg : location->segment;
910 label_ofs = 0;
911 } else if (i == TOKEN_HERE) {
912 label_seg = in_abs_seg ? abs_seg : location->segment;
913 label_ofs = in_abs_seg ? abs_offset : location->offset;
914 } else {
915 if (!labelfunc(tokval->t_charptr, &label_seg, &label_ofs)) {
916 scope = local_scope(tokval->t_charptr);
917 if (critical == 2) {
918 error(ERR_NONFATAL, "symbol `%s%s' undefined",
919 scope,tokval->t_charptr);
920 return NULL;
921 } else if (critical == 1) {
922 error(ERR_NONFATAL,
923 "symbol `%s%s' not defined before use",
924 scope,tokval->t_charptr);
925 return NULL;
926 } else {
927 if (opflags)
928 *opflags |= OPFLAG_FORWARD;
929 type = EXPR_UNKNOWN;
930 label_seg = NO_SEG;
931 label_ofs = 1;
934 if (opflags && is_extern(tokval->t_charptr))
935 *opflags |= OPFLAG_EXTERN;
937 addtotemp(type, label_ofs);
938 if (label_seg != NO_SEG)
939 addtotemp(EXPR_SEGBASE + label_seg, 1L);
940 break;
942 i = scan(scpriv, tokval);
943 return finishtemp();
945 default:
946 error(ERR_NONFATAL, "expression syntax error");
947 return NULL;
951 void eval_global_info(struct ofmt *output, lfunc lookup_label,
952 struct location * locp)
954 outfmt = output;
955 labelfunc = lookup_label;
956 location = locp;
959 expr *evaluate(scanner sc, void *scprivate, struct tokenval *tv,
960 int *fwref, int critical, efunc report_error,
961 struct eval_hints *hints)
963 expr *e;
964 expr *f = NULL;
966 hint = hints;
967 if (hint)
968 hint->type = EAH_NOHINT;
970 if (critical & CRITICAL) {
971 critical &= ~CRITICAL;
972 bexpr = rexp0;
973 } else
974 bexpr = expr0;
976 scan = sc;
977 scpriv = scprivate;
978 tokval = tv;
979 error = report_error;
980 opflags = fwref;
982 if (tokval->t_type == TOKEN_INVALID)
983 i = scan(scpriv, tokval);
984 else
985 i = tokval->t_type;
987 while (ntempexprs) /* initialize temporary storage */
988 nasm_free(tempexprs[--ntempexprs]);
990 e = bexpr(critical);
991 if (!e)
992 return NULL;
994 if (i == TOKEN_WRT) {
995 i = scan(scpriv, tokval); /* eat the WRT */
996 f = expr6(critical);
997 if (!f)
998 return NULL;
1000 e = scalar_mult(e, 1L, false); /* strip far-absolute segment part */
1001 if (f) {
1002 expr *g;
1003 if (is_just_unknown(f))
1004 g = unknown_expr();
1005 else {
1006 int64_t value;
1007 begintemp();
1008 if (!is_reloc(f)) {
1009 error(ERR_NONFATAL, "invalid right-hand operand to WRT");
1010 return NULL;
1012 value = reloc_seg(f);
1013 if (value == NO_SEG)
1014 value = reloc_value(f) | SEG_ABS;
1015 else if (!(value & SEG_ABS) && !(value % 2) && critical) {
1016 error(ERR_NONFATAL, "invalid right-hand operand to WRT");
1017 return NULL;
1019 addtotemp(EXPR_WRT, value);
1020 g = finishtemp();
1022 e = add_vectors(e, g);
1024 return e;