From: Matthias Braun <matze@braunis.de>
Date: Thu, 11 Aug 2011 11:59:17 +0000 (+0200)
Subject: simplify/remove unnecessary complicated copy-pasta code
X-Git-Url: http://nsz.repo.hu/git/?a=commitdiff_plain;h=318e6ade20d62835d75c39ea24e1a398daaf5d05;p=libfirm

simplify/remove unnecessary complicated copy-pasta code
---

diff --git a/ir/be/TEMPLATE/TEMPLATE_emitter.c b/ir/be/TEMPLATE/TEMPLATE_emitter.c
index 01be7239f..8401bbdaf 100644
--- a/ir/be/TEMPLATE/TEMPLATE_emitter.c
+++ b/ir/be/TEMPLATE/TEMPLATE_emitter.c
@@ -54,57 +54,10 @@
  */
 static const arch_register_t *get_in_reg(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(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 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(node);
-	} else if (is_TEMPLATE_irn(node)) {
-		reg = arch_irn_get_register(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(proj);
-				break;
-			}
-		}
-	}
-
-	assert(reg && "no out register found");
-	return reg;
+	ir_node *op = get_irn_n(node, pos);
+	return arch_get_irn_register(op);
 }
 
-
-
 void TEMPLATE_emit_immediate(const ir_node *node)
 {
 	const TEMPLATE_attr_t *attr = get_TEMPLATE_attr_const(node);
@@ -124,7 +77,7 @@ void TEMPLATE_emit_source_register(const ir_node *node, int pos)
 
 void TEMPLATE_emit_dest_register(const ir_node *node, int pos)
 {
-	const arch_register_t *reg = get_out_reg(node, pos);
+	const arch_register_t *reg = arch_irn_get_register(node, pos);
 	emit_register(reg);
 }
 
diff --git a/ir/be/amd64/amd64_emitter.c b/ir/be/amd64/amd64_emitter.c
index 1a7a417bc..897a900ed 100644
--- a/ir/be/amd64/amd64_emitter.c
+++ b/ir/be/amd64/amd64_emitter.c
@@ -56,53 +56,8 @@
  */
 static const arch_register_t *get_in_reg(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(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 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(node);
-	} else if (is_amd64_irn(node)) {
-		reg = arch_irn_get_register(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(proj);
-				break;
-			}
-		}
-	}
-
-	assert(reg && "no out register found");
-	return reg;
+	ir_node *op = get_irn_n(node, pos);
+	return arch_get_irn_register(op);
 }
 
 /*************************************************************
@@ -143,7 +98,7 @@ void amd64_emit_source_register(const ir_node *node, int pos)
 
 void amd64_emit_dest_register(const ir_node *node, int pos)
 {
-	amd64_emit_register(get_out_reg(node, pos));
+	amd64_emit_register(arch_irn_get_register(node, pos));
 }
 
 /**
@@ -377,7 +332,7 @@ static void emit_be_Copy(const ir_node *irn)
 {
 	ir_mode *mode = get_irn_mode(irn);
 
-	if (get_in_reg(irn, 0) == get_out_reg(irn, 0)) {
+	if (get_in_reg(irn, 0) == arch_irn_get_register(irn, 0)) {
 		/* omitted Copy */
 		return;
 	}
@@ -501,7 +456,7 @@ static void emit_amd64_binop(const ir_node *irn)
 {
 	const arch_register_t *reg_s1 = get_in_reg(irn, 0);
 	const arch_register_t *reg_s2 = get_in_reg(irn, 1);
-	const arch_register_t *reg_d1 = get_out_reg(irn, 0);
+	const arch_register_t *reg_d1 = arch_irn_get_register(irn, 0);
 
 	int second_op = 0;
 
diff --git a/ir/be/arm/arm_emitter.c b/ir/be/arm/arm_emitter.c
index dc7e63252..0ed948067 100644
--- a/ir/be/arm/arm_emitter.c
+++ b/ir/be/arm/arm_emitter.c
@@ -70,68 +70,8 @@ static arm_isa_t *isa;
  */
 static const arch_register_t *get_in_reg(const 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(op);
-
-	assert(reg && "no in register found");
-
-	/* in case of a joker register: just return a valid register */
-	if (reg->type & arch_register_type_joker) {
-		const arch_register_req_t *req = arch_get_register_req(irn, pos);
-
-		if (arch_register_req_is(req, limited)) {
-			/* in case of limited requirements: get the first allowed register */
-			unsigned idx = rbitset_next(req->limited, 0, 1);
-			reg = arch_register_for_index(req->cls, idx);
-		} else {
-			/* otherwise get first register in class */
-			reg = arch_register_for_index(req->cls, 0);
-		}
-	}
-	return reg;
-}
-
-
-/**
- * Returns the register at out position pos.
- */
-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(node);
-    } else if (is_arm_irn(node)) {
-        reg = arch_irn_get_register(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(proj);
-                break;
-            }
-        }
-    }
-
-    assert(reg && "no out register found");
-    return reg;
+	ir_node *op = get_irn_n(irn, pos);
+	return arch_get_irn_register(op);
 }
 
 static void arm_emit_register(const arch_register_t *reg)
@@ -147,7 +87,7 @@ void arm_emit_source_register(const ir_node *node, int pos)
 
 void arm_emit_dest_register(const ir_node *node, int pos)
 {
-	const arch_register_t *reg = get_out_reg(node, pos);
+	const arch_register_t *reg = arch_irn_get_register(node, pos);
 	arm_emit_register(reg);
 }
 
@@ -751,7 +691,7 @@ static void emit_be_Copy(const ir_node *irn)
 {
 	ir_mode *mode = get_irn_mode(irn);
 
-	if (get_in_reg(irn, 0) == get_out_reg(irn, 0)) {
+	if (get_in_reg(irn, 0) == arch_irn_get_register(irn, 0)) {
 		/* omitted Copy */
 		return;
 	}
diff --git a/ir/be/ia32/ia32_emitter.c b/ir/be/ia32/ia32_emitter.c
index 6aef8b4ce..25d2f5f6e 100644
--- a/ir/be/ia32/ia32_emitter.c
+++ b/ir/be/ia32/ia32_emitter.c
@@ -142,58 +142,8 @@ static int block_needs_label(const ir_node *block)
  */
 static const arch_register_t *get_in_reg(const 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(op);
-
-	assert(reg && "no in register found");
-
-	if (reg == &ia32_registers[REG_GP_NOREG])
-		panic("trying to emit noreg for %+F input %d", irn, pos);
-
-	return reg;
-}
-
-/**
- * Returns the register at out position pos.
- */
-static const arch_register_t *get_out_reg(const 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) {
-		assert(pos == 0);
-		reg = arch_get_irn_register(irn);
-	} else if (is_ia32_irn(irn)) {
-		reg = arch_irn_get_register(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(proj);
-				break;
-			}
-		}
-	}
-
-	assert(reg && "no out register found");
-	return reg;
+	ir_node *op = get_irn_n(irn, pos);
+	return arch_get_irn_register(op);
 }
 
 /**
@@ -350,21 +300,21 @@ void ia32_emit_16bit_source_register_or_immediate(const ir_node *node, int pos)
 
 void ia32_emit_dest_register(const ir_node *node, int pos)
 {
-	const arch_register_t *reg  = get_out_reg(node, pos);
+	const arch_register_t *reg  = arch_irn_get_register(node, pos);
 
 	emit_register(reg, NULL);
 }
 
 void ia32_emit_dest_register_size(const ir_node *node, int pos)
 {
-	const arch_register_t *reg  = get_out_reg(node, pos);
+	const arch_register_t *reg  = arch_irn_get_register(node, pos);
 
 	emit_register(reg, get_ia32_ls_mode(node));
 }
 
 void ia32_emit_8bit_dest_register(const ir_node *node, int pos)
 {
-	const arch_register_t *reg  = get_out_reg(node, pos);
+	const arch_register_t *reg  = arch_irn_get_register(node, pos);
 
 	emit_register(reg, mode_Bu);
 }
@@ -716,7 +666,7 @@ emit_AM:
 			case 'D':
 				if (*fmt < '0' || '9' <= *fmt)
 					goto unknown;
-				reg = get_out_reg(node, *fmt++ - '0');
+				reg = arch_irn_get_register(node, *fmt++ - '0');
 				goto emit_R;
 
 			case 'I':
@@ -866,7 +816,7 @@ void ia32_emit_unop(const ir_node *node, int pos)
 static void emit_ia32_IMul(const ir_node *node)
 {
 	ir_node               *left    = get_irn_n(node, n_ia32_IMul_left);
-	const arch_register_t *out_reg = get_out_reg(node, pn_ia32_IMul_res);
+	const arch_register_t *out_reg = arch_irn_get_register(node, pn_ia32_IMul_res);
 
 	/* do we need the 3-address form? */
 	if (is_ia32_NoReg_GP(left) ||
@@ -1057,7 +1007,7 @@ static void emit_ia32_Jcc(const ir_node *node)
  */
 static void emit_ia32_Setcc(const ir_node *node)
 {
-	const arch_register_t *dreg = get_out_reg(node, pn_ia32_Setcc_res);
+	const arch_register_t *dreg = arch_irn_get_register(node, pn_ia32_Setcc_res);
 
 	ia32_condition_code_t cc = get_ia32_condcode(node);
 	cc = determine_final_cc(node, n_ia32_Setcc_eflags, cc);
@@ -1223,7 +1173,7 @@ static const char* emit_asm_operand(const ir_node *node, const char *s)
 
 	/* get register */
 	if (asm_reg->use_input == 0) {
-		reg = get_out_reg(node, asm_reg->inout_pos);
+		reg = arch_irn_get_register(node, asm_reg->inout_pos);
 	} else {
 		ir_node *pred = get_irn_n(node, asm_reg->inout_pos);
 
@@ -1519,8 +1469,8 @@ static void emit_ia32_Minus64Bit(const ir_node *node)
 {
 	const arch_register_t *in_lo  = get_in_reg(node, 0);
 	const arch_register_t *in_hi  = get_in_reg(node, 1);
-	const arch_register_t *out_lo = get_out_reg(node, 0);
-	const arch_register_t *out_hi = get_out_reg(node, 1);
+	const arch_register_t *out_lo = arch_irn_get_register(node, 0);
+	const arch_register_t *out_hi = arch_irn_get_register(node, 1);
 
 	if (out_lo == in_lo) {
 		if (out_hi != in_hi) {
@@ -2374,7 +2324,7 @@ static void bemit_unop(const ir_node *node, unsigned char code, unsigned char ex
 
 static void bemit_unop_reg(const ir_node *node, unsigned char code, int input)
 {
-	const arch_register_t *out = get_out_reg(node, 0);
+	const arch_register_t *out = arch_irn_get_register(node, 0);
 	bemit_unop(node, code, reg_gp_map[out->index], input);
 }
 
@@ -2396,7 +2346,7 @@ static void bemit_immediate(const ir_node *node, bool relative)
 static void bemit_copy(const ir_node *copy)
 {
 	const arch_register_t *in  = get_in_reg(copy, 0);
-	const arch_register_t *out = get_out_reg(copy, 0);
+	const arch_register_t *out = arch_irn_get_register(copy, 0);
 
 	if (in == out)
 		return;
@@ -2446,14 +2396,14 @@ static void bemit_perm(const ir_node *node)
 
 static void bemit_xor0(const ir_node *node)
 {
-	const arch_register_t *out = get_out_reg(node, 0);
+	const arch_register_t *out = arch_irn_get_register(node, 0);
 	bemit8(0x31);
 	bemit_modrr(out, out);
 }
 
 static void bemit_mov_const(const ir_node *node)
 {
-	const arch_register_t *out = get_out_reg(node, 0);
+	const arch_register_t *out = arch_irn_get_register(node, 0);
 	bemit8(0xB8 + reg_gp_map[out->index]);
 	bemit_immediate(node, false);
 }
@@ -2503,7 +2453,7 @@ static void bemit_##op(const ir_node *node) \
 		} \
 	} else { \
 		bemit8(ext << 3 | 1); \
-		bemit_mod_am(reg_gp_map[get_out_reg(val, 0)->index], node); \
+		bemit_mod_am(reg_gp_map[arch_irn_get_register(val, 0)->index], node); \
 	} \
 } \
  \
@@ -2516,7 +2466,7 @@ static void bemit_##op##8bit(const ir_node *node) \
 		bemit8(get_ia32_immediate_attr_const(val)->offset); \
 	} else { \
 		bemit8(ext << 3); \
-		bemit_mod_am(reg_gp_map[get_out_reg(val, 0)->index], node); \
+		bemit_mod_am(reg_gp_map[arch_irn_get_register(val, 0)->index], node); \
 	} \
 }
 
@@ -2548,7 +2498,7 @@ UNOP(ijmp,    0xFF, 4, n_ia32_IJmp_target)
 #define SHIFT(op, ext) \
 static void bemit_##op(const ir_node *node) \
 { \
-	const arch_register_t *out   = get_out_reg(node, 0); \
+	const arch_register_t *out   = arch_irn_get_register(node, 0); \
 	ir_node               *count = get_irn_n(node, 1); \
 	if (is_ia32_Immediate(count)) { \
 		int offset = get_ia32_immediate_attr_const(count)->offset; \
@@ -2598,7 +2548,7 @@ SHIFT(sar, 7)
 static void bemit_shld(const ir_node *node)
 {
 	const arch_register_t *in  = get_in_reg(node, n_ia32_ShlD_val_low);
-	const arch_register_t *out = get_out_reg(node, pn_ia32_ShlD_res);
+	const arch_register_t *out = arch_irn_get_register(node, pn_ia32_ShlD_res);
 	ir_node *count = get_irn_n(node, n_ia32_ShlD_count);
 	bemit8(0x0F);
 	if (is_ia32_Immediate(count)) {
@@ -2614,7 +2564,7 @@ static void bemit_shld(const ir_node *node)
 static void bemit_shrd(const ir_node *node)
 {
 	const arch_register_t *in  = get_in_reg(node, n_ia32_ShrD_val_low);
-	const arch_register_t *out = get_out_reg(node, pn_ia32_ShrD_res);
+	const arch_register_t *out = arch_irn_get_register(node, pn_ia32_ShrD_res);
 	ir_node *count = get_irn_n(node, n_ia32_ShrD_count);
 	bemit8(0x0F);
 	if (is_ia32_Immediate(count)) {
@@ -2632,7 +2582,7 @@ static void bemit_shrd(const ir_node *node)
  */
 static void bemit_setcc(const ir_node *node)
 {
-	const arch_register_t *dreg = get_out_reg(node, pn_ia32_Setcc_res);
+	const arch_register_t *dreg = arch_irn_get_register(node, pn_ia32_Setcc_res);
 
 	ia32_condition_code_t cc = get_ia32_condcode(node);
 	cc = determine_final_cc(node, n_ia32_Setcc_eflags, cc);
@@ -2864,13 +2814,13 @@ static void bemit_imul(const ir_node *node)
 
 static void bemit_dec(const ir_node *node)
 {
-	const arch_register_t *out = get_out_reg(node, pn_ia32_Dec_res);
+	const arch_register_t *out = arch_irn_get_register(node, pn_ia32_Dec_res);
 	bemit8(0x48 + reg_gp_map[out->index]);
 }
 
 static void bemit_inc(const ir_node *node)
 {
-	const arch_register_t *out = get_out_reg(node, pn_ia32_Inc_res);
+	const arch_register_t *out = arch_irn_get_register(node, pn_ia32_Inc_res);
 	bemit8(0x40 + reg_gp_map[out->index]);
 }
 
@@ -2887,7 +2837,7 @@ UNOPMEM(decmem, 0xFE, 1)
 
 static void bemit_ldtls(const ir_node *node)
 {
-	const arch_register_t *out = get_out_reg(node, 0);
+	const arch_register_t *out = arch_irn_get_register(node, 0);
 
 	bemit8(0x65); // gs:
 	if (out->index == REG_GP_EAX) {
@@ -2904,7 +2854,7 @@ static void bemit_ldtls(const ir_node *node)
  */
 static void bemit_lea(const ir_node *node)
 {
-	const arch_register_t *out = get_out_reg(node, 0);
+	const arch_register_t *out = arch_irn_get_register(node, 0);
 	bemit8(0x8D);
 	bemit_mod_am(reg_gp_map[out->index], node);
 }
@@ -2962,8 +2912,8 @@ static void bemit_minus64bit(const ir_node *node)
 {
 	const arch_register_t *in_lo  = get_in_reg(node, 0);
 	const arch_register_t *in_hi  = get_in_reg(node, 1);
-	const arch_register_t *out_lo = get_out_reg(node, 0);
-	const arch_register_t *out_hi = get_out_reg(node, 1);
+	const arch_register_t *out_lo = arch_irn_get_register(node, 0);
+	const arch_register_t *out_hi = arch_irn_get_register(node, 1);
 
 	if (out_lo == in_lo) {
 		if (out_hi != in_hi) {
@@ -3049,7 +2999,7 @@ EMIT_SINGLEOP(stc,   0xF9)
  */
 static void bemit_load(const ir_node *node)
 {
-	const arch_register_t *out = get_out_reg(node, 0);
+	const arch_register_t *out = arch_irn_get_register(node, 0);
 
 	if (out->index == REG_GP_EAX) {
 		ir_node   *base      = get_irn_n(node, n_ia32_base);
@@ -3183,7 +3133,7 @@ static void bemit_push(const ir_node *node)
  */
 static void bemit_pop(const ir_node *node)
 {
-	const arch_register_t *reg = get_out_reg(node, pn_ia32_Pop_res);
+	const arch_register_t *reg = arch_irn_get_register(node, pn_ia32_Pop_res);
 	bemit8(0x58 + reg_gp_map[reg->index]);
 }
 
@@ -3322,7 +3272,7 @@ static void bemit_subsp(const ir_node *node)
 	bemit_sub(node);
 	/* mov %esp, %out */
 	bemit8(0x8B);
-	out = get_out_reg(node, 1);
+	out = arch_irn_get_register(node, 1);
 	bemit8(MOD_REG | ENC_REG(reg_gp_map[out->index]) | ENC_RM(0x04));
 }
 
@@ -3347,7 +3297,7 @@ static void bemit_incsp(const ir_node *node)
 	size = get_signed_imm_size(offs);
 	bemit8(size == 1 ? 0x83 : 0x81);
 
-	reg  = get_out_reg(node, 0);
+	reg  = arch_irn_get_register(node, 0);
 	bemit_modru(reg, ext);
 
 	if (size == 1) {
diff --git a/ir/be/sparc/sparc_emitter.c b/ir/be/sparc/sparc_emitter.c
index cdb1e57ca..520e763f4 100644
--- a/ir/be/sparc/sparc_emitter.c
+++ b/ir/be/sparc/sparc_emitter.c
@@ -69,53 +69,8 @@ static void sparc_emit_node(const ir_node *node);
  */
 static const arch_register_t *get_in_reg(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(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 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(node);
-	} else if (is_sparc_irn(node)) {
-		reg = arch_irn_get_register(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(proj);
-				break;
-			}
-		}
-	}
-
-	assert(reg && "no out register found");
-	return reg;
+	ir_node *op = get_irn_n(node, pos);
+	return arch_get_irn_register(op);
 }
 
 void sparc_emit_immediate(const ir_node *node)
@@ -164,7 +119,7 @@ void sparc_emit_source_register(const ir_node *node, int pos)
 
 void sparc_emit_dest_register(const ir_node *node, int pos)
 {
-	const arch_register_t *reg = get_out_reg(node, pos);
+	const arch_register_t *reg = arch_irn_get_register(node, pos);
 	be_emit_char('%');
 	be_emit_string(arch_register_get_name(reg));
 }
@@ -346,7 +301,7 @@ static bool is_no_instruction(const ir_node *node)
 	/* copies are nops if src_reg == dest_reg */
 	if (be_is_Copy(node) || be_is_CopyKeep(node)) {
 		const arch_register_t *src_reg  = get_in_reg(node, 0);
-		const arch_register_t *dest_reg = get_out_reg(node, 0);
+		const arch_register_t *dest_reg = arch_irn_get_register(node, 0);
 
 		if (src_reg == dest_reg)
 			return true;
@@ -881,7 +836,7 @@ static void emit_be_Copy(const ir_node *node)
 {
 	ir_mode               *mode    = get_irn_mode(node);
 	const arch_register_t *src_reg = get_in_reg(node, 0);
-	const arch_register_t *dst_reg = get_out_reg(node, 0);
+	const arch_register_t *dst_reg = arch_irn_get_register(node, 0);
 
 	if (src_reg == dst_reg)
 		return;