X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fana%2Fircfscc.c;h=c643afad3fc3a68d5a17365b2946e124ab7a674e;hb=0cc8bfc863da28d3799e9eca1d1765d564b6e573;hp=a8219fa010a34cf005856207cbe15347f049d344;hpb=e7029027d04ede583d186f3f9dafedb8a885b249;p=libfirm

diff --git a/ir/ana/ircfscc.c b/ir/ana/ircfscc.c
index a8219fa01..c643afad3 100644
--- a/ir/ana/ircfscc.c
+++ b/ir/ana/ircfscc.c
@@ -163,6 +163,12 @@ static INLINE void init_stack(void) {
 	tos = 0;
 }
 
+static void finish_stack(void)
+{
+	DEL_ARR_F(stack);
+	stack = NULL;
+}
+
 /**
  * Push a node n onto the IR-node stack.
  */
@@ -252,32 +258,10 @@ static INLINE void pop_scc_unmark_visit(ir_node *n) {
  * The loop is allocated on the outermost_ir_graphs's obstack.
  */
 static ir_loop *new_loop(void) {
-	ir_loop *father, *son;
-
-	father = current_loop;
-
-	son = obstack_alloc(outermost_ir_graph->obst, sizeof(*son));
-	memset(son, 0, sizeof(*son));
-	son->kind     = k_ir_loop;
-	son->children = NEW_ARR_F(loop_element, 0);
-	son->n_nodes  = 0;
-	son->n_sons   = 0;
-	if (father) {
-		son->outer_loop = father;
-		add_loop_son(father, son);
-		son->depth = father->depth+1;
-		if (son->depth > max_loop_depth)
-			max_loop_depth = son->depth;
-	} else {  /* The root loop */
-		son->outer_loop = son;
-		son->depth      = 0;
-	}
-
-#ifdef DEBUG_libfirm
-	son->loop_nr = get_irp_new_node_nr();
-	son->link    = NULL;
-#endif
+	ir_loop *father = current_loop;
+	ir_loop *son    = alloc_loop(father, outermost_ir_graph->obst);
 
+	if (son->depth > max_loop_depth) max_loop_depth = son->depth;
 	current_loop = son;
 	return father;
 }
@@ -318,6 +302,11 @@ static INLINE void init_scc(ir_graph *irg, struct obstack *obst) {
 	irg_walk_graph(irg, init_node, NULL, obst);
 }
 
+static INLINE void finish_scc(void)
+{
+	finish_stack();
+}
+
 #ifdef INTERPROCEDURAL_VIEW
 /**
  * Initializes the scc algorithm for the interprocedural case.
@@ -357,20 +346,23 @@ static int is_outermost_StartBlock(ir_node *n) {
 static int is_head(ir_node *n, ir_node *root) {
 	int i, arity;
 	int some_outof_loop = 0, some_in_loop = 0;
+	(void) root;
 
 	assert(is_Block(n));
 
 	if (!is_outermost_StartBlock(n)) {
-		arity = get_irn_arity(n);
+		arity = get_Block_n_cfgpreds(n);
 		for (i = 0; i < arity; i++) {
-			ir_node *pred = get_nodes_block(skip_Proj(get_irn_n(n, i)));
-			if (is_backedge(n, i)) continue;
+			ir_node *pred = get_Block_cfgpred_block(n, i);
+			/* ignore Bad control flow: it cannot happen */
+			if (is_Bad(pred))
+				continue;
+			if (is_backedge(n, i))
+				continue;
 			if (!irn_is_in_stack(pred)) {
 				some_outof_loop = 1;
 			} else {
-				if (get_irn_uplink(pred) < get_irn_uplink(root)) {
-					assert(get_irn_uplink(pred) >= get_irn_uplink(root));
-				}
+				assert(get_irn_uplink(pred) >= get_irn_uplink(root));
 				some_in_loop = 1;
 			}
 		}
@@ -381,7 +373,7 @@ static int is_head(ir_node *n, ir_node *root) {
 
 /**
  * Returns non-zero if n is possible loop head of an endless loop.
- * I.e., it is a Block, Phi or Filter node and has only predecessors
+ * I.e., it is a Block node and has only predecessors
  * within the loop.
  *
  * @param n     the block node to check
@@ -389,28 +381,29 @@ static int is_head(ir_node *n, ir_node *root) {
  */
 static int is_endless_head(ir_node *n, ir_node *root) {
 	int i, arity;
-	int some_outof_loop = 0, some_in_loop = 0;
+	int none_outof_loop = 1, some_in_loop = 0;
+	(void) root;
 
 	assert(is_Block(n));
 	/* Test for legal loop header: Block, Phi, ... */
 	if (!is_outermost_StartBlock(n)) {
-		arity = get_irn_arity(n);
+		arity = get_Block_n_cfgpreds(n);
 		for (i = 0; i < arity; i++) {
-			ir_node *pred = get_nodes_block(skip_Proj(get_irn_n(n, i)));
-			assert(pred);
+			ir_node *pred = get_Block_cfgpred_block(n, i);
+			/* ignore Bad control flow: it cannot happen */
+			if (is_Bad(pred))
+				continue;
 			if (is_backedge(n, i))
 				continue;
 			if (!irn_is_in_stack(pred)) {
-				some_outof_loop = 1; //printf(" some out of loop ");
+				none_outof_loop = 0;
 			} else {
-				if (get_irn_uplink(pred) < get_irn_uplink(root)) {
-					assert(get_irn_uplink(pred) >= get_irn_uplink(root));
-				}
+				assert(get_irn_uplink(pred) >= get_irn_uplink(root));
 				some_in_loop = 1;
 			}
 		}
 	}
-	return !some_outof_loop && some_in_loop;
+	return none_outof_loop && some_in_loop;
 }
 
 /**
@@ -421,9 +414,12 @@ static int smallest_dfn_pred(ir_node *n, int limit) {
 	int i, index = -2, min = -1;
 
 	if (!is_outermost_StartBlock(n)) {
-		int arity = get_irn_arity(n);
+		int arity = get_Block_n_cfgpreds(n);
 		for (i = 0; i < arity; i++) {
-			ir_node *pred = get_nodes_block(skip_Proj(get_irn_n(n, i)));
+			ir_node *pred = get_Block_cfgpred_block(n, i);
+			/* ignore Bad control flow: it cannot happen */
+			if (is_Bad(pred))
+				continue;
 			if (is_backedge(n, i) || !irn_is_in_stack(pred))
 				continue;
 			if (get_irn_dfn(pred) >= limit && (min == -1 || get_irn_dfn(pred) < min)) {
@@ -442,9 +438,12 @@ static int largest_dfn_pred(ir_node *n) {
 	int i, index = -2, max = -1;
 
 	if (!is_outermost_StartBlock(n)) {
-		int arity = get_irn_arity(n);
+		int arity = get_Block_n_cfgpreds(n);
 		for (i = 0; i < arity; i++) {
-			ir_node *pred = get_nodes_block(skip_Proj(get_irn_n(n, i)));
+			ir_node *pred = get_Block_cfgpred_block(n, i);
+			/* ignore Bad control flow: it cannot happen */
+			if (is_Bad(pred))
+				continue;
 			if (is_backedge(n, i) || !irn_is_in_stack(pred))
 				continue;
 			if (get_irn_dfn(pred) > max) {
@@ -502,10 +501,10 @@ static ir_node *find_tail(ir_node *n) {
 			/* A dead loop not reachable from Start. */
 			for (i = tos-2; i >= 0; --i) {
 				m = stack[i];
-				if (is_endless_head (m, n)) {
+				if (is_endless_head(m, n)) {
 					res_index = smallest_dfn_pred (m, get_irn_dfn(m) + 1);
 					if (res_index == -2)  /* no smallest dfn pred found. */
-						res_index = largest_dfn_pred (m);
+						res_index = largest_dfn_pred(m);
 					break;
 				}
 				if (m == n) break;   /* It's not an unreachable loop, either. */
@@ -516,7 +515,7 @@ static ir_node *find_tail(ir_node *n) {
 	assert(res_index > -2);
 
 	set_backedge(m, res_index);
-	return is_outermost_StartBlock(n) ? NULL : get_nodes_block(skip_Proj(get_irn_n(m, res_index)));
+	return is_outermost_StartBlock(n) ? NULL : get_Block_cfgpred_block(m, res_index);
 }
 
 /**
@@ -538,8 +537,7 @@ static void cfscc(ir_node *n) {
 
 	assert(is_Block(n));
 
-	if (irn_visited(n)) return;
-	mark_irn_visited(n);
+	if (irn_visited_else_mark(n)) return;
 
 	/* Initialize the node */
 	set_irn_dfn(n, current_dfn);      /* Depth first number for this node */
@@ -549,14 +547,17 @@ static void cfscc(ir_node *n) {
 	push(n);
 
 	if (!is_outermost_StartBlock(n)) {
-		int arity = get_irn_arity(n);
+		int arity = get_Block_n_cfgpreds(n);
 
 		for (i = 0; i < arity; i++) {
 			ir_node *m;
 
 			if (is_backedge(n, i))
 				continue;
-			m = get_nodes_block(skip_Proj(get_irn_n(n, i)));
+			m = get_Block_cfgpred_block(n, i);
+			/* ignore Bad control flow: it cannot happen */
+			if (is_Bad(m))
+				continue;
 
 			cfscc(m);
 			if (irn_is_in_stack(m)) {
@@ -613,7 +614,7 @@ static void cfscc(ir_node *n) {
 #endif
 
 			/* Remove the cfloop from the stack ... */
-			pop_scc_unmark_visit (n);
+			pop_scc_unmark_visit(n);
 
 			/* The current backedge has been marked, that is temporarily eliminated,
 			   by find tail. Start the scc algorithm
@@ -635,28 +636,6 @@ static void cfscc(ir_node *n) {
 	}
 }
 
-/**
- * Mature all loops by removing the flexible arrays of a loop.
- */
-static void mature_loops(ir_loop *loop) {
-	loop_element *new_children = DUP_ARR_D(loop_element, outermost_ir_graph->obst, loop->children);
-	DEL_ARR_F(loop->children);
-	loop->children = new_children;
-
-	if (loop->n_sons > 0) {
-		/* we have child loops, mature them */
-		int i;
-
-		for (i = ARR_LEN(new_children) - 1; i >= 0; --i) {
-			loop_element child = new_children[i];
-
-			if (*child.kind == k_ir_loop) {
-				mature_loops(child.son);
-			}
-		}
-	}
-}
-
 /* Constructs control flow backedge information for irg. */
 int construct_cf_backedges(ir_graph *irg) {
 	ir_graph *rem = current_ir_graph;
@@ -688,18 +667,26 @@ int construct_cf_backedges(ir_graph *irg) {
 		if (is_Block(el))
 			cfscc(el);
 	}
+	finish_scc();
+	obstack_free(&temp, NULL);
 
 	assert(head_rem == current_loop);
-	mature_loops(current_loop);
+	mature_loops(current_loop, irg->obst);
 	set_irg_loop(irg, current_loop);
 	set_irg_loopinfo_state(irg, loopinfo_cf_consistent);
 	assert(get_irg_loop(irg)->kind == k_ir_loop);
 
-	obstack_free(&temp, NULL);
 	current_ir_graph = rem;
 	return max_loop_depth;
 }
 
+void assure_cf_loop(ir_graph *irg) {
+	irg_loopinfo_state state = get_irg_loopinfo_state(irg);
+
+	if (state != loopinfo_cf_consistent)
+		construct_cf_backedges(irg);
+}
+
 #ifdef INTERPROCEDURAL_VIEW
 int construct_ip_cf_backedges (void) {
 	ir_graph *rem = current_ir_graph;