diff --git a/mach/proto/mcg/mcg.h b/mach/proto/mcg/mcg.h index 193ed3690..a5a148847 100644 --- a/mach/proto/mcg/mcg.h +++ b/mach/proto/mcg/mcg.h @@ -50,7 +50,7 @@ enum PARAM_BVALUE, }; -struct insn +struct em { int opcode; int paramtype; @@ -78,7 +78,7 @@ struct procedure struct basicblock { const char* name; - ARRAY(struct insn, insns); + ARRAY(struct em, ems); ARRAY(struct ir, irs); bool is_fake : 1; bool is_root : 1; diff --git a/mach/proto/mcg/parse_em.c b/mach/proto/mcg/parse_em.c index 699e6b4f4..705bc1587 100644 --- a/mach/proto/mcg/parse_em.c +++ b/mach/proto/mcg/parse_em.c @@ -1,6 +1,6 @@ #include "mcg.h" -static struct e_instr insn; +static struct e_instr em; static struct procedure* current_proc; static struct basicblock* code_bb; static struct basicblock* data_bb; @@ -46,7 +46,7 @@ static void unknown_type(const char* s) { fatal("%s with unknown type '%s'", s, - argtype_to_str(insn.em_arg.ema_argtype)); + argtype_to_str(em.em_arg.ema_argtype)); } static const char* ilabel_to_str(label l) @@ -66,18 +66,18 @@ static void terminate_block(void) code_bb = NULL; } -static struct insn* new_insn(int opcode) +static struct em* new_insn(int opcode) { - struct insn* insn = calloc(sizeof(struct insn), 1); - insn->opcode = opcode; - return insn; + struct em* em = calloc(sizeof(struct em), 1); + em->opcode = opcode; + return em; } static void queue_insn_simple(int opcode) { - struct insn* insn = new_insn(opcode); - insn->paramtype = PARAM_NONE; - APPEND(code_bb->insns, insn); + struct em* em = new_insn(opcode); + em->paramtype = PARAM_NONE; + APPEND(code_bb->ems, em); switch (opcode) { @@ -89,10 +89,10 @@ static void queue_insn_simple(int opcode) static void queue_insn_value(int opcode, arith value) { - struct insn* insn = new_insn(opcode); - insn->paramtype = PARAM_IVALUE; - insn->u.ivalue = value; - APPEND(code_bb->insns, insn); + struct em* em = new_insn(opcode); + em->paramtype = PARAM_IVALUE; + em->u.ivalue = value; + APPEND(code_bb->ems, em); switch (opcode) { @@ -106,11 +106,11 @@ static void queue_insn_value(int opcode, arith value) static void queue_insn_label(int opcode, const char* label, arith offset) { - struct insn* insn = new_insn(opcode); - insn->paramtype = PARAM_LVALUE; - insn->u.lvalue.label = label; - insn->u.lvalue.offset = offset; - APPEND(code_bb->insns, insn); + struct em* em = new_insn(opcode); + em->paramtype = PARAM_LVALUE; + em->u.lvalue.label = label; + em->u.lvalue.offset = offset; + APPEND(code_bb->ems, em); switch (opcode) { @@ -122,11 +122,11 @@ static void queue_insn_label(int opcode, const char* label, arith offset) static void queue_insn_block(int opcode, struct basicblock* left, struct basicblock* right) { - struct insn* insn = new_insn(opcode); - insn->paramtype = PARAM_BVALUE; - insn->u.bvalue.left = left; - insn->u.bvalue.right = right; - APPEND(code_bb->insns, insn); + struct em* em = new_insn(opcode); + em->paramtype = PARAM_BVALUE; + em->u.bvalue.left = left; + em->u.bvalue.right = right; + APPEND(code_bb->ems, em); terminate_block(); } @@ -143,13 +143,13 @@ static void change_basicblock(struct basicblock* newbb) static void queue_insn_ilabel(int opcode, int label) { - const char* name = ilabel_to_str(insn.em_ilb); + const char* name = ilabel_to_str(em.em_ilb); struct basicblock* left = bb_get(name); switch (opcode) { case op_bra: - queue_insn_block(insn.em_opcode, left, NULL); + queue_insn_block(em.em_opcode, left, NULL); break; case op_zeq: @@ -160,7 +160,7 @@ static void queue_insn_ilabel(int opcode, int label) case op_zge: { struct basicblock* bb = bb_get(NULL); - queue_insn_block(insn.em_opcode, left, bb); + queue_insn_block(em.em_opcode, left, bb); change_basicblock(bb); break; } @@ -178,30 +178,30 @@ static void queue_ilabel(arith label) static void parse_pseu(void) { - switch (insn.em_opcode) + switch (em.em_opcode) { case ps_exp: /* external proc */ case ps_exa: /* external array */ case ps_inp: /* internal proc */ case ps_ina: /* internal array */ { - bool export = (insn.em_opcode == ps_exp) || (insn.em_opcode == ps_exa); - bool proc = (insn.em_opcode == ps_exp) || (insn.em_opcode == ps_inp); + bool export = (em.em_opcode == ps_exp) || (em.em_opcode == ps_exa); + bool proc = (em.em_opcode == ps_exp) || (em.em_opcode == ps_inp); - switch (insn.em_arg.ema_argtype) + switch (em.em_arg.ema_argtype) { case pro_ptyp: - symbol_declare(strdup(insn.em_pnam), export, proc); + symbol_declare(strdup(em.em_pnam), export, proc); break; case sof_ptyp: - assert(insn.em_off == 0); - symbol_declare(strdup(insn.em_dnam), export, proc); + assert(em.em_off == 0); + symbol_declare(strdup(em.em_dnam), export, proc); break; case nof_ptyp: - assert(insn.em_off == 0); - symbol_declare(dlabel_to_str(insn.em_dlb), export, proc); + assert(em.em_off == 0); + symbol_declare(dlabel_to_str(em.em_dlb), export, proc); break; default: @@ -213,33 +213,33 @@ static void parse_pseu(void) case ps_con: /* .data */ case ps_rom: /* .rom */ { - bool ro = (insn.em_opcode == ps_rom); + bool ro = (em.em_opcode == ps_rom); - switch (insn.em_arg.ema_argtype) + switch (em.em_arg.ema_argtype) { case ico_ptyp: case uco_ptyp: { - arith val = atol(insn.em_string); - data_int(val, insn.em_size, ro); + arith val = atol(em.em_string); + data_int(val, em.em_size, ro); break; } case str_ptyp: - data_block(strdup(insn.em_string), insn.em_size, ro); + data_block(strdup(em.em_string), em.em_size, ro); break; case cst_ptyp: - data_int(insn.em_cst, EM_wordsize, ro); + data_int(em.em_cst, EM_wordsize, ro); break; case nof_ptyp: - data_offset(dlabel_to_str(insn.em_dlb), insn.em_off, ro); + data_offset(dlabel_to_str(em.em_dlb), em.em_off, ro); break; case ilb_ptyp: { - const char* label = ilabel_to_str(insn.em_ilb); + const char* label = ilabel_to_str(em.em_ilb); /* This is really hacky; to handle basic block flow * descriptor blocks, we need to track which bbs a descriptor @@ -249,10 +249,10 @@ static void parse_pseu(void) if (data_bb) { - struct insn* insn = new_insn(op_bra); - insn->paramtype = PARAM_BVALUE; - insn->u.bvalue.left = bb_get(label); - APPEND(data_bb->insns, insn); + struct em* em = new_insn(op_bra); + em->paramtype = PARAM_BVALUE; + em->u.bvalue.left = bb_get(label); + APPEND(data_bb->ems, em); } data_offset(label, 0, ro); @@ -267,10 +267,10 @@ static void parse_pseu(void) case ps_bss: { - switch (insn.em_arg.ema_argtype) + switch (em.em_arg.ema_argtype) { case cst_ptyp: - data_bss(EM_bsssize, insn.em_cst); + data_bss(EM_bsssize, em.em_cst); break; default: @@ -284,9 +284,9 @@ static void parse_pseu(void) struct symbol* symbol; current_proc = calloc(sizeof(struct procedure), 1); - current_proc->name = strdup(insn.em_pnam); + current_proc->name = strdup(em.em_pnam); current_proc->root_bb = bb_get(current_proc->name); - current_proc->nlocals = insn.em_nlocals; + current_proc->nlocals = em.em_nlocals; code_bb = current_proc->root_bb; code_bb->is_root = true; APPEND(current_proc->blocks, code_bb); @@ -306,22 +306,22 @@ static void parse_pseu(void) break; default: - fatal("unknown pseudo with opcode %d\n", insn.em_opcode); + fatal("unknown pseudo with opcode %d\n", em.em_opcode); } } static arith mes_get_cst(void) { - EM_getinstr(&insn); - if (insn.em_type != EM_MESARG) + EM_getinstr(&em); + if (em.em_type != EM_MESARG) fatal("malformed MES"); - return insn.em_cst; + return em.em_cst; } static void parse_mes(void) { - assert(insn.em_arg.ema_argtype == cst_ptyp); - switch (insn.em_cst) + assert(em.em_arg.ema_argtype == cst_ptyp); + switch (em.em_cst) { case 0: /* error */ fatal("MES 0 received (explicit halt)"); @@ -337,10 +337,10 @@ static void parse_mes(void) } } - while ((insn.em_type == EM_STARTMES) || (insn.em_type == EM_MESARG)) - EM_getinstr(&insn); + while ((em.em_type == EM_STARTMES) || (em.em_type == EM_MESARG)) + EM_getinstr(&em); - if (insn.em_type != EM_ENDMES) + if (em.em_type != EM_ENDMES) fatal("malformed MES"); } @@ -357,27 +357,27 @@ static void create_data_label(const char* label) void parse_em(void) { - EM_getinstr(&insn); + EM_getinstr(&em); tb_filestart(); - while (insn.em_type != EM_EOF) + while (em.em_type != EM_EOF) { - switch (insn.em_type) + switch (em.em_type) { case EM_PSEU: parse_pseu(); break; case EM_DEFILB: - queue_ilabel(insn.em_ilb); + queue_ilabel(em.em_ilb); break; case EM_DEFDLB: - create_data_label(dlabel_to_str(insn.em_dlb)); + create_data_label(dlabel_to_str(em.em_dlb)); break; case EM_DEFDNAM: - create_data_label(strdup(insn.em_dnam)); + create_data_label(strdup(em.em_dnam)); break; case EM_STARTMES: @@ -387,36 +387,36 @@ void parse_em(void) case EM_MNEM: if (code_bb) { - int flags = em_flag[insn.em_opcode - sp_fmnem]; + int flags = em_flag[em.em_opcode - sp_fmnem]; if (flags & EM_PAR) { - switch (insn.em_argtype) + switch (em.em_argtype) { case ilb_ptyp: - queue_insn_ilabel(insn.em_opcode, insn.em_ilb); + queue_insn_ilabel(em.em_opcode, em.em_ilb); break; case nof_ptyp: - queue_insn_label(insn.em_opcode, - dlabel_to_str(insn.em_dlb), insn.em_off); + queue_insn_label(em.em_opcode, + dlabel_to_str(em.em_dlb), em.em_off); break; case sof_ptyp: - queue_insn_label(insn.em_opcode, - strdup(insn.em_dnam), insn.em_off); + queue_insn_label(em.em_opcode, + strdup(em.em_dnam), em.em_off); break; case pro_ptyp: - queue_insn_label(insn.em_opcode, - strdup(insn.em_pnam), 0); + queue_insn_label(em.em_opcode, + strdup(em.em_pnam), 0); break; case cst_ptyp: if ((flags & EM_PAR) == PAR_B) - queue_insn_ilabel(insn.em_opcode, insn.em_ilb); + queue_insn_ilabel(em.em_opcode, em.em_ilb); else - queue_insn_value(insn.em_opcode, insn.em_cst); + queue_insn_value(em.em_opcode, em.em_cst); break; default: @@ -424,15 +424,15 @@ void parse_em(void) } } else - queue_insn_simple(insn.em_opcode); + queue_insn_simple(em.em_opcode); } break; default: - fatal("unrecognised instruction type '%d'", insn.em_type); + fatal("unrecognised instruction type '%d'", em.em_type); } - EM_getinstr(&insn); + EM_getinstr(&em); } tb_fileend(); diff --git a/mach/proto/mcg/treebuilder.c b/mach/proto/mcg/treebuilder.c index 1b0d51da5..92c7bcf3f 100644 --- a/mach/proto/mcg/treebuilder.c +++ b/mach/proto/mcg/treebuilder.c @@ -323,15 +323,15 @@ static struct ir* extract_block_refs(struct basicblock* bb) struct ir* outir = NULL; int i; - for (i=0; iinsns_count; i++) + for (i=0; iems_count; i++) { - struct insn* insn = bb->insns[i]; - assert(insn->opcode == op_bra); - assert(insn->paramtype == PARAM_BVALUE); + struct em* em = bb->ems[i]; + assert(em->opcode == op_bra); + assert(em->paramtype == PARAM_BVALUE); outir = new_ir2( IR_PAIR, 0, - new_bbir(insn->u.bvalue.left), + new_bbir(em->u.bvalue.left), outir ); } @@ -651,34 +651,34 @@ static void generate_tree(struct basicblock* bb) current_bb = bb; reset_stack(); - for (i=0; iinsns_count; i++) + for (i=0; iems_count; i++) { - struct insn* insn = bb->insns[i]; - tracef('E', "E: read %s ", em_mnem[insn->opcode - sp_fmnem]); - switch (insn->paramtype) + struct em* em = bb->ems[i]; + tracef('E', "E: read %s ", em_mnem[em->opcode - sp_fmnem]); + switch (em->paramtype) { case PARAM_NONE: tracef('E', "\n"); - insn_simple(insn->opcode); + insn_simple(em->opcode); break; case PARAM_IVALUE: - tracef('E', "value=%d\n", insn->u.ivalue); - insn_ivalue(insn->opcode, insn->u.ivalue); + tracef('E', "value=%d\n", em->u.ivalue); + insn_ivalue(em->opcode, em->u.ivalue); break; case PARAM_LVALUE: tracef('E', "label=%s offset=%d\n", - insn->u.lvalue.label, insn->u.lvalue.offset); - insn_lvalue(insn->opcode, insn->u.lvalue.label, insn->u.lvalue.offset); + em->u.lvalue.label, em->u.lvalue.offset); + insn_lvalue(em->opcode, em->u.lvalue.label, em->u.lvalue.offset); break; case PARAM_BVALUE: - tracef('E', "true=%s", insn->u.bvalue.left->name); - if (insn->u.bvalue.right) - tracef('E', " false=%s", insn->u.bvalue.right->name); + tracef('E', "true=%s", em->u.bvalue.left->name); + if (em->u.bvalue.right) + tracef('E', " false=%s", em->u.bvalue.right->name); tracef('E', "\n"); - insn_bvalue(insn->opcode, insn->u.bvalue.left, insn->u.bvalue.right); + insn_bvalue(em->opcode, em->u.bvalue.left, em->u.bvalue.right); break; default: