X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fmips%2Fmips_emitter.c;h=13a5d708bb1f030cef9e498c85362751a644954b;hb=aebc3c0c980bcc0536ffdc4cb2a545961b5a8b81;hp=9f6e98c7e3fd6f00bbf71eabb76e963db4c26759;hpb=b2dba3350d751a784b350c19ddd839566e0eb3f0;p=libfirm diff --git a/ir/be/mips/mips_emitter.c b/ir/be/mips/mips_emitter.c index 9f6e98c7e..13a5d708b 100644 --- a/ir/be/mips/mips_emitter.c +++ b/ir/be/mips/mips_emitter.c @@ -17,8 +17,12 @@ * PURPOSE. */ -/* mips emitter */ -/* $Id$ */ +/** + * @file + * @brief implementation of mips assembly emitter + * @author Matthias Braun, Mehdi + * @version $Id$ + */ #ifdef HAVE_CONFIG_H #include "config.h" #endif @@ -26,7 +30,6 @@ #include #include "xmalloc.h" -#include "tv.h" #include "iredges.h" #include "debug.h" #include "irgwalk.h" @@ -35,11 +38,13 @@ #include "irargs_t.h" #include "irprog_t.h" #include "irouts.h" +#include "tv.h" #include "error.h" #include "../besched.h" #include "../benode_t.h" #include "../beutil.h" +#include "../begnuas.h" #include "mips_emitter.h" #include "gen_mips_emitter.h" @@ -47,10 +52,65 @@ #include "mips_new_nodes.h" #include "mips_map_regs.h" +DEBUG_ONLY(static firm_dbg_module_t *dbg = NULL;) + #define SNPRINTF_BUF_LEN 128 -static const arch_env_t *arch_env = NULL; +/** + * 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) +{ + ir_node *op; + const arch_register_t *reg = NULL; + + 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); + + reg = arch_get_irn_register(arch_env, op); + + 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; +} /************************************************************* * _ _ __ _ _ @@ -63,6 +123,21 @@ static const arch_env_t *arch_env = NULL; * |_| |_| *************************************************************/ +void mips_emit_source_register(mips_emit_env_t *env, 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)); +} + +void mips_emit_dest_register(mips_emit_env_t *env, 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)); +} + +#if 0 static const char *get_symconst_str(ir_node *node) { ident *id; @@ -144,207 +219,22 @@ static const char *node_const_to_str(ir_node *n) return buf; } +#endif -/** - * Returns node's offset as string. - */ -static const char *node_offset_to_str(ir_node *n) -{ - return ""; -} - -/* We always pass the ir_node which is a pointer. */ -static int mips_get_arg_type(const lc_arg_occ_t *occ) { - return lc_arg_type_ptr; -} - - -/** - * Returns the register at in position pos. - */ -static const arch_register_t *get_in_reg(ir_node *irn, int pos) -{ - ir_node *op; - const arch_register_t *reg = NULL; - - assert(get_irn_arity(irn) > pos && "Invalid IN position"); - - /* The out register of the operator at position pos is the - in register we need. */ - op = get_irn_n(irn, pos); - - reg = arch_get_irn_register(arch_env, op); - - assert(reg && "no in register found"); - return reg; -} - -/** - * Returns the register at out position pos. - */ -static const arch_register_t *get_out_reg(ir_node *irn, 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(irn) != mode_T) { - reg = arch_get_irn_register(arch_env, irn); - } - else if (is_mips_irn(irn)) { - reg = get_mips_out_reg(irn, pos); - } - else { - const ir_edge_t *edge; - - foreach_out_edge(irn, 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; -} - -/** - * Returns the number of the in register at position pos. - */ -int get_mips_reg_nr(ir_node *irn, int pos, int in_out) -{ - const arch_register_t *reg; - - if (in_out == 1) { - reg = get_in_reg(irn, pos); - } - else { - reg = get_out_reg(irn, pos); - } - - return arch_register_get_index(reg); -} - -/** - * Returns the name of the in register at position pos. - */ -const char *get_mips_reg_name(ir_node *irn, int pos, int in_out) -{ - const arch_register_t *reg; - - if (in_out == 1) { - reg = get_in_reg(irn, pos); - } - else { - reg = get_out_reg(irn, pos); - } - - return arch_register_get_name(reg); -} - -/** - * Get the register name for a node. - */ -static int mips_get_reg_name(lc_appendable_t *app, - const lc_arg_occ_t *occ, const lc_arg_value_t *arg) -{ - const char *buf; - int res; - ir_node *X = arg->v_ptr; - int nr = occ->width - 1; - - if (!X) - return lc_arg_append(app, occ, "(null)", 6); - - if (occ->conversion == 'S') { - buf = get_mips_reg_name(X, nr, 1); - } - else { /* 'D' */ - buf = get_mips_reg_name(X, nr, 0); - } - - res = lc_appendable_chadd(app, '$'); - res += lc_appendable_snadd(app, buf, strlen(buf)); - return res; -} - -/** - * Returns the tarval or offset of an mips node as a string. - */ -static int mips_const_to_str(lc_appendable_t *app, - const lc_arg_occ_t *occ, const lc_arg_value_t *arg) -{ - const char *buf; - ir_node *X = arg->v_ptr; - - if (!X) - return lc_arg_append(app, occ, "(null)", 6); - - if (occ->conversion == 'C') { - buf = node_const_to_str(X); - } - else { /* 'O' */ - buf = node_offset_to_str(X); - } - - return lc_arg_append(app, occ, buf, strlen(buf)); -} - -/** - * Determines the SSE suffix depending on the mode. - */ -static int mips_get_mode_suffix(lc_appendable_t *app, - const lc_arg_occ_t *occ, const lc_arg_value_t *arg) -{ - ir_node *X = arg->v_ptr; - - if (!X) - return lc_arg_append(app, occ, "(null)", 6); - - if (get_mode_size_bits(get_irn_mode(X)) == 32) - return lc_appendable_chadd(app, 's'); - else - return lc_appendable_chadd(app, 'd'); -} - -/** - * Return the mips printf arg environment. - * We use the firm environment with some additional handlers. - */ -const lc_arg_env_t *mips_get_arg_env(void) +void mips_emit_immediate(mips_emit_env_t *env, const ir_node *node) { - static lc_arg_env_t *env = NULL; - - static const lc_arg_handler_t mips_reg_handler = { mips_get_arg_type, mips_get_reg_name }; - static const lc_arg_handler_t mips_const_handler = { mips_get_arg_type, mips_const_to_str }; - static const lc_arg_handler_t mips_mode_handler = { mips_get_arg_type, mips_get_mode_suffix }; - - if(env == NULL) { - /* extend the firm printer */ - env = firm_get_arg_env(); - //lc_arg_new_env(); - - lc_arg_register(env, "mips:sreg", 'S', &mips_reg_handler); - lc_arg_register(env, "mips:dreg", 'D', &mips_reg_handler); - lc_arg_register(env, "mips:cnst", 'C', &mips_const_handler); - lc_arg_register(env, "mips:offs", 'O', &mips_const_handler); - lc_arg_register(env, "mips:mode", 'M', &mips_mode_handler); - } + const mips_attr_t *attr = get_mips_attr(node); - return env; + be_emit_char(env->emit, '$'); + tarval *tv = attr->tv; + be_emit_tarval(env->emit, tv); } /* * 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); @@ -355,13 +245,14 @@ static char *get_unique_label(char *buf, size_t buflen, const char *prefix) /* ABI Handling */ /************************************************************************/ -static void mips_emit_IncSP(const ir_node *node, mips_emit_env_t *env) +static +void mips_emit_IncSP(mips_emit_env_t *env, const ir_node *node) { - FILE *F = env->out; int offset = be_get_IncSP_offset(node); if(offset == 0) { - fprintf(F, "\t\t\t\t # omitted IncSP with 0\n"); + be_emit_cstring(env->emit, "\t/* omitted IncSP with 0 */"); + be_emit_finish_line_gas(env->emit, node); return; } @@ -370,85 +261,113 @@ static void mips_emit_IncSP(const ir_node *node, mips_emit_env_t *env) } if(offset > 0) { - fprintf(F, "\tsubu $sp, $sp, %d\n", offset); + be_emit_irprintf(env->emit, "\tsubu $sp, $sp, %d", offset); } else { - fprintf(F, "\taddu $sp, $sp, %d\n", -offset); + be_emit_irprintf(env->emit, "\taddu $sp, $sp, %d", -offset); } + be_emit_finish_line_gas(env->emit, node); } -static void mips_emit_Copy(const ir_node *node, mips_emit_env_t *env) +static void mips_emit_Copy(mips_emit_env_t *env, const ir_node *node) { - FILE *F = env->out; - - lc_efprintf(mips_get_arg_env(), F, "\tmove %1D, %1S\t\t\t# copy\n", 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); } -static void mips_emit_Return(const ir_node* node, mips_emit_env_t *env) +static void mips_emit_Return(mips_emit_env_t *env, const ir_node* node) { - FILE *F = env->out; - fprintf(F, "\tj $ra\t\t\t\t# return\n"); + be_emit_cstring(env->emit, "\tj $ra"); + be_emit_finish_line_gas(env->emit, node); } -static void mips_emit_nops(FILE* F, int n) +static __attribute__((unused)) +void mips_emit_nops(mips_emit_env_t *env, int n) { int i; for(i = 0; i < n; ++i) { - fprintf(F, "\tnop\n"); + be_emit_cstring(env->emit, "\tnop\n"); + be_emit_write_line(env->emit); } } static void mips_emit_Perm(const ir_node *node, mips_emit_env_t *env) { - FILE *F = env->out; - assert(get_irn_arity(node) == 2); - lc_efprintf(mips_get_arg_env(), F, "\txor %1S, %1S, %2S\t\t\t# perm\n", node, node, node); - mips_emit_nops(F, 3); - lc_efprintf(mips_get_arg_env(), F, "\txor %2S, %2S, %1S\n", node, node, node); - mips_emit_nops(F, 3); - lc_efprintf(mips_get_arg_env(), F, "\txor %1S, %1S, %2S\n", node, node, node); - mips_emit_nops(F, 3); + 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(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); */ } -static void mips_emit_Spill(const ir_node* node, mips_emit_env_t *env) + +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); 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... */ } -static void mips_emit_Reload(const ir_node* node, mips_emit_env_t *env) +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); 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... */ } /************************************************************************/ /* Calls */ /************************************************************************/ -static void mips_emit_Call(ir_node *node, mips_emit_env_t *env) +static void mips_emit_Call(mips_emit_env_t *env, const ir_node *node) { - FILE *F = env->out; - const arch_register_t *callee_reg; + be_emit_cstring(env->emit, "\tjal "); // call to imediate value (label) ir_entity *callee = be_Call_get_entity(node); if(callee != NULL) { - fprintf(F, "\tjal %s\n", get_entity_name(callee)); - return; + be_emit_ident(env->emit, get_entity_ident(callee)); + } else { + mips_emit_source_register(env, node, be_pos_Call_ptr); } - - // call to function pointer - callee_reg = get_in_reg(node, be_pos_Call_ptr); - assert(callee_reg != NULL); - - fprintf(F, "\tjal %s\n", arch_register_get_name(callee_reg)); + be_emit_finish_line_gas(env->emit, node); } /************************************************************************ @@ -468,14 +387,20 @@ const char* mips_get_block_label(const ir_node* block) return buf; } -static void mips_emit_Jump(ir_node *node, mips_emit_env_t *env) +static +void mips_emit_block_label(mips_emit_env_t *env, const ir_node *block) { - FILE *F = env->out; - const ir_node *block = get_irn_link(node); + be_emit_irprintf(env->emit, "BLOCK_%ld", get_irn_node_nr(block)); +} +static void mips_emit_Jump(mips_emit_env_t *env, const ir_node *node) +{ + const ir_node *block = get_irn_link(node); assert(is_Block(block)); - fprintf(F, "\tb %s\n", mips_get_block_label(block)); + be_emit_cstring(env->emit, "\tb "); + mips_emit_block_label(env, block); + be_emit_finish_line_gas(env->emit, node); } ir_node *mips_get_jump_block(const ir_node* node, int projn) @@ -495,6 +420,22 @@ 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) +{ + ir_node *jumpblock = mips_get_jump_block(node, projn); + assert(jumpblock != NULL); + + mips_emit_block_label(env, jumpblock); +} + +void mips_emit_jump_target(mips_emit_env_t *env, const ir_node *node) +{ + ir_node *jumpblock = get_irn_link(node); + assert(jumpblock != NULL); + + mips_emit_block_label(env, jumpblock); +} + /************************************************************************ * ____ _ _ _ _ * * / ___|_ _(_) |_ ___| |__ | |_ _ _ __ ___ _ __ * @@ -546,7 +487,7 @@ 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(const ir_node *irn, FILE* F) { +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; @@ -583,17 +524,26 @@ void emit_mips_jump_table(const ir_node *irn, FILE* F) { /* sort the branches by their number */ qsort(tbl.branches, tbl.num_branches, sizeof(tbl.branches[0]), mips_cmp_branch_t); - fprintf(F, "%s:\n", mips_get_jumptbl_label(irn)); + be_emit_string(env->emit, mips_get_jumptbl_label(irn)); + be_emit_cstring(env->emit, ":\n"); + be_emit_write_line(env->emit); 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) { - fprintf(F, "\t.word %s\n", get_id_str(attr->symconst_id)); + 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); } - fprintf(F, "\t.word %s\n", mips_get_block_label(branch->target)); + 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); + lastval = branch->value; } @@ -603,15 +553,20 @@ void emit_mips_jump_table(const ir_node *irn, FILE* F) { free(tbl.branches); } -static void dump_jump_tables(ir_node* node, void *env) +static +void dump_jump_tables(ir_node* node, void *data) { - FILE* F = (FILE*) env; + mips_emit_env_t *env = data; // emit jump tables if(is_mips_SwitchJump(node)) { - fprintf(F, ".data\n"); - emit_mips_jump_table(node, F); - fprintf(F, ".text\n"); + be_emit_cstring(env->emit, ".data\n"); + be_emit_write_line(env->emit); + + emit_mips_jump_table(env, node); + + be_emit_cstring(env->emit, ".text\n"); + be_emit_write_line(env->emit); } } @@ -666,30 +621,21 @@ void mips_register_emitters(void) op_Cond->ops.generic = (op_func) mips_emit_this_shouldnt_happen; } -typedef void (*emit_func) (const ir_node *, mips_emit_env_t *); +typedef void (*emit_func) (mips_emit_env_t *, const ir_node *); /** * Emits assembly for a single node */ -static void mips_emit_node(ir_node *irn, mips_emit_env_t* env) +static void mips_emit_node(mips_emit_env_t *env, const ir_node *node) { - mips_emit_env_t *emit_env = env; - FILE *F = emit_env->out; - ir_op *op = get_irn_op(irn); - DEBUG_ONLY(firm_dbg_module_t *mod = emit_env->mod;) - - DBG((mod, LEVEL_1, "emitting code for %+F\n", irn)); + ir_op *op = get_irn_op(node); if (op->ops.generic) { emit_func emit = (emit_func) op->ops.generic; - (*emit) (irn, env); - -#if 0 - if(emit != (emit_func) mips_emit_nothing) - mips_emit_nops(F, 5); -#endif + (*emit) (env, node); } else { - ir_fprintf(F, "\t\t\t\t\t# %+F\n", irn); + be_emit_cstring(env->emit, "\t/* TODO */"); + be_emit_finish_line_gas(env->emit, node); } } @@ -697,54 +643,76 @@ static void mips_emit_node(ir_node *irn, mips_emit_env_t* env) * Walks over the nodes in a block connected by scheduling edges * and emits code for each node. */ -void mips_gen_block(ir_node *block, void *env) +void mips_gen_block(mips_emit_env_t *env, ir_node *block) { - FILE *F = ((mips_emit_env_t *)env)->out; - ir_node *irn; + ir_node *node; if (! is_Block(block)) return; - fprintf(F, "%s:\n", mips_get_block_label(block)); - sched_foreach(block, irn) { - mips_emit_node(irn, env); + mips_emit_block_label(env, block); + be_emit_cstring(env->emit, ":\n"); + be_emit_write_line(env->emit); + + sched_foreach(block, node) { + mips_emit_node(env, node); } - fprintf(F, "\n"); + + be_emit_char(env->emit, '\n'); + be_emit_write_line(env->emit); } /** * Emits code for function start. */ -void mips_emit_start(FILE *F, ir_graph *irg) +void mips_emit_func_prolog(mips_emit_env_t *env, ir_graph *irg) { - const char *irg_name = get_entity_name(get_irg_entity(irg)); + ident *irg_ident = get_entity_ident(get_irg_entity(irg)); + be_emit_env_t *eenv = env->emit; // dump jump tables - irg_walk_graph(irg, NULL, dump_jump_tables, F); + 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_cstring(eenv, "\t.balign\t4\n"); + + be_emit_cstring(eenv, "\t.global\t") + be_emit_ident(eenv, irg_ident); + be_emit_char(eenv, '\n'); - fprintf(F, "\n\n"); - fprintf(F, "\t.balign\t4\n"); - fprintf(F, "\t.global\t%s\n", irg_name); - fprintf(F, "\t.set\tnomips16\n"); - fprintf(F, "\t.ent\t%s\n", irg_name); - fprintf(F, "%s:\n", irg_name); - fprintf(F, "\t.frame\t$fp, 24, $ra\n"); - fprintf(F, "\t.mask\t0xc0000000, -4\n"); - fprintf(F, "\t.fmask\t0x00000000, 0\n"); + be_emit_cstring(eenv, "\t.set\tnomips16\n"); + + be_emit_cstring(eenv, "\t.ent\t"); + be_emit_ident(eenv, irg_ident); + be_emit_char(eenv, '\n'); + + be_emit_ident(eenv, irg_ident); + be_emit_cstring(eenv, ":\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_write_line(eenv); } /** * Emits code for function end */ -void mips_emit_end(FILE *F, ir_graph *irg) +void mips_emit_func_epilog(mips_emit_env_t *env, ir_graph *irg) { - const char *irg_name = get_entity_name(get_irg_entity(irg)); - fprintf(F, "\t.end\t%s\n", irg_name); + 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); } /** * Sets labels for control flow nodes (jump target) - * TODO: Jump optimization */ void mips_gen_labels(ir_node *block, void *env) { @@ -760,29 +728,33 @@ void mips_gen_labels(ir_node *block, void *env) /** * Main driver */ -void mips_gen_routine(FILE *F, ir_graph *irg, const mips_code_gen_t *cg) +void mips_gen_routine(mips_code_gen_t *cg, ir_graph *irg) { - mips_emit_env_t emit_env; + mips_emit_env_t env; int i, n; - emit_env.out = F; - emit_env.arch_env = cg->arch_env; - emit_env.cg = cg; - FIRM_DBG_REGISTER(emit_env.mod, "firm.be.mips.emit"); + env.isa = (mips_isa_t*) cg->arch_env->isa; + env.emit = &env.isa->emit; + env.arch_env = cg->arch_env; + env.cg = cg; - /* set the global arch_env (needed by print hooks) */ - arch_env = cg->arch_env; + mips_register_emitters(); - irg_block_walk_graph(irg, mips_gen_labels, NULL, &emit_env); - mips_emit_start(F, irg); -// irg_walk_blkwise_graph(irg, NULL, mips_gen_block, &emit_env); + irg_block_walk_graph(irg, mips_gen_labels, NULL, &env); + + mips_emit_func_prolog(&env, 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(block, &emit_env); + mips_gen_block(&env, block); } - mips_emit_end(F, irg); + mips_emit_func_epilog(&env, irg); +} + +void mips_init_emitter(void) +{ + FIRM_DBG_REGISTER(dbg, "firm.be.mips.emitter"); }