X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fmips%2Fmips_emitter.c;h=de1d27a722e21ee4c8ef50b5e2ffd290bfd56f9a;hb=026ec52ac914eee06e7afb961fb754735fb4ad9f;hp=27822722f8e45448cb7c6f19798b3af61a0dfb47;hpb=a3aac700b76408de6e0212ad5725306385fc96ac;p=libfirm

diff --git a/ir/be/mips/mips_emitter.c b/ir/be/mips/mips_emitter.c
index 27822722f..de1d27a72 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.
  *
@@ -23,9 +23,7 @@
  * @author  Matthias Braun, Mehdi
  * @version $Id$
  */
-#ifdef HAVE_CONFIG_H
 #include "config.h"
-#endif
 
 #include <limits.h>
 
@@ -61,8 +59,7 @@ DEBUG_ONLY(static firm_dbg_module_t *dbg = 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)
+static const arch_register_t *get_in_reg(const ir_node *node, int pos)
 {
 	ir_node                *op;
 	const arch_register_t  *reg = NULL;
@@ -73,7 +70,7 @@ static const arch_register_t *get_in_reg(const arch_env_t *arch_env,
 	   in register we need. */
 	op = get_irn_n(node, pos);
 
-	reg = arch_get_irn_register(arch_env, op);
+	reg = arch_get_irn_register(op);
 
 	assert(reg && "no in register found");
 	return reg;
@@ -82,8 +79,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;
@@ -94,7 +90,7 @@ static const arch_register_t *get_out_reg(const arch_env_t *arch_env,
 	/*           Proj with the corresponding projnum for the register */
 
 	if (get_irn_mode(node) != mode_T) {
-		reg = arch_get_irn_register(arch_env, node);
+		reg = arch_get_irn_register(node);
 	} else if (is_mips_irn(node)) {
 		reg = get_mips_out_reg(node, pos);
 	} else {
@@ -104,7 +100,7 @@ static const arch_register_t *get_out_reg(const arch_env_t *arch_env,
 			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);
+				reg = arch_get_irn_register(proj);
 				break;
 			}
 		}
@@ -128,23 +124,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
@@ -160,7 +154,7 @@ static const char *get_symconst_str(ir_node *node)
 		id = get_entity_ident(get_SymConst_entity(node));
 		return get_id_str(id);
 	default:
-		assert(0);
+		panic("Unsupported SymConst kind");
 	}
 
 	return NULL;
@@ -231,47 +225,45 @@ static const char *node_const_to_str(ir_node *n)
 }
 #endif
 
-void mips_emit_load_store_address(mips_emit_env_t *env, const ir_node *node,
-                                  int pos)
+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(env->emit, "%d(", attr->offset);
-	mips_emit_source_register(env, node, pos);
-	be_emit_char(env->emit, ')');
+	be_emit_irprintf("%d(", attr->offset);
+	mips_emit_source_register(node, pos);
+	be_emit_char(')');
 }
 
-void mips_emit_immediate_suffix(mips_emit_env_t *env, const ir_node *node,
-                                int pos)
+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(env->emit, 'i');
+		be_emit_char('i');
 }
 
-void mips_emit_immediate(mips_emit_env_t *env, const ir_node *node)
+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(env->emit, "%d", attr->val);
+		be_emit_irprintf("%d", attr->val);
 		break;
 	case MIPS_IMM_SYMCONST_LO:
-		be_emit_cstring(env->emit, "%lo($");
-		be_emit_ident(env->emit, get_entity_ld_ident(attr->entity));
+		be_emit_cstring("%lo($");
+		be_emit_ident(get_entity_ld_ident(attr->entity));
 		if(attr->val != 0) {
-			be_emit_irprintf(env->emit, "%+d", attr->val);
+			be_emit_irprintf("%+d", attr->val);
 		}
-		be_emit_char(env->emit, ')');
+		be_emit_char(')');
 		break;
 	case MIPS_IMM_SYMCONST_HI:
-		be_emit_cstring(env->emit, "%hi($");
-		be_emit_ident(env->emit, get_entity_ld_ident(attr->entity));
+		be_emit_cstring("%hi($");
+		be_emit_ident(get_entity_ld_ident(attr->entity));
 		if(attr->val != 0) {
-			be_emit_irprintf(env->emit, "%+d", attr->val);
+			be_emit_irprintf("%+d", attr->val);
 		}
-		be_emit_char(env->emit, ')');
+		be_emit_char(')');
 		break;
 	default:
 		panic("invalid immediate type found");
@@ -281,14 +273,13 @@ void mips_emit_immediate(mips_emit_env_t *env, const ir_node *node)
 /**
  * Emit the name of the destination register at given output position.
  */
-void mips_emit_source_register_or_immediate(mips_emit_env_t *env,
-                                            const ir_node *node, int pos)
+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(env, op);
+		mips_emit_immediate(op);
 	} else {
-		mips_emit_source_register(env, node, pos);
+		mips_emit_source_register(node, pos);
 	}
 }
 
@@ -309,107 +300,105 @@ static char *get_unique_label(char *buf, size_t buflen, const char *prefix)
 /************************************************************************/
 
 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);
 		return;
 	}
 
 	if(offset > 0xffff || offset < -0xffff) {
-		panic("stackframe > 2^16 bytes not supported yet\n");
+		panic("stackframe > 2^16 bytes not supported yet");
 	}
 
 	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);
 }
 
 /************************************************************************
@@ -432,27 +421,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)
 {
 	if (has_Block_label(block)) {
-		be_emit_string(env->emit, be_gas_label_prefix());
-		be_emit_irprintf(env->emit, "%lu", get_Block_label(block));
+		be_emit_string(be_gas_block_label_prefix());
+		be_emit_irprintf("%lu", get_Block_label(block));
 	} else {
-		be_emit_cstring(env->emit, BLOCK_PREFIX);
-		be_emit_irprintf(env->emit, "%d", get_irn_node_nr(block));
+		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)
@@ -472,32 +460,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);
 }
 
 /************************************************************************
@@ -553,7 +539,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;
@@ -561,11 +548,11 @@ void emit_mips_jump_table(mips_emit_env_t *env, const ir_node *irn) {
 	const mips_attr_t *attr = get_mips_attr_const(irn);
 
 	/* fill the table structure */
-	tbl.label        = xmalloc(SNPRINTF_BUF_LEN);
+	tbl.label        = XMALLOCN(char, SNPRINTF_BUF_LEN);
 	tbl.label        = get_unique_label(tbl.label, SNPRINTF_BUF_LEN, "JMPTBL_");
 	tbl.defBlock     = NULL;
 	tbl.num_branches = get_irn_n_edges(irn);
-	tbl.branches     = xcalloc(tbl.num_branches, sizeof(tbl.branches[0]));
+	tbl.branches     = XMALLOCNZ(branch_t, tbl.num_branches);
 	tbl.min_value    = INT_MAX;
 	tbl.max_value    = INT_MIN;
 
@@ -590,25 +577,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;
 	}
@@ -619,20 +606,19 @@ 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
@@ -647,34 +633,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();
 
@@ -707,13 +693,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);
 	}
@@ -723,72 +709,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);
 
-	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();
 }
 
 /**
@@ -809,30 +794,23 @@ 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;
-
 	mips_register_emitters();
 
-	irg_block_walk_graph(irg, mips_gen_labels, NULL, &env);
-
-	mips_emit_func_prolog(&env, irg);
+	irg_block_walk_graph(irg, mips_gen_labels, NULL, NULL);
 
-	dump_ir_block_graph_sched(irg, "-kaputtelist");
+	mips_emit_func_prolog(irg);
 
-	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);
+	n = ARR_LEN(mips_cg->block_schedule);
+	for (i = 0; i < n; ++i) {
+		ir_node *block = mips_cg->block_schedule[i];
+		mips_gen_block(block);
 	}
 
-	mips_emit_func_epilog(&env, irg);
+	mips_emit_func_epilog(irg);
 }
 
 void mips_init_emitter(void)