Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Fetching contributors…

Cannot retrieve contributors at this time

296 lines (264 sloc) 9.097 kB
/*
* 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;
}
}
}
Jump to Line
Something went wrong with that request. Please try again.