/*
- * 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.
*
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;
/**
* 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;
/**
* 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
}
#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;
}
}
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);
}
/************************************************************************
/**
* 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)
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);
}
/************************************************************************
* *
************************************************************************/
+#if 0
/* jump table entry (target and corresponding number) */
typedef struct _branch_t {
ir_node *target;
/**
* 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;
* 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;
/* 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;
}
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
/***********************************************************************************
* _ __ _
*
***********************************************************************************/
-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();
/* 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);
/**
* 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);
}
* 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();
}
/**
/**
* 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)
projects / libfirm / blobdiff