mirror of
https://git.code.sf.net/p/quake/quakeforge
synced 2024-11-22 20:41:20 +00:00
[gamecode] Use text for all v6p opcode names
This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable.
This commit is contained in:
Bill Currie
parent
30008aeb13
commit
143030fec4
5 changed files with 405 additions and 405 deletions
File diff suppressed because it is too large
Load diff
|
|
@ -327,8 +327,8 @@ dagnode_match (const dagnode_t *n, const daglabel_t *op,
|
|||
|
||||
if (n->killed)
|
||||
return 0;
|
||||
if (!strcmp (op->opcode, ".")
|
||||
&& n->label->opcode && !strcmp (n->label->opcode, ".="))
|
||||
if (!strcmp (op->opcode, "load")
|
||||
&& n->label->opcode && !strcmp (n->label->opcode, "store"))
|
||||
return dagnode_deref_match (n, op, children);
|
||||
if (n->label->opcode != op->opcode)
|
||||
return 0;
|
||||
|
|
@ -452,12 +452,12 @@ dagnode_set_edges (dag_t *dag, dagnode_t *n)
|
|||
int first_param = 0;
|
||||
flowvar_t **flowvars = dag->flownode->graph->func->vars;
|
||||
|
||||
if (!strncmp (n->label->opcode, "<RCALL", 6)) {
|
||||
if (!strncmp (n->label->opcode, "rcall", 5)) {
|
||||
num_params = n->label->opcode + 6;
|
||||
first_param = 2;
|
||||
} else if (!strncmp (n->label->opcode, "<CALL", 5)) {
|
||||
} else if (!strncmp (n->label->opcode, "call", 4)) {
|
||||
num_params = n->label->opcode + 5;
|
||||
} else if (!strcmp (n->label->opcode, "<RETURN>")) {
|
||||
} else if (!strcmp (n->label->opcode, "return")) {
|
||||
daglabel_t *label = n->children[0]->label;
|
||||
if (!label->op) {
|
||||
set_iter_t *lab_i;
|
||||
|
|
@ -997,7 +997,7 @@ generate_moves (dag_t *dag, sblock_t *block, dagnode_t *dagnode)
|
|||
var = dag->labels[var_iter->element];
|
||||
operands[2] = var->op;
|
||||
dst = operands[2];
|
||||
st = build_statement ("<MOVE>", operands, var->expr);
|
||||
st = build_statement ("move", operands, var->expr);
|
||||
sblock_add_statement (block, st);
|
||||
}
|
||||
return dst;
|
||||
|
|
@ -1019,7 +1019,7 @@ generate_moveps (dag_t *dag, sblock_t *block, dagnode_t *dagnode)
|
|||
operands[1] = make_operand (dag, block, dagnode, 1);
|
||||
if (dagnode->children[2]) {
|
||||
operands[2] = make_operand (dag, block, dagnode, 2);
|
||||
st = build_statement ("<MOVEP>", operands, dagnode->label->expr);
|
||||
st = build_statement ("movep", operands, dagnode->label->expr);
|
||||
sblock_add_statement (block, st);
|
||||
if ((var_iter = set_first (dagnode->identifiers))) {
|
||||
var = dag->labels[var_iter->element];
|
||||
|
|
@ -1039,7 +1039,7 @@ generate_moveps (dag_t *dag, sblock_t *block, dagnode_t *dagnode)
|
|||
}
|
||||
operands[2] = value_operand (new_pointer_val (offset, type, dstDef, 0),
|
||||
operands[1]->expr);
|
||||
st = build_statement ("<MOVEP>", operands, var->expr);
|
||||
st = build_statement ("movep", operands, var->expr);
|
||||
sblock_add_statement (block, st);
|
||||
}
|
||||
}
|
||||
|
|
@ -1063,7 +1063,7 @@ generate_memsets (dag_t *dag, sblock_t *block, dagnode_t *dagnode)
|
|||
var = dag->labels[var_iter->element];
|
||||
operands[2] = var->op;
|
||||
dst = operands[2];
|
||||
st = build_statement ("<MEMSET>", operands, var->expr);
|
||||
st = build_statement ("memset", operands, var->expr);
|
||||
sblock_add_statement (block, st);
|
||||
}
|
||||
return dst;
|
||||
|
|
@ -1085,7 +1085,7 @@ generate_memsetps (dag_t *dag, sblock_t *block, dagnode_t *dagnode)
|
|||
operands[1] = make_operand (dag, block, dagnode, 1);
|
||||
if (dagnode->children[2]) {
|
||||
operands[2] = make_operand (dag, block, dagnode, 2);
|
||||
st = build_statement ("<MEMSETP>", operands, dagnode->label->expr);
|
||||
st = build_statement ("memsetp", operands, dagnode->label->expr);
|
||||
sblock_add_statement (block, st);
|
||||
} else {
|
||||
for (var_iter = set_first (dagnode->identifiers); var_iter;
|
||||
|
|
@ -1100,7 +1100,7 @@ generate_memsetps (dag_t *dag, sblock_t *block, dagnode_t *dagnode)
|
|||
}
|
||||
operands[2] = value_operand (new_pointer_val (offset, type, dstDef, 0),
|
||||
operands[1]->expr);
|
||||
st = build_statement ("<MEMSETP>", operands, var->expr);
|
||||
st = build_statement ("memsetp", operands, var->expr);
|
||||
sblock_add_statement (block, st);
|
||||
}
|
||||
}
|
||||
|
|
@ -1123,7 +1123,7 @@ generate_assignments (dag_t *dag, sblock_t *block, operand_t *src,
|
|||
if (!dst)
|
||||
dst = operands[1];
|
||||
|
||||
st = build_statement ("=", operands, var->expr);
|
||||
st = build_statement ("assign", operands, var->expr);
|
||||
sblock_add_statement (block, st);
|
||||
}
|
||||
return dst;
|
||||
|
|
|
|||
|
|
@ -1205,20 +1205,20 @@ flow_analyze_statement (statement_t *s, set_t *use, set_t *def, set_t *kill,
|
|||
case st_ptrmemset:
|
||||
flow_add_op_var (use, s->opa, 1);
|
||||
flow_add_op_var (use, s->opb, 1);
|
||||
if (!strcmp (s->opcode, "<MOVE>")
|
||||
|| !strcmp (s->opcode, "<MEMSET>")) {
|
||||
if (!strcmp (s->opcode, "move")
|
||||
|| !strcmp (s->opcode, "memset")) {
|
||||
flow_add_op_var (def, s->opc, 0);
|
||||
res_op = s->opc;
|
||||
} else if (!strcmp (s->opcode, "<MOVEP>")) {
|
||||
} else if (!strcmp (s->opcode, "movep")) {
|
||||
flow_add_op_var (use, s->opc, 0);
|
||||
aux_op2 = flow_analyze_pointer_operand (s->opa, use);
|
||||
res_op = flow_analyze_pointer_operand (s->opc, def);
|
||||
aux_op1 = s->opc;
|
||||
} else if (!strcmp (s->opcode, "<MEMSETP>")) {
|
||||
} else if (!strcmp (s->opcode, "memsetp")) {
|
||||
flow_add_op_var (use, s->opc, 0);
|
||||
res_op = flow_analyze_pointer_operand (s->opc, def);
|
||||
aux_op1 = s->opc;
|
||||
} else if (!strcmp (s->opcode, ".=")) {
|
||||
} else if (!strcmp (s->opcode, "store")) {
|
||||
flow_add_op_var (use, s->opc, 1);
|
||||
res_op = flow_analyze_pointer_operand (s->opb, def);
|
||||
aux_op1 = s->opc;
|
||||
|
|
@ -1250,19 +1250,19 @@ flow_analyze_statement (statement_t *s, set_t *use, set_t *def, set_t *kill,
|
|||
}
|
||||
break;
|
||||
case st_func:
|
||||
if (strcmp (s->opcode, "<RETURN>") == 0
|
||||
|| strcmp (s->opcode, "<DONE>") == 0) {
|
||||
if (strcmp (s->opcode, "return") == 0
|
||||
|| strcmp (s->opcode, "done") == 0) {
|
||||
flow_add_op_var (use, s->opa, 1);
|
||||
} else if (strcmp (s->opcode, "<RETURN_V>") == 0) {
|
||||
} else if (strcmp (s->opcode, "return_v") == 0) {
|
||||
if (use) {
|
||||
flow_add_op_var (use, &flow_params[0].op, 1);
|
||||
}
|
||||
}
|
||||
if (strncmp (s->opcode, "<CALL", 5) == 0) {
|
||||
if (strncmp (s->opcode, "call", 4) == 0) {
|
||||
start = 0;
|
||||
calln = s->opcode[5] - '0';
|
||||
flow_add_op_var (use, s->opa, 1);
|
||||
} else if (strncmp (s->opcode, "<RCALL", 6) == 0) {
|
||||
} else if (strncmp (s->opcode, "rcall", 5) == 0) {
|
||||
start = 2;
|
||||
calln = s->opcode[6] - '0';
|
||||
flow_add_op_var (use, s->opa, 1);
|
||||
|
|
@ -1296,9 +1296,9 @@ flow_analyze_statement (statement_t *s, set_t *use, set_t *def, set_t *kill,
|
|||
}
|
||||
break;
|
||||
case st_flow:
|
||||
if (strcmp (s->opcode, "<GOTO>") != 0) {
|
||||
if (strcmp (s->opcode, "jump") != 0) {
|
||||
flow_add_op_var (use, s->opa, 1);
|
||||
if (strcmp (s->opcode, "<JUMPB>") == 0)
|
||||
if (strcmp (s->opcode, "jumpb") == 0)
|
||||
flow_add_op_var (use, s->opb, 1);
|
||||
}
|
||||
if (operands) {
|
||||
|
|
|
|||
|
|
@ -53,26 +53,26 @@ typedef struct v6p_uint_opcode_s {
|
|||
} v6p_uint_opcode_t;
|
||||
|
||||
static v6p_uint_opcode_t v6p_uint_opcodes[] = {
|
||||
{OP_LOAD_I_v6p, {".", "load.i", ev_entity, ev_field, ev_uint }},
|
||||
{OP_LOADBI_I_v6p, {".", "loadbi.i", ev_ptr, ev_short, ev_uint }},
|
||||
{OP_ADDRESS_I_v6p, {"&", "address.i", ev_uint, ev_invalid, ev_ptr }},
|
||||
{OP_STORE_I_v6p, {"=", "store.i", ev_uint, ev_uint, ev_invalid }},
|
||||
{OP_STOREP_I_v6p, {".=", "storep.i", ev_uint, ev_ptr, ev_invalid }},
|
||||
{OP_STOREB_I_v6p, {".=", "storeb.i", ev_uint, ev_ptr, ev_int }},
|
||||
{OP_STOREBI_I_v6p, {".=", "storebi.i", ev_uint, ev_ptr, ev_short }},
|
||||
{OP_IF_v6p, {"<IF>", "if", ev_uint, ev_short, ev_invalid }},
|
||||
{OP_IFNOT_v6p, {"<IFNOT>", "ifnot", ev_uint, ev_short, ev_invalid }},
|
||||
{OP_ADD_I_v6p, {"+", "add.i", ev_uint, ev_uint, ev_uint }},
|
||||
{OP_SUB_I_v6p, {"-", "sub.i", ev_uint, ev_uint, ev_uint }},
|
||||
{OP_MUL_I_v6p, {"*", "mul.i", ev_uint, ev_uint, ev_uint }},
|
||||
{OP_DIV_I_v6p, {"/", "div.i", ev_uint, ev_uint, ev_uint }},
|
||||
{OP_BITAND_I_v6p, {"&", "bitand.i", ev_uint, ev_uint, ev_uint }},
|
||||
{OP_BITOR_I_v6p, {"|", "bitor.i", ev_uint, ev_uint, ev_uint }},
|
||||
{OP_BITXOR_I_v6p, {"^", "bitxor.i", ev_uint, ev_uint, ev_uint }},
|
||||
{OP_REM_I_v6p, {"%", "rem.i", ev_uint, ev_uint, ev_uint }},
|
||||
{OP_MOD_I_v6p, {"%%", "mod.i", ev_uint, ev_uint, ev_uint }},
|
||||
{OP_SHL_I_v6p, {"<<", "shl.i", ev_uint, ev_uint, ev_uint }},
|
||||
{OP_BITNOT_I_v6p, {"<<", "bitnot.i", ev_uint, ev_invalid, ev_int }},
|
||||
{OP_LOAD_I_v6p, {"load", "load.i", ev_entity, ev_field, ev_uint }},
|
||||
{OP_LOADBI_I_v6p, {"load", "loadbi.i", ev_ptr, ev_short, ev_uint }},
|
||||
{OP_ADDRESS_I_v6p, {"lea", "address.i",ev_uint, ev_invalid, ev_ptr }},
|
||||
{OP_STORE_I_v6p, {"assign", "store.i", ev_uint, ev_uint, ev_invalid }},
|
||||
{OP_STOREP_I_v6p, {"store", "storep.i", ev_uint, ev_ptr, ev_invalid }},
|
||||
{OP_STOREB_I_v6p, {"store", "storeb.i", ev_uint, ev_ptr, ev_int }},
|
||||
{OP_STOREBI_I_v6p, {"store", "storebi.i",ev_uint, ev_ptr, ev_short }},
|
||||
{OP_IF_v6p, {"if", "if", ev_uint, ev_short, ev_invalid }},
|
||||
{OP_IFNOT_v6p, {"ifnot", "ifnot", ev_uint, ev_short, ev_invalid }},
|
||||
{OP_ADD_I_v6p, {"add", "add.i", ev_uint, ev_uint, ev_uint }},
|
||||
{OP_SUB_I_v6p, {"sub", "sub.i", ev_uint, ev_uint, ev_uint }},
|
||||
{OP_MUL_I_v6p, {"mul", "mul.i", ev_uint, ev_uint, ev_uint }},
|
||||
{OP_DIV_I_v6p, {"div", "div.i", ev_uint, ev_uint, ev_uint }},
|
||||
{OP_BITAND_I_v6p, {"bitand", "bitand.i", ev_uint, ev_uint, ev_uint }},
|
||||
{OP_BITOR_I_v6p, {"bitor", "bitor.i", ev_uint, ev_uint, ev_uint }},
|
||||
{OP_BITXOR_I_v6p, {"bitxor", "bitxor.i", ev_uint, ev_uint, ev_uint }},
|
||||
{OP_REM_I_v6p, {"rem", "rem.i", ev_uint, ev_uint, ev_uint }},
|
||||
{OP_MOD_I_v6p, {"mod", "mod.i", ev_uint, ev_uint, ev_uint }},
|
||||
{OP_SHL_I_v6p, {"shl", "shl.i", ev_uint, ev_uint, ev_uint }},
|
||||
{OP_BITNOT_I_v6p, {"bitnot", "bitnot.i", ev_uint, ev_invalid, ev_int }},
|
||||
{}
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -571,28 +571,28 @@ static const char *
|
|||
convert_op (int op)
|
||||
{
|
||||
switch (op) {
|
||||
case OR: return "||";
|
||||
case AND: return "&&";
|
||||
case EQ: return "==";
|
||||
case NE: return "!=";
|
||||
case LE: return "<=";
|
||||
case GE: return ">=";
|
||||
case LT: return "<";
|
||||
case GT: return ">";
|
||||
case '+': return "+";
|
||||
case '-': return "-";
|
||||
case '*': return "*";
|
||||
case '/': return "/";
|
||||
case '%': return "%";
|
||||
case MOD: return "%%";
|
||||
case '&': return "&";
|
||||
case '|': return "|";
|
||||
case '^': return "^";
|
||||
case '~': return "~";
|
||||
case '!': return "!";
|
||||
case SHL: return "<<";
|
||||
case SHR: return ">>";
|
||||
case '.': return ".";
|
||||
case OR: return "or";
|
||||
case AND: return "and";
|
||||
case EQ: return "eq";
|
||||
case NE: return "ne";
|
||||
case LE: return "le";
|
||||
case GE: return "ge";
|
||||
case LT: return "lt";
|
||||
case GT: return "gt";
|
||||
case '+': return "add";
|
||||
case '-': return "sub";
|
||||
case '*': return "mul";
|
||||
case '/': return "div";
|
||||
case '%': return "rem";
|
||||
case MOD: return "mod";
|
||||
case '&': return "bitand";
|
||||
case '|': return "bitor";
|
||||
case '^': return "bitxor";
|
||||
case '~': return "bitnot";
|
||||
case '!': return "not";
|
||||
case SHL: return "shl";
|
||||
case SHR: return "shr";
|
||||
case '.': return "load";
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -603,7 +603,7 @@ statement_is_cond (statement_t *s)
|
|||
{
|
||||
if (!s)
|
||||
return 0;
|
||||
return !strncmp (s->opcode, "<IF", 3);
|
||||
return !strncmp (s->opcode, "if", 2);
|
||||
}
|
||||
|
||||
int
|
||||
|
|
@ -611,7 +611,7 @@ statement_is_goto (statement_t *s)
|
|||
{
|
||||
if (!s)
|
||||
return 0;
|
||||
return !strcmp (s->opcode, "<GOTO>");
|
||||
return !strcmp (s->opcode, "jump");
|
||||
}
|
||||
|
||||
int
|
||||
|
|
@ -619,7 +619,7 @@ statement_is_jumpb (statement_t *s)
|
|||
{
|
||||
if (!s)
|
||||
return 0;
|
||||
return !strcmp (s->opcode, "<JUMPB>");
|
||||
return !strcmp (s->opcode, "jumpb");
|
||||
}
|
||||
|
||||
int
|
||||
|
|
@ -627,9 +627,9 @@ statement_is_call (statement_t *s)
|
|||
{
|
||||
if (!s)
|
||||
return 0;
|
||||
if (!strncmp (s->opcode, "<CALL", 5))
|
||||
if (!strncmp (s->opcode, "call", 4))
|
||||
return 1;
|
||||
if (!strncmp (s->opcode, "<RCALL", 6))
|
||||
if (!strncmp (s->opcode, "rcall", 5))
|
||||
return 2;
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -639,7 +639,7 @@ statement_is_return (statement_t *s)
|
|||
{
|
||||
if (!s)
|
||||
return 0;
|
||||
return !strncmp (s->opcode, "<RETURN", 7);
|
||||
return !strncmp (s->opcode, "return", 6);
|
||||
}
|
||||
|
||||
sblock_t *
|
||||
|
|
@ -687,18 +687,18 @@ statement_get_targetlist (statement_t *s)
|
|||
static void
|
||||
invert_conditional (statement_t *s)
|
||||
{
|
||||
if (!strcmp (s->opcode, "<IF>"))
|
||||
s->opcode = "<IFNOT>";
|
||||
else if (!strcmp (s->opcode, "<IFNOT>"))
|
||||
s->opcode = "<IF>";
|
||||
else if (!strcmp (s->opcode, "<IFBE>"))
|
||||
s->opcode = "<IFA>";
|
||||
else if (!strcmp (s->opcode, "<IFB>"))
|
||||
s->opcode = "<IFAE>";
|
||||
else if (!strcmp (s->opcode, "<IFAE>"))
|
||||
s->opcode = "<IFB>";
|
||||
else if (!strcmp (s->opcode, "<IFA>"))
|
||||
s->opcode = "<IFBE>";
|
||||
if (!strcmp (s->opcode, "if"))
|
||||
s->opcode = "ifnot";
|
||||
else if (!strcmp (s->opcode, "ifnot"))
|
||||
s->opcode = "if";
|
||||
else if (!strcmp (s->opcode, "ifbe"))
|
||||
s->opcode = "ifa";
|
||||
else if (!strcmp (s->opcode, "ifb"))
|
||||
s->opcode = "ifae";
|
||||
else if (!strcmp (s->opcode, "ifae"))
|
||||
s->opcode = "ifb";
|
||||
else if (!strcmp (s->opcode, "ifa"))
|
||||
s->opcode = "ifbe";
|
||||
}
|
||||
|
||||
typedef sblock_t *(*statement_f) (sblock_t *, expr_t *);
|
||||
|
|
@ -712,7 +712,7 @@ static sblock_t *
|
|||
expr_address (sblock_t *sblock, expr_t *e, operand_t **op)
|
||||
{
|
||||
statement_t *s;
|
||||
s = new_statement (st_expr, "&", e);
|
||||
s = new_statement (st_expr, "lea", e);
|
||||
sblock = statement_subexpr (sblock, e->e.address.lvalue, &s->opa);
|
||||
if (e->e.address.offset) {
|
||||
sblock = statement_subexpr (sblock, e->e.address.offset, &s->opb);
|
||||
|
|
@ -797,8 +797,8 @@ expr_assign_copy (sblock_t *sblock, expr_t *e, operand_t **op, operand_t *src)
|
|||
operand_t *dst = 0;
|
||||
operand_t *size = 0;
|
||||
static const char *opcode_sets[][2] = {
|
||||
{"<MOVE>", "<MOVEP>"},
|
||||
{"<MEMSET>", "<MEMSETP>"},
|
||||
{"move", "movep"},
|
||||
{"memset", "memsetp"},
|
||||
};
|
||||
const unsigned max_count = 1 << 16;
|
||||
const char **opcode_set = opcode_sets[0];
|
||||
|
|
@ -887,7 +887,7 @@ expr_assign (sblock_t *sblock, expr_t *e, operand_t **op)
|
|||
operand_t *src = 0;
|
||||
operand_t *dst = 0;
|
||||
operand_t *ofs = 0;
|
||||
const char *opcode = "=";
|
||||
const char *opcode = "assign";
|
||||
st_type_t type;
|
||||
|
||||
if (src_expr->type == ex_assign) {
|
||||
|
|
@ -931,7 +931,7 @@ dereference_dst:
|
|||
// dst_expr is a dereferenced pointer, so need to un-dereference it
|
||||
// to get the pointer and switch to storep instructions.
|
||||
dst_expr = expr_file_line (address_expr (dst_expr, 0, 0), e);
|
||||
opcode = ".="; // FIXME find a nicer representation (lose strings?)
|
||||
opcode = "store";// FIXME find a nicer representation (lose strings?)
|
||||
if (dst_expr->type == ex_address && dst_expr->e.address.offset
|
||||
&& !is_const_ptr (dst_expr->e.address.lvalue)) {
|
||||
sblock = statement_subexpr (sblock,
|
||||
|
|
@ -952,7 +952,7 @@ dereference_dst:
|
|||
}
|
||||
|
||||
if (is_entity (dst->type) && ofs && is_field (ofs->type)) {
|
||||
s = new_statement (st_expr, "&", dst_expr);
|
||||
s = new_statement (st_expr, "lea", dst_expr);
|
||||
s->opa = dst;
|
||||
s->opb = ofs;
|
||||
s->opc = temp_operand (&type_ptr, dst_expr);
|
||||
|
|
@ -1012,7 +1012,7 @@ expr_call (sblock_t *sblock, expr_t *call, operand_t **op)
|
|||
ind--;
|
||||
param = new_param_expr (get_type (a), ind);
|
||||
if (count && options.code.progsversion != PROG_ID_VERSION && ind < 2) {
|
||||
pref = "R";
|
||||
pref = "r";
|
||||
sblock = statement_subexpr (sblock, param, &arguments[ind]);
|
||||
if (options.code.vector_calls && a->type == ex_value
|
||||
&& a->e.value->lltype == ev_vector)
|
||||
|
|
@ -1037,7 +1037,7 @@ expr_call (sblock_t *sblock, expr_t *call, operand_t **op)
|
|||
arg = p;
|
||||
sblock = statement_subexpr (sblock, a, &arg);
|
||||
if (arg != p) {
|
||||
s = new_statement (st_assign, "=", a);
|
||||
s = new_statement (st_assign, "assign", a);
|
||||
s->opa = arg;
|
||||
s->opb = p;
|
||||
sblock_add_statement (sblock, s);
|
||||
|
|
@ -1045,7 +1045,7 @@ expr_call (sblock_t *sblock, expr_t *call, operand_t **op)
|
|||
}
|
||||
}
|
||||
}
|
||||
opcode = va (0, "<%sCALL%d>", pref, count);
|
||||
opcode = va (0, "%scall%d", pref, count);
|
||||
s = new_statement (st_func, opcode, call);
|
||||
sblock = statement_subexpr (sblock, func, &s->opa);
|
||||
s->opb = arguments[0];
|
||||
|
|
@ -1059,13 +1059,13 @@ static sblock_t *
|
|||
statement_branch (sblock_t *sblock, expr_t *e)
|
||||
{
|
||||
static const char *opcodes[] = {
|
||||
"<IFNOT>",
|
||||
"<IFB>",
|
||||
"<IFA>",
|
||||
"ifnot",
|
||||
"ifb",
|
||||
"ifa",
|
||||
0, // special handling
|
||||
"<IF>",
|
||||
"<IFAE>",
|
||||
"<IFBE>",
|
||||
"if",
|
||||
"ifae",
|
||||
"ifbe",
|
||||
0, // not used here
|
||||
};
|
||||
statement_t *s = 0;
|
||||
|
|
@ -1076,11 +1076,11 @@ statement_branch (sblock_t *sblock, expr_t *e)
|
|||
}
|
||||
if (e->e.branch.type == pr_branch_jump) {
|
||||
if (e->e.branch.index) {
|
||||
s = new_statement (st_flow, "<JUMPB>", e);
|
||||
s = new_statement (st_flow, "jumpb", e);
|
||||
sblock = statement_subexpr (sblock, e->e.branch.target, &s->opa);
|
||||
sblock = statement_subexpr (sblock, e->e.branch.index, &s->opb);
|
||||
} else {
|
||||
s = new_statement (st_flow, "<GOTO>", e);
|
||||
s = new_statement (st_flow, "jump", e);
|
||||
s->opa = label_operand (e->e.branch.target);
|
||||
}
|
||||
} else {
|
||||
|
|
@ -1102,10 +1102,10 @@ statement_return (sblock_t *sblock, expr_t *e)
|
|||
statement_t *s;
|
||||
|
||||
debug (e, "RETURN");
|
||||
opcode = "<RETURN>";
|
||||
opcode = "return";
|
||||
if (!e->e.retrn.ret_val) {
|
||||
if (options.code.progsversion != PROG_ID_VERSION) {
|
||||
opcode = "<RETURN_V>";
|
||||
opcode = "return_v";
|
||||
} else {
|
||||
e->e.retrn.ret_val = new_float_expr (0);
|
||||
}
|
||||
|
|
@ -1125,7 +1125,7 @@ statement_return (sblock_t *sblock, expr_t *e)
|
|||
static statement_t *
|
||||
lea_statement (operand_t *pointer, operand_t *offset, expr_t *e)
|
||||
{
|
||||
statement_t *s = new_statement (st_expr, "&", e);
|
||||
statement_t *s = new_statement (st_expr, "lea", e);
|
||||
s->opa = pointer;
|
||||
s->opb = offset;
|
||||
s->opc = temp_operand (&type_ptr, e);
|
||||
|
|
@ -1162,14 +1162,14 @@ expr_deref (sblock_t *sblock, expr_t *deref, operand_t **op)
|
|||
|
||||
dst_addr = operand_address (*op, e);
|
||||
|
||||
s = new_statement (st_ptrmove, "<MOVEP>", deref);
|
||||
s = new_statement (st_ptrmove, "movep", deref);
|
||||
s->opa = src_addr;
|
||||
//FIXME large types
|
||||
s->opb = short_operand (type_size (type), e);
|
||||
s->opc = dst_addr;
|
||||
sblock_add_statement (sblock, s);
|
||||
} else {
|
||||
s = new_statement (st_expr, ".", deref);
|
||||
s = new_statement (st_expr, "load", deref);
|
||||
s->opa = ptr;
|
||||
s->opb = offs;
|
||||
s->opc = *op;
|
||||
|
|
@ -1186,7 +1186,7 @@ expr_deref (sblock_t *sblock, expr_t *deref, operand_t **op)
|
|||
sblock = statement_subexpr (sblock, e, &ptr);
|
||||
if (!*op)
|
||||
*op = temp_operand (type, e);
|
||||
s = new_statement (st_expr, ".", deref);
|
||||
s = new_statement (st_expr, "load", deref);
|
||||
s->opa = ptr;
|
||||
s->opb = short_operand (0, e);
|
||||
s->opc = *op;
|
||||
|
|
@ -1295,7 +1295,7 @@ expr_cast (sblock_t *sblock, expr_t *e, operand_t **op)
|
|||
operand_t *src = 0;
|
||||
sblock = statement_subexpr (sblock, e->e.expr.e1, &src);
|
||||
*op = temp_operand (e->e.expr.type, e);
|
||||
s = new_statement (st_expr, "<CONV>", e);
|
||||
s = new_statement (st_expr, "conv", e);
|
||||
s->opa = src;
|
||||
s->opc = *op;
|
||||
sblock_add_statement (sblock, s);
|
||||
|
|
@ -1483,7 +1483,7 @@ expr_nil (sblock_t *sblock, expr_t *e, operand_t **op)
|
|||
sblock = statement_subexpr (sblock, new_int_expr(0), &zero);
|
||||
sblock = statement_subexpr (sblock, size_expr, &size);
|
||||
|
||||
s = new_statement (st_memset, "<MEMSET>", e);
|
||||
s = new_statement (st_memset, "memset", e);
|
||||
s->opa = zero;
|
||||
s->opb = size;
|
||||
s->opc = *op;
|
||||
|
|
@ -1549,7 +1549,7 @@ statement_state (sblock_t *sblock, expr_t *e)
|
|||
{
|
||||
statement_t *s;
|
||||
|
||||
s = new_statement (st_state, "<STATE>", e);
|
||||
s = new_statement (st_state, "state", e);
|
||||
sblock = statement_subexpr (sblock, e->e.state.frame, &s->opa);
|
||||
sblock = statement_subexpr (sblock, e->e.state.think, &s->opb);
|
||||
sblock = statement_subexpr (sblock, e->e.state.step, &s->opc);
|
||||
|
|
@ -1738,7 +1738,7 @@ statement_memset (sblock_t *sblock, expr_t *e)
|
|||
expr_t *dst = e->e.memset.dst;
|
||||
expr_t *val = e->e.memset.val;
|
||||
expr_t *count = e->e.memset.count;
|
||||
const char *opcode = "<MEMSET>";
|
||||
const char *opcode = "memset";
|
||||
statement_t *s;
|
||||
|
||||
if (is_constant (count)) {
|
||||
|
|
@ -2115,9 +2115,9 @@ check_final_block (sblock_t *sblock)
|
|||
sblock->next = new_sblock ();
|
||||
sblock = sblock->next;
|
||||
}
|
||||
s = new_statement (st_func, "<RETURN_V>", 0);
|
||||
s = new_statement (st_func, "return_v", 0);
|
||||
if (options.traditional || options.code.progsversion == PROG_ID_VERSION) {
|
||||
s->opcode = save_string ("<RETURN>");
|
||||
s->opcode = save_string ("return");
|
||||
s->opa = return_operand (&type_void, 0);
|
||||
}
|
||||
sblock_add_statement (sblock, s);
|
||||
|
|
|
|||
Loading…
Reference in a new issue