296 lines
8.9 KiB
C
296 lines
8.9 KiB
C
/*
|
|
* Mnemonic instruction bytecode
|
|
*
|
|
* Copyright (C) 2005-2007 Peter Johnson
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. 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 AUTHOR AND OTHER 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 AUTHOR OR OTHER 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.
|
|
*/
|
|
#include "util.h"
|
|
|
|
#include "libyasm-stdint.h"
|
|
#include "coretype.h"
|
|
|
|
#include "errwarn.h"
|
|
#include "expr.h"
|
|
#include "value.h"
|
|
|
|
#include "bytecode.h"
|
|
#include "insn.h"
|
|
#include "arch.h"
|
|
|
|
|
|
void
|
|
yasm_ea_set_segreg(yasm_effaddr *ea, uintptr_t segreg)
|
|
{
|
|
if (!ea)
|
|
return;
|
|
|
|
if (segreg != 0 && ea->segreg != 0)
|
|
yasm_warn_set(YASM_WARN_GENERAL,
|
|
N_("multiple segment overrides, using leftmost"));
|
|
|
|
ea->segreg = segreg;
|
|
}
|
|
|
|
yasm_insn_operand *
|
|
yasm_operand_create_reg(uintptr_t reg)
|
|
{
|
|
yasm_insn_operand *retval = yasm_xmalloc(sizeof(yasm_insn_operand));
|
|
|
|
retval->type = YASM_INSN__OPERAND_REG;
|
|
retval->data.reg = reg;
|
|
retval->seg = 0;
|
|
retval->targetmod = 0;
|
|
retval->size = 0;
|
|
retval->deref = 0;
|
|
retval->strict = 0;
|
|
|
|
return retval;
|
|
}
|
|
|
|
yasm_insn_operand *
|
|
yasm_operand_create_segreg(uintptr_t segreg)
|
|
{
|
|
yasm_insn_operand *retval = yasm_xmalloc(sizeof(yasm_insn_operand));
|
|
|
|
retval->type = YASM_INSN__OPERAND_SEGREG;
|
|
retval->data.reg = segreg;
|
|
retval->seg = 0;
|
|
retval->targetmod = 0;
|
|
retval->size = 0;
|
|
retval->deref = 0;
|
|
retval->strict = 0;
|
|
|
|
return retval;
|
|
}
|
|
|
|
yasm_insn_operand *
|
|
yasm_operand_create_mem(/*@only@*/ yasm_effaddr *ea)
|
|
{
|
|
yasm_insn_operand *retval = yasm_xmalloc(sizeof(yasm_insn_operand));
|
|
|
|
retval->type = YASM_INSN__OPERAND_MEMORY;
|
|
retval->data.ea = ea;
|
|
retval->seg = 0;
|
|
retval->targetmod = 0;
|
|
retval->size = 0;
|
|
retval->deref = 0;
|
|
retval->strict = 0;
|
|
retval->size = ea->data_len * 8;
|
|
|
|
return retval;
|
|
}
|
|
|
|
yasm_insn_operand *
|
|
yasm_operand_create_imm(/*@only@*/ yasm_expr *val)
|
|
{
|
|
yasm_insn_operand *retval;
|
|
const uintptr_t *reg;
|
|
|
|
reg = yasm_expr_get_reg(&val, 0);
|
|
if (reg) {
|
|
retval = yasm_operand_create_reg(*reg);
|
|
yasm_expr_destroy(val);
|
|
} else {
|
|
retval = yasm_xmalloc(sizeof(yasm_insn_operand));
|
|
retval->type = YASM_INSN__OPERAND_IMM;
|
|
retval->data.val = val;
|
|
retval->seg = 0;
|
|
retval->targetmod = 0;
|
|
retval->size = 0;
|
|
retval->deref = 0;
|
|
retval->strict = 0;
|
|
}
|
|
|
|
return retval;
|
|
}
|
|
|
|
yasm_insn_operand *
|
|
yasm_insn_ops_append(yasm_insn *insn, yasm_insn_operand *op)
|
|
{
|
|
if (op) {
|
|
insn->num_operands++;
|
|
STAILQ_INSERT_TAIL(&insn->operands, op, link);
|
|
return op;
|
|
}
|
|
return (yasm_insn_operand *)NULL;
|
|
}
|
|
|
|
void
|
|
yasm_insn_add_prefix(yasm_insn *insn, uintptr_t prefix)
|
|
{
|
|
insn->prefixes =
|
|
yasm_xrealloc(insn->prefixes,
|
|
(insn->num_prefixes+1)*sizeof(uintptr_t));
|
|
insn->prefixes[insn->num_prefixes] = prefix;
|
|
insn->num_prefixes++;
|
|
}
|
|
|
|
void
|
|
yasm_insn_add_seg_prefix(yasm_insn *insn, uintptr_t segreg)
|
|
{
|
|
insn->segregs =
|
|
yasm_xrealloc(insn->segregs, (insn->num_segregs+1)*sizeof(uintptr_t));
|
|
insn->segregs[insn->num_segregs] = segreg;
|
|
insn->num_segregs++;
|
|
}
|
|
|
|
void
|
|
yasm_insn_initialize(yasm_insn *insn)
|
|
{
|
|
STAILQ_INIT(&insn->operands);
|
|
|
|
insn->prefixes = NULL;
|
|
insn->segregs = NULL;
|
|
|
|
insn->num_operands = 0;
|
|
insn->num_prefixes = 0;
|
|
insn->num_segregs = 0;
|
|
}
|
|
|
|
void
|
|
yasm_insn_delete(yasm_insn *insn,
|
|
void (*ea_destroy) (/*@only@*/ yasm_effaddr *))
|
|
{
|
|
if (insn->num_operands > 0) {
|
|
yasm_insn_operand *cur, *next;
|
|
|
|
cur = STAILQ_FIRST(&insn->operands);
|
|
while (cur) {
|
|
next = STAILQ_NEXT(cur, link);
|
|
switch (cur->type) {
|
|
case YASM_INSN__OPERAND_MEMORY:
|
|
ea_destroy(cur->data.ea);
|
|
break;
|
|
case YASM_INSN__OPERAND_IMM:
|
|
yasm_expr_destroy(cur->data.val);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
yasm_xfree(cur);
|
|
cur = next;
|
|
}
|
|
}
|
|
if (insn->num_prefixes > 0)
|
|
yasm_xfree(insn->prefixes);
|
|
if (insn->num_segregs > 0)
|
|
yasm_xfree(insn->segregs);
|
|
}
|
|
|
|
void
|
|
yasm_insn_print(const yasm_insn *insn, FILE *f, int indent_level)
|
|
{
|
|
const yasm_insn_operand *op;
|
|
|
|
STAILQ_FOREACH (op, &insn->operands, link) {
|
|
switch (op->type) {
|
|
case YASM_INSN__OPERAND_REG:
|
|
fprintf(f, "%*sReg=", indent_level, "");
|
|
/*yasm_arch_reg_print(arch, op->data.reg, f);*/
|
|
fprintf(f, "\n");
|
|
break;
|
|
case YASM_INSN__OPERAND_SEGREG:
|
|
fprintf(f, "%*sSegReg=", indent_level, "");
|
|
/*yasm_arch_segreg_print(arch, op->data.reg, f);*/
|
|
fprintf(f, "\n");
|
|
break;
|
|
case YASM_INSN__OPERAND_MEMORY:
|
|
fprintf(f, "%*sMemory=\n", indent_level, "");
|
|
/*yasm_arch_ea_print(arch, op->data.ea, f, indent_level);*/
|
|
break;
|
|
case YASM_INSN__OPERAND_IMM:
|
|
fprintf(f, "%*sImm=", indent_level, "");
|
|
yasm_expr_print(op->data.val, f);
|
|
fprintf(f, "\n");
|
|
break;
|
|
}
|
|
fprintf(f, "%*sTargetMod=%lx\n", indent_level+1, "",
|
|
(unsigned long)op->targetmod);
|
|
fprintf(f, "%*sSize=%u\n", indent_level+1, "", op->size);
|
|
fprintf(f, "%*sDeref=%d, Strict=%d\n", indent_level+1, "",
|
|
(int)op->deref, (int)op->strict);
|
|
}
|
|
}
|
|
|
|
void
|
|
yasm_insn_finalize(yasm_insn *insn)
|
|
{
|
|
unsigned int i;
|
|
yasm_insn_operand *op;
|
|
yasm_error_class eclass;
|
|
char *str, *xrefstr;
|
|
unsigned long xrefline;
|
|
|
|
/* Simplify the operands' expressions first. */
|
|
for (i = 0, op = yasm_insn_ops_first(insn);
|
|
op && i<insn->num_operands; op = yasm_insn_op_next(op), i++) {
|
|
/* Check operand type */
|
|
switch (op->type) {
|
|
case YASM_INSN__OPERAND_MEMORY:
|
|
/* Don't get over-ambitious here; some archs' memory expr
|
|
* parser are sensitive to the presence of *1, etc, so don't
|
|
* simplify reg*1 identities.
|
|
*/
|
|
if (op->data.ea)
|
|
op->data.ea->disp.abs =
|
|
yasm_expr__level_tree(op->data.ea->disp.abs, 1, 1, 0,
|
|
0, NULL, NULL);
|
|
if (yasm_error_occurred()) {
|
|
/* Add a pointer to where it was used to the error */
|
|
yasm_error_fetch(&eclass, &str, &xrefline, &xrefstr);
|
|
if (xrefstr) {
|
|
yasm_error_set_xref(xrefline, "%s", xrefstr);
|
|
yasm_xfree(xrefstr);
|
|
}
|
|
if (str) {
|
|
yasm_error_set(eclass, "%s in memory expression", str);
|
|
yasm_xfree(str);
|
|
}
|
|
return;
|
|
}
|
|
break;
|
|
case YASM_INSN__OPERAND_IMM:
|
|
op->data.val =
|
|
yasm_expr__level_tree(op->data.val, 1, 1, 1, 0, NULL,
|
|
NULL);
|
|
if (yasm_error_occurred()) {
|
|
/* Add a pointer to where it was used to the error */
|
|
yasm_error_fetch(&eclass, &str, &xrefline, &xrefstr);
|
|
if (xrefstr) {
|
|
yasm_error_set_xref(xrefline, "%s", xrefstr);
|
|
yasm_xfree(xrefstr);
|
|
}
|
|
if (str) {
|
|
yasm_error_set(eclass, "%s in immediate expression",
|
|
str);
|
|
yasm_xfree(str);
|
|
}
|
|
return;
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|