X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fana%2Firdom.c;h=c25953667274b950015cf263ebcaca17639a744b;hb=8d40867b11db9064f88bc3fd928e034058873631;hp=312e1dbc8c83309ca4d630ec81899d7cacdaaf68;hpb=f8cc15664f571aa7ef89d6f6bc8d5bd2b8ca7d53;p=libfirm

diff --git a/ir/ana/irdom.c b/ir/ana/irdom.c
index 312e1dbc8..c25953667 100644
--- a/ir/ana/irdom.c
+++ b/ir/ana/irdom.c
@@ -42,10 +42,6 @@
 #define get_dom_info(bl)  (&(bl)->attr.block.dom)
 #define get_pdom_info(bl) (&(bl)->attr.block.pdom)
 
-/*--------------------------------------------------------------------*/
-/** Accessing the dominator and post dominator data structures       **/
-/*--------------------------------------------------------------------*/
-
 ir_node *get_Block_idom(const ir_node *bl)
 {
 	assert(is_Block(bl));
@@ -183,7 +179,6 @@ unsigned get_Block_pdom_max_subtree_pre_num(const ir_node *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)
 {
 	const ir_dom_info *ai, *bi;
@@ -198,13 +193,11 @@ int block_dominates(const ir_node *a, const ir_node *b)
 	return 0;
 }
 
-/* Check, if a block strictly dominates another block. */
 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 *bl_a   = is_Block(a) ? a : get_nodes_block(a);
@@ -232,64 +225,6 @@ ir_node *node_smallest_common_dominator(ir_node *a, ir_node *b)
 	return dom_bl;
 }
 
-/* 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)
-{
-	int n, j, i = 0, success;
-	ir_node **user_blocks, *dom_bl;
-	const ir_edge_t *edge;
-
-	assert(! is_Block(irn) && "WRONG USAGE of node_users_smallest_common_dominator");
-	assert(edges_activated(get_irn_irg(irn)) && "need edges activated");
-
-	n = get_irn_n_edges(irn);
-
-	/* get array to hold all block of the node users */
-	NEW_ARR_A(ir_node *, user_blocks, n);
-	foreach_out_edge(irn, edge) {
-		ir_node *src = get_edge_src_irn(edge);
-
-		if (is_Phi(src) && handle_phi) {
-			/* get the corresponding cfg predecessor block if phi handling requested */
-			j  = get_edge_src_pos(edge);
-			assert(j >= 0 && "kaputt");
-			user_blocks[i++] = get_Block_cfgpred_block(get_nodes_block(src), j);
-		}
-		else
-			user_blocks[i++] = is_Block(src) ? src : get_nodes_block(src);
-	}
-
-	assert(i == n && "get_irn_n_edges probably broken");
-
-	/* in case of only one user: return the block of the user */
-	if (n == 1)
-		return user_blocks[0];
-
-	i = 0;
-	/* search the smallest block dominating all user blocks */
-	do {
-		dom_bl  = node_smallest_common_dominator(user_blocks[i], user_blocks[i + 1]);
-		success = 1;
-
-		/* check if this block dominates all remaining blocks as well */
-		for (j = i + 2; j < n; j++) {
-			if (! block_dominates(dom_bl, user_blocks[j]))
-				success = 0;
-		}
-
-		if (success)
-			break;
-
-		/* inherit the dominator block of the first (i + 1) users */
-		user_blocks[++i] = dom_bl;
-	} while (i < n - 1);
-
-	assert(success && "no block found dominating all users");
-
-	return dom_bl;
-}
-
-
 /* Get the first node in the list of nodes dominated by a given block. */
 ir_node *get_Block_dominated_first(const ir_node *bl)
 {
@@ -297,15 +232,12 @@ ir_node *get_Block_dominated_first(const ir_node *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)
 {
 	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)
 {
 	const ir_dom_info *ai, *bi;
@@ -320,29 +252,23 @@ int block_postdominates(const ir_node *a, const ir_node *b)
 	return 0;
 }
 
-/* Check, if a block strictly dominates another block. */
 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)
 {
 	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)
 {
 	assert(is_Block(bl));
 	return get_pdom_info(bl)->next;
 }
 
-/* Visit all nodes in the dominator subtree of a given node. */
 void dom_tree_walk(ir_node *bl, irg_walk_func *pre,
 		irg_walk_func *post, void *env)
 {
@@ -359,7 +285,6 @@ void dom_tree_walk(ir_node *bl, irg_walk_func *pre,
 		post(bl, env);
 }
 
-/* Visit all nodes in the post dominator subtree of a given node. */
 void postdom_tree_walk(ir_node *bl, irg_walk_func *pre,
 		irg_walk_func *post, void *env)
 {
@@ -376,14 +301,13 @@ void postdom_tree_walk(ir_node *bl, irg_walk_func *pre,
 		post(bl, env);
 }
 
-/* Walk over the dominator tree of an irg starting at the root. */
 void dom_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 Start block. */
 	ir_node *root = get_irg_start_block(irg);
 
-	assert(is_irg_state(irg, IR_GRAPH_STATE_CONSISTENT_DOMINANCE)
+	assert(irg_has_properties(irg, IR_GRAPH_PROPERTY_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
@@ -391,14 +315,13 @@ void dom_tree_walk_irg(ir_graph *irg, irg_walk_func *pre,
 	dom_tree_walk(root, pre, post, env);
 }
 
-/* Walk over the post dominator tree of an irg starting at the root. */
 void postdom_tree_walk_irg(ir_graph *irg, irg_walk_func *pre,
 		irg_walk_func *post, void *env)
 {
 	/* The root of the post dominator tree should be the End block. */
 	ir_node *root = get_irg_end_block(irg);
 
-	assert(is_irg_state(irg, IR_GRAPH_STATE_CONSISTENT_POSTDOMINANCE)
+	assert(irg_has_properties(irg, IR_GRAPH_PROPERTY_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
@@ -459,10 +382,6 @@ static void assign_tree_postdom_pre_order_max(ir_node *bl, void *data)
 	assert(bi->max_subtree_pre_num >= bi->tree_pre_num);
 }
 
-/*--------------------------------------------------------------------*/
-/*  Building and Removing the dominator data structure                */
-/*--------------------------------------------------------------------*/
-
 /**
  * count the number of blocks and clears the post dominance info
  */
@@ -639,7 +558,6 @@ static void count_and_init_blocks_dom(ir_node *bl, void *env)
 	set_Block_dom_depth(bl, -1);
 }
 
-/* Computes the dominator trees. */
 void compute_doms(ir_graph *irg)
 {
 	ir_graph *rem = current_ir_graph;
@@ -649,7 +567,7 @@ void compute_doms(ir_graph *irg)
 	current_ir_graph = irg;
 
 	/* Update graph state */
-	assert(get_irg_phase_state(irg) != phase_building);
+	assert(!irg_is_constrained(irg, IR_GRAPH_CONSTRAINT_CONSTRUCTION));
 
 	/* Count the number of blocks in the graph. */
 	n_blocks = 0;
@@ -766,26 +684,26 @@ void compute_doms(ir_graph *irg)
 		                  assign_tree_dom_pre_order_max, &tree_pre_order);
 	}
 	current_ir_graph = rem;
-	set_irg_state(irg, IR_GRAPH_STATE_CONSISTENT_DOMINANCE);
+	add_irg_properties(irg, IR_GRAPH_PROPERTY_CONSISTENT_DOMINANCE);
 }
 
 void assure_doms(ir_graph *irg)
 {
-	if (! is_irg_state(irg, IR_GRAPH_STATE_CONSISTENT_DOMINANCE))
+	if (! irg_has_properties(irg, IR_GRAPH_PROPERTY_CONSISTENT_DOMINANCE))
 		compute_doms(irg);
 }
 
 void free_dom(ir_graph *irg)
 {
 	/* Update graph state */
-	assert(get_irg_phase_state(irg) != phase_building);
-	clear_irg_state(irg, IR_GRAPH_STATE_CONSISTENT_DOMINANCE);
+	clear_irg_properties(irg, IR_GRAPH_PROPERTY_CONSISTENT_DOMINANCE);
+
+	/* With the implementation right now there is nothing to free */
 
-	/* With the implementation right now there is nothing to free,
-	   but better call it anyways... */
+	/* free dominance frontiers */
+	ir_free_dominance_frontiers(irg);
 }
 
-/* Computes the post dominator trees. */
 void compute_postdoms(ir_graph *irg)
 {
 	ir_graph *rem = current_ir_graph;
@@ -795,7 +713,7 @@ void compute_postdoms(ir_graph *irg)
 	current_ir_graph = irg;
 
 	/* Update graph state */
-	assert(get_irg_phase_state(irg) != phase_building);
+	assert(!irg_is_constrained(irg, IR_GRAPH_CONSTRAINT_CONSTRUCTION));
 
 	/* Count the number of blocks in the graph. */
 	n_blocks = 0;
@@ -879,21 +797,17 @@ void compute_postdoms(ir_graph *irg)
 			assign_tree_postdom_pre_order_max, &tree_pre_order);
 	}
 	current_ir_graph = rem;
-	set_irg_state(irg, IR_GRAPH_STATE_CONSISTENT_POSTDOMINANCE);
+	add_irg_properties(irg, IR_GRAPH_PROPERTY_CONSISTENT_POSTDOMINANCE);
 }
 
 void assure_postdoms(ir_graph *irg)
 {
-	if (! is_irg_state(irg, IR_GRAPH_STATE_CONSISTENT_POSTDOMINANCE))
+	if (! irg_has_properties(irg, IR_GRAPH_PROPERTY_CONSISTENT_POSTDOMINANCE))
 		compute_postdoms(irg);
 }
 
 void free_postdom(ir_graph *irg)
 {
 	/* Update graph state */
-	assert(get_irg_phase_state(irg) != phase_building);
-	clear_irg_state(irg, IR_GRAPH_STATE_CONSISTENT_POSTDOMINANCE);
-
-	/* With the implementation right now there is nothing to free,
-	   but better call it anyways... */
+	clear_irg_properties(irg, IR_GRAPH_PROPERTY_CONSISTENT_POSTDOMINANCE);
 }