/*
- * 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;
+ 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;
}
/*************************************************************
* |_| |_|
*************************************************************/
-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
}
#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;
}
}
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);
}
/************************************************************************
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;
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;
/**
* 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) {
- 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);
/* 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;
}
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(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;
}
/**
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);
}
}
* 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();
}
/**
{
ir_node *pred;
int n = get_Block_n_cfgpreds(block);
+ (void) env;
for (n--; n >= 0; n--) {
pred = get_Block_cfgpred(block, n);
/**
* 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