X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fopt%2Fcombo.c;h=ad3d385116e45a1b5b78acf6f88c238e40d54dbe;hb=fb5957cbc4aaecd4e14cbc481e92e1c81260535a;hp=384617c648313db5e5dcbb45be634688da794bbd;hpb=af300963705d97b2f596e8cf2887813c25de6ad8;p=libfirm

diff --git a/ir/opt/combo.c b/ir/opt/combo.c
index 384617c64..ad3d38511 100644
--- a/ir/opt/combo.c
+++ b/ir/opt/combo.c
@@ -780,7 +780,8 @@ static void init_block_phis(ir_node *irn, void *ctx)
 	(void) ctx;
 
 	if (is_Phi(irn)) {
-		add_Block_phi(get_nodes_block(irn), irn);
+		ir_node *block = get_nodes_block(irn);
+		add_Block_phi(block, irn);
 	}
 }  /* init_block_phis */
 
@@ -845,7 +846,7 @@ static void add_to_cprop(node_t *y, environment_t *env)
 	irn = y->node;
 	if (get_irn_mode(irn) == mode_T) {
 		/* mode_T nodes always produce tarval_bottom, so we must explicitly
-		   add it's Proj's to get constant evaluation to work */
+		 * add its Projs to get constant evaluation to work */
 		int i;
 
 		for (i = get_irn_n_outs(irn) - 1; i >= 0; --i) {
@@ -1813,7 +1814,7 @@ static void split_by(partition_t *X, environment_t *env)
 	dump_partition("split_by", X);
 
 	if (X->n_leader == 1) {
-		/* we have only one leader, no need to split, just check it's type */
+		/* we have only one leader, no need to split, just check its type */
 		node_t *x = get_first_node(X);
 		X->type_is_T_or_C = x->type.tv == tarval_top || is_con(x->type);
 		return;
@@ -2257,11 +2258,13 @@ static void compute_Cmp(node_t *node)
 	} else if (r->part == l->part && !mode_is_float(get_irn_mode(l->node))) {
 		tv = relation & ir_relation_equal ? tarval_b_true : tarval_b_false;
 
-		/* if the node was ONCE evaluated by all constants, but now
+		/* if the node was ONCE evaluated to a constant, but now
 		   this breaks AND we get from the argument partitions a different
-		   result, switch to bottom.
+		   result, ensure monotony by fall to bottom.
 		   This happens because initially all nodes are in the same partition ... */
-		if (node->type.tv != tv)
+		if (node->type.tv == tarval_bottom)
+			tv = tarval_bottom;
+		else if (node->type.tv != tv && is_constant_type(node->type))
 			tv = tarval_bottom;
 		node->type.tv = tv;
 	} else {
@@ -3001,18 +3004,21 @@ static void apply_cf(ir_node *block, void *ctx)
 			ir_node *pred = get_Block_cfgpred(block, i);
 
 			if (! is_Bad(pred)) {
-				node_t *pred_bl = get_irn_node(get_nodes_block(skip_Proj(pred)));
-
-				if (pred_bl->flagged == 0) {
-					pred_bl->flagged = 3;
-
-					if (pred_bl->type.tv == tarval_reachable) {
-						/*
-						 * We will remove an edge from block to its pred.
-						 * This might leave the pred block as an endless loop
-						 */
-						if (! is_backedge(block, i))
-							keep_alive(pred_bl->node);
+				ir_node *pred_block = get_nodes_block(skip_Proj(pred));
+				if (!is_Bad(pred_block)) {
+					node_t *pred_bl = get_irn_node(pred_block);
+
+					if (pred_bl->flagged == 0) {
+						pred_bl->flagged = 3;
+
+						if (pred_bl->type.tv == tarval_reachable) {
+							/*
+							 * We will remove an edge from block to its pred.
+							 * This might leave the pred block as an endless loop
+							 */
+							if (! is_backedge(block, i))
+								keep_alive(pred_bl->node);
+						}
 					}
 				}
 			}
@@ -3022,7 +3028,9 @@ static void apply_cf(ir_node *block, void *ctx)
 		   finds out the opposite :-) */
 		if (block != get_irg_end_block(current_ir_graph)) {
 			/* mark dead blocks */
-			set_Block_dead(block);
+			//set_Block_dead(block);
+			//ir_graph *irg = get_irn_irg(block);
+			//exchange(block, get_irg_bad(irg));
 			DB((dbg, LEVEL_1, "Removing dead %+F\n", block));
 		} else {
 			/* the endblock is unreachable */
@@ -3057,18 +3065,21 @@ static void apply_cf(ir_node *block, void *ctx)
 		} else {
 			DB((dbg, LEVEL_1, "Removing dead input %d from %+F (%+F)\n", i, block, pred));
 			if (! is_Bad(pred)) {
-				node_t *pred_bl = get_irn_node(get_nodes_block(skip_Proj(pred)));
-
-				if (pred_bl->flagged == 0) {
-					pred_bl->flagged = 3;
-
-					if (pred_bl->type.tv == tarval_reachable) {
-						/*
-						 * We will remove an edge from block to its pred.
-						 * This might leave the pred block as an endless loop
-						 */
-						if (! is_backedge(block, i))
-							keep_alive(pred_bl->node);
+				ir_node *pred_block = get_nodes_block(skip_Proj(pred));
+				if (!is_Bad(pred_block)) {
+					node_t *pred_bl = get_irn_node(pred_block);
+
+					if (!is_Bad(pred_bl->node) && pred_bl->flagged == 0) {
+						pred_bl->flagged = 3;
+
+						if (pred_bl->type.tv == tarval_reachable) {
+							/*
+							 * We will remove an edge from block to its pred.
+							 * This might leave the pred block as an endless loop
+							 */
+							if (! is_backedge(block, i))
+								keep_alive(pred_bl->node);
+						}
 					}
 				}
 			}
@@ -3397,13 +3408,22 @@ static void apply_end(ir_node *end, environment_t *env)
 
 	/* fix the keep alive */
 	for (i = j = 0; i < n; i++) {
-		ir_node *ka   = get_End_keepalive(end, i);
-		node_t  *node = get_irn_node(ka);
+		ir_node *ka = get_End_keepalive(end, i);
+		ir_node *block;
+		node_t  *node;
 
-		if (! is_Block(ka))
-			node = get_irn_node(get_nodes_block(ka));
+		if (is_Bad(ka))
+			continue;
+		if (!is_Block(ka)) {
+			block = get_nodes_block(ka);
+			if (is_Bad(block))
+				continue;
+		} else {
+			block = ka;
+		}
 
-		if (node->type.tv != tarval_unreachable && !is_Bad(ka))
+		node = get_irn_node(block);
+		if (node->type.tv != tarval_unreachable)
 			in[j++] = ka;
 	}
 	if (j != n) {