X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firgopt.c;h=3de7ae9fa7ff7eb51c097486b81257c06b28932f;hb=357886575cb0becb5bd9be376fde49b57edd5385;hp=7a312e6ed5fdce31d4cbd00cad8420a8281f4454;hpb=ca3c5f449efdd622e037b667fbe88c5011b747d4;p=libfirm

diff --git a/ir/ir/irgopt.c b/ir/ir/irgopt.c
index 7a312e6ed..3de7ae9fa 100644
--- a/ir/ir/irgopt.c
+++ b/ir/ir/irgopt.c
@@ -78,9 +78,7 @@ static inline void do_local_optimize(ir_node *n)
 
 	if (get_opt_global_cse())
 		set_irg_pinned(irg, op_pin_state_floats);
-	set_irg_outs_inconsistent(irg);
 	set_irg_doms_inconsistent(irg);
-	set_irg_loopinfo_inconsistent(irg);
 
 	/* Clean the value_table in irg for the CSE. */
 	new_identities(irg);
@@ -100,6 +98,14 @@ void local_optimize_node(ir_node *n)
 	current_ir_graph = rem;
 }
 
+static void enqueue_node(ir_node *node, pdeq *waitq)
+{
+	if (get_irn_link(node) == waitq)
+		return;
+	pdeq_putr(waitq, node);
+	set_irn_link(node, waitq);
+}
+
 /**
  * Enqueue all users of a node to a wait queue.
  * Handles mode_T nodes.
@@ -111,10 +117,7 @@ static void enqueue_users(ir_node *n, pdeq *waitq)
 	foreach_out_edge(n, edge) {
 		ir_node *succ = get_edge_src_irn(edge);
 
-		if (get_irn_link(succ) != waitq) {
-			pdeq_putr(waitq, succ);
-			set_irn_link(succ, waitq);
-		}
+		enqueue_node(succ, waitq);
 		if (get_irn_mode(succ) == mode_T) {
 		/* A mode_T node has Proj's. Because most optimizations
 			run on the Proj's we have to enqueue them also. */
@@ -126,18 +129,26 @@ static void enqueue_users(ir_node *n, pdeq *waitq)
 /**
  * Block-Walker: uses dominance depth to mark dead blocks.
  */
-static void kill_dead_blocks(ir_node *block, void *env)
+static void find_unreachable_blocks(ir_node *block, void *env)
 {
 	pdeq *waitq = (pdeq*) env;
 
 	if (get_Block_dom_depth(block) < 0) {
-		/*
-		 * Note that the new dominance code correctly handles
-		 * the End block, i.e. it is always reachable from Start
-		 */
 		ir_graph *irg = get_irn_irg(block);
-		enqueue_users(block, waitq);
-		exchange(block, get_irg_bad(irg));
+		ir_node  *end = get_irg_end(irg);
+
+		const ir_edge_t *edge;
+		foreach_block_succ(block, edge) {
+			const ir_edge_t *edge2;
+			ir_node *succ_block = get_edge_src_irn(edge);
+			enqueue_node(succ_block, waitq);
+			foreach_out_edge(succ_block, edge2) {
+				ir_node *succ = get_edge_src_irn(edge2);
+				if (is_Phi(succ))
+					enqueue_node(succ, waitq);
+			}
+		}
+		enqueue_node(end, waitq);
 	}
 }
 
@@ -195,12 +206,13 @@ int optimize_graph_df(ir_graph *irg)
 	set_irg_state(irg, IR_GRAPH_STATE_BAD_BLOCK);
 
 	/* invalidate info */
-	set_irg_outs_inconsistent(irg);
 	set_irg_doms_inconsistent(irg);
-	set_irg_loopinfo_inconsistent(irg);
 
 	ir_reserve_resources(irg, IR_RESOURCE_IRN_LINK);
 
+	/* Calculate dominance so we can kill unreachable code */
+	assure_doms(irg);
+
 	/* walk over the graph, but don't touch keep-alives */
 	irg_walk_graph(irg, NULL, opt_walker, waitq);
 
@@ -208,17 +220,17 @@ int optimize_graph_df(ir_graph *irg)
 	 * so if it's not empty, the graph has been changed */
 	changed = !pdeq_empty(waitq);
 
-	do {
+	while (!pdeq_empty(waitq)) {
 		/* finish the wait queue */
 		while (! pdeq_empty(waitq)) {
 			ir_node *n = (ir_node*)pdeq_getl(waitq);
 			opt_walker(n, waitq);
 		}
-		/* kill newly generated unreachable code */
-		set_irg_outs_inconsistent(irg);
+		/* Calculate dominance so we can kill unreachable code */
 		compute_doms(irg);
-		irg_block_walk_graph(irg, NULL, kill_dead_blocks, waitq);
-	} while (! pdeq_empty(waitq));
+		irg_block_walk_graph(irg, NULL, find_unreachable_blocks, waitq);
+	}
+	set_irg_doms_inconsistent(irg);
 
 	del_pdeq(waitq);
 
@@ -227,6 +239,10 @@ int optimize_graph_df(ir_graph *irg)
 	if (! state)
 		edges_deactivate(irg);
 
+	if (remove_bads(irg)) {
+		edges_deactivate(irg);
+	}
+
 	/* Finally kill BAD and doublets from the keep alives.
 	   Doing this AFTER edges where deactivated saves cycles */
 	end = get_irg_end(irg);