X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firopt.c;h=c2cecb135541755428bf95090f081897abbfa566;hb=7498ed3766f3f98604d96d1b75978a3a9e6768ed;hp=6d8c06fda401bedfe46b070578d34b1f0e8f29cd;hpb=79d03a49b258b76f33a10e964f8a9c6716c70807;p=libfirm

diff --git a/ir/ir/iropt.c b/ir/ir/iropt.c
index 6d8c06fda..c2cecb135 100644
--- a/ir/ir/iropt.c
+++ b/ir/ir/iropt.c
@@ -722,10 +722,16 @@ static ir_op_ops *firm_set_default_computed_value(ir_opcode code, ir_op_ops *ops
 static ir_node *equivalent_node_Block(ir_node *n)
 {
 	ir_node *oldn = n;
-	int n_preds   = get_Block_n_cfgpreds(n);
+	int     n_preds;
 
-	/* The Block constructor does not call optimize, but mature_immBlock
-	calls the optimization. */
+	/* don't optimize dead blocks */
+	if (is_Block_dead(n))
+		return n;
+
+	n_preds = get_Block_n_cfgpreds(n);
+
+	/* The Block constructor does not call optimize, but mature_immBlock()
+	   calls the optimization. */
 	assert(get_Block_matured(n));
 
 	/* Straightening: a single entry Block following a single exit Block
@@ -1297,45 +1303,36 @@ static ir_node *equivalent_node_Phi(ir_node *n) {
  *   themselves.
  */
 static ir_node *equivalent_node_Sync(ir_node *n) {
-	int i, n_preds;
-
-	ir_node *oldn = n;
-	ir_node *first_val = NULL; /* to shutup gcc */
-
-	if (!get_opt_normalize()) return n;
+	int arity = get_Sync_n_preds(n);
+	int i;
 
-	n_preds = get_Sync_n_preds(n);
+	for (i = 0; i < arity;) {
+		ir_node *pred = get_Sync_pred(n, i);
+		int      j;
 
-	/* Find first non-self-referencing input */
-	for (i = 0; i < n_preds; ++i) {
-		first_val = get_Sync_pred(n, i);
-		if ((first_val != n)  /* not self pointer */ &&
-		    (! is_Bad(first_val))
-		   ) {                /* value not dead */
-			break;            /* then found first value. */
+		/* Remove Bad predecessors */
+		if (is_Bad(pred)) {
+			del_Sync_n(n, i);
+			--arity;
+			continue;
 		}
-	}
-
-	if (i >= n_preds)
-		/* A totally Bad or self-referencing Sync (we didn't break the above loop) */
-		return new_Bad();
 
-	/* search the rest of inputs, determine if any of these
-	   are non-self-referencing */
-	while (++i < n_preds) {
-		ir_node *scnd_val = get_Sync_pred(n, i);
-		if ((scnd_val != n) &&
-		    (scnd_val != first_val) &&
-		    (! is_Bad(scnd_val))
-		   )
-			break;
+		/* Remove duplicate predecessors */
+		for (j = 0;; ++j) {
+			if (j >= i) {
+				++i;
+				break;
+			}
+			if (get_Sync_pred(n, j) == pred) {
+				del_Sync_n(n, i);
+				--arity;
+				break;
+			}
+		}
 	}
 
-	if (i >= n_preds) {
-		/* Fold, if no multiple distinct non-self-referencing inputs */
-		n = first_val;
-		DBG_OPT_SYNC(oldn, n);
-	}
+	if (arity == 0) return new_Bad();
+	if (arity == 1) return get_Sync_pred(n, 0);
 	return n;
 }  /* equivalent_node_Sync */
 
@@ -2853,7 +2850,8 @@ static ir_node *transform_node_Abs(ir_node *n) {
 
 		/*
 		 * We can replace the Abs by -x here.
-		 * We even could add a new Confirm here.
+		 * We even could add a new Confirm here
+		 * (if not twos complement)
 		 *
 		 * Note that -x would create a new node, so we could
 		 * not run it in the equivalent_node() context.
@@ -3655,11 +3653,9 @@ static ir_node *transform_node_Proj_Cmp(ir_node *proj) {
 		break;
 	}
 
-	/* remove Casts */
-	if (is_Cast(left))
-		left = get_Cast_op(left);
-	if (is_Cast(right))
-		right = get_Cast_op(right);
+	/* remove Casts of both sides */
+	left  = skip_Cast(left);
+	right = skip_Cast(right);
 
 	/* Remove unnecessary conversions */
 	/* TODO handle constants */
@@ -3694,7 +3690,7 @@ static ir_node *transform_node_Proj_Cmp(ir_node *proj) {
 		}
 	}
 
-	/* remove operation of both sides if possible */
+	/* remove operation on both sides if possible */
 	if (proj_nr == pn_Cmp_Eq || proj_nr == pn_Cmp_Lg) {
 		/*
 		 * The following operations are NOT safe for floating point operations, for instance
@@ -4872,28 +4868,35 @@ static ir_node *transform_node_Psi(ir_node *n) {
  * of the other sync to our own inputs
  */
 static ir_node *transform_node_Sync(ir_node *n) {
-	int i, arity;
+	int arity = get_Sync_n_preds(n);
+	int i;
 
-	arity = get_irn_arity(n);
-	for(i = 0; i < get_irn_arity(n); /*empty*/) {
-		int i2, arity2;
-		ir_node *in = get_irn_n(n, i);
-		if(!is_Sync(in)) {
+	for (i = 0; i < arity;) {
+		ir_node *pred = get_Sync_pred(n, i);
+		int      pred_arity;
+		int      j;
+
+		if (!is_Sync(pred)) {
 			++i;
 			continue;
 		}
 
-		/* set sync input 0 instead of the sync */
-		set_irn_n(n, i, get_irn_n(in, 0));
-		/* so we check this input again for syncs */
-
-		/* append all other inputs of the sync to our sync */
-		arity2 = get_irn_arity(in);
-		for(i2 = 1; i2 < arity2; ++i2) {
-			ir_node *in_in = get_irn_n(in, i2);
-			add_irn_n(n, in_in);
-			/* increase arity so we also check the new inputs for syncs */
-			arity++;
+		del_Sync_n(n, i);
+		--arity;
+
+		pred_arity = get_Sync_n_preds(pred);
+		for (j = 0; j < pred_arity; ++j) {
+			ir_node *pred_pred = get_Sync_pred(pred, j);
+			int      k;
+
+			for (k = 0;; ++k) {
+				if (k >= arity) {
+					add_irn_n(n, pred_pred);
+					++arity;
+					break;
+				}
+				if (get_Sync_pred(n, k) == pred_pred) break;
+			}
 		}
 	}
 
@@ -5019,7 +5022,7 @@ static int node_cmp_attr_Free(ir_node *a, ir_node *b) {
 static int node_cmp_attr_SymConst(ir_node *a, ir_node *b) {
 	const symconst_attr *pa = get_irn_symconst_attr(a);
 	const symconst_attr *pb = get_irn_symconst_attr(b);
-	return (pa->num        != pb->num)
+	return (pa->kind       != pb->kind)
 	    || (pa->sym.type_p != pb->sym.type_p)
 	    || (pa->tp         != pb->tp);
 }  /* node_cmp_attr_SymConst */