X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fmips%2Fmips_emitter.c;h=a10de95c938ad17edd3dc66eab262d2064e19fa0;hb=f37b4dbb329604edd67ff5877161cb5322e93020;hp=6a1ea258907955131b89b961bda5fe168ebf64d7;hpb=9e56dbf066d3698df877e2a9f78caeca29ea5a03;p=libfirm diff --git a/ir/be/mips/mips_emitter.c b/ir/be/mips/mips_emitter.c index 6a1ea2589..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,13 +54,18 @@ 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; @@ -80,8 +85,7 @@ static const arch_register_t *get_in_reg(const arch_env_t *arch_env, /** * 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) +static const arch_register_t *get_out_reg(const ir_node *node, int pos) { ir_node *proj; const arch_register_t *reg = NULL; @@ -126,23 +130,21 @@ static const arch_register_t *get_out_reg(const arch_env_t *arch_env, /** * Emit the name of the source register at given input position. */ -void mips_emit_source_register(mips_emit_env_t *env, const ir_node *node, - int pos) +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_char(env->emit, '$'); - 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)); } /** * Emit the name of the destination register at given output position. */ -void mips_emit_dest_register(mips_emit_env_t *env, const ir_node *node, - int pos) +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_char(env->emit, '$'); - 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 @@ -229,40 +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_load_store_attr_t *attr = get_mips_load_store_attr_const(node); + + 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_attr_t *attr = get_mips_attr_const(node); + const mips_immediate_attr_t *attr = get_mips_immediate_attr_const(node); - if(attr->tv != NULL) { - be_emit_tarval(env->emit, attr->tv); + 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 { - be_emit_cstring(env->emit, "/* TODO */ 0"); + 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; } @@ -271,92 +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(mips_emit_env_t *env, const ir_node *node) +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); + 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); - /* mips_emit_nops(env, 3); */ + /* mips_emit_nops(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); + 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); - /* mips_emit_nops(env, 3); */ + /* mips_emit_nops(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); + 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); - /* mips_emit_nops(env, 3); */ + /* 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) { ir_entity *callee; - be_emit_cstring(env->emit, "\tjal "); + 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_ld_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); } /************************************************************************ @@ -379,20 +429,26 @@ const char* mips_get_block_label(const ir_node* block) /** * Emits a block label from the given block. */ -static -void mips_emit_block_label(mips_emit_env_t *env, const ir_node *block) +static void mips_emit_block_label(const ir_node *block) { - be_emit_irprintf(env->emit, "BLOCK_%d", 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, long projn) @@ -412,32 +468,30 @@ ir_node *mips_get_jump_block(const ir_node* node, long projn) return NULL; } -void mips_emit_jump_target_proj(mips_emit_env_t *env, const ir_node *node, - long 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(mips_emit_env_t *env, const ir_node *node, - long pn) +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(env->emit, "b "); - mips_emit_block_label(env, jumpblock); + be_emit_cstring("b "); + mips_emit_block_label(jumpblock); } /************************************************************************ @@ -450,6 +504,7 @@ void mips_emit_jump_or_fallthrough(mips_emit_env_t *env, const ir_node *node, * * ************************************************************************/ +#if 0 /* jump table entry (target and corresponding number) */ typedef struct _branch_t { ir_node *target; @@ -469,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; @@ -491,7 +547,8 @@ 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) { +void emit_mips_jump_table(const ir_node *irn) +{ int lastval, i, i2, pn; jmp_tbl_t tbl; ir_node *proj; @@ -528,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, get_entity_ld_ident(attr->symconst)); - 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; } @@ -557,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 /*********************************************************************************** * _ __ _ @@ -584,34 +641,34 @@ void dump_jump_tables(ir_node* node, void *data) * ***********************************************************************************/ -static void mips_emit_nothing(mips_emit_env_t *env, const ir_node *node) +static void mips_emit_nothing(const ir_node *node) { - (void) env; (void) node; } -static void mips_emit_this_shouldnt_happen(mips_emit_env_t *env, const ir_node *node) +static void mips_emit_this_shouldnt_happen(const ir_node *node) { - (void) env; panic("Found non-lowered node %+F while emitting", node); } /** * The type of a emitter function. */ -typedef void (*emit_func) (mips_emit_env_t *, const ir_node *); +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) { +static void register_emitter(ir_op *op, emit_func func) +{ op->ops.generic = (op_func) func; } /** * Register emitter functions for mips backend */ -void mips_register_emitters(void) { +void mips_register_emitters(void) +{ /* first clear the generic function pointer for all ops */ clear_irp_opcodes_generic_func(); @@ -620,7 +677,6 @@ void mips_register_emitters(void) { /* benode emitter */ register_emitter(op_be_IncSP, mips_emit_IncSP); - register_emitter(op_be_SetSP, mips_emit_this_shouldnt_happen); 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); @@ -645,13 +701,13 @@ void mips_register_emitters(void) { /** * 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 { panic("No emitter defined for node %+F", node); } @@ -661,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_ld_ident(get_irg_entity(irg)); - be_emit_env_t *eenv = env->emit; // 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(); } /** @@ -747,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)