X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fana%2Firdom.c;h=7e6f712dc325ac8e9027dc87833866155d2180f2;hb=ac384815dc66fb1846385515a19404ad89b897de;hp=4d5ef26af09ea58801470a3ebb40f092bfe3d378;hpb=54c484d60ebde08dd8decd9954412a622a4681f0;p=libfirm

diff --git a/ir/ana/irdom.c b/ir/ana/irdom.c
index 4d5ef26af..7e6f712dc 100644
--- a/ir/ana/irdom.c
+++ b/ir/ana/irdom.c
@@ -33,7 +33,7 @@
 #include "xmalloc.h"
 #include "irgwalk.h"
 #include "irdom_t.h"
-#include "irgraph_t.h"   /* To access state field. */
+#include "irgraph_t.h"
 #include "irnode_t.h"
 #include "ircons_t.h"
 #include "array_t.h"
@@ -47,16 +47,19 @@
 /** Accessing the dominator and post dominator data structures       **/
 /*--------------------------------------------------------------------*/
 
-ir_node *get_Block_idom(const ir_node *bl) {
+ir_node *get_Block_idom(const ir_node *bl)
+{
 	assert(is_Block(bl));
 	if (get_Block_dom_depth(bl) == -1) {
 		/* This block is not reachable from Start */
-		return new_Bad();
+		ir_graph *irg = get_irn_irg(bl);
+		return new_r_Bad(irg, mode_BB);
 	}
 	return get_dom_info(bl)->idom;
 }
 
-void set_Block_idom(ir_node *bl, ir_node *n) {
+void set_Block_idom(ir_node *bl, ir_node *n)
+{
 	ir_dom_info *bli = get_dom_info(bl);
 
 	assert(is_Block(bl));
@@ -68,7 +71,7 @@ void set_Block_idom(ir_node *bl, ir_node *n) {
 	 * If we don't set the root of the dominator tree
 	 * Append bl to the dominates queue of n.
 	 */
-	if(n != NULL) {
+	if (n != NULL) {
 		ir_dom_info *ni = get_dom_info(n);
 
 		bli->next = ni->first;
@@ -76,16 +79,19 @@ void set_Block_idom(ir_node *bl, ir_node *n) {
 	}
 }
 
-ir_node *get_Block_ipostdom(const ir_node *bl) {
+ir_node *get_Block_ipostdom(const ir_node *bl)
+{
 	assert(is_Block(bl));
 	if (get_Block_postdom_depth(bl) == -1) {
 		/* This block is not reachable from Start */
-		return new_Bad();
+		ir_graph *irg = get_irn_irg(bl);
+		return new_r_Bad(irg, mode_BB);
 	}
 	return get_pdom_info(bl)->idom;
 }
 
-void set_Block_ipostdom(ir_node *bl, ir_node *n) {
+void set_Block_ipostdom(ir_node *bl, ir_node *n)
+{
 	ir_dom_info *bli = get_pdom_info(bl);
 
 	assert(is_Block(bl));
@@ -97,7 +103,7 @@ void set_Block_ipostdom(ir_node *bl, ir_node *n) {
 	 * If we don't set the root of the post dominator tree
 	 * Append bl to the post dominates queue of n.
 	 */
-	if(n != NULL) {
+	if (n != NULL) {
 		ir_dom_info *ni = get_pdom_info(n);
 
 		bli->next = ni->first;
@@ -105,69 +111,82 @@ void set_Block_ipostdom(ir_node *bl, ir_node *n) {
 	}
 }
 
-int get_Block_dom_pre_num(const ir_node *bl) {
+int get_Block_dom_pre_num(const ir_node *bl)
+{
 	assert(is_Block(bl));
 	return get_dom_info(bl)->pre_num;
 }
 
-void set_Block_dom_pre_num(ir_node *bl, int num) {
+void set_Block_dom_pre_num(ir_node *bl, int num)
+{
 	assert(is_Block(bl));
 	get_dom_info(bl)->pre_num = num;
 }
 
-int get_Block_dom_depth(const ir_node *bl) {
+int get_Block_dom_depth(const ir_node *bl)
+{
 	assert(is_Block(bl));
 	return get_dom_info(bl)->dom_depth;
 }
 
-void set_Block_dom_depth(ir_node *bl, int depth) {
+void set_Block_dom_depth(ir_node *bl, int depth)
+{
 	assert(is_Block(bl));
 	get_dom_info(bl)->dom_depth = depth;
 }
 
 
-int get_Block_postdom_pre_num(const ir_node *bl) {
+int get_Block_postdom_pre_num(const ir_node *bl)
+{
 	assert(is_Block(bl));
 	return get_pdom_info(bl)->pre_num;
 }
 
-void set_Block_postdom_pre_num(ir_node *bl, int num) {
+void set_Block_postdom_pre_num(ir_node *bl, int num)
+{
 	assert(is_Block(bl));
 	get_pdom_info(bl)->pre_num = num;
 }
 
-int get_Block_postdom_depth(const ir_node *bl) {
+int get_Block_postdom_depth(const ir_node *bl)
+{
 	assert(is_Block(bl));
 	return get_pdom_info(bl)->dom_depth;
 }
 
-void set_Block_postdom_depth(ir_node *bl, int depth) {
+void set_Block_postdom_depth(ir_node *bl, int depth)
+{
 	assert(is_Block(bl));
 	get_pdom_info(bl)->dom_depth = depth;
 }
 
-unsigned get_Block_dom_tree_pre_num(const ir_node *bl) {
+unsigned get_Block_dom_tree_pre_num(const ir_node *bl)
+{
 	assert(is_Block(bl));
 	return get_dom_info(bl)->tree_pre_num;
 }
 
-unsigned get_Block_dom_max_subtree_pre_num(const ir_node *bl) {
+unsigned get_Block_dom_max_subtree_pre_num(const ir_node *bl)
+{
 	assert(is_Block(bl));
 	return get_dom_info(bl)->max_subtree_pre_num;
 }
 
-unsigned get_Block_pdom_tree_pre_num(const ir_node *bl) {
+unsigned get_Block_pdom_tree_pre_num(const ir_node *bl)
+{
 	assert(is_Block(bl));
 	return get_pdom_info(bl)->tree_pre_num;
 }
 
-unsigned get_Block_pdom_max_subtree_pre_num(const ir_node *bl) {
+unsigned get_Block_pdom_max_subtree_pre_num(const ir_node *bl)
+{
 	assert(is_Block(bl));
 	return get_pdom_info(bl)->max_subtree_pre_num;
 }
 
 /* Check, if a block dominates another block. */
-int block_dominates(const ir_node *a, const ir_node *b) {
+int block_dominates(const ir_node *a, const ir_node *b)
+{
 	const ir_dom_info *ai, *bi;
 
 	if (is_Block(a) && is_Block(b)) {
@@ -181,12 +200,14 @@ int block_dominates(const ir_node *a, const ir_node *b) {
 }
 
 /* Check, if a block strictly dominates another block. */
-int block_strictly_dominates(const ir_node *a, const ir_node *b) {
+int block_strictly_dominates(const ir_node *a, const ir_node *b)
+{
 	return (a != b) && block_dominates(a, b);
 }
 
 /* Returns the smallest common dominator block of two nodes. */
-ir_node *node_smallest_common_dominator(ir_node *a, ir_node *b) {
+ir_node *node_smallest_common_dominator(ir_node *a, ir_node *b)
+{
 	ir_node *bl_a   = is_Block(a) ? a : get_nodes_block(a);
 	ir_node *bl_b   = is_Block(b) ? b : get_nodes_block(b);
 	ir_node *dom_bl = NULL;
@@ -213,7 +234,8 @@ ir_node *node_smallest_common_dominator(ir_node *a, ir_node *b) {
 }
 
 /* Returns the smallest common dominator block of all users of a node. */
-ir_node *node_users_smallest_common_dominator(ir_node *irn, int handle_phi) {
+ir_node *node_users_smallest_common_dominator(ir_node *irn, int handle_phi)
+{
 	int n, j, i = 0, success;
 	ir_node **user_blocks, *dom_bl;
 	const ir_edge_t *edge;
@@ -270,20 +292,23 @@ ir_node *node_users_smallest_common_dominator(ir_node *irn, int handle_phi) {
 
 
 /* Get the first node in the list of nodes dominated by a given block. */
-ir_node *get_Block_dominated_first(const ir_node *bl) {
+ir_node *get_Block_dominated_first(const ir_node *bl)
+{
 	assert(is_Block(bl));
 	return get_dom_info(bl)->first;
 }
 
 /* Get the next node in a list of nodes which are dominated by some
  * other node. */
-ir_node *get_Block_dominated_next(const ir_node *bl) {
+ir_node *get_Block_dominated_next(const ir_node *bl)
+{
 	assert(is_Block(bl));
 	return get_dom_info(bl)->next;
 }
 
 /* Check, if a block post dominates another block. */
-int block_postdominates(const ir_node *a, const ir_node *b) {
+int block_postdominates(const ir_node *a, const ir_node *b)
+{
 	const ir_dom_info *ai, *bi;
 
 	if (is_Block(a) && is_Block(b)) {
@@ -297,20 +322,23 @@ int block_postdominates(const ir_node *a, const ir_node *b) {
 }
 
 /* Check, if a block strictly dominates another block. */
-int block_strictly_postdominates(const ir_node *a, const ir_node *b) {
+int block_strictly_postdominates(const ir_node *a, const ir_node *b)
+{
 	return (a != b) && block_postdominates(a, b);
 }
 
 
 /* Get the first node in the list of nodes post dominated by a given block. */
-ir_node *get_Block_postdominated_first(const ir_node *bl) {
+ir_node *get_Block_postdominated_first(const ir_node *bl)
+{
 	assert(is_Block(bl));
 	return get_pdom_info(bl)->first;
 }
 
 /* Get the next node in a list of nodes which are post dominated by some
  * other node. */
-ir_node *get_Block_postdominated_next(const ir_node *bl) {
+ir_node *get_Block_postdominated_next(const ir_node *bl)
+{
 	assert(is_Block(bl));
 	return get_pdom_info(bl)->next;
 }
@@ -321,14 +349,14 @@ void dom_tree_walk(ir_node *bl, irg_walk_func *pre,
 {
 	ir_node *p;
 
-	if(pre)
+	if (pre)
 		pre(bl, env);
 
 	dominates_for_each(bl, p) {
 		dom_tree_walk(p, pre, post, env);
 	}
 
-	if(post)
+	if (post)
 		post(bl, env);
 }
 
@@ -338,14 +366,14 @@ void postdom_tree_walk(ir_node *bl, irg_walk_func *pre,
 {
 	ir_node *p;
 
-	if(pre)
+	if (pre)
 		pre(bl, env);
 
 	postdominates_for_each(bl, p) {
 		postdom_tree_walk(p, pre, post, env);
 	}
 
-	if(post)
+	if (post)
 		post(bl, env);
 }
 
@@ -356,7 +384,7 @@ void dom_tree_walk_irg(ir_graph *irg, irg_walk_func *pre,
 	/* The root of the dominator tree should be the Start block. */
 	ir_node *root = get_irg_start_block(irg);
 
-  assert(irg->dom_state == dom_consistent
+	assert(is_irg_state(irg, IR_GRAPH_STATE_CONSISTENT_DOMINANCE)
 			&& "The dominators of the irg must be consistent");
 	assert(root && "The start block of the graph is NULL?");
 	assert(get_dom_info(root)->idom == NULL
@@ -368,10 +396,10 @@ void dom_tree_walk_irg(ir_graph *irg, irg_walk_func *pre,
 void postdom_tree_walk_irg(ir_graph *irg, irg_walk_func *pre,
 		irg_walk_func *post, void *env)
 {
-	/* The root of the dominator tree should be the End block. */
+	/* The root of the post dominator tree should be the End block. */
 	ir_node *root = get_irg_end_block(irg);
 
-	assert(irg->pdom_state == dom_consistent
+	assert(is_irg_state(irg, IR_GRAPH_STATE_CONSISTENT_POSTDOMINANCE)
 			&& "The dominators of the irg must be consistent");
 	assert(root && "The end block of the graph is NULL?");
 	assert(get_pdom_info(root)->idom == NULL
@@ -382,7 +410,7 @@ void postdom_tree_walk_irg(ir_graph *irg, irg_walk_func *pre,
 
 static void assign_tree_dom_pre_order(ir_node *bl, void *data)
 {
-	unsigned *num = data;
+	unsigned *num = (unsigned*) data;
 	ir_dom_info *bi = get_dom_info(bl);
 
 	bi->tree_pre_num = (*num)++;
@@ -396,7 +424,7 @@ static void assign_tree_dom_pre_order_max(ir_node *bl, void *data)
 	unsigned children = 0;
 	(void) data;
 
-	for(p = bi->first; p; p = get_dom_info(p)->next) {
+	for (p = bi->first; p; p = get_dom_info(p)->next) {
 		unsigned max_p = get_dom_info(p)->max_subtree_pre_num;
 		max = max > max_p ? max : max_p;
 		children++;
@@ -408,7 +436,7 @@ static void assign_tree_dom_pre_order_max(ir_node *bl, void *data)
 
 static void assign_tree_postdom_pre_order(ir_node *bl, void *data)
 {
-	unsigned *num = data;
+	unsigned *num = (unsigned*) data;
 	ir_dom_info *bi = get_pdom_info(bl);
 
 	bi->tree_pre_num = (*num)++;
@@ -422,7 +450,7 @@ static void assign_tree_postdom_pre_order_max(ir_node *bl, void *data)
 	unsigned children = 0;
 	(void) data;
 
-	for(p = bi->first; p; p = get_pdom_info(p)->next) {
+	for (p = bi->first; p; p = get_pdom_info(p)->next) {
 		unsigned max_p = get_pdom_info(p)->max_subtree_pre_num;
 		max = max > max_p ? max : max_p;
 		children++;
@@ -439,8 +467,10 @@ static void assign_tree_postdom_pre_order_max(ir_node *bl, void *data)
 /**
  * count the number of blocks and clears the post dominance info
  */
-static void count_and_init_blocks_pdom(ir_node *bl, void *env) {
+static void count_and_init_blocks_pdom(ir_node *bl, void *env)
+{
 	int *n_blocks = (int *) env;
+
 	(*n_blocks) ++;
 
 	memset(get_pdom_info(bl), 0, sizeof(ir_dom_info));
@@ -479,12 +509,13 @@ typedef struct {
  * Start block misses control dead blocks.
  */
 static void init_tmp_dom_info(ir_node *bl, tmp_dom_info *parent,
-                              tmp_dom_info *tdi_list, int *used, int n_blocks) {
+                              tmp_dom_info *tdi_list, int *used, int n_blocks)
+{
 	tmp_dom_info *tdi;
 	int i;
 
 	assert(is_Block(bl));
-	if (get_irg_block_visited(current_ir_graph) == get_Block_block_visited(bl))
+	if (Block_block_visited(bl))
 	  return;
 	mark_Block_block_visited(bl);
 	set_Block_dom_pre_num(bl, *used);
@@ -517,7 +548,8 @@ static void init_tmp_dom_info(ir_node *bl, tmp_dom_info *parent,
  * End block misses blocks in endless loops.
  */
 static void init_tmp_pdom_info(ir_node *bl, tmp_dom_info *parent,
-                               tmp_dom_info *tdi_list, int* used, int n_blocks) {
+                               tmp_dom_info *tdi_list, int* used, int n_blocks)
+{
 	tmp_dom_info *tdi;
 	int i;
 
@@ -564,7 +596,8 @@ static void init_tmp_pdom_info(ir_node *bl, tmp_dom_info *parent,
 	}
 }
 
-static void dom_compress(tmp_dom_info *v) {
+static void dom_compress(tmp_dom_info *v)
+{
 	assert (v->ancestor);
 	if (v->ancestor->ancestor) {
 		dom_compress (v->ancestor);
@@ -579,22 +612,26 @@ static void dom_compress(tmp_dom_info *v) {
  * if V is a root, return v, else return the vertex u, not being the
  * root, with minimum u->semi on the path from v to its root.
  */
-inline static tmp_dom_info *dom_eval(tmp_dom_info *v) {
+inline static tmp_dom_info *dom_eval(tmp_dom_info *v)
+{
 	if (!v->ancestor) return v;
 	dom_compress (v);
 	return v->label;
 }
 
 /** make V W's ancestor */
-inline static void dom_link(tmp_dom_info *v, tmp_dom_info *w) {
+inline static void dom_link(tmp_dom_info *v, tmp_dom_info *w)
+{
 	w->ancestor = v;
 }
 
 /**
  * Walker: count the number of blocks and clears the dominance info
  */
-static void count_and_init_blocks_dom(ir_node *bl, void *env) {
+static void count_and_init_blocks_dom(ir_node *bl, void *env)
+{
 	int *n_blocks = (int *) env;
+
 	(*n_blocks) ++;
 
 	memset(get_dom_info(bl), 0, sizeof(ir_dom_info));
@@ -603,66 +640,9 @@ static void count_and_init_blocks_dom(ir_node *bl, void *env) {
 	set_Block_dom_depth(bl, -1);
 }
 
-/**
- * Initialize the dominance/postdominance construction:
- *
- * - count the number of blocks
- * - clear the dominance info
- * - remove Block-keepalives of live blocks to reduce
- *   the number of "phantom" block edges
- *
- * @param irg  the graph
- * @param pre  a walker function that will be called for every block in the graph
- */
-static int init_construction(ir_graph *irg, irg_walk_func *pre) {
-	ir_graph *rem = current_ir_graph;
-	ir_node *end;
-	int arity;
-	int n_blocks = 0;
-
-	current_ir_graph = irg;
-
-	/* this visits only the reachable blocks */
-	irg_block_walk(get_irg_end_block(irg), pre, NULL, &n_blocks);
-
-	/* now visit the unreachable (from End) Blocks and remove unnecessary keep-alives */
-	end   = get_irg_end(irg);
-	arity = get_End_n_keepalives(end);
-	if (arity) {    /* we have keep-alives */
-		ir_node **in;
-		int i, j;
-
-		NEW_ARR_A(ir_node *, in, arity);
-		for (i = j = 0; i < arity; i++) {
-			ir_node *pred = get_End_keepalive(end, i);
-
-			if (!is_Block(pred)) {
-				pred = get_nodes_block(pred);
-				if (!is_Block(pred)) {
-					/* a node which has a bad block input: kill it */
-					continue;
-				}
-			}
-			dec_irg_block_visited(irg);
-			irg_block_walk(pred, pre, NULL, &n_blocks);
-			in[j++] = pred;
-		}
-		if (j != arity) {
-			/* we kill some keep-alives */
-			set_End_keepalives(end, j, in);
-			set_irg_outs_inconsistent(irg);
-		}
-	}
-
-	current_ir_graph = rem;
-	return n_blocks;
-}
-
-
-/* Computes the dominator trees.  Sets a flag in irg to "dom_consistent".
-   If the control flow of the graph is changed this flag must be set to
-   "dom_inconsistent".  */
-void compute_doms(ir_graph *irg) {
+/* Computes the dominator trees. */
+void compute_doms(ir_graph *irg)
+{
 	ir_graph *rem = current_ir_graph;
 	int n_blocks, used, i, j;
 	tmp_dom_info *tdi_list;   /* Ein Golf? */
@@ -671,10 +651,10 @@ void compute_doms(ir_graph *irg) {
 
 	/* Update graph state */
 	assert(get_irg_phase_state(irg) != phase_building);
-	irg->dom_state = dom_consistent;
 
 	/* Count the number of blocks in the graph. */
-	n_blocks = init_construction(irg, count_and_init_blocks_dom);
+	n_blocks = 0;
+	irg_block_walk_graph(irg, count_and_init_blocks_dom, NULL, &n_blocks);
 
 	/* Memory for temporary information. */
 	tdi_list = XMALLOCNZ(tmp_dom_info, n_blocks);
@@ -695,25 +675,28 @@ void compute_doms(ir_graph *irg) {
 
 
 	for (i = n_blocks-1; i > 0; i--) {  /* Don't iterate the root, it's done. */
-		int irn_arity;
-		tmp_dom_info *w = &tdi_list[i];
+		tmp_dom_info *w     = &tdi_list[i];
+		ir_node      *block = w->block;
 		tmp_dom_info *v;
+		int           irn_arity;
 
 		/* Step 2 */
-		irn_arity = get_irn_arity(w->block);
+		irn_arity = get_irn_arity(block);
 		for (j = 0; j < irn_arity;  j++) {
-			ir_node *pred = get_Block_cfgpred_block(w->block, j);
+			ir_node *pred       = get_Block_cfgpred(block, j);
+			ir_node *pred_block = get_nodes_block(pred);
 			tmp_dom_info *u;
 
-			if (is_Bad(pred) || (get_Block_dom_pre_num (pred) == -1))
-				continue;	/* control-dead */
+			if (is_Bad(pred) || (get_Block_dom_pre_num (pred_block) == -1))
+				continue;    /* unreachable */
 
-			u = dom_eval (&tdi_list[get_Block_dom_pre_num(pred)]);
-			if (u->semi < w->semi) w->semi = u->semi;
+			u = dom_eval (&tdi_list[get_Block_dom_pre_num(pred_block)]);
+			if (u->semi < w->semi)
+				w->semi = u->semi;
 		}
 
 		/* handle keep-alives if we are at the end block */
-		if (w->block == get_irg_end_block(irg)) {
+		if (block == get_irg_end_block(irg)) {
 			ir_node *end = get_irg_end(irg);
 
 			irn_arity = get_irn_arity(end);
@@ -721,11 +704,12 @@ void compute_doms(ir_graph *irg) {
 				ir_node *pred = get_irn_n(end, j);
 				tmp_dom_info *u;
 
-				if (is_no_Block(pred) || get_Block_dom_pre_num(pred) == -1)
-					continue;	/* control-dead */
+				if (!is_Block(pred) || get_Block_dom_pre_num(pred) == -1)
+					continue;   /* unreachable */
 
 				u = dom_eval (&tdi_list[get_Block_dom_pre_num(pred)]);
-				if (u->semi < w->semi) w->semi = u->semi;
+				if (u->semi < w->semi)
+					w->semi = u->semi;
 			}
 		}
 
@@ -762,7 +746,8 @@ void compute_doms(ir_graph *irg) {
 		if (! w->dom)
 			continue; /* control dead */
 
-		if (w->dom != w->semi) w->dom = w->dom->dom;
+		if (w->dom != w->semi)
+			w->dom = w->dom->dom;
 		set_Block_idom(w->block, w->dom->block);
 
 		/* blocks dominated by dead one's are still dead */
@@ -778,30 +763,32 @@ void compute_doms(ir_graph *irg) {
 	/* Do a walk over the tree and assign the tree pre orders. */
 	{
 		unsigned tree_pre_order = 0;
-		dom_tree_walk_irg(irg, assign_tree_dom_pre_order,
-			assign_tree_dom_pre_order_max, &tree_pre_order);
+		dom_tree_walk(get_irg_start_block(irg), assign_tree_dom_pre_order,
+		                  assign_tree_dom_pre_order_max, &tree_pre_order);
 	}
 	current_ir_graph = rem;
+	set_irg_state(irg, IR_GRAPH_STATE_CONSISTENT_DOMINANCE);
 }
 
-void assure_doms(ir_graph *irg) {
-	if (get_irg_dom_state(irg) != dom_consistent)
+void assure_doms(ir_graph *irg)
+{
+	if (! is_irg_state(irg, IR_GRAPH_STATE_CONSISTENT_DOMINANCE))
 		compute_doms(irg);
 }
 
-void free_dom(ir_graph *irg) {
+void free_dom(ir_graph *irg)
+{
 	/* Update graph state */
 	assert(get_irg_phase_state(irg) != phase_building);
-	irg->dom_state = dom_none;
+	clear_irg_state(irg, IR_GRAPH_STATE_CONSISTENT_DOMINANCE);
 
 	/* With the implementation right now there is nothing to free,
 	   but better call it anyways... */
 }
 
-/* Computes the post dominator trees.  Sets a flag in irg to "dom_consistent".
-   If the control flow of the graph is changed this flag must be set to
-   "dom_inconsistent".  */
-void compute_postdoms(ir_graph *irg) {
+/* Computes the post dominator trees. */
+void compute_postdoms(ir_graph *irg)
+{
 	ir_graph *rem = current_ir_graph;
 	int n_blocks, used, i, j;
 	tmp_dom_info *tdi_list;
@@ -810,10 +797,10 @@ void compute_postdoms(ir_graph *irg) {
 
 	/* Update graph state */
 	assert(get_irg_phase_state(irg) != phase_building);
-	irg->pdom_state = dom_consistent;
 
 	/* Count the number of blocks in the graph. */
-	n_blocks = init_construction(irg, count_and_init_blocks_pdom);
+	n_blocks = 0;
+	irg_block_walk_graph(irg, count_and_init_blocks_pdom, NULL, &n_blocks);
 
 	/* Memory for temporary information. */
 	tdi_list = XMALLOCNZ(tmp_dom_info, n_blocks);
@@ -844,7 +831,7 @@ void compute_postdoms(ir_graph *irg) {
 			tmp_dom_info *u;
 
 			if (get_Block_postdom_pre_num (succ) == -1)
-				continue;	/* endless-loop */
+				continue;    /* endless-loop */
 
 			u = dom_eval (&tdi_list[get_Block_postdom_pre_num(succ)]);
 			if (u->semi < w->semi) w->semi = u->semi;
@@ -889,21 +876,24 @@ void compute_postdoms(ir_graph *irg) {
 	/* Do a walk over the tree and assign the tree pre orders. */
 	{
 		unsigned tree_pre_order = 0;
-		postdom_tree_walk_irg(irg, assign_tree_postdom_pre_order,
+		postdom_tree_walk(get_irg_end_block(irg), assign_tree_postdom_pre_order,
 			assign_tree_postdom_pre_order_max, &tree_pre_order);
 	}
 	current_ir_graph = rem;
+	set_irg_state(irg, IR_GRAPH_STATE_CONSISTENT_POSTDOMINANCE);
 }
 
-void assure_postdoms(ir_graph *irg) {
-	if (get_irg_postdom_state(irg) != dom_consistent)
+void assure_postdoms(ir_graph *irg)
+{
+	if (! is_irg_state(irg, IR_GRAPH_STATE_CONSISTENT_POSTDOMINANCE))
 		compute_postdoms(irg);
 }
 
-void free_postdom(ir_graph *irg) {
+void free_postdom(ir_graph *irg)
+{
 	/* Update graph state */
 	assert(get_irg_phase_state(irg) != phase_building);
-	irg->pdom_state = dom_none;
+	clear_irg_state(irg, IR_GRAPH_STATE_CONSISTENT_POSTDOMINANCE);
 
 	/* With the implementation right now there is nothing to free,
 	   but better call it anyways... */