X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fana%2Firdom.c;h=ff572d8de4e40c5ebe8045d8baa87db802545de9;hb=2a018b8111bd0596816c1d00c38a0024857753f7;hp=1ba5b9d75cd6002d2e333d90b11a9c89bc6eb20a;hpb=81d4cf5aeab4d0c0bc2a5e7c461d58ee7a7522d6;p=libfirm

diff --git a/ir/ana/irdom.c b/ir/ana/irdom.c
index 1ba5b9d75..ff572d8de 100644
--- a/ir/ana/irdom.c
+++ b/ir/ana/irdom.c
@@ -24,20 +24,16 @@
  * @date      2.2002
  * @version   $Id$
  */
-#ifdef HAVE_CONFIG_H
 #include "config.h"
-#endif
 
-#ifdef HAVE_STRING_H
 #include <string.h>
-#endif
 
 #include "irouts.h"
 
 #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"
@@ -51,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);
 	}
 	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));
@@ -72,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;
@@ -80,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);
 	}
 	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));
@@ -101,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;
@@ -109,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)) {
@@ -185,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;
@@ -217,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;
@@ -274,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)) {
@@ -301,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;
 }
@@ -325,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);
 }
 
@@ -342,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);
 }
 
@@ -360,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(irg->dom_state == dom_consistent
 			&& "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
@@ -386,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)++;
@@ -400,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++;
@@ -412,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)++;
@@ -426,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++;
@@ -443,8 +467,13 @@ 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;
+
+	if (is_Block_dead(bl))
+		return;
+
 	(*n_blocks) ++;
 
 	memset(get_pdom_info(bl), 0, sizeof(ir_dom_info));
@@ -483,12 +512,16 @@ 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;
 
+	if (is_Block_dead(bl))
+		return;
+
 	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);
@@ -507,7 +540,11 @@ static void init_tmp_dom_info(ir_node *bl, tmp_dom_info *parent,
 	/* Iterate */
 	for (i = get_Block_n_cfg_outs_ka(bl) - 1; i >= 0; --i) {
 		ir_node *pred = get_Block_cfg_out_ka(bl, i);
-		assert(is_Block(pred));
+		/* can happen for half-optimized dead code (I've seen this in student
+		   projects */
+		if (!is_Block(pred))
+			continue;
+
 		init_tmp_dom_info(pred, tdi, tdi_list, used, n_blocks);
 	}
 }
@@ -517,10 +554,14 @@ 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;
 
+	if (is_Block_dead(bl))
+		return;
+
 	assert(is_Block(bl));
 	if (get_irg_block_visited(current_ir_graph) == get_Block_block_visited(bl))
 	  return;
@@ -564,7 +605,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 +621,28 @@ 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;
+	if (is_Block_dead(bl))
+		return;
+
 	(*n_blocks) ++;
 
 	memset(get_dom_info(bl), 0, sizeof(ir_dom_info));
@@ -603,65 +651,11 @@ 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)) {
-				if (Block_block_visited(pred))
-					continue;
-
-				/* we found an endless loop */
-				dec_irg_block_visited(irg);
-				irg_block_walk(pred, pre, NULL, &n_blocks);
-			}
-			in[j++] = pred;
-		}
-		if (j != arity) {
-			/* we kill some Block 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) {
+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? */
@@ -673,10 +667,11 @@ void compute_doms(ir_graph *irg) {
 	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 = xcalloc(n_blocks, sizeof(tdi_list[0]));
+	tdi_list = XMALLOCNZ(tmp_dom_info, n_blocks);
 
 	/* We need the out data structure. */
 	assure_irg_outs(irg);
@@ -705,7 +700,7 @@ void compute_doms(ir_graph *irg) {
 			tmp_dom_info *u;
 
 			if (is_Bad(pred) || (get_Block_dom_pre_num (pred) == -1))
-				continue;	/* control-dead */
+				continue;    /* control-dead */
 
 			u = dom_eval (&tdi_list[get_Block_dom_pre_num(pred)]);
 			if (u->semi < w->semi) w->semi = u->semi;
@@ -720,8 +715,8 @@ 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;   /* control-dead */
 
 				u = dom_eval (&tdi_list[get_Block_dom_pre_num(pred)]);
 				if (u->semi < w->semi) w->semi = u->semi;
@@ -783,12 +778,14 @@ void compute_doms(ir_graph *irg) {
 	current_ir_graph = rem;
 }
 
-void assure_doms(ir_graph *irg) {
+void assure_doms(ir_graph *irg)
+{
 	if (get_irg_dom_state(irg) != dom_consistent)
 		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;
@@ -800,7 +797,8 @@ void free_dom(ir_graph *irg) {
 /* 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) {
+void compute_postdoms(ir_graph *irg)
+{
 	ir_graph *rem = current_ir_graph;
 	int n_blocks, used, i, j;
 	tmp_dom_info *tdi_list;
@@ -812,10 +810,11 @@ void compute_postdoms(ir_graph *irg) {
 	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 = xcalloc(n_blocks, sizeof(tdi_list[0]));
+	tdi_list = XMALLOCNZ(tmp_dom_info, n_blocks);
 
 	/* We need the out data structure. */
 	assure_irg_outs(irg);
@@ -843,7 +842,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;
@@ -894,12 +893,14 @@ void compute_postdoms(ir_graph *irg) {
 	current_ir_graph = rem;
 }
 
-void assure_postdoms(ir_graph *irg) {
+void assure_postdoms(ir_graph *irg)
+{
 	if (get_irg_postdom_state(irg) != dom_consistent)
 		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;