X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbespillremat.c;h=99caaf4987327bd7f85de324650c1d6738f14f80;hb=c1fdf770d4d000dd5cf22daead32369342c5f5d1;hp=2d418f6374c3c7478fec1b7d9f2b95c430bf0787;hpb=f8351f6e96dfce9aa29522997a70a3eb2ae50fdb;p=libfirm

diff --git a/ir/be/bespillremat.c b/ir/be/bespillremat.c
index 2d418f637..99caaf498 100644
--- a/ir/be/bespillremat.c
+++ b/ir/be/bespillremat.c
@@ -24,14 +24,13 @@
  * @date        06.04.2006
  * @version     $Id$
  */
-#ifdef HAVE_CONFIG_H
 #include "config.h"
-#endif
 
 #ifdef WITH_ILP
 
 #include <math.h>
 
+#include "array_t.h"
 #include "hashptr.h"
 #include "debug.h"
 #include "obst.h"
@@ -282,8 +281,7 @@ typedef struct _memoperand_t {
 static INLINE int
 has_reg_class(const spill_ilp_t * si, const ir_node * irn)
 {
-	return arch_irn_consider_in_reg_alloc(si->birg->main_env->arch_env,
-	                                      si->cls, irn);
+	return arch_irn_consider_in_reg_alloc(si->cls, irn);
 }
 
 #if 0
@@ -403,7 +401,7 @@ set_find_spill(set * set, const ir_node * value)
 #define pset_foreach(s,i) for((i)=pset_first((s)); (i); (i)=pset_next((s)))
 #define set_foreach(s,i) for((i)=set_first((s)); (i); (i)=set_next((s)))
 #define foreach_post_remat(s,i) for((i)=next_post_remat((s)); (i); (i)=next_post_remat((i)))
-#define foreach_pre_remat(si,s,i) for((i)=next_pre_remat((si),(s)); (i); (i)=next_pre_remat((si),(i)))
+#define foreach_pre_remat(s,i) for((i)=next_pre_remat((s)); (i); (i)=next_pre_remat((i)))
 #define	sched_foreach_op(s,i) for((i)=sched_next_op((s));!sched_is_end((i));(i)=sched_next_op((i)))
 
 static int
@@ -453,15 +451,14 @@ execution_frequency(const spill_ilp_t *si, const ir_node * irn)
 #endif
 }
 
-static double
-get_cost(const spill_ilp_t * si, const ir_node * irn)
+static double get_cost(const ir_node *irn)
 {
 	if(be_is_Spill(irn)) {
 		return opt_cost_spill;
 	} else if(be_is_Reload(irn)){
 		return opt_cost_reload;
 	} else {
-		return arch_get_op_estimated_cost(si->birg->main_env->arch_env, irn);
+		return arch_get_op_estimated_cost(irn);
 	}
 }
 
@@ -471,9 +468,8 @@ get_cost(const spill_ilp_t * si, const ir_node * irn)
 static INLINE int
 is_rematerializable(const spill_ilp_t * si, const ir_node * irn)
 {
-	int               n;
-	const arch_env_t *arch_env = si->birg->main_env->arch_env;
-	int               remat = (arch_irn_get_flags(arch_env, irn) & arch_irn_flags_rematerializable) != 0;
+	int n;
+	int remat = (arch_irn_get_flags(irn) & arch_irn_flags_rematerializable) != 0;
 
 #if 0
 	if(!remat)
@@ -482,7 +478,7 @@ is_rematerializable(const spill_ilp_t * si, const ir_node * irn)
 
 	for (n = get_irn_arity(irn)-1; n>=0 && remat; --n) {
 		ir_node        *op = get_irn_n(irn, n);
-		remat &= has_reg_class(si, op) || arch_irn_get_flags(arch_env, op) & arch_irn_flags_ignore || (get_irn_op(op) == op_NoMem);
+		remat &= has_reg_class(si, op) || arch_irn_get_flags(op) & arch_irn_flags_ignore || is_NoMem(op);
 
 //		if(!remat)
 //			ir_fprintf(stderr, "  Argument %d (%+F) of Node %+F has wrong regclass\n", i, op, irn);
@@ -515,7 +511,7 @@ get_remat_from_op(spill_ilp_t * si, const ir_node * dest_value, const ir_node *
 
 		remat          = obstack_alloc(si->obst, sizeof(*remat));
 		remat->op      = op;
-		remat->cost    = (int)get_cost(si, op);
+		remat->cost    = (int)get_cost(op);
 		remat->value   = dest_value;
 		remat->proj    = proj;
 		remat->inverse = 0;
@@ -534,7 +530,7 @@ get_remat_from_op(spill_ilp_t * si, const ir_node * dest_value, const ir_node *
 		DBG((si->dbg, LEVEL_5, "\t  requesting inverse op for argument %d of op %+F\n", n, op));
 
 		/* else ask the backend to give an inverse op */
-		if(arch_get_inverse(si->birg->main_env->arch_env, op, n, &inverse, si->obst)) {
+		if(arch_get_inverse(op, n, &inverse, si->obst)) {
 			int   i;
 
 			DBG((si->dbg, LEVEL_4, "\t  backend gave us an inverse op with %d nodes and cost %d\n", inverse.n, inverse.costs));
@@ -709,10 +705,9 @@ value_is_defined_before(const spill_ilp_t * si, const ir_node * pos, const ir_no
 	return ret;
 }
 
-static INLINE ir_node *
-sched_block_last_noncf(const spill_ilp_t * si, const ir_node * bb)
+static INLINE ir_node *sched_block_last_noncf(const ir_node * bb)
 {
-    return sched_skip((ir_node*)bb, 0, sched_skip_cf_predicator, (void *) si->birg->main_env->arch_env);
+	return sched_skip((ir_node*)bb, 0, sched_skip_cf_predicator, NULL);
 }
 
 /**
@@ -779,11 +774,10 @@ sched_put_after(ir_node * insert, ir_node * irn)
 	sched_add_before(insert, irn);
 }
 
-static void
-sched_put_before(const spill_ilp_t * si, ir_node * insert, ir_node * irn)
+static void sched_put_before(ir_node * insert, ir_node * irn)
 {
   if(is_Block(insert)) {
-	  insert = sched_block_last_noncf(si, insert);
+	  insert = sched_block_last_noncf(insert);
   } else {
 	  insert = sched_next_nonproj(insert, 0);
 	  insert = sched_prev(insert);
@@ -816,14 +810,13 @@ next_post_remat(const ir_node * irn)
 }
 
 
-static ir_node *
-next_pre_remat(const spill_ilp_t * si, const ir_node * irn)
+static ir_node *next_pre_remat(const ir_node * irn)
 {
 	op_t      *op;
 	ir_node   *ret;
 
 	if(is_Block(irn)) {
-		ret = sched_block_last_noncf(si, irn);
+		ret = sched_block_last_noncf(irn);
 		ret = sched_next(ret);
 		ret = sched_prev_op(ret);
 	} else {
@@ -853,7 +846,7 @@ can_remat_before(const spill_ilp_t * si, const remat_t * remat, const ir_node *
 			   res = 1;
 
 	if(is_Block(pos)) {
-		prev = sched_block_last_noncf(si, pos);
+		prev = sched_block_last_noncf(pos);
 		prev = sched_next_nonproj(prev, 0);
 	} else {
 		prev = sched_prev_op(pos);
@@ -938,7 +931,7 @@ insert_copy_before(const spill_ilp_t * si, const ir_node * irn, ir_node * pos)
 
 	set_phi_class(si->pc, copy, NULL);
 	set_nodes_block(copy, bb);
-	sched_put_before(si, pos, copy);
+	sched_put_before(pos, copy);
 
 	return copy;
 }
@@ -1102,7 +1095,7 @@ get_live_end(spill_ilp_t * si, ir_node * bb, pset * live)
 	sched_foreach_reverse(bb, irn) {
 		int  i;
 
-		if(!sched_skip_cf_predicator(irn, si->birg->main_env->arch_env)) break;
+		if (!sched_skip_cf_predicator(irn, NULL)) break;
 
 		for(i=get_irn_arity(irn)-1; i>=0; --i) {
 			ir_node *arg = get_irn_n(irn,i);
@@ -1116,7 +1109,7 @@ get_live_end(spill_ilp_t * si, ir_node * bb, pset * live)
 	 * find values that are used by remats at end of block
 	 * and insert them into live set
 	 */
-	foreach_pre_remat(si, bb, irn) {
+	foreach_pre_remat(bb, irn) {
 		int       n;
 
 		for (n=get_irn_arity(irn)-1; n>=0; --n) {
@@ -1148,7 +1141,7 @@ walker_regclass_copy_insertor(ir_node * irn, void * data)
 
 			if(!has_reg_class(si, phi_arg)) {
 				ir_node   *copy = be_new_Copy(si->cls, si->birg->irg, bb, phi_arg);
-				ir_node   *pos = sched_block_last_noncf(si, bb);
+				ir_node   *pos = sched_block_last_noncf(bb);
 				op_t      *op = obstack_alloc(si->obst, sizeof(*op));
 
 				DBG((si->dbg, LEVEL_2, "\t copy to my regclass for arg %+F of %+F\n", phi_arg, irn));
@@ -1266,7 +1259,7 @@ walker_remat_insertor(ir_node * bb, void * data)
 		}
 
 		/* do not place post remats after jumps */
-		if(sched_skip_cf_predicator(irn, si->birg->main_env->arch_env)) {
+		if (sched_skip_cf_predicator(irn, si->birg->main_env->arch_env)) {
 			del_pset(used);
 			del_pset(args);
 			break;
@@ -1480,7 +1473,7 @@ luke_endwalker(ir_node * bb, void * data)
 	 * find values that are used by remats at end of block
 	 * and insert them into live set
 	 */
-	foreach_pre_remat(si, bb, irn) {
+	foreach_pre_remat(bb, irn) {
 		int       n;
 
 		for (n=get_irn_arity(irn)-1; n>=0; --n) {
@@ -1497,7 +1490,7 @@ luke_endwalker(ir_node * bb, void * data)
 	sched_foreach_reverse(bb, irn) {
 		int   n;
 
-		if(!sched_skip_cf_predicator(irn, si->birg->main_env->arch_env)) break;
+		if (!sched_skip_cf_predicator(irn, si->birg->main_env->arch_env)) break;
 
 		for (n=get_irn_arity(irn)-1; n>=0; --n) {
 			ir_node        *irn_arg = get_irn_n(irn, n);
@@ -1756,7 +1749,7 @@ insert_mem_copy_position(spill_ilp_t * si, pset * live, const ir_node * block)
 		lpp_set_factor_fast(si->lpp, cst, to_copy_spill->reg_out, -1.0);
 		if(reload != ILP_UNDEF) lpp_set_factor_fast(si->lpp, cst, reload, -1.0);
 		lpp_set_factor_fast(si->lpp, cst, to_copy_op->attr.live_range.ilp, -1.0);
-		foreach_pre_remat(si, block, tmp) {
+		foreach_pre_remat(block, tmp) {
 			op_t     *remat_op = get_irn_link(tmp);
 			if(remat_op->attr.remat.remat->value == to_copy) {
 				lpp_set_factor_fast(si->lpp, cst, remat_op->attr.remat.ilp, -1.0);
@@ -1780,16 +1773,15 @@ insert_mem_copy_position(spill_ilp_t * si, pset * live, const ir_node * block)
 static void
 luke_blockwalker(ir_node * bb, void * data)
 {
-	spill_ilp_t    *si = (spill_ilp_t*)data;
-	ir_node        *irn;
-	pset           *live;
-	char            buf[256];
-	ilp_cst_t       cst;
-	spill_bb_t     *spill_bb = get_irn_link(bb);
-	ir_node        *tmp;
-	spill_t        *spill;
-	pset           *defs = pset_new_ptr_default();
-	const arch_env_t *arch_env = si->birg->main_env->arch_env;
+	spill_ilp_t *si = (spill_ilp_t*)data;
+	ir_node     *irn;
+	pset        *live;
+	char         buf[256];
+	ilp_cst_t    cst;
+	spill_bb_t  *spill_bb = get_irn_link(bb);
+	ir_node     *tmp;
+	spill_t     *spill;
+	pset        *defs = pset_new_ptr_default();
 
 	live = pset_new_ptr_default();
 
@@ -1830,7 +1822,7 @@ luke_blockwalker(ir_node * bb, void * data)
 		lpp_set_factor_fast(si->lpp, cst, spill->reg_out, 1.0);
 		if(reload != ILP_UNDEF) lpp_set_factor_fast(si->lpp, cst, reload, -1.0);
 		lpp_set_factor_fast(si->lpp, cst, op->attr.live_range.ilp, -1.0);
-		foreach_pre_remat(si, bb, tmp) {
+		foreach_pre_remat(bb, tmp) {
 			op_t     *remat_op = get_irn_link(tmp);
 			if(remat_op->attr.remat.remat->value == irn) {
 				lpp_set_factor_fast(si->lpp, cst, remat_op->attr.remat.ilp, -1.0);
@@ -1844,7 +1836,7 @@ luke_blockwalker(ir_node * bb, void * data)
 		lpp_set_factor_fast(si->lpp, cst, spill->reg_out, 1.0);
 		if(reload != ILP_UNDEF) lpp_set_factor_fast(si->lpp, cst, reload, -1.0);
 		lpp_set_factor_fast(si->lpp, cst, op->attr.live_range.ilp, -1.0);
-		foreach_pre_remat(si, bb, tmp) {
+		foreach_pre_remat(bb, tmp) {
 			op_t     *remat_op = get_irn_link(tmp);
 			if(remat_op->attr.remat.remat->value == irn) {
 				lpp_set_factor_fast(si->lpp, cst, remat_op->attr.remat.ilp, -1.0);
@@ -1879,7 +1871,7 @@ luke_blockwalker(ir_node * bb, void * data)
 	/*
 	 * assure the remat args are available
 	 */
-	foreach_pre_remat(si, bb, tmp) {
+	foreach_pre_remat(bb, tmp) {
 		op_t     *remat_op = get_irn_link(tmp);
 		int       n;
 
@@ -1925,7 +1917,7 @@ luke_blockwalker(ir_node * bb, void * data)
 	 *    B A S I C  B L O C K  B O D Y
 	 **************************************/
 
-	sched_foreach_reverse_from(sched_block_last_noncf(si, bb), irn) {
+	sched_foreach_reverse_from(sched_block_last_noncf(bb), irn) {
 		op_t       *op;
 		op_t       *tmp_op;
 		int         n,
@@ -1986,7 +1978,7 @@ luke_blockwalker(ir_node * bb, void * data)
 					}
 				}
 			}
-			foreach_pre_remat(si, irn, tmp) {
+			foreach_pre_remat(irn, tmp) {
 				for (n=get_irn_arity(tmp)-1; n>=0; --n) {
 					ir_node        *remat_arg = get_irn_n(tmp, n);
 					if(has_reg_class(si, remat_arg)) {
@@ -2242,7 +2234,8 @@ skip_one_must_die:
 
 			if(opt_memoperands && (!is_start_block(bb) || be_is_Barrier(irn))) {
 				for(n = get_irn_arity(irn)-1; n>=0; --n) {
-					if(get_irn_n(irn, n) == arg && arch_possible_memory_operand(arch_env, irn, n)) {
+					if (get_irn_n(irn, n) == arg &&
+							arch_possible_memory_operand(irn, n)) {
 						ilp_var_t       memoperand;
 
 						ir_snprintf(buf, sizeof(buf), "memoperand_%N_%d", irn, n);
@@ -2278,7 +2271,7 @@ skip_one_must_die:
 				assert(spill);
 
 				ir_snprintf(buf, sizeof(buf), "delete_%N", tmp);
-				delete = lpp_add_var_default(si->lpp, buf, lpp_binary, -1.0*get_cost(si, irn)*execution_frequency(si, bb), 0.0);
+				delete = lpp_add_var_default(si->lpp, buf, lpp_binary, -1.0 * get_cost(irn) * execution_frequency(si, bb), 0.0);
 
 				/* op may not be killed if its first live_range is 1 */
 				ir_snprintf(buf, sizeof(buf), "killorig-lr_%N", tmp);
@@ -2296,7 +2289,7 @@ skip_one_must_die:
 				assert(spill);
 
 				ir_snprintf(buf, sizeof(buf), "keep_%N", tmp);
-				keep = lpp_add_var_default(si->lpp, buf, lpp_binary, get_cost(si, irn)*execution_frequency(si, bb), 1.0);
+				keep = lpp_add_var_default(si->lpp, buf, lpp_binary, get_cost(irn) * execution_frequency(si, bb), 1.0);
 
 				/* op may not be killed if its first live_range is 1 */
 				ir_snprintf(buf, sizeof(buf), "killorig-lr_%N", tmp);
@@ -2380,7 +2373,7 @@ skip_one_must_die:
 
 			lpp_set_factor_fast(si->lpp, requirements, arg_op->attr.live_range.ilp, 1.0);
 			lpp_set_factor_fast(si->lpp, requirements, op->attr.live_range.args.reloads[i], 1.0);
-			foreach_pre_remat(si, irn, tmp) {
+			foreach_pre_remat(irn, tmp) {
 				op_t     *remat_op = get_irn_link(tmp);
 				if(remat_op->attr.remat.remat->value == arg) {
 					lpp_set_factor_fast(si->lpp, requirements, remat_op->attr.remat.ilp, 1.0);
@@ -2395,7 +2388,8 @@ skip_one_must_die:
 					}
 				}
 				for(n = get_irn_arity(irn)-1; n>=0; --n) {
-					if(get_irn_n(irn, n) == arg && arch_possible_memory_operand(arch_env, irn, n)) {
+					if (get_irn_n(irn, n) == arg &&
+							arch_possible_memory_operand(irn, n)) {
 						memoperand_t  *memoperand;
 						memoperand = set_find_memoperand(si->memoperands, irn, n);
 
@@ -2428,7 +2422,7 @@ skip_one_must_die:
 		}
 
 		/* requirements for remats */
-		foreach_pre_remat(si, irn, tmp) {
+		foreach_pre_remat(irn, tmp) {
 			op_t        *remat_op = get_irn_link(tmp);
 			int          n;
 
@@ -3422,15 +3416,15 @@ connect_all_spills_with_keep(spill_ilp_t * si)
 }
 
 /** insert a spill at an arbitrary position */
-ir_node *be_spill2(const arch_env_t *arch_env, ir_node *irn, ir_node *insert)
+static ir_node *be_spill2(ir_node *irn, ir_node *insert)
 {
 	ir_node  *bl    = is_Block(insert) ? insert : get_nodes_block(insert);
 	ir_graph *irg   = get_irn_irg(bl);
 	ir_node  *frame = get_irg_frame(irg);
 	ir_node  *spill;
 	ir_node  *next;
-	const arch_register_class_t *cls       = arch_get_irn_reg_class(arch_env, irn, -1);
-	const arch_register_class_t *cls_frame = arch_get_irn_reg_class(arch_env, frame, -1);
+	const arch_register_class_t *cls       = arch_get_irn_reg_class(irn, -1);
+	const arch_register_class_t *cls_frame = arch_get_irn_reg_class(frame, -1);
 
 	spill = be_new_Spill(cls, cls_frame, irg, bl, frame, irn);
 
@@ -3617,11 +3611,10 @@ insert_spill(spill_ilp_t * si, ir_node * irn, const ir_node * value, ir_node * b
 {
 	defs_t   *defs;
 	ir_node  *spill;
-	const arch_env_t *arch_env = si->birg->main_env->arch_env;
 
 	DBG((si->dbg, LEVEL_3, "\t  inserting spill for value %+F after %+F\n", irn, before));
 
-	spill = be_spill2(arch_env, irn, before);
+	spill = be_spill2(irn, before);
 
 	defs = set_insert_def(si->values, value);
 	assert(defs);
@@ -3704,7 +3697,6 @@ insert_reload(spill_ilp_t * si, const ir_node * value, ir_node * after)
 	defs_t   *defs;
 	ir_node  *reload,
 			 *spill;
-	const arch_env_t *arch_env = si->birg->main_env->arch_env;
 
 	DBG((si->dbg, LEVEL_3, "\t  inserting reload for value %+F before %+F\n", value, after));
 
@@ -3713,7 +3705,7 @@ insert_reload(spill_ilp_t * si, const ir_node * value, ir_node * after)
 	spill = defs->spills;
 	assert(spill && "no spill placed before reload");
 
-	reload = be_reload(arch_env, si->cls, after, get_irn_mode(value), spill);
+	reload = be_reload(si->cls, after, get_irn_mode(value), spill);
 
 	/* enter into the linked list */
 	set_irn_link(reload, defs->remats);
@@ -3724,10 +3716,9 @@ insert_reload(spill_ilp_t * si, const ir_node * value, ir_node * after)
 
 void perform_memory_operand(spill_ilp_t * si, memoperand_t * memoperand)
 {
-	defs_t           *defs;
-	ir_node          *value = get_irn_n(memoperand->irn, memoperand->pos);
-	ir_node          *spill;
-	const arch_env_t *arch_env = si->birg->main_env->arch_env;
+	defs_t  *defs;
+	ir_node *value = get_irn_n(memoperand->irn, memoperand->pos);
+	ir_node *spill;
 
 	DBG((si->dbg, LEVEL_2, "\t  inserting memory operand for value %+F at %+F\n", value, memoperand->irn));
 
@@ -3736,7 +3727,7 @@ void perform_memory_operand(spill_ilp_t * si, memoperand_t * memoperand)
 	spill = defs->spills;
 	assert(spill && "no spill placed before reload");
 
-	arch_perform_memory_operand(arch_env, memoperand->irn, spill, memoperand->pos);
+	arch_perform_memory_operand(memoperand->irn, spill, memoperand->pos);
 }
 
 void insert_memoperands(spill_ilp_t * si)
@@ -3830,7 +3821,6 @@ insert_mem_copy(spill_ilp_t * si, ir_node * bb, ir_node * value)
 {
 	ir_node          *insert_pos = bb;
 	ir_node          *spill;
-	const arch_env_t *arch_env = si->birg->main_env->arch_env;
 
 	/* find last definition of arg value in block */
 	ir_node  *next;
@@ -3855,7 +3845,7 @@ insert_mem_copy(spill_ilp_t * si, ir_node * bb, ir_node * value)
 
 	DBG((si->dbg, LEVEL_2, "\t  inserting mem copy for value %+F after %+F\n", value, insert_pos));
 
-	spill = be_spill2(arch_env, is_Block(insert_pos)?value:insert_pos, insert_pos);
+	spill = be_spill2(is_Block(insert_pos)?value:insert_pos, insert_pos);
 
 	return spill;
 }
@@ -3929,7 +3919,7 @@ walker_reload_placer(ir_node * bb, void * data) {
 			if(!is_zero(name->value)) {
 				ir_node    *reload;
 				ir_node    *insert_pos = bb;
-				ir_node    *prev = sched_block_last_noncf(si, bb);
+				ir_node    *prev = sched_block_last_noncf(bb);
 				op_t       *prev_op = get_irn_link(prev);
 
 				while(be_is_Spill(prev)) {
@@ -4049,7 +4039,7 @@ walker_kill_unused(ir_node * bb, void * data)
 
 		if(!bitset_is_set(kh->used, get_irn_idx(irn))) {
 			if(be_is_Spill(irn) || be_is_Reload(irn)) {
-				DBG((kh->si->dbg, LEVEL_1, "\t SUBOPTIMAL! %+F IS UNUSED (cost: %g)\n", irn, get_cost(kh->si, irn)*execution_frequency(kh->si, bb)));
+				DBG((kh->si->dbg, LEVEL_1, "\t SUBOPTIMAL! %+F IS UNUSED (cost: %g)\n", irn, get_cost(irn) * execution_frequency(kh->si, bb)));
 #if 0
 				assert(lpp_get_sol_state(kh->si->lpp) != lpp_optimal && "optimal solution is suboptimal?");
 #endif
@@ -4297,8 +4287,8 @@ get_n_regs(spill_ilp_t * si)
 	bitset_t *arch_regs = bitset_malloc(arch_n_regs);
 	bitset_t *abi_regs = bitset_malloc(arch_n_regs);
 
-	arch_put_non_ignore_regs(si->birg->main_env->arch_env, si->cls, arch_regs);
-    be_abi_put_ignore_regs(si->birg->abi, si->cls, abi_regs);
+	arch_put_non_ignore_regs(si->cls, arch_regs);
+	be_abi_put_ignore_regs(si->birg->abi, si->cls, abi_regs);
 
 	bitset_andnot(arch_regs, abi_regs);
 	arch_n_regs = bitset_popcnt(arch_regs);
@@ -4425,7 +4415,6 @@ be_spill_remat(be_irg_t *birg, const arch_register_class_t *cls)
 	if(opt_verify & VERIFY_DOMINANCE)
 		be_check_dominance(irg);
 
-	be_assure_dom_front(birg);
 	be_assure_liveness(birg);
 
 	obstack_init(&obst);