mirror/nasm
2
0
Fork 0
mirror of https://github.com/netwide-assembler/nasm.git synced 2024-12-21 09:19:31 +08:00
Code Issues Packages Projects Releases Wiki Activity
e91f5cc132
nasm/asm/parser.c
H. Peter Anvin (Intel) 84b852bff0 Implement an enhanced version of MASM's dup() and "db ?" syntax. 
Add support for complex data (Dx) statement expressions involving both
initialized and uninitialized data. In addition, we have support for
overriding the size of each element on an individual item and/or list
basis.

Signed-off-by: H. Peter Anvin (Intel) <hpa@zytor.com>
2019-10-16 14:29:16 -07:00

1344 lines
44 KiB
C
Raw Blame History

/* ----------------------------------------------------------------------- *
*
* Copyright 1996-2019 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.
*
* ----------------------------------------------------------------------- */
/*
* parser.c source line parser for the Netwide Assembler
*/
#include "compiler.h"
#include "nctype.h"
#include "nasm.h"
#include "insns.h"
#include "nasmlib.h"
#include "error.h"
#include "stdscan.h"
#include "eval.h"
#include "parser.h"
#include "float.h"
#include "assemble.h"
#include "tables.h"
static int end_expression_next(void);
static struct tokenval tokval;
static int prefix_slot(int prefix)
{
switch (prefix) {
case P_WAIT:
return PPS_WAIT;
case R_CS:
case R_DS:
case R_SS:
case R_ES:
case R_FS:
case R_GS:
return PPS_SEG;
case P_LOCK:
return PPS_LOCK;
case P_REP:
case P_REPE:
case P_REPZ:
case P_REPNE:
case P_REPNZ:
case P_XACQUIRE:
case P_XRELEASE:
case P_BND:
case P_NOBND:
return PPS_REP;
case P_O16:
case P_O32:
case P_O64:
case P_OSP:
return PPS_OSIZE;
case P_A16:
case P_A32:
case P_A64:
case P_ASP:
return PPS_ASIZE;
case P_EVEX:
case P_VEX3:
case P_VEX2:
return PPS_VEX;
default:
nasm_panic("Invalid value %d passed to prefix_slot()", prefix);
return -1;
}
}
static void process_size_override(insn *result, operand *op)
{
if (tasm_compatible_mode) {
switch (tokval.t_integer) {
/* For TASM compatibility a size override inside the
* brackets changes the size of the operand, not the
* address type of the operand as it does in standard
* NASM syntax. Hence:
*
* mov eax,[DWORD val]
*
* is valid syntax in TASM compatibility mode. Note that
* you lose the ability to override the default address
* type for the instruction, but we never use anything
* but 32-bit flat model addressing in our code.
*/
case S_BYTE:
op->type |= BITS8;
break;
case S_WORD:
op->type |= BITS16;
break;
case S_DWORD:
case S_LONG:
op->type |= BITS32;
break;
case S_QWORD:
op->type |= BITS64;
break;
case S_TWORD:
op->type |= BITS80;
break;
case S_OWORD:
op->type |= BITS128;
break;
default:
nasm_nonfatal("invalid operand size specification");
break;
}
} else {
/* Standard NASM compatible syntax */
switch (tokval.t_integer) {
case S_NOSPLIT:
op->eaflags |= EAF_TIMESTWO;
break;
case S_REL:
op->eaflags |= EAF_REL;
break;
case S_ABS:
op->eaflags |= EAF_ABS;
break;
case S_BYTE:
op->disp_size = 8;
op->eaflags |= EAF_BYTEOFFS;
break;
case P_A16:
case P_A32:
case P_A64:
if (result->prefixes[PPS_ASIZE] &&
result->prefixes[PPS_ASIZE] != tokval.t_integer)
nasm_nonfatal("conflicting address size specifications");
else
result->prefixes[PPS_ASIZE] = tokval.t_integer;
break;
case S_WORD:
op->disp_size = 16;
op->eaflags |= EAF_WORDOFFS;
break;
case S_DWORD:
case S_LONG:
op->disp_size = 32;
op->eaflags |= EAF_WORDOFFS;
break;
case S_QWORD:
op->disp_size = 64;
op->eaflags |= EAF_WORDOFFS;
break;
default:
nasm_nonfatal("invalid size specification in"
" effective address");
break;
}
}
}
/*
* Brace decorators are are parsed here. opmask and zeroing
* decorators can be placed in any order. e.g. zmm1 {k2}{z} or zmm2
* {z}{k3} decorator(s) are placed at the end of an operand.
*/
static bool parse_braces(decoflags_t *decoflags)
{
int i, j;
i = tokval.t_type;
while (true) {
switch (i) {
case TOKEN_OPMASK:
if (*decoflags & OPMASK_MASK) {
nasm_nonfatal("opmask k%"PRIu64" is already set",
*decoflags & OPMASK_MASK);
*decoflags &= ~OPMASK_MASK;
}
*decoflags |= VAL_OPMASK(nasm_regvals[tokval.t_integer]);
break;
case TOKEN_DECORATOR:
j = tokval.t_integer;
switch (j) {
case BRC_Z:
*decoflags |= Z_MASK;
break;
case BRC_1TO2:
case BRC_1TO4:
case BRC_1TO8:
case BRC_1TO16:
*decoflags |= BRDCAST_MASK | VAL_BRNUM(j - BRC_1TO2);
break;
default:
nasm_nonfatal("{%s} is not an expected decorator",
tokval.t_charptr);
break;
}
break;
case ',':
case TOKEN_EOS:
return false;
default:
nasm_nonfatal("only a series of valid decorators expected");
return true;
}
i = stdscan(NULL, &tokval);
}
}
static inline const expr *next_expr(const expr *e, const expr **next_list)
{
e++;
if (!e->type) {
if (next_list) {
e = *next_list;
*next_list = NULL;
} else {
e = NULL;
}
}
return e;
}
static inline void init_operand(operand *op)
{
memset(op, 0, sizeof *op);
op->basereg = -1;
op->indexreg = -1;
op->segment = NO_SEG;
op->wrt = NO_SEG;
}
static int parse_mref(operand *op, const expr *e)
{
int b, i, s; /* basereg, indexreg, scale */
int64_t o; /* offset */
b = op->basereg;
i = op->indexreg;
s = op->scale;
o = op->offset;
for (; e->type; e++) {
if (e->type <= EXPR_REG_END) {
bool is_gpr = is_class(REG_GPR,nasm_reg_flags[e->type]);
if (is_gpr && e->value == 1 && b == -1) {
/* It can be basereg */
b = e->type;
} else if (i == -1) {
/* Must be index register */
i = e->type;
s = e->value;
} else {
if (b == -1)
nasm_nonfatal("invalid effective address: two index registers");
else if (!is_gpr)
nasm_nonfatal("invalid effective address: impossible register");
else
nasm_nonfatal("invalid effective address: too many registers");
return -1;
}
} else if (e->type == EXPR_UNKNOWN) {
op->opflags |= OPFLAG_UNKNOWN;
} else if (e->type == EXPR_SIMPLE) {
o += e->value;
} else if (e->type == EXPR_WRT) {
op->wrt = e->value;
} else if (e->type >= EXPR_SEGBASE) {
if (e->value == 1) {
if (op->segment != NO_SEG) {
nasm_nonfatal("invalid effective address: multiple base segments");
return -1;
}
op->segment = e->type - EXPR_SEGBASE;
} else if (e->value == -1 &&
e->type == location.segment + EXPR_SEGBASE &&
!(op->opflags & OPFLAG_RELATIVE)) {
op->opflags |= OPFLAG_RELATIVE;
} else {
nasm_nonfatal("invalid effective address: impossible segment base multiplier");
return -1;
}
} else {
nasm_nonfatal("invalid effective address: bad subexpression type");
return -1;
}
}
op->basereg = b;
op->indexreg = i;
op->scale = s;
op->offset = o;
return 0;
}
static void mref_set_optype(operand *op)
{
int b = op->basereg;
int i = op->indexreg;
int s = op->scale;
/* It is memory, but it can match any r/m operand */
op->type |= MEMORY_ANY;
if (b == -1 && (i == -1 || s == 0)) {
int is_rel = globalbits == 64 &&
!(op->eaflags & EAF_ABS) &&
((globalrel &&
!(op->eaflags & EAF_FSGS)) ||
(op->eaflags & EAF_REL));
op->type |= is_rel ? IP_REL : MEM_OFFS;
}
if (i != -1) {
opflags_t iclass = nasm_reg_flags[i];
if (is_class(XMMREG,iclass))
op->type |= XMEM;
else if (is_class(YMMREG,iclass))
op->type |= YMEM;
else if (is_class(ZMMREG,iclass))
op->type |= ZMEM;
}
}
/*
* Convert an expression vector returned from evaluate() into an
* extop structure. Return zero on success. Note that the eop
* already has dup and elem set, so we can't clear it here.
*/
static int value_to_extop(expr *vect, extop *eop, int32_t myseg)
{
eop->type = EOT_DB_NUMBER;
eop->val.num.offset = 0;
eop->val.num.segment = eop->val.num.wrt = NO_SEG;
eop->val.num.relative = false;
for (; vect->type; vect++) {
if (!vect->value) /* zero term, safe to ignore */
continue;
if (vect->type <= EXPR_REG_END) /* false if a register is present */
return -1;
if (vect->type == EXPR_UNKNOWN) /* something we can't resolve yet */
return 0;
if (vect->type == EXPR_SIMPLE) {
/* Simple number expression */
eop->val.num.offset += vect->value;
continue;
}
if (eop->val.num.wrt == NO_SEG && !eop->val.num.relative &&
vect->type == EXPR_WRT) {
/* WRT term */
eop->val.num.wrt = vect->value;
continue;
}
if (!eop->val.num.relative &&
vect->type == EXPR_SEGBASE + myseg && vect->value == -1) {
/* Expression of the form: foo - $ */
eop->val.num.relative = true;
continue;
}
if (eop->val.num.segment == NO_SEG &&
vect->type >= EXPR_SEGBASE && vect->value == 1) {
eop->val.num.segment = vect->type - EXPR_SEGBASE;
continue;
}
/* Otherwise, badness */
return -1;
}
/* We got to the end and it was all okay */
return 0;
}
/*
* Parse an extended expression, used by db et al. "elem" is the element
* size; initially comes from the specific opcode (e.g. db == 1) but
* can be overridden.
*/
static int parse_eops(extop **result, bool critical, int elem)
{
extop *eop = NULL, *prev = NULL;
extop **tail = result;
int sign;
int i = tokval.t_type;
int oper_num = 0;
bool do_subexpr = false;
*tail = NULL;
/* End of string is obvious; ) ends a sub-expression list e.g. DUP */
for (i = tokval.t_type; i != TOKEN_EOS; i = stdscan(NULL, &tokval)) {
char endparen = ')'; /* Is a right paren the end of list? */
if (i == ')')
break;
if (!eop) {
nasm_new(eop);
eop->dup = 1;
eop->elem = elem;
do_subexpr = false;
}
sign = +1;
/*
* end_expression_next() here is to distinguish this from
* a string used as part of an expression...
*/
if (i == TOKEN_QMARK) {
eop->type = EOT_DB_RESERVE;
} else if (do_subexpr && i == '(') {
extop *subexpr;
stdscan(NULL, &tokval); /* Skip paren */
if (parse_eops(&eop->val.subexpr, critical, eop->elem) < 0)
goto fail;
subexpr = eop->val.subexpr;
if (!subexpr) {
/* Subexpression is empty */
eop->type = EOT_NOTHING;
} else if (!subexpr->next) {
/* Subexpression is a single element, flatten */
eop->val = subexpr->val;
eop->type = subexpr->type;
eop->dup *= subexpr->dup;
nasm_free(subexpr);
} else {
eop->type = EOT_EXTOP;
}
/* We should have ended on a closing paren */
if (tokval.t_type != ')') {
nasm_nonfatal("expected `)' after subexpression, got `%s'",
i == TOKEN_EOS ?
"end of line" : tokval.t_charptr);
goto fail;
}
endparen = 0; /* This time the paren is not the end */
} else if (i == '%') {
/* %(expression_list) */
do_subexpr = true;
continue;
} else if (i == TOKEN_SIZE) {
/* Element size override */
eop->elem = tokval.t_inttwo;
do_subexpr = true;
continue;
} else if (i == TOKEN_STR && end_expression_next()) {
eop->type = EOT_DB_STRING;
eop->val.string.data = tokval.t_charptr;
eop->val.string.len = tokval.t_inttwo;
} else if (i == TOKEN_STRFUNC) {
bool parens = false;
const char *funcname = tokval.t_charptr;
enum strfunc func = tokval.t_integer;
i = stdscan(NULL, &tokval);
if (i == '(') {
parens = true;
endparen = 0;
i = stdscan(NULL, &tokval);
}
if (i != TOKEN_STR) {
nasm_nonfatal("%s must be followed by a string constant",
funcname);
eop->type = EOT_NOTHING;
} else {
eop->type = EOT_DB_STRING_FREE;
eop->val.string.len =
string_transform(tokval.t_charptr, tokval.t_inttwo,
&eop->val.string.data, func);
if (eop->val.string.len == (size_t)-1) {
nasm_nonfatal("invalid input string to %s", funcname);
eop->type = EOT_NOTHING;
}
}
if (parens && i && i != ')') {
i = stdscan(NULL, &tokval);
if (i != ')')
nasm_nonfatal("unterminated %s function", funcname);
}
} else if (i == '-' || i == '+') {
char *save = stdscan_get();
struct tokenval tmptok;
sign = (i == '-') ? -1 : 1;
if (stdscan(NULL, &tmptok) != TOKEN_FLOAT) {
stdscan_set(save);
goto is_expression;
} else {
tokval = tmptok;
goto is_float;
}
} else if (i == TOKEN_FLOAT) {
is_float:
eop->type = EOT_DB_FLOAT;
if (eop->elem > 16) {
nasm_nonfatal("no %d-bit floating-point format supported",
eop->elem << 3);
eop->val.string.len = 0;
} else if (eop->elem < 1) {
nasm_nonfatal("floating-point constant"
" encountered in unknown instruction");
/*
* fix suggested by Pedro Gimeno... original line was:
* eop->type = EOT_NOTHING;
*/
eop->val.string.len = 0;
} else {
eop->val.string.len = eop->elem;
eop = nasm_realloc(eop, sizeof(extop) + eop->val.string.len);
eop->val.string.data = (char *)eop + sizeof(extop);
if (!float_const(tokval.t_charptr, sign,
(uint8_t *)eop->val.string.data,
eop->val.string.len))
eop->val.string.len = 0;
}
if (!eop->val.string.len)
eop->type = EOT_NOTHING;
} else {
/* anything else, assume it is an expression */
expr *value;
is_expression:
value = evaluate(stdscan, NULL, &tokval, NULL,
critical, NULL);
i = tokval.t_type;
if (!value) /* Error in evaluator */
goto fail;
if (tokval.t_flag & TFLAG_DUP) {
/* Expression followed by DUP */
if (!is_simple(value)) {
nasm_nonfatal("non-constant argument supplied to DUP");
goto fail;
} else if (value->value < 0) {
nasm_nonfatal("negative argument supplied to DUP");
goto fail;
}
eop->dup *= (size_t)value->value;
do_subexpr = true;
continue;
}
if (value_to_extop(value, eop, location.segment)) {
nasm_nonfatal("expression is not simple or relocatable");
}
}
if (eop->dup == 0 || eop->type == EOT_NOTHING) {
nasm_free(eop);
} else if (eop->type == EOT_DB_RESERVE &&
prev && prev->type == EOT_DB_RESERVE &&
prev->elem == eop->elem) {
/* Coalesce multiple EOT_DB_RESERVE */
prev->dup += eop->dup;
nasm_free(eop);
} else {
/* Add this eop to the end of the chain */
prev = eop;
*tail = eop;
tail = &eop->next;
}
oper_num++;
eop = NULL; /* Done with this operand */
/*
* We're about to call stdscan(), which will eat the
* comma that we're currently sitting on between
* arguments. However, we'd better check first that it
* _is_ a comma.
*/
if (i == TOKEN_EOS || i == endparen) /* Already at end? */
break;
if (i != ',') {
i = stdscan(NULL, &tokval); /* eat the comma or final paren */
if (i == TOKEN_EOS || i == ')') /* got end of expression */
break;
if (i != ',') {
nasm_nonfatal("comma expected after operand");
goto fail;
}
}
}
return oper_num;
fail:
if (eop)
nasm_free(eop);
return -1;
}
insn *parse_line(char *buffer, insn *result)
{
bool insn_is_label = false;
struct eval_hints hints;
int opnum;
bool critical;
bool first;
bool recover;
bool far_jmp_ok;
int i;
nasm_static_assert(P_none == 0);
restart_parse:
first = true;
result->forw_ref = false;
stdscan_reset();
stdscan_set(buffer);
i = stdscan(NULL, &tokval);
memset(result->prefixes, P_none, sizeof(result->prefixes));
result->times = 1; /* No TIMES either yet */
result->label = NULL; /* Assume no label */
result->eops = NULL; /* must do this, whatever happens */
result->operands = 0; /* must initialize this */
result->evex_rm = 0; /* Ensure EVEX rounding mode is reset */
result->evex_brerop = -1; /* Reset EVEX broadcasting/ER op position */
/* Ignore blank lines */
if (i == TOKEN_EOS)
goto fail;
if (i != TOKEN_ID &&
i != TOKEN_INSN &&
i != TOKEN_PREFIX &&
(i != TOKEN_REG || !IS_SREG(tokval.t_integer))) {
nasm_nonfatal("label or instruction expected at start of line");
goto fail;
}
if (i == TOKEN_ID || (insn_is_label && i == TOKEN_INSN)) {
/* there's a label here */
first = false;
result->label = tokval.t_charptr;
i = stdscan(NULL, &tokval);
if (i == ':') { /* skip over the optional colon */
i = stdscan(NULL, &tokval);
} else if (i == 0) {
/*!
*!label-orphan [on] labels alone on lines without trailing `:'
*!=orphan-labels
*! warns about source lines which contain no instruction but define
*! a label without a trailing colon. This is most likely indicative
*! of a typo, but is technically correct NASM syntax (see \k{syntax}.)
*/
nasm_warn(WARN_LABEL_ORPHAN ,
"label alone on a line without a colon might be in error");
}
if (i != TOKEN_INSN || tokval.t_integer != I_EQU) {
/*
* FIXME: location.segment could be NO_SEG, in which case
* it is possible we should be passing 'absolute.segment'. Look into this.
* Work out whether that is *really* what we should be doing.
* Generally fix things. I think this is right as it is, but
* am still not certain.
*/
define_label(result->label,
in_absolute ? absolute.segment : location.segment,
location.offset, true);
}
}
/* Just a label here */
if (i == TOKEN_EOS)
goto fail;
while (i == TOKEN_PREFIX ||
(i == TOKEN_REG && IS_SREG(tokval.t_integer))) {
first = false;
/*
* Handle special case: the TIMES prefix.
*/
if (i == TOKEN_PREFIX && tokval.t_integer == P_TIMES) {
expr *value;
i = stdscan(NULL, &tokval);
value = evaluate(stdscan, NULL, &tokval, NULL, pass_stable(), NULL);
i = tokval.t_type;
if (!value) /* Error in evaluator */
goto fail;
if (!is_simple(value)) {
nasm_nonfatal("non-constant argument supplied to TIMES");
result->times = 1L;
} else {
result->times = value->value;
if (value->value < 0) {
nasm_nonfatalf(ERR_PASS2, "TIMES value %"PRId64" is negative", value->value);
result->times = 0;
}
}
} else {
int slot = prefix_slot(tokval.t_integer);
if (result->prefixes[slot]) {
if (result->prefixes[slot] == tokval.t_integer)
nasm_warn(WARN_OTHER, "instruction has redundant prefixes");
else
nasm_nonfatal("instruction has conflicting prefixes");
}
result->prefixes[slot] = tokval.t_integer;
i = stdscan(NULL, &tokval);
}
}
if (i != TOKEN_INSN) {
int j;
enum prefixes pfx;
for (j = 0; j < MAXPREFIX; j++) {
if ((pfx = result->prefixes[j]) != P_none)
break;
}
if (i == 0 && pfx != P_none) {
/*
* Instruction prefixes are present, but no actual
* instruction. This is allowed: at this point we
* invent a notional instruction of RESB 0.
*/
result->opcode = I_RESB;
result->operands = 1;
nasm_zero(result->oprs);
result->oprs[0].type = IMMEDIATE;
result->oprs[0].offset = 0L;
result->oprs[0].segment = result->oprs[0].wrt = NO_SEG;
return result;
} else {
nasm_nonfatal("parser: instruction expected");
goto fail;
}
}
result->opcode = tokval.t_integer;
result->condition = tokval.t_inttwo;
/*
* INCBIN cannot be satisfied with incorrectly
* evaluated operands, since the correct values _must_ be known
* on the first pass. Hence, even in pass one, we set the
* `critical' flag on calling evaluate(), so that it will bomb
* out on undefined symbols.
*/
critical = pass_final() || (result->opcode == I_INCBIN);
if (opcode_is_db(result->opcode) || result->opcode == I_INCBIN) {
int oper_num;
i = stdscan(NULL, &tokval);
if (first && i == ':') {
/* Really a label */
insn_is_label = true;
goto restart_parse;
}
first = false;
oper_num = parse_eops(&result->eops, critical, db_bytes(result->opcode));
if (oper_num < 0)
goto fail;
if (result->opcode == I_INCBIN) {
/*
* Correct syntax for INCBIN is that there should be
* one string operand, followed by one or two numeric
* operands.
*/
if (!result->eops || result->eops->type != EOT_DB_STRING)
nasm_nonfatal("`incbin' expects a file name");
else if (result->eops->next &&
result->eops->next->type != EOT_DB_NUMBER)
nasm_nonfatal("`incbin': second parameter is"
" non-numeric");
else if (result->eops->next && result->eops->next->next &&
result->eops->next->next->type != EOT_DB_NUMBER)
nasm_nonfatal("`incbin': third parameter is"
" non-numeric");
else if (result->eops->next && result->eops->next->next &&
result->eops->next->next->next)
nasm_nonfatal("`incbin': more than three parameters");
else
return result;
/*
* If we reach here, one of the above errors happened.
* Throw the instruction away.
*/
goto fail;
} else {
/* DB et al */
result->operands = oper_num;
if (oper_num == 0)
nasm_warn(WARN_OTHER, "no operand for data declaration");
}
return result;
}
/*
* Now we begin to parse the operands. There may be up to four
* of these, separated by commas, and terminated by a zero token.
*/
far_jmp_ok = result->opcode == I_JMP || result->opcode == I_CALL;
for (opnum = 0; opnum < MAX_OPERANDS; opnum++) {
operand *op = &result->oprs[opnum];
expr *value; /* used most of the time */
bool mref = false; /* is this going to be a memory ref? */
int bracket = 0; /* is it a [] mref, or a "naked" mref? */
bool mib; /* compound (mib) mref? */
int setsize = 0;
decoflags_t brace_flags = 0; /* flags for decorators in braces */
init_operand(op);
i = stdscan(NULL, &tokval);
if (i == TOKEN_EOS)
break; /* end of operands: get out of here */
else if (first && i == ':') {
insn_is_label = true;
goto restart_parse;
}
first = false;
op->type = 0; /* so far, no override */
/* size specifiers */
while (i == TOKEN_SPECIAL || i == TOKEN_SIZE) {
switch (tokval.t_integer) {
case S_BYTE:
if (!setsize) /* we want to use only the first */
op->type |= BITS8;
setsize = 1;
break;
case S_WORD:
if (!setsize)
op->type |= BITS16;
setsize = 1;
break;
case S_DWORD:
case S_LONG:
if (!setsize)
op->type |= BITS32;
setsize = 1;
break;
case S_QWORD:
if (!setsize)
op->type |= BITS64;
setsize = 1;
break;
case S_TWORD:
if (!setsize)
op->type |= BITS80;
setsize = 1;
break;
case S_OWORD:
if (!setsize)
op->type |= BITS128;
setsize = 1;
break;
case S_YWORD:
if (!setsize)
op->type |= BITS256;
setsize = 1;
break;
case S_ZWORD:
if (!setsize)
op->type |= BITS512;
setsize = 1;
break;
case S_TO:
op->type |= TO;
break;
case S_STRICT:
op->type |= STRICT;
break;
case S_FAR:
op->type |= FAR;
break;
case S_NEAR:
op->type |= NEAR;
break;
case S_SHORT:
op->type |= SHORT;
break;
default:
nasm_nonfatal("invalid operand size specification");
}
i = stdscan(NULL, &tokval);
}
if (i == '[' || i == TOKEN_MASM_PTR || i == '&') {
/* memory reference */
mref = true;
bracket += (i == '[');
i = stdscan(NULL, &tokval);
}
mref_more:
if (mref) {
bool done = false;
bool nofw = false;
while (!done) {
switch (i) {
case TOKEN_SPECIAL:
case TOKEN_SIZE:
case TOKEN_PREFIX:
process_size_override(result, op);
break;
case '[':
bracket++;
break;
case ',':
tokval.t_type = TOKEN_NUM;
tokval.t_integer = 0;
stdscan_set(stdscan_get() - 1); /* rewind the comma */
done = nofw = true;
break;
case TOKEN_MASM_FLAT:
i = stdscan(NULL, &tokval);
if (i != ':') {
nasm_nonfatal("unknown use of FLAT in MASM emulation");
nofw = true;
}
done = true;
break;
default:
done = nofw = true;
break;
}
if (!nofw)
i = stdscan(NULL, &tokval);
}
}
value = evaluate(stdscan, NULL, &tokval,
&op->opflags, critical, &hints);
i = tokval.t_type;
if (op->opflags & OPFLAG_FORWARD) {
result->forw_ref = true;
}
if (!value) /* Error in evaluator */
goto fail;
if (i == '[' && !bracket) {
/* displacement[regs] syntax */
mref = true;
parse_mref(op, value); /* Process what we have so far */
goto mref_more;
}
if (i == ':' && (mref || !far_jmp_ok)) {
/* segment override? */
mref = true;
/*
* Process the segment override.
*/
if (value[1].type != 0 ||
value->value != 1 ||
!IS_SREG(value->type))
nasm_nonfatal("invalid segment override");
else if (result->prefixes[PPS_SEG])
nasm_nonfatal("instruction has conflicting segment overrides");
else {
result->prefixes[PPS_SEG] = value->type;
if (IS_FSGS(value->type))
op->eaflags |= EAF_FSGS;
}
i = stdscan(NULL, &tokval); /* then skip the colon */
goto mref_more;
}
mib = false;
if (mref && bracket && i == ',') {
/* [seg:base+offset,index*scale] syntax (mib) */
operand o2; /* Index operand */
if (parse_mref(op, value))
goto fail;
i = stdscan(NULL, &tokval); /* Eat comma */
value = evaluate(stdscan, NULL, &tokval, &op->opflags,
critical, &hints);
i = tokval.t_type;
if (!value)
goto fail;
init_operand(&o2);
if (parse_mref(&o2, value))
goto fail;
if (o2.basereg != -1 && o2.indexreg == -1) {
o2.indexreg = o2.basereg;
o2.scale = 1;
o2.basereg = -1;
}
if (op->indexreg != -1 || o2.basereg != -1 || o2.offset != 0 ||
o2.segment != NO_SEG || o2.wrt != NO_SEG) {
nasm_nonfatal("invalid mib expression");
goto fail;
}
op->indexreg = o2.indexreg;
op->scale = o2.scale;
if (op->basereg != -1) {
op->hintbase = op->basereg;
op->hinttype = EAH_MAKEBASE;
} else if (op->indexreg != -1) {
op->hintbase = op->indexreg;
op->hinttype = EAH_NOTBASE;
} else {
op->hintbase = -1;
op->hinttype = EAH_NOHINT;
}
mib = true;
}
recover = false;
if (mref) {
if (bracket == 1) {
if (i == ']') {
bracket--;
i = stdscan(NULL, &tokval);
} else {
nasm_nonfatal("expecting ] at end of memory operand");
recover = true;
}
} else if (bracket == 0) {
/* Do nothing */
} else if (bracket > 0) {
nasm_nonfatal("excess brackets in memory operand");
recover = true;
} else if (bracket < 0) {
nasm_nonfatal("unmatched ] in memory operand");
recover = true;
}
if (i == TOKEN_DECORATOR || i == TOKEN_OPMASK) {
/* parse opmask (and zeroing) after an operand */
recover = parse_braces(&brace_flags);
i = tokval.t_type;
}
if (!recover && i != 0 && i != ',') {
nasm_nonfatal("comma, decorator or end of line expected, got %d", i);
recover = true;
}
} else { /* immediate operand */
if (i != 0 && i != ',' && i != ':' &&
i != TOKEN_DECORATOR && i != TOKEN_OPMASK) {
nasm_nonfatal("comma, colon, decorator or end of "
"line expected after operand");
recover = true;
} else if (i == ':') {
op->type |= COLON;
} else if (i == TOKEN_DECORATOR || i == TOKEN_OPMASK) {
/* parse opmask (and zeroing) after an operand */
recover = parse_braces(&brace_flags);
}
}
if (recover) {
do { /* error recovery */
i = stdscan(NULL, &tokval);
} while (i != 0 && i != ',');
}
/*
* now convert the exprs returned from evaluate()
* into operand descriptions...
*/
op->decoflags |= brace_flags;
if (mref) { /* it's a memory reference */
/* A mib reference was fully parsed already */
if (!mib) {
if (parse_mref(op, value))
goto fail;
op->hintbase = hints.base;
op->hinttype = hints.type;
}
mref_set_optype(op);
} else if ((op->type & FAR) && !far_jmp_ok) {
nasm_nonfatal("invalid use of FAR operand specifier");
recover = true;
} else { /* it's not a memory reference */
if (is_just_unknown(value)) { /* it's immediate but unknown */
op->type |= IMMEDIATE;
op->opflags |= OPFLAG_UNKNOWN;
op->offset = 0; /* don't care */
op->segment = NO_SEG; /* don't care again */
op->wrt = NO_SEG; /* still don't care */
if(optimizing.level >= 0 && !(op->type & STRICT)) {
/* Be optimistic */
op->type |=
UNITY | SBYTEWORD | SBYTEDWORD | UDWORD | SDWORD;
}
} else if (is_reloc(value)) { /* it's immediate */
uint64_t n = reloc_value(value);
op->type |= IMMEDIATE;
op->offset = n;
op->segment = reloc_seg(value);
op->wrt = reloc_wrt(value);
op->opflags |= is_self_relative(value) ? OPFLAG_RELATIVE : 0;
if (is_simple(value)) {
if (n == 1)
op->type |= UNITY;
if (optimizing.level >= 0 && !(op->type & STRICT)) {
if ((uint32_t) (n + 128) <= 255)
op->type |= SBYTEDWORD;
if ((uint16_t) (n + 128) <= 255)
op->type |= SBYTEWORD;
if (n <= UINT64_C(0xFFFFFFFF))
op->type |= UDWORD;
if (n + UINT64_C(0x80000000) <= UINT64_C(0xFFFFFFFF))
op->type |= SDWORD;
}
}
} else if (value->type == EXPR_RDSAE) {
/*
* it's not an operand but a rounding or SAE decorator.
* put the decorator information in the (opflag_t) type field
* of previous operand.
*/
opnum--; op--;
switch (value->value) {
case BRC_RN:
case BRC_RU:
case BRC_RD:
case BRC_RZ:
case BRC_SAE:
op->decoflags |= (value->value == BRC_SAE ? SAE : ER);
result->evex_rm = value->value;
break;
default:
nasm_nonfatal("invalid decorator");
break;
}
} else { /* it's a register */
opflags_t rs;
uint64_t regset_size = 0;
if (value->type >= EXPR_SIMPLE || value->value != 1) {
nasm_nonfatal("invalid operand type");
goto fail;
}
/*
* We do not allow any kind of expression, except for
* reg+value in which case it is a register set.
*/
for (i = 1; value[i].type; i++) {
if (!value[i].value)
continue;
switch (value[i].type) {
case EXPR_SIMPLE:
if (!regset_size) {
regset_size = value[i].value + 1;
break;
}
/* fallthrough */
default:
nasm_nonfatal("invalid operand type");
goto fail;
}
}
if ((regset_size & (regset_size - 1)) ||
regset_size >= (UINT64_C(1) << REGSET_BITS)) {
nasm_nonfatalf(ERR_PASS2, "invalid register set size");
regset_size = 0;
}
/* clear overrides, except TO which applies to FPU regs */
if (op->type & ~TO) {
/*
* we want to produce a warning iff the specified size
* is different from the register size
*/
rs = op->type & SIZE_MASK;
} else {
rs = 0;
}
/*
* Make sure we're not out of nasm_reg_flags, still
* probably this should be fixed when we're defining
* the label.
*
* An easy trigger is
*
* e equ 0x80000000:0
* pshufw word e-0
*
*/
if (value->type < EXPR_REG_START ||
value->type > EXPR_REG_END) {
nasm_nonfatal("invalid operand type");
goto fail;
}
op->type &= TO;
op->type |= REGISTER;
op->type |= nasm_reg_flags[value->type];
op->type |= (regset_size >> 1) << REGSET_SHIFT;
op->decoflags |= brace_flags;
op->basereg = value->type;
if (rs) {
opflags_t opsize = nasm_reg_flags[value->type] & SIZE_MASK;
if (!opsize) {
op->type |= rs; /* For non-size-specific registers, permit size override */
} else if (opsize != rs) {
/*!
*!regsize [on] register size specification ignored
*!
*! warns about a register with implicit size (such as \c{EAX}, which is always 32 bits)
*! been given an explicit size specification which is inconsistent with the size
*! of the named register, e.g. \c{WORD EAX}. \c{DWORD EAX} or \c{WORD AX} are
*! permitted, and do not trigger this warning. Some registers which \e{do not} imply
*! a specific size, such as \c{K0}, may need this specification unless the instruction
*! itself implies the instruction size:
*!-
*! \c KMOVW K0,[foo] ; Permitted, KMOVW implies 16 bits
*! \c KMOV WORD K0,[foo] ; Permitted, WORD K0 specifies instruction size
*! \c KMOV K0,WORD [foo] ; Permitted, WORD [foo] specifies instruction size
*! \c KMOV K0,[foo] ; Not permitted, instruction size ambiguous
*/
nasm_warn(WARN_REGSIZE, "invalid register size specification ignored");
}
}
}
}
/* remember the position of operand having broadcasting/ER mode */
if (op->decoflags & (BRDCAST_MASK | ER | SAE))
result->evex_brerop = opnum;
}
result->operands = opnum; /* set operand count */
/* clear remaining operands */
while (opnum < MAX_OPERANDS)
result->oprs[opnum++].type = 0;
return result;
fail:
result->opcode = I_none;
return result;
}
static int end_expression_next(void)
{
struct tokenval tv;
char *p;
int i;
p = stdscan_get();
i = stdscan(NULL, &tv);
stdscan_set(p);
return (i == ',' || i == ';' || i == ')' || !i);
}
static void free_eops(extop *e)
{
extop *next;
while (e) {
next = e->next;
switch (e->type) {
case EOT_EXTOP:
free_eops(e->val.subexpr);
break;
case EOT_DB_STRING_FREE:
nasm_free(e->val.string.data);
break;
default:
break;
}
nasm_free(e);
e = next;
}
}
void cleanup_insn(insn * i)
{
free_eops(i->eops);
}
Reference in New Issue View Git Blame Copy Permalink