X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fmips%2Fmips_emitter.c;h=a10de95c938ad17edd3dc66eab262d2064e19fa0;hb=f37b4dbb329604edd67ff5877161cb5322e93020;hp=13a5d708bb1f030cef9e498c85362751a644954b;hpb=aebc3c0c980bcc0536ffdc4cb2a545961b5a8b81;p=libfirm diff --git a/ir/be/mips/mips_emitter.c b/ir/be/mips/mips_emitter.c index 13a5d708b..a10de95c9 100644 --- a/ir/be/mips/mips_emitter.c +++ b/ir/be/mips/mips_emitter.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 1995-2007 University of Karlsruhe. All right reserved. + * Copyright (C) 1995-2008 University of Karlsruhe. All right reserved. * * This file is part of libFirm. * @@ -54,62 +54,66 @@ DEBUG_ONLY(static firm_dbg_module_t *dbg = NULL;) +#define BLOCK_PREFIX ".L" + #define SNPRINTF_BUF_LEN 128 +static const mips_isa_t *isa; +static const arch_env_t *arch_env; +static const mips_code_gen_t *cg; + /** * Returns the register at in position pos. */ -static const arch_register_t *get_in_reg(const arch_env_t *arch_env, - const ir_node *node, int pos) +static const arch_register_t *get_in_reg(const ir_node *node, int pos) { - ir_node *op; - const arch_register_t *reg = NULL; + ir_node *op; + const arch_register_t *reg = NULL; - assert(get_irn_arity(node) > pos && "Invalid IN position"); + assert(get_irn_arity(node) > pos && "Invalid IN position"); - /* The out register of the operator at position pos is the - in register we need. */ - op = get_irn_n(node, pos); + /* The out register of the operator at position pos is the + in register we need. */ + op = get_irn_n(node, pos); - reg = arch_get_irn_register(arch_env, op); + reg = arch_get_irn_register(arch_env, op); - assert(reg && "no in register found"); - return reg; + assert(reg && "no in register found"); + return reg; } /** * Returns the register at out position pos. */ -static const arch_register_t *get_out_reg(const arch_env_t *arch_env, - const ir_node *node, int pos) -{ - ir_node *proj; - const arch_register_t *reg = NULL; - - /* 1st case: irn is not of mode_T, so it has only */ - /* one OUT register -> good */ - /* 2nd case: irn is of mode_T -> collect all Projs and ask the */ - /* Proj with the corresponding projnum for the register */ - - if (get_irn_mode(node) != mode_T) { - reg = arch_get_irn_register(arch_env, node); - } else if (is_mips_irn(node)) { - reg = get_mips_out_reg(node, pos); - } else { - const ir_edge_t *edge; - - foreach_out_edge(node, edge) { - proj = get_edge_src_irn(edge); - assert(is_Proj(proj) && "non-Proj from mode_T node"); - if (get_Proj_proj(proj) == pos) { - reg = arch_get_irn_register(arch_env, proj); - break; - } - } - } - - assert(reg && "no out register found"); - return reg; +static const arch_register_t *get_out_reg(const ir_node *node, int pos) +{ + ir_node *proj; + const arch_register_t *reg = NULL; + + /* 1st case: irn is not of mode_T, so it has only */ + /* one OUT register -> good */ + /* 2nd case: irn is of mode_T -> collect all Projs and ask the */ + /* Proj with the corresponding projnum for the register */ + + if (get_irn_mode(node) != mode_T) { + reg = arch_get_irn_register(arch_env, node); + } else if (is_mips_irn(node)) { + reg = get_mips_out_reg(node, pos); + } else { + const ir_edge_t *edge; + + foreach_out_edge(node, edge) { + proj = get_edge_src_irn(edge); + assert(is_Proj(proj) && "non-Proj from mode_T node"); + if (get_Proj_proj(proj) == pos) { + reg = arch_get_irn_register(arch_env, proj); + break; + } + } + } + + assert(reg && "no out register found"); + return reg; } /************************************************************* @@ -123,18 +127,24 @@ static const arch_register_t *get_out_reg(const arch_env_t *arch_env, * |_| |_| *************************************************************/ -void mips_emit_source_register(mips_emit_env_t *env, const ir_node *node, - int pos) +/** + * Emit the name of the source register at given input position. + */ +void mips_emit_source_register(const ir_node *node, int pos) { - const arch_register_t *reg = get_in_reg(env->arch_env, node, pos); - be_emit_string(env->emit, arch_register_get_name(reg)); + const arch_register_t *reg = get_in_reg(node, pos); + be_emit_char('$'); + be_emit_string(arch_register_get_name(reg)); } -void mips_emit_dest_register(mips_emit_env_t *env, const ir_node *node, - int pos) +/** + * Emit the name of the destination register at given output position. + */ +void mips_emit_dest_register(const ir_node *node, int pos) { - const arch_register_t *reg = get_out_reg(env->arch_env, node, pos); - be_emit_string(env->emit, arch_register_get_name(reg)); + const arch_register_t *reg = get_out_reg(node, pos); + be_emit_char('$'); + be_emit_string(arch_register_get_name(reg)); } #if 0 @@ -221,38 +231,88 @@ static const char *node_const_to_str(ir_node *n) } #endif -void mips_emit_immediate(mips_emit_env_t *env, const ir_node *node) +void mips_emit_load_store_address(const ir_node *node, int pos) { - const mips_attr_t *attr = get_mips_attr(node); + const mips_load_store_attr_t *attr = get_mips_load_store_attr_const(node); - be_emit_char(env->emit, '$'); - tarval *tv = attr->tv; - be_emit_tarval(env->emit, tv); + be_emit_irprintf("%d(", attr->offset); + mips_emit_source_register(node, pos); + be_emit_char(')'); } +void mips_emit_immediate_suffix(const ir_node *node, int pos) +{ + ir_node *op = get_irn_n(node, pos); + if(is_mips_Immediate(op)) + be_emit_char('i'); +} + +void mips_emit_immediate(const ir_node *node) +{ + const mips_immediate_attr_t *attr = get_mips_immediate_attr_const(node); + + switch(attr->imm_type) { + case MIPS_IMM_CONST: + be_emit_irprintf("%d", attr->val); + break; + case MIPS_IMM_SYMCONST_LO: + be_emit_cstring("%lo($"); + be_emit_ident(get_entity_ld_ident(attr->entity)); + if(attr->val != 0) { + be_emit_irprintf("%+d", attr->val); + } + be_emit_char(')'); + break; + case MIPS_IMM_SYMCONST_HI: + be_emit_cstring("%hi($"); + be_emit_ident(get_entity_ld_ident(attr->entity)); + if(attr->val != 0) { + be_emit_irprintf("%+d", attr->val); + } + be_emit_char(')'); + break; + default: + panic("invalid immediate type found"); + } +} + +/** + * Emit the name of the destination register at given output position. + */ +void mips_emit_source_register_or_immediate(const ir_node *node, int pos) +{ + const ir_node *op = get_irn_n(node, pos); + if(is_mips_Immediate(op)) { + mips_emit_immediate(op); + } else { + mips_emit_source_register(node, pos); + } +} + +#if 0 /* * Add a number to a prefix. This number will not be used a second time. */ -static -char *get_unique_label(char *buf, size_t buflen, const char *prefix) +static char *get_unique_label(char *buf, size_t buflen, const char *prefix) { static unsigned long id = 0; snprintf(buf, buflen, "%s%lu", prefix, ++id); return buf; } +#endif /************************************************************************/ /* ABI Handling */ /************************************************************************/ static -void mips_emit_IncSP(mips_emit_env_t *env, const ir_node *node) +void mips_emit_IncSP(const ir_node *node) { int offset = be_get_IncSP_offset(node); if(offset == 0) { - be_emit_cstring(env->emit, "\t/* omitted IncSP with 0 */"); - be_emit_finish_line_gas(env->emit, node); + be_emit_cstring("\t/* omitted IncSP with 0 */"); + be_emit_finish_line_gas(node); return; } @@ -261,113 +321,92 @@ void mips_emit_IncSP(mips_emit_env_t *env, const ir_node *node) } if(offset > 0) { - be_emit_irprintf(env->emit, "\tsubu $sp, $sp, %d", offset); + be_emit_irprintf("\tsubu $sp, $sp, %d", offset); } else { - be_emit_irprintf(env->emit, "\taddu $sp, $sp, %d", -offset); + be_emit_irprintf("\taddu $sp, $sp, %d", -offset); } - be_emit_finish_line_gas(env->emit, node); + be_emit_finish_line_gas(node); } -static void mips_emit_Copy(mips_emit_env_t *env, const ir_node *node) +static void mips_emit_Copy(const ir_node *node) { - be_emit_cstring(env->emit, "\tmove "); - mips_emit_dest_register(env, node, 0); - be_emit_cstring(env->emit, ", "); - mips_emit_source_register(env, node, 0); - be_emit_finish_line_gas(env->emit, node); + be_emit_cstring("\tmove "); + mips_emit_dest_register(node, 0); + be_emit_cstring(", "); + mips_emit_source_register(node, 0); + be_emit_finish_line_gas(node); } -static void mips_emit_Return(mips_emit_env_t *env, const ir_node* node) +static void mips_emit_Return(const ir_node* node) { - be_emit_cstring(env->emit, "\tj $ra"); - be_emit_finish_line_gas(env->emit, node); + be_emit_cstring("\tj $ra"); + be_emit_finish_line_gas(node); } static __attribute__((unused)) -void mips_emit_nops(mips_emit_env_t *env, int n) +void mips_emit_nops(int n) { int i; for(i = 0; i < n; ++i) { - be_emit_cstring(env->emit, "\tnop\n"); - be_emit_write_line(env->emit); + be_emit_cstring("\tnop\n"); + be_emit_write_line(); } } -static void mips_emit_Perm(const ir_node *node, mips_emit_env_t *env) +static void mips_emit_Perm(const ir_node *node) { assert(get_irn_arity(node) == 2); - be_emit_cstring(env->emit, "\txor "); - mips_emit_source_register(env, node, 0); - be_emit_cstring(env->emit, ", "); - mips_emit_source_register(env, node, 0); - be_emit_cstring(env->emit, ", "); - mips_emit_source_register(env, node, 1); - be_emit_finish_line_gas(env->emit, node); - - /* mips_emit_nops(env, 3); */ - - be_emit_cstring(env->emit, "\txor "); - mips_emit_source_register(env, node, 1); - be_emit_cstring(env->emit, ", "); - mips_emit_source_register(env, node, 1); - be_emit_cstring(env->emit, ", "); - mips_emit_source_register(env, node, 0); - be_emit_finish_line_gas(env->emit, node); - - /* mips_emit_nops(env, 3); */ + be_emit_cstring("\txor "); + mips_emit_source_register(node, 0); + be_emit_cstring(", "); + mips_emit_source_register(node, 0); + be_emit_cstring(", "); + mips_emit_source_register(node, 1); + be_emit_finish_line_gas(node); - be_emit_cstring(env->emit, "\txor "); - mips_emit_source_register(env, node, 0); - be_emit_cstring(env->emit, ", "); - mips_emit_source_register(env, node, 0); - be_emit_cstring(env->emit, ", "); - mips_emit_source_register(env, node, 1); - be_emit_finish_line_gas(env->emit, node); + /* mips_emit_nops(3); */ - /* mips_emit_nops(env, 3); */ -} - - -static void mips_emit_Spill(mips_emit_env_t *env, const ir_node *node) -{ -#if 0 - FILE *F = env->out; - ir_entity *ent = be_get_frame_entity(node); + be_emit_cstring("\txor "); + mips_emit_source_register(node, 1); + be_emit_cstring(", "); + mips_emit_source_register(node, 1); + be_emit_cstring(", "); + mips_emit_source_register(node, 0); + be_emit_finish_line_gas(node); - lc_efprintf(mips_get_arg_env(), F, "\tsw %1S, %d($fp)\n", node, get_entity_offset(ent)); -#endif - /* TODO lower spills and don't emit them... */ -} + /* mips_emit_nops(3); */ -static void mips_emit_Reload(mips_emit_env_t *env, const ir_node *node) -{ -#if 0 - FILE *F = env->out; - ir_entity *ent = be_get_frame_entity(node); + be_emit_cstring("\txor "); + mips_emit_source_register(node, 0); + be_emit_cstring(", "); + mips_emit_source_register(node, 0); + be_emit_cstring(", "); + mips_emit_source_register(node, 1); + be_emit_finish_line_gas(node); - lc_efprintf(mips_get_arg_env(), F, "\tlw %1D, %d($fp)\n", node, get_entity_offset(ent)); -#endif - /* TODO lower reloads instead of emitting them... */ + /* mips_emit_nops(3); */ } /************************************************************************/ /* Calls */ /************************************************************************/ -static void mips_emit_Call(mips_emit_env_t *env, const ir_node *node) +static void mips_emit_Call(const ir_node *node) { - be_emit_cstring(env->emit, "\tjal "); + ir_entity *callee; - // call to imediate value (label) - ir_entity *callee = be_Call_get_entity(node); + be_emit_cstring("\tjal "); + + /* call of immediate value (label) */ + callee = be_Call_get_entity(node); if(callee != NULL) { - be_emit_ident(env->emit, get_entity_ident(callee)); + be_emit_ident(get_entity_ld_ident(callee)); } else { - mips_emit_source_register(env, node, be_pos_Call_ptr); + mips_emit_source_register(node, be_pos_Call_ptr); } - be_emit_finish_line_gas(env->emit, node); + be_emit_finish_line_gas(node); } /************************************************************************ @@ -387,23 +426,32 @@ const char* mips_get_block_label(const ir_node* block) return buf; } -static -void mips_emit_block_label(mips_emit_env_t *env, const ir_node *block) +/** + * Emits a block label from the given block. + */ +static void mips_emit_block_label(const ir_node *block) { - be_emit_irprintf(env->emit, "BLOCK_%ld", get_irn_node_nr(block)); + if (has_Block_label(block)) { + be_emit_string(be_gas_block_label_prefix()); + be_emit_irprintf("%lu", get_Block_label(block)); + } else { + be_emit_cstring(BLOCK_PREFIX); + be_emit_irprintf("%ld", get_irn_node_nr(block)); + + } } -static void mips_emit_Jump(mips_emit_env_t *env, const ir_node *node) +static void mips_emit_Jump(const ir_node *node) { const ir_node *block = get_irn_link(node); assert(is_Block(block)); - be_emit_cstring(env->emit, "\tb "); - mips_emit_block_label(env, block); - be_emit_finish_line_gas(env->emit, node); + be_emit_cstring("\tb "); + mips_emit_block_label(block); + be_emit_finish_line_gas(node); } -ir_node *mips_get_jump_block(const ir_node* node, int projn) +ir_node *mips_get_jump_block(const ir_node* node, long projn) { const ir_edge_t *oute; for(oute = get_irn_out_edge_first(node); oute != NULL; @@ -420,32 +468,43 @@ ir_node *mips_get_jump_block(const ir_node* node, int projn) return NULL; } -void mips_emit_jump_target_proj(mips_emit_env_t *env, const ir_node *node, int projn) +void mips_emit_jump_target_proj(const ir_node *node, long projn) { ir_node *jumpblock = mips_get_jump_block(node, projn); assert(jumpblock != NULL); - mips_emit_block_label(env, jumpblock); + mips_emit_block_label(jumpblock); } -void mips_emit_jump_target(mips_emit_env_t *env, const ir_node *node) +void mips_emit_jump_target(const ir_node *node) { ir_node *jumpblock = get_irn_link(node); assert(jumpblock != NULL); - mips_emit_block_label(env, jumpblock); + mips_emit_block_label(jumpblock); +} + +void mips_emit_jump_or_fallthrough(const ir_node *node, long pn) +{ + ir_node *jumpblock = mips_get_jump_block(node, pn); + assert(jumpblock != NULL); + + /* TODO: use fallthrough when possible */ + be_emit_cstring("b "); + mips_emit_block_label(jumpblock); } /************************************************************************ - * ____ _ _ _ _ * - * / ___|_ _(_) |_ ___| |__ | |_ _ _ __ ___ _ __ * - * \___ \ \ /\ / / | __/ __| '_ \ _ | | | | | '_ ` _ \| '_ \ * - * ___) \ V V /| | || (__| | | | |_| | |_| | | | | | | |_) | * - * |____/ \_/\_/ |_|\__\___|_| |_|\___/ \__,_|_| |_| |_| .__/ * - * |_| * + * ____ _ _ _ _ * + * / ___|_ _(_) |_ ___| |__ | |_ _ _ __ ___ _ __ * + * \___ \ \ /\ / / | __/ __| '_ \ _ | | | | | '_ ` _ \| '_ \ * + * ___) \ V V /| | || (__| | | | |_| | |_| | | | | | | |_) | * + * |____/ \_/\_/ |_|\__\___|_| |_|\___/ \__,_|_| |_| |_| .__/ * + * |_| * * * ************************************************************************/ +#if 0 /* jump table entry (target and corresponding number) */ typedef struct _branch_t { ir_node *target; @@ -465,7 +524,8 @@ typedef struct _jmp_tbl_t { /** * Compare two variables of type branch_t. Used to sort all switch cases */ -static int mips_cmp_branch_t(const void *a, const void *b) { +static int mips_cmp_branch_t(const void *a, const void *b) +{ branch_t *b1 = (branch_t *)a; branch_t *b2 = (branch_t *)b; @@ -487,12 +547,13 @@ const char* mips_get_jumptbl_label(const ir_node* switchjmp) * Emits code for a SwitchJmp (creates a jump table if * possible otherwise a cmp-jmp cascade). Stolen from ia32 */ -void emit_mips_jump_table(mips_emit_env_t *env, const ir_node *irn) { - int lastval, i, i2, pn; - jmp_tbl_t tbl; - ir_node *proj; - const ir_edge_t *edge; - mips_attr_t *attr = get_mips_attr(irn); +void emit_mips_jump_table(const ir_node *irn) +{ + int lastval, i, i2, pn; + jmp_tbl_t tbl; + ir_node *proj; + const ir_edge_t *edge; + const mips_attr_t *attr = get_mips_attr_const(irn); /* fill the table structure */ tbl.label = xmalloc(SNPRINTF_BUF_LEN); @@ -524,25 +585,25 @@ void emit_mips_jump_table(mips_emit_env_t *env, const ir_node *irn) { /* sort the branches by their number */ qsort(tbl.branches, tbl.num_branches, sizeof(tbl.branches[0]), mips_cmp_branch_t); - be_emit_string(env->emit, mips_get_jumptbl_label(irn)); - be_emit_cstring(env->emit, ":\n"); - be_emit_write_line(env->emit); + be_emit_string(mips_get_jumptbl_label(irn)); + be_emit_cstring(":\n"); + be_emit_write_line(); lastval = tbl.min_value; for(i = 0; i < tbl.num_branches; ++i) { const branch_t *branch = &tbl.branches[i]; int value = branch->value; for(i2 = lastval + 1; i2 < value; ++i2) { - be_emit_cstring(env->emit, "\t.word "); - be_emit_ident(env->emit, attr->symconst_id); - be_emit_char(env->emit, '\n'); - be_emit_write_line(env->emit); + be_emit_cstring("\t.word "); + be_emit_ident(get_entity_ld_ident(attr->symconst)); + be_emit_char('\n'); + be_emit_write_line(); } - be_emit_cstring(env->emit, "\t.word "); - mips_emit_block_label(env, branch->target); - be_emit_char(env->emit, '\n'); - be_emit_write_line(env->emit); + be_emit_cstring("\t.word "); + mips_emit_block_label(branch->target); + be_emit_char('\n'); + be_emit_write_line(); lastval = branch->value; } @@ -553,22 +614,22 @@ void emit_mips_jump_table(mips_emit_env_t *env, const ir_node *irn) { free(tbl.branches); } -static -void dump_jump_tables(ir_node* node, void *data) +static void dump_jump_tables(ir_node* node, void *data) { - mips_emit_env_t *env = data; + (void) data; // emit jump tables if(is_mips_SwitchJump(node)) { - be_emit_cstring(env->emit, ".data\n"); - be_emit_write_line(env->emit); + be_emit_cstring(".data\n"); + be_emit_write_line(); - emit_mips_jump_table(env, node); + emit_mips_jump_table(node); - be_emit_cstring(env->emit, ".text\n"); - be_emit_write_line(env->emit); + be_emit_cstring(".text\n"); + be_emit_write_line(); } } +#endif /*********************************************************************************** * _ __ _ @@ -580,13 +641,27 @@ void dump_jump_tables(ir_node* node, void *data) * ***********************************************************************************/ -static void mips_emit_nothing(ir_mode *mode, mips_emit_env_t *env) +static void mips_emit_nothing(const ir_node *node) +{ + (void) node; +} + +static void mips_emit_this_shouldnt_happen(const ir_node *node) { + panic("Found non-lowered node %+F while emitting", node); } -static void mips_emit_this_shouldnt_happen(ir_mode *mode, mips_emit_env_t *env) +/** + * The type of a emitter function. + */ +typedef void (*emit_func) (const ir_node *); + +/** + * Set a node emitter. Make it a bit more type safe. + */ +static void register_emitter(ir_op *op, emit_func func) { - assert(0); + op->ops.generic = (op_func) func; } /** @@ -601,41 +676,40 @@ void mips_register_emitters(void) mips_register_spec_emitters(); /* benode emitter */ - op_be_IncSP->ops.generic = (op_func) mips_emit_IncSP; - op_be_SetSP->ops.generic = (op_func) mips_emit_this_shouldnt_happen; - op_be_AddSP->ops.generic = (op_func) mips_emit_this_shouldnt_happen; - op_be_Call->ops.generic = (op_func) mips_emit_Call; - op_be_Keep->ops.generic = (op_func) mips_emit_nothing; - op_be_Copy->ops.generic = (op_func) mips_emit_Copy; - op_be_Return->ops.generic = (op_func) mips_emit_Return; - op_be_RegParams->ops.generic = (op_func) mips_emit_nothing; - op_be_Spill->ops.generic = (op_func) mips_emit_Spill; - op_be_Reload->ops.generic = (op_func) mips_emit_Reload; - op_be_Perm->ops.generic = (op_func) mips_emit_Perm; - - op_Start->ops.generic = (op_func) mips_emit_nothing; - op_Proj->ops.generic = (op_func) mips_emit_nothing; - op_SymConst->ops.generic = (op_func) mips_emit_nothing; - op_Jmp->ops.generic = (op_func) mips_emit_Jump; - op_Cmp->ops.generic = (op_func) mips_emit_this_shouldnt_happen; - op_Cond->ops.generic = (op_func) mips_emit_this_shouldnt_happen; -} - -typedef void (*emit_func) (mips_emit_env_t *, const ir_node *); + register_emitter(op_be_IncSP, mips_emit_IncSP); + register_emitter(op_be_AddSP, mips_emit_this_shouldnt_happen); + register_emitter(op_be_Call, mips_emit_Call); + register_emitter(op_be_Copy, mips_emit_Copy); + register_emitter(op_be_Keep, mips_emit_nothing); + register_emitter(op_be_Barrier, mips_emit_nothing); + register_emitter(op_be_Return, mips_emit_Return); + register_emitter(op_be_RegParams, mips_emit_nothing); + register_emitter(op_be_Spill, mips_emit_this_shouldnt_happen); + register_emitter(op_be_Reload, mips_emit_this_shouldnt_happen); + register_emitter(op_be_Perm, mips_emit_Perm); + + register_emitter(op_Start, mips_emit_nothing); + register_emitter(op_Proj, mips_emit_nothing); + register_emitter(op_SymConst, mips_emit_this_shouldnt_happen); + register_emitter(op_Const, mips_emit_this_shouldnt_happen); + register_emitter(op_Jmp, mips_emit_Jump); + register_emitter(op_Cmp, mips_emit_this_shouldnt_happen); + register_emitter(op_Cond, mips_emit_this_shouldnt_happen); + register_emitter(op_Phi, mips_emit_nothing); +} /** * Emits assembly for a single node */ -static void mips_emit_node(mips_emit_env_t *env, const ir_node *node) +static void mips_emit_node(const ir_node *node) { ir_op *op = get_irn_op(node); if (op->ops.generic) { emit_func emit = (emit_func) op->ops.generic; - (*emit) (env, node); + (*emit) (node); } else { - be_emit_cstring(env->emit, "\t/* TODO */"); - be_emit_finish_line_gas(env->emit, node); + panic("No emitter defined for node %+F", node); } } @@ -643,72 +717,71 @@ static void mips_emit_node(mips_emit_env_t *env, const ir_node *node) * Walks over the nodes in a block connected by scheduling edges * and emits code for each node. */ -void mips_gen_block(mips_emit_env_t *env, ir_node *block) +void mips_gen_block(const ir_node *block) { ir_node *node; if (! is_Block(block)) return; - mips_emit_block_label(env, block); - be_emit_cstring(env->emit, ":\n"); - be_emit_write_line(env->emit); + mips_emit_block_label(block); + be_emit_cstring(":\n"); + be_emit_write_line(); sched_foreach(block, node) { - mips_emit_node(env, node); + mips_emit_node(node); } - be_emit_char(env->emit, '\n'); - be_emit_write_line(env->emit); + be_emit_char('\n'); + be_emit_write_line(); } /** * Emits code for function start. */ -void mips_emit_func_prolog(mips_emit_env_t *env, ir_graph *irg) +void mips_emit_func_prolog(ir_graph *irg) { - ident *irg_ident = get_entity_ident(get_irg_entity(irg)); - be_emit_env_t *eenv = env->emit; + ident *irg_ident = get_entity_ld_ident(get_irg_entity(irg)); // dump jump tables - irg_walk_graph(irg, NULL, dump_jump_tables, env); + //irg_walk_graph(irg, NULL, dump_jump_tables, env); - be_emit_write_line(eenv); - be_gas_emit_switch_section(eenv, GAS_SECTION_TEXT); + be_emit_write_line(); + be_gas_emit_switch_section(GAS_SECTION_TEXT); - be_emit_cstring(eenv, "\t.balign\t4\n"); + be_emit_cstring("\t.balign\t4\n"); - be_emit_cstring(eenv, "\t.global\t") - be_emit_ident(eenv, irg_ident); - be_emit_char(eenv, '\n'); + be_emit_cstring("\t.global\t"); + be_emit_ident(irg_ident); + be_emit_char('\n'); - be_emit_cstring(eenv, "\t.set\tnomips16\n"); + be_emit_cstring("\t.set\tnomips16\n"); - be_emit_cstring(eenv, "\t.ent\t"); - be_emit_ident(eenv, irg_ident); - be_emit_char(eenv, '\n'); + be_emit_cstring("\t.ent\t"); + be_emit_ident(irg_ident); + be_emit_char('\n'); - be_emit_ident(eenv, irg_ident); - be_emit_cstring(eenv, ":\n"); + be_emit_ident(irg_ident); + be_emit_cstring(":\n"); - be_emit_cstring(eenv, "\t.frame\t$fp, 24, $ra\n"); - be_emit_cstring(eenv, "\t.mask\t0xc0000000, -4\n"); - be_emit_cstring(eenv, "\t.fmask\t0x00000000, 0\n"); + be_emit_cstring("\t.frame\t$fp, 24, $ra\n"); + be_emit_cstring("\t.mask\t0xc0000000, -4\n"); + be_emit_cstring("\t.fmask\t0x00000000, 0\n"); - be_emit_write_line(eenv); + be_emit_write_line(); } /** * Emits code for function end */ -void mips_emit_func_epilog(mips_emit_env_t *env, ir_graph *irg) +void mips_emit_func_epilog(ir_graph *irg) { ident *irg_ident = get_entity_ident(get_irg_entity(irg)); - be_emit_cstring(env->emit, "\t.end\t"); - be_emit_ident(env->emit, irg_ident); - be_emit_char(env->emit, '\n'); - be_emit_write_line(env->emit); + be_emit_cstring("\t.end\t"); + be_emit_ident(irg_ident); + be_emit_char('\n'); + be_emit_write_line(); } /** @@ -718,6 +791,7 @@ void mips_gen_labels(ir_node *block, void *env) { ir_node *pred; int n = get_Block_n_cfgpreds(block); + (void) env; for (n--; n >= 0; n--) { pred = get_Block_cfgpred(block, n); @@ -728,30 +802,28 @@ void mips_gen_labels(ir_node *block, void *env) /** * Main driver */ -void mips_gen_routine(mips_code_gen_t *cg, ir_graph *irg) +void mips_gen_routine(mips_code_gen_t *mips_cg, ir_graph *irg) { - mips_emit_env_t env; int i, n; - env.isa = (mips_isa_t*) cg->arch_env->isa; - env.emit = &env.isa->emit; - env.arch_env = cg->arch_env; - env.cg = cg; + cg = mips_cg; + isa = (const mips_isa_t*) cg->arch_env; + arch_env = cg->arch_env; mips_register_emitters(); - irg_block_walk_graph(irg, mips_gen_labels, NULL, &env); + irg_block_walk_graph(irg, mips_gen_labels, NULL, NULL); - mips_emit_func_prolog(&env, irg); + mips_emit_func_prolog(irg); dump_ir_block_graph_sched(irg, "-kaputtelist"); for (i = 0, n = mips_get_sched_n_blocks(cg); i < n; ++i) { ir_node *block = mips_get_sched_block(cg, i); - mips_gen_block(&env, block); + mips_gen_block(block); } - mips_emit_func_epilog(&env, irg); + mips_emit_func_epilog(irg); } void mips_init_emitter(void)