laag-nasm 2.13.03.2

data/vendor/repo.or.cz/nasm/asm/directiv.dat

@@ -0,0 +1,92 @@
+;; --------------------------------------------------------------------------
+;;
+;;   Copyright 1996-2017 The NASM Authors - All Rights Reserved
+;;   See the file AUTHORS included with the NASM distribution for
+;;   the specific copyright holders.
+;;
+;;   Redistribution and use in source and binary forms, with or without
+;;   modification, are permitted provided that the following
+;;   conditions are met:
+;;
+;;   * Redistributions of source code must retain the above copyright
+;;     notice, this list of conditions and the following disclaimer.
+;;   * Redistributions in binary form must reproduce the above
+;;     copyright notice, this list of conditions and the following
+;;     disclaimer in the documentation and/or other materials provided
+;;     with the distribution.
+;;
+;;     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+;;     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+;;     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+;;     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+;;     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+;;     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+;;     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+;;     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+;;     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+;;     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+;;     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+;;     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+;;     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+;;
+;; --------------------------------------------------------------------------
+;;
+;; List of global NASM directives and pragma operations codes
+;;
+;; ALL directives, including backend-specific, need to be added here.
+;;
+;; %pragma operation keywords (the second word, after facility) MAY
+;; be added here too to assist in parsing, but it is not required.
+;; See the definition of struct pragma in include/nasm.h.
+;;
+;; The same keyword can be used as a directive and as a pragma
+;; operation, or as pragma operations in different namespaces.  The
+;; same D_ constant will be used for both, and this is perfectly
+;; acceptable.
+;;
+
+; --- General configuration
+#name directive
+#prefix D_
+#errval D_unknown
+#header directiv.h
+
+; --- Special enum values
+#special none = 0			; Must be zero
+#special unknown
+#special corrupt
+
+; --- Global directives
+absolute
+bits
+common
+cpu
+debug
+default
+extern
+float
+global
+list
+section
+segment
+warning
+sectalign
+pragma
+
+; --- Format-specific directives
+export				; outcoff, outobj
+group				; outobj
+import				; outobj
+library				; outrdf2
+map				; outbin
+module				; outrdf2
+org				; outbin
+osabi				; outelf
+safeseh				; outcoff
+uppercase			; outieee, outobj
+
+; --- Pragma operations
+subsections_via_symbols		; macho
+no_dead_strip			; macho
+maxdump				; dbg
+nodepend			; obj

data/vendor/repo.or.cz/nasm/asm/error.c

@@ -0,0 +1,202 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2017 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * error.c - error message handling routines for the assembler
+ */
+
+#include "compiler.h"
+
+#include <stdlib.h>
+
+#include "nasmlib.h"
+#include "error.h"
+
+/*
+ * Description of the suppressible warnings for the command line and
+ * the [warning] directive.
+ */
+const struct warning warnings[ERR_WARN_ALL+1] = {
+    {"other", "any warning not specifially mentioned below", true},
+    {"macro-params", "macro calls with wrong parameter count", true},
+    {"macro-selfref", "cyclic macro references", false},
+    {"macro-defaults", "macros with more default than optional parameters", true},
+    {"orphan-labels", "labels alone on lines without trailing `:'", true},
+    {"number-overflow", "numeric constant does not fit", true},
+    {"gnu-elf-extensions", "using 8- or 16-bit relocation in ELF32, a GNU extension", false},
+    {"float-overflow", "floating point overflow", true},
+    {"float-denorm", "floating point denormal", false},
+    {"float-underflow", "floating point underflow", false},
+    {"float-toolong", "too many digits in floating-point number", true},
+    {"user", "%warning directives", true},
+    {"lock", "lock prefix on unlockable instructions", true},
+    {"hle", "invalid hle prefixes", true},
+    {"bnd", "invalid bnd prefixes", true},
+    {"zext-reloc", "relocation zero-extended to match output format", true},
+    {"ptr", "non-NASM keyword used in other assemblers", true},
+    {"bad-pragma", "empty or malformed %pragma", false},
+    {"unknown-pragma", "unknown %pragma facility or directive", false},
+    {"not-my-pragma", "%pragma not applicable to this compilation", false},
+    {"unknown-warning", "unknown warning in -W/-w or warning directive", false},
+
+    /* THIS ENTRY MUST COME LAST */
+    {"all", "all possible warnings", false}
+};
+
+uint8_t warning_state[ERR_WARN_ALL];/* Current state */
+uint8_t warning_state_init[ERR_WARN_ALL]; /* Command-line state, for reset */
+
+vefunc nasm_verror;    /* Global error handling function */
+
+void nasm_error(int severity, const char *fmt, ...)
+{
+    va_list ap;
+
+    va_start(ap, fmt);
+    nasm_verror(severity, fmt, ap);
+    va_end(ap);
+}
+
+no_return nasm_fatal(int flags, const char *fmt, ...)
+{
+    va_list ap;
+
+    va_start(ap, fmt);
+    nasm_verror(flags | ERR_FATAL, fmt, ap);
+    abort();			/* We should never get here */
+}
+
+no_return nasm_panic(int flags, const char *fmt, ...)
+{
+    va_list ap;
+
+    va_start(ap, fmt);
+    nasm_verror(flags | ERR_PANIC, fmt, ap);
+    abort();			/* We should never get here */
+}
+
+no_return nasm_panic_from_macro(const char *file, int line)
+{
+    nasm_panic(ERR_NOFILE, "Internal error at %s:%d\n", file, line);
+}
+
+no_return nasm_assert_failed(const char *file, int line, const char *msg)
+{
+    nasm_panic(0, "assertion %s failed at %s:%d", msg, file, line);
+}
+
+/*
+ * This is called when processing a -w or -W option, or a warning directive.
+ * Returns true if if the action was successful.
+ */
+bool set_warning_status(const char *value)
+{
+    enum warn_action { WID_OFF, WID_ON, WID_RESET };
+    enum warn_action action;
+    uint8_t mask;
+    int i;
+    bool ok = false;
+
+    value = nasm_skip_spaces(value);
+    switch (*value) {
+    case '-':
+        action = WID_OFF;
+        value++;
+        break;
+    case '+':
+        action = WID_ON;
+        value++;
+        break;
+    case '*':
+        action = WID_RESET;
+        value++;
+        break;
+    case 'N':
+    case 'n':
+        if (!nasm_strnicmp(value, "no-", 3)) {
+            action = WID_OFF;
+            value += 3;
+            break;
+        } else if (!nasm_stricmp(value, "none")) {
+            action = WID_OFF;
+            value = NULL;
+            break;
+        }
+        /* else fall through */
+    default:
+        action = WID_ON;
+        break;
+    }
+
+    mask = WARN_ST_ENABLED;
+
+    if (value && !nasm_strnicmp(value, "error", 5)) {
+        switch (value[5]) {
+        case '=':
+            mask = WARN_ST_ERROR;
+            value += 6;
+            break;
+        case '\0':
+            mask = WARN_ST_ERROR;
+            value = NULL;
+            break;
+        default:
+            /* Just an accidental prefix? */
+            break;
+        }
+    }
+
+    if (value && !nasm_stricmp(value, "all"))
+        value = NULL;
+
+    /* This is inefficient, but it shouldn't matter... */
+    for (i = 0; i < ERR_WARN_ALL; i++) {
+        if (!value || !nasm_stricmp(value, warnings[i].name)) {
+            ok = true;          /* At least one action taken */
+            switch (action) {
+            case WID_OFF:
+                warning_state[i] &= ~mask;
+                break;
+            case WID_ON:
+                warning_state[i] |= mask;
+                break;
+            case WID_RESET:
+                warning_state[i] &= ~mask;
+                warning_state[i] |= warning_state_init[i] & mask;
+                break;
+            }
+        }
+    }
+
+    return ok;
+}

data/vendor/repo.or.cz/nasm/asm/eval.c

@@ -0,0 +1,1014 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2017 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * eval.c    expression evaluator for the Netwide Assembler
+ */
+
+#include "compiler.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <string.h>
+#include <ctype.h>
+
+#include "nasm.h"
+#include "nasmlib.h"
+#include "error.h"
+#include "eval.h"
+#include "labels.h"
+#include "float.h"
+#include "assemble.h"
+
+#define TEMPEXPRS_DELTA 128
+#define TEMPEXPR_DELTA 8
+
+static scanner scan;            /* Address of scanner routine */
+
+static expr **tempexprs = NULL;
+static int ntempexprs;
+static int tempexprs_size = 0;
+
+static expr *tempexpr;
+static int ntempexpr;
+static int tempexpr_size;
+
+static struct tokenval *tokval; /* The current token */
+static int i;                   /* The t_type of tokval */
+
+static void *scpriv;
+static int *opflags;
+
+static struct eval_hints *hint;
+
+
+/*
+ * Unimportant cleanup is done to avoid confusing people who are trying
+ * to debug real memory leaks
+ */
+void eval_cleanup(void)
+{
+    while (ntempexprs)
+        nasm_free(tempexprs[--ntempexprs]);
+    nasm_free(tempexprs);
+}
+
+/*
+ * Construct a temporary expression.
+ */
+static void begintemp(void)
+{
+    tempexpr = NULL;
+    tempexpr_size = ntempexpr = 0;
+}
+
+static void addtotemp(int32_t type, int64_t value)
+{
+    while (ntempexpr >= tempexpr_size) {
+        tempexpr_size += TEMPEXPR_DELTA;
+        tempexpr = nasm_realloc(tempexpr,
+                                tempexpr_size * sizeof(*tempexpr));
+    }
+    tempexpr[ntempexpr].type = type;
+    tempexpr[ntempexpr++].value = value;
+}
+
+static expr *finishtemp(void)
+{
+    addtotemp(0L, 0L);          /* terminate */
+    while (ntempexprs >= tempexprs_size) {
+        tempexprs_size += TEMPEXPRS_DELTA;
+        tempexprs = nasm_realloc(tempexprs,
+                                 tempexprs_size * sizeof(*tempexprs));
+    }
+    return tempexprs[ntempexprs++] = tempexpr;
+}
+
+/*
+ * Add two vector datatypes. We have some bizarre behaviour on far-
+ * absolute segment types: we preserve them during addition _only_
+ * if one of the segments is a truly pure scalar.
+ */
+static expr *add_vectors(expr * p, expr * q)
+{
+    int preserve;
+
+    preserve = is_really_simple(p) || is_really_simple(q);
+
+    begintemp();
+
+    while (p->type && q->type &&
+           p->type < EXPR_SEGBASE + SEG_ABS &&
+           q->type < EXPR_SEGBASE + SEG_ABS) {
+        int lasttype;
+
+        if (p->type > q->type) {
+            addtotemp(q->type, q->value);
+            lasttype = q++->type;
+        } else if (p->type < q->type) {
+            addtotemp(p->type, p->value);
+            lasttype = p++->type;
+        } else {                /* *p and *q have same type */
+            int64_t sum = p->value + q->value;
+            if (sum) {
+                addtotemp(p->type, sum);
+                if (hint)
+                    hint->type = EAH_SUMMED;
+            }
+            lasttype = p->type;
+            p++, q++;
+        }
+        if (lasttype == EXPR_UNKNOWN) {
+            return finishtemp();
+        }
+    }
+    while (p->type && (preserve || p->type < EXPR_SEGBASE + SEG_ABS)) {
+        addtotemp(p->type, p->value);
+        p++;
+    }
+    while (q->type && (preserve || q->type < EXPR_SEGBASE + SEG_ABS)) {
+        addtotemp(q->type, q->value);
+        q++;
+    }
+
+    return finishtemp();
+}
+
+/*
+ * Multiply a vector by a scalar. Strip far-absolute segment part
+ * if present.
+ *
+ * Explicit treatment of UNKNOWN is not required in this routine,
+ * since it will silently do the Right Thing anyway.
+ *
+ * If `affect_hints' is set, we also change the hint type to
+ * NOTBASE if a MAKEBASE hint points at a register being
+ * multiplied. This allows [eax*1+ebx] to hint EBX rather than EAX
+ * as the base register.
+ */
+static expr *scalar_mult(expr * vect, int64_t scalar, int affect_hints)
+{
+    expr *p = vect;
+
+    while (p->type && p->type < EXPR_SEGBASE + SEG_ABS) {
+        p->value = scalar * (p->value);
+        if (hint && hint->type == EAH_MAKEBASE &&
+            p->type == hint->base && affect_hints)
+            hint->type = EAH_NOTBASE;
+        p++;
+    }
+    p->type = 0;
+
+    return vect;
+}
+
+static expr *scalarvect(int64_t scalar)
+{
+    begintemp();
+    addtotemp(EXPR_SIMPLE, scalar);
+    return finishtemp();
+}
+
+static expr *unknown_expr(void)
+{
+    begintemp();
+    addtotemp(EXPR_UNKNOWN, 1L);
+    return finishtemp();
+}
+
+/*
+ * The SEG operator: calculate the segment part of a relocatable
+ * value. Return NULL, as usual, if an error occurs. Report the
+ * error too.
+ */
+static expr *segment_part(expr * e)
+{
+    int32_t seg;
+
+    if (is_unknown(e))
+        return unknown_expr();
+
+    if (!is_reloc(e)) {
+        nasm_error(ERR_NONFATAL, "cannot apply SEG to a non-relocatable value");
+        return NULL;
+    }
+
+    seg = reloc_seg(e);
+    if (seg == NO_SEG) {
+        nasm_error(ERR_NONFATAL, "cannot apply SEG to a non-relocatable value");
+        return NULL;
+    } else if (seg & SEG_ABS) {
+        return scalarvect(seg & ~SEG_ABS);
+    } else if (seg & 1) {
+        nasm_error(ERR_NONFATAL, "SEG applied to something which"
+              " is already a segment base");
+        return NULL;
+    } else {
+        int32_t base = ofmt->segbase(seg + 1);
+
+        begintemp();
+        addtotemp((base == NO_SEG ? EXPR_UNKNOWN : EXPR_SEGBASE + base),
+                  1L);
+        return finishtemp();
+    }
+}
+
+/*
+ * Recursive-descent parser. Called with a single boolean operand,
+ * which is true if the evaluation is critical (i.e. unresolved
+ * symbols are an error condition). Must update the global `i' to
+ * reflect the token after the parsed string. May return NULL.
+ *
+ * evaluate() should report its own errors: on return it is assumed
+ * that if NULL has been returned, the error has already been
+ * reported.
+ */
+
+/*
+ * Grammar parsed is:
+ *
+ * expr  : bexpr [ WRT expr6 ]
+ * bexpr : rexp0 or expr0 depending on relative-mode setting
+ * rexp0 : rexp1 [ {||} rexp1...]
+ * rexp1 : rexp2 [ {^^} rexp2...]
+ * rexp2 : rexp3 [ {&&} rexp3...]
+ * rexp3 : expr0 [ {=,==,<>,!=,<,>,<=,>=} expr0 ]
+ * expr0 : expr1 [ {|} expr1...]
+ * expr1 : expr2 [ {^} expr2...]
+ * expr2 : expr3 [ {&} expr3...]
+ * expr3 : expr4 [ {<<,>>} expr4...]
+ * expr4 : expr5 [ {+,-} expr5...]
+ * expr5 : expr6 [ {*,/,%,//,%%} expr6...]
+ * expr6 : { ~,+,-,IFUNC,SEG } expr6
+ *       | (bexpr)
+ *       | symbol
+ *       | $
+ *       | number
+ */
+
+static expr *rexp0(int), *rexp1(int), *rexp2(int), *rexp3(int);
+
+static expr *expr0(int), *expr1(int), *expr2(int), *expr3(int);
+static expr *expr4(int), *expr5(int), *expr6(int);
+
+static expr *(*bexpr) (int);
+
+static expr *rexp0(int critical)
+{
+    expr *e, *f;
+
+    e = rexp1(critical);
+    if (!e)
+        return NULL;
+
+    while (i == TOKEN_DBL_OR) {
+        i = scan(scpriv, tokval);
+        f = rexp1(critical);
+        if (!f)
+            return NULL;
+        if (!(is_simple(e) || is_just_unknown(e)) ||
+            !(is_simple(f) || is_just_unknown(f))) {
+            nasm_error(ERR_NONFATAL, "`|' operator may only be applied to"
+                  " scalar values");
+        }
+
+        if (is_just_unknown(e) || is_just_unknown(f))
+            e = unknown_expr();
+        else
+            e = scalarvect((int64_t)(reloc_value(e) || reloc_value(f)));
+    }
+    return e;
+}
+
+static expr *rexp1(int critical)
+{
+    expr *e, *f;
+
+    e = rexp2(critical);
+    if (!e)
+        return NULL;
+
+    while (i == TOKEN_DBL_XOR) {
+        i = scan(scpriv, tokval);
+        f = rexp2(critical);
+        if (!f)
+            return NULL;
+        if (!(is_simple(e) || is_just_unknown(e)) ||
+            !(is_simple(f) || is_just_unknown(f))) {
+            nasm_error(ERR_NONFATAL, "`^' operator may only be applied to"
+                  " scalar values");
+        }
+
+        if (is_just_unknown(e) || is_just_unknown(f))
+            e = unknown_expr();
+        else
+            e = scalarvect((int64_t)(!reloc_value(e) ^ !reloc_value(f)));
+    }
+    return e;
+}
+
+static expr *rexp2(int critical)
+{
+    expr *e, *f;
+
+    e = rexp3(critical);
+    if (!e)
+        return NULL;
+    while (i == TOKEN_DBL_AND) {
+        i = scan(scpriv, tokval);
+        f = rexp3(critical);
+        if (!f)
+            return NULL;
+        if (!(is_simple(e) || is_just_unknown(e)) ||
+            !(is_simple(f) || is_just_unknown(f))) {
+            nasm_error(ERR_NONFATAL, "`&' operator may only be applied to"
+                  " scalar values");
+        }
+        if (is_just_unknown(e) || is_just_unknown(f))
+            e = unknown_expr();
+        else
+            e = scalarvect((int64_t)(reloc_value(e) && reloc_value(f)));
+    }
+    return e;
+}
+
+static expr *rexp3(int critical)
+{
+    expr *e, *f;
+    int64_t v;
+
+    e = expr0(critical);
+    if (!e)
+        return NULL;
+
+    while (i == TOKEN_EQ || i == TOKEN_LT || i == TOKEN_GT ||
+           i == TOKEN_NE || i == TOKEN_LE || i == TOKEN_GE) {
+        int j = i;
+        i = scan(scpriv, tokval);
+        f = expr0(critical);
+        if (!f)
+            return NULL;
+
+        e = add_vectors(e, scalar_mult(f, -1L, false));
+
+        switch (j) {
+        case TOKEN_EQ:
+        case TOKEN_NE:
+            if (is_unknown(e))
+                v = -1;         /* means unknown */
+            else if (!is_really_simple(e) || reloc_value(e) != 0)
+                v = (j == TOKEN_NE);    /* unequal, so return true if NE */
+            else
+                v = (j == TOKEN_EQ);    /* equal, so return true if EQ */
+            break;
+        default:
+            if (is_unknown(e))
+                v = -1;         /* means unknown */
+            else if (!is_really_simple(e)) {
+                nasm_error(ERR_NONFATAL,
+                      "`%s': operands differ by a non-scalar",
+                      (j == TOKEN_LE ? "<=" : j == TOKEN_LT ? "<" : j ==
+                       TOKEN_GE ? ">=" : ">"));
+                v = 0;          /* must set it to _something_ */
+            } else {
+                int64_t vv = reloc_value(e);
+                if (vv == 0)
+                    v = (j == TOKEN_LE || j == TOKEN_GE);
+                else if (vv > 0)
+                    v = (j == TOKEN_GE || j == TOKEN_GT);
+                else            /* vv < 0 */
+                    v = (j == TOKEN_LE || j == TOKEN_LT);
+            }
+            break;
+        }
+
+        if (v == -1)
+            e = unknown_expr();
+        else
+            e = scalarvect(v);
+    }
+    return e;
+}
+
+static expr *expr0(int critical)
+{
+    expr *e, *f;
+
+    e = expr1(critical);
+    if (!e)
+        return NULL;
+
+    while (i == '|') {
+        i = scan(scpriv, tokval);
+        f = expr1(critical);
+        if (!f)
+            return NULL;
+        if (!(is_simple(e) || is_just_unknown(e)) ||
+            !(is_simple(f) || is_just_unknown(f))) {
+            nasm_error(ERR_NONFATAL, "`|' operator may only be applied to"
+                  " scalar values");
+        }
+        if (is_just_unknown(e) || is_just_unknown(f))
+            e = unknown_expr();
+        else
+            e = scalarvect(reloc_value(e) | reloc_value(f));
+    }
+    return e;
+}
+
+static expr *expr1(int critical)
+{
+    expr *e, *f;
+
+    e = expr2(critical);
+    if (!e)
+        return NULL;
+
+    while (i == '^') {
+        i = scan(scpriv, tokval);
+        f = expr2(critical);
+        if (!f)
+            return NULL;
+        if (!(is_simple(e) || is_just_unknown(e)) ||
+            !(is_simple(f) || is_just_unknown(f))) {
+            nasm_error(ERR_NONFATAL, "`^' operator may only be applied to"
+                  " scalar values");
+        }
+        if (is_just_unknown(e) || is_just_unknown(f))
+            e = unknown_expr();
+        else
+            e = scalarvect(reloc_value(e) ^ reloc_value(f));
+    }
+    return e;
+}
+
+static expr *expr2(int critical)
+{
+    expr *e, *f;
+
+    e = expr3(critical);
+    if (!e)
+        return NULL;
+
+    while (i == '&') {
+        i = scan(scpriv, tokval);
+        f = expr3(critical);
+        if (!f)
+            return NULL;
+        if (!(is_simple(e) || is_just_unknown(e)) ||
+            !(is_simple(f) || is_just_unknown(f))) {
+            nasm_error(ERR_NONFATAL, "`&' operator may only be applied to"
+                  " scalar values");
+        }
+        if (is_just_unknown(e) || is_just_unknown(f))
+            e = unknown_expr();
+        else
+            e = scalarvect(reloc_value(e) & reloc_value(f));
+    }
+    return e;
+}
+
+static expr *expr3(int critical)
+{
+    expr *e, *f;
+
+    e = expr4(critical);
+    if (!e)
+        return NULL;
+
+    while (i == TOKEN_SHL || i == TOKEN_SHR) {
+        int j = i;
+        i = scan(scpriv, tokval);
+        f = expr4(critical);
+        if (!f)
+            return NULL;
+        if (!(is_simple(e) || is_just_unknown(e)) ||
+            !(is_simple(f) || is_just_unknown(f))) {
+            nasm_error(ERR_NONFATAL, "shift operator may only be applied to"
+                  " scalar values");
+        } else if (is_just_unknown(e) || is_just_unknown(f)) {
+            e = unknown_expr();
+        } else
+            switch (j) {
+            case TOKEN_SHL:
+                e = scalarvect(reloc_value(e) << reloc_value(f));
+                break;
+            case TOKEN_SHR:
+                e = scalarvect(((uint64_t)reloc_value(e)) >>
+                               reloc_value(f));
+                break;
+            }
+    }
+    return e;
+}
+
+static expr *expr4(int critical)
+{
+    expr *e, *f;
+
+    e = expr5(critical);
+    if (!e)
+        return NULL;
+    while (i == '+' || i == '-') {
+        int j = i;
+        i = scan(scpriv, tokval);
+        f = expr5(critical);
+        if (!f)
+            return NULL;
+        switch (j) {
+        case '+':
+            e = add_vectors(e, f);
+            break;
+        case '-':
+            e = add_vectors(e, scalar_mult(f, -1L, false));
+            break;
+        }
+    }
+    return e;
+}
+
+static expr *expr5(int critical)
+{
+    expr *e, *f;
+
+    e = expr6(critical);
+    if (!e)
+        return NULL;
+    while (i == '*' || i == '/' || i == '%' ||
+           i == TOKEN_SDIV || i == TOKEN_SMOD) {
+        int j = i;
+        i = scan(scpriv, tokval);
+        f = expr6(critical);
+        if (!f)
+            return NULL;
+        if (j != '*' && (!(is_simple(e) || is_just_unknown(e)) ||
+                         !(is_simple(f) || is_just_unknown(f)))) {
+            nasm_error(ERR_NONFATAL, "division operator may only be applied to"
+                  " scalar values");
+            return NULL;
+        }
+        if (j != '*' && !is_unknown(f) && reloc_value(f) == 0) {
+            nasm_error(ERR_NONFATAL, "division by zero");
+            return NULL;
+        }
+        switch (j) {
+        case '*':
+            if (is_simple(e))
+                e = scalar_mult(f, reloc_value(e), true);
+            else if (is_simple(f))
+                e = scalar_mult(e, reloc_value(f), true);
+            else if (is_just_unknown(e) && is_just_unknown(f))
+                e = unknown_expr();
+            else {
+                nasm_error(ERR_NONFATAL, "unable to multiply two "
+                      "non-scalar objects");
+                return NULL;
+            }
+            break;
+        case '/':
+            if (is_just_unknown(e) || is_just_unknown(f))
+                e = unknown_expr();
+            else
+                e = scalarvect(((uint64_t)reloc_value(e)) /
+                               ((uint64_t)reloc_value(f)));
+            break;
+        case '%':
+            if (is_just_unknown(e) || is_just_unknown(f))
+                e = unknown_expr();
+            else
+                e = scalarvect(((uint64_t)reloc_value(e)) %
+                               ((uint64_t)reloc_value(f)));
+            break;
+        case TOKEN_SDIV:
+            if (is_just_unknown(e) || is_just_unknown(f))
+                e = unknown_expr();
+            else
+                e = scalarvect(((int64_t)reloc_value(e)) /
+                               ((int64_t)reloc_value(f)));
+            break;
+        case TOKEN_SMOD:
+            if (is_just_unknown(e) || is_just_unknown(f))
+                e = unknown_expr();
+            else
+                e = scalarvect(((int64_t)reloc_value(e)) %
+                               ((int64_t)reloc_value(f)));
+            break;
+        }
+    }
+    return e;
+}
+
+static expr *eval_floatize(enum floatize type)
+{
+    uint8_t result[16], *p;     /* Up to 128 bits */
+    static const struct {
+        int bytes, start, len;
+    } formats[] = {
+        {  1, 0, 1 },           /* FLOAT_8 */
+        {  2, 0, 2 },           /* FLOAT_16 */
+        {  4, 0, 4 },           /* FLOAT_32 */
+        {  8, 0, 8 },           /* FLOAT_64 */
+        { 10, 0, 8 },           /* FLOAT_80M */
+        { 10, 8, 2 },           /* FLOAT_80E */
+        { 16, 0, 8 },           /* FLOAT_128L */
+        { 16, 8, 8 },           /* FLOAT_128H */
+    };
+    int sign = 1;
+    int64_t val;
+    int j;
+
+    i = scan(scpriv, tokval);
+    if (i != '(') {
+        nasm_error(ERR_NONFATAL, "expecting `('");
+        return NULL;
+    }
+    i = scan(scpriv, tokval);
+    if (i == '-' || i == '+') {
+        sign = (i == '-') ? -1 : 1;
+        i = scan(scpriv, tokval);
+    }
+    if (i != TOKEN_FLOAT) {
+        nasm_error(ERR_NONFATAL, "expecting floating-point number");
+        return NULL;
+    }
+    if (!float_const(tokval->t_charptr, sign, result, formats[type].bytes))
+        return NULL;
+    i = scan(scpriv, tokval);
+    if (i != ')') {
+        nasm_error(ERR_NONFATAL, "expecting `)'");
+        return NULL;
+    }
+
+    p = result+formats[type].start+formats[type].len;
+    val = 0;
+    for (j = formats[type].len; j; j--) {
+        p--;
+        val = (val << 8) + *p;
+    }
+
+    begintemp();
+    addtotemp(EXPR_SIMPLE, val);
+
+    i = scan(scpriv, tokval);
+    return finishtemp();
+}
+
+static expr *eval_strfunc(enum strfunc type)
+{
+    char *string;
+    size_t string_len;
+    int64_t val;
+    bool parens, rn_warn;
+
+    parens = false;
+    i = scan(scpriv, tokval);
+    if (i == '(') {
+        parens = true;
+        i = scan(scpriv, tokval);
+    }
+    if (i != TOKEN_STR) {
+        nasm_error(ERR_NONFATAL, "expecting string");
+        return NULL;
+    }
+    string_len = string_transform(tokval->t_charptr, tokval->t_inttwo,
+                                  &string, type);
+    if (string_len == (size_t)-1) {
+        nasm_error(ERR_NONFATAL, "invalid string for transform");
+        return NULL;
+    }
+
+    val = readstrnum(string, string_len, &rn_warn);
+    if (parens) {
+        i = scan(scpriv, tokval);
+        if (i != ')') {
+            nasm_error(ERR_NONFATAL, "expecting `)'");
+            return NULL;
+        }
+    }
+
+    if (rn_warn)
+        nasm_error(ERR_WARNING|ERR_PASS1, "character constant too long");
+
+    begintemp();
+    addtotemp(EXPR_SIMPLE, val);
+
+    i = scan(scpriv, tokval);
+    return finishtemp();
+}
+
+static int64_t eval_ifunc(int64_t val, enum ifunc func)
+{
+    int errtype;
+    uint64_t uval = (uint64_t)val;
+    int64_t rv;
+
+    switch (func) {
+    case IFUNC_ILOG2E:
+    case IFUNC_ILOG2W:
+        errtype = (func == IFUNC_ILOG2E) ? ERR_NONFATAL : ERR_WARNING;
+
+        if (!is_power2(uval))
+            nasm_error(errtype, "ilog2 argument is not a power of two");
+        /* fall through */
+    case IFUNC_ILOG2F:
+        rv = ilog2_64(uval);
+        break;
+
+    case IFUNC_ILOG2C:
+        rv = (uval < 2) ? 0 : ilog2_64(uval-1) + 1;
+        break;
+
+    default:
+        nasm_panic(0, "invalid IFUNC token %d", func);
+        rv = 0;
+        break;
+    }
+
+    return rv;
+}
+
+static expr *expr6(int critical)
+{
+    int32_t type;
+    expr *e;
+    int32_t label_seg;
+    int64_t label_ofs;
+    int64_t tmpval;
+    bool rn_warn;
+    char *scope;
+
+    switch (i) {
+    case '-':
+        i = scan(scpriv, tokval);
+        e = expr6(critical);
+        if (!e)
+            return NULL;
+        return scalar_mult(e, -1L, false);
+
+    case '+':
+        i = scan(scpriv, tokval);
+        return expr6(critical);
+
+    case '~':
+        i = scan(scpriv, tokval);
+        e = expr6(critical);
+        if (!e)
+            return NULL;
+        if (is_just_unknown(e))
+            return unknown_expr();
+        else if (!is_simple(e)) {
+            nasm_error(ERR_NONFATAL, "`~' operator may only be applied to"
+                  " scalar values");
+            return NULL;
+        }
+        return scalarvect(~reloc_value(e));
+
+    case '!':
+        i = scan(scpriv, tokval);
+        e = expr6(critical);
+        if (!e)
+            return NULL;
+        if (is_just_unknown(e))
+            return unknown_expr();
+        else if (!is_simple(e)) {
+            nasm_error(ERR_NONFATAL, "`!' operator may only be applied to"
+                  " scalar values");
+            return NULL;
+        }
+        return scalarvect(!reloc_value(e));
+
+    case TOKEN_IFUNC:
+    {
+        enum ifunc func = tokval->t_integer;
+        i = scan(scpriv, tokval);
+        e = expr6(critical);
+        if (!e)
+            return NULL;
+        if (is_just_unknown(e))
+            return unknown_expr();
+        else if (!is_simple(e)) {
+            nasm_error(ERR_NONFATAL, "function may only be applied to"
+                  " scalar values");
+            return NULL;
+        }
+        return scalarvect(eval_ifunc(reloc_value(e), func));
+    }
+
+    case TOKEN_SEG:
+        i = scan(scpriv, tokval);
+        e = expr6(critical);
+        if (!e)
+            return NULL;
+        e = segment_part(e);
+        if (!e)
+            return NULL;
+        if (is_unknown(e) && critical) {
+            nasm_error(ERR_NONFATAL, "unable to determine segment base");
+            return NULL;
+        }
+        return e;
+
+    case TOKEN_FLOATIZE:
+        return eval_floatize(tokval->t_integer);
+
+    case TOKEN_STRFUNC:
+        return eval_strfunc(tokval->t_integer);
+
+    case '(':
+        i = scan(scpriv, tokval);
+        e = bexpr(critical);
+        if (!e)
+            return NULL;
+        if (i != ')') {
+            nasm_error(ERR_NONFATAL, "expecting `)'");
+            return NULL;
+        }
+        i = scan(scpriv, tokval);
+        return e;
+
+    case TOKEN_NUM:
+    case TOKEN_STR:
+    case TOKEN_REG:
+    case TOKEN_ID:
+    case TOKEN_INSN:            /* Opcodes that occur here are really labels */
+    case TOKEN_HERE:
+    case TOKEN_BASE:
+    case TOKEN_DECORATOR:
+        begintemp();
+        switch (i) {
+        case TOKEN_NUM:
+            addtotemp(EXPR_SIMPLE, tokval->t_integer);
+            break;
+        case TOKEN_STR:
+            tmpval = readstrnum(tokval->t_charptr, tokval->t_inttwo, &rn_warn);
+            if (rn_warn)
+                nasm_error(ERR_WARNING|ERR_PASS1, "character constant too long");
+            addtotemp(EXPR_SIMPLE, tmpval);
+            break;
+        case TOKEN_REG:
+            addtotemp(tokval->t_integer, 1L);
+            if (hint && hint->type == EAH_NOHINT)
+                hint->base = tokval->t_integer, hint->type = EAH_MAKEBASE;
+            break;
+        case TOKEN_ID:
+        case TOKEN_INSN:
+        case TOKEN_HERE:
+        case TOKEN_BASE:
+            /*
+             * If !location.known, this indicates that no
+             * symbol, Here or Base references are valid because we
+             * are in preprocess-only mode.
+             */
+            if (!location.known) {
+                nasm_error(ERR_NONFATAL,
+                      "%s not supported in preprocess-only mode",
+                      (i == TOKEN_HERE ? "`$'" :
+                       i == TOKEN_BASE ? "`$$'" :
+                       "symbol references"));
+                addtotemp(EXPR_UNKNOWN, 1L);
+                break;
+            }
+
+            type = EXPR_SIMPLE; /* might get overridden by UNKNOWN */
+            if (i == TOKEN_BASE) {
+                label_seg = in_absolute ? absolute.segment : location.segment;
+                label_ofs = 0;
+            } else if (i == TOKEN_HERE) {
+                label_seg = in_absolute ? absolute.segment : location.segment;
+                label_ofs = in_absolute ? absolute.offset : location.offset;
+            } else {
+                if (!lookup_label(tokval->t_charptr, &label_seg, &label_ofs)) {
+                    scope = local_scope(tokval->t_charptr);
+                    if (critical == 2) {
+                        nasm_error(ERR_NONFATAL, "symbol `%s%s' undefined",
+                              scope,tokval->t_charptr);
+                        return NULL;
+                    } else if (critical == 1) {
+                        nasm_error(ERR_NONFATAL,
+                              "symbol `%s%s' not defined before use",
+                              scope,tokval->t_charptr);
+                        return NULL;
+                    } else {
+                        if (opflags)
+                            *opflags |= OPFLAG_FORWARD;
+                        type = EXPR_UNKNOWN;
+                        label_seg = NO_SEG;
+                        label_ofs = 1;
+                    }
+                }
+                if (opflags && is_extern(tokval->t_charptr))
+                    *opflags |= OPFLAG_EXTERN;
+            }
+            addtotemp(type, label_ofs);
+            if (label_seg != NO_SEG)
+                addtotemp(EXPR_SEGBASE + label_seg, 1L);
+            break;
+        case TOKEN_DECORATOR:
+            addtotemp(EXPR_RDSAE, tokval->t_integer);
+            break;
+        }
+        i = scan(scpriv, tokval);
+        return finishtemp();
+
+    default:
+        nasm_error(ERR_NONFATAL, "expression syntax error");
+        return NULL;
+    }
+}
+
+expr *evaluate(scanner sc, void *scprivate, struct tokenval *tv,
+               int *fwref, int critical, struct eval_hints *hints)
+{
+    expr *e;
+    expr *f = NULL;
+
+    hint = hints;
+    if (hint)
+        hint->type = EAH_NOHINT;
+
+    if (critical & CRITICAL) {
+        critical &= ~CRITICAL;
+        bexpr = rexp0;
+    } else
+        bexpr = expr0;
+
+    scan = sc;
+    scpriv = scprivate;
+    tokval = tv;
+    opflags = fwref;
+
+    if (tokval->t_type == TOKEN_INVALID)
+        i = scan(scpriv, tokval);
+    else
+        i = tokval->t_type;
+
+    while (ntempexprs)          /* initialize temporary storage */
+        nasm_free(tempexprs[--ntempexprs]);
+
+    e = bexpr(critical);
+    if (!e)
+        return NULL;
+
+    if (i == TOKEN_WRT) {
+        i = scan(scpriv, tokval);       /* eat the WRT */
+        f = expr6(critical);
+        if (!f)
+            return NULL;
+    }
+    e = scalar_mult(e, 1L, false);      /* strip far-absolute segment part */
+    if (f) {
+        expr *g;
+        if (is_just_unknown(f))
+            g = unknown_expr();
+        else {
+            int64_t value;
+            begintemp();
+            if (!is_reloc(f)) {
+                nasm_error(ERR_NONFATAL, "invalid right-hand operand to WRT");
+                return NULL;
+            }
+            value = reloc_seg(f);
+            if (value == NO_SEG)
+                value = reloc_value(f) | SEG_ABS;
+            else if (!(value & SEG_ABS) && !(value % 2) && critical) {
+                nasm_error(ERR_NONFATAL, "invalid right-hand operand to WRT");
+                return NULL;
+            }
+            addtotemp(EXPR_WRT, value);
+            g = finishtemp();
+        }
+        e = add_vectors(e, g);
+    }
+    return e;
+}