X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Ftree-ssa-forwprop.c;h=cac5d0ae36912e1f0d3bafd7e96218f85af1e3ed;hb=b2e02dcc7c5b43e5088291a6c6b4bb60f9c4ce3c;hp=d91ab45b331a04696f9f938d32c2df2ff02b2881;hpb=2a1990e9c656063ab626fab258ae2d418378c76d;p=pf3gnuchains%2Fgcc-fork.git

diff --git a/gcc/tree-ssa-forwprop.c b/gcc/tree-ssa-forwprop.c
index d91ab45b331..cac5d0ae369 100644
--- a/gcc/tree-ssa-forwprop.c
+++ b/gcc/tree-ssa-forwprop.c
@@ -1,11 +1,11 @@
 /* Forward propagation of expressions for single use variables.
-   Copyright (C) 2004, 2005 Free Software Foundation, Inc.
+   Copyright (C) 2004, 2005, 2007 Free Software Foundation, Inc.
 
 This file is part of GCC.
 
 GCC is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2, or (at your option)
+the Free Software Foundation; either version 3, or (at your option)
 any later version.
 
 GCC is distributed in the hope that it will be useful,
@@ -14,9 +14,8 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
-along with GCC; see the file COPYING.  If not, write to
-the Free Software Foundation, 51 Franklin Street, Fifth Floor,
-Boston, MA 02110-1301, USA.  */
+along with GCC; see the file COPYING3.  If not see
+<http://www.gnu.org/licenses/>.  */
 
 #include "config.h"
 #include "system.h"
@@ -33,6 +32,7 @@ Boston, MA 02110-1301, USA.  */
 #include "tree-pass.h"
 #include "tree-dump.h"
 #include "langhooks.h"
+#include "flags.h"
 
 /* This pass propagates the RHS of assignment statements into use
    sites of the LHS of the assignment.  It's basically a specialized
@@ -149,427 +149,320 @@ Boston, MA 02110-1301, USA.  */
 
    This will (of course) be extended as other needs arise.  */
 
+static bool forward_propagate_addr_expr (tree name, tree rhs);
 
 /* Set to true if we delete EH edges during the optimization.  */
 static bool cfg_changed;
 
 
-/* Given an SSA_NAME VAR, return true if and only if VAR is defined by
-   a comparison.  */
+/* Get the next statement we can propagate NAME's value into skipping
+   trivial copies.  Returns the statement that is suitable as a
+   propagation destination or NULL_TREE if there is no such one.
+   This only returns destinations in a single-use chain.  FINAL_NAME_P
+   if non-NULL is written to the ssa name that represents the use.  */
 
-static bool
-ssa_name_defined_by_comparison_p (tree var)
+static tree
+get_prop_dest_stmt (tree name, tree *final_name_p)
 {
-  tree def = SSA_NAME_DEF_STMT (var);
+  use_operand_p use;
+  tree use_stmt;
 
-  if (TREE_CODE (def) == MODIFY_EXPR)
-    {
-      tree rhs = TREE_OPERAND (def, 1);
-      return COMPARISON_CLASS_P (rhs);
-    }
+  do {
+    /* If name has multiple uses, bail out.  */
+    if (!single_imm_use (name, &use, &use_stmt))
+      return NULL_TREE;
 
-  return 0;
+    /* If this is not a trivial copy, we found it.  */
+    if (TREE_CODE (use_stmt) != GIMPLE_MODIFY_STMT
+	|| TREE_CODE (GIMPLE_STMT_OPERAND (use_stmt, 0)) != SSA_NAME
+	|| GIMPLE_STMT_OPERAND (use_stmt, 1) != name)
+      break;
+
+    /* Continue searching uses of the copy destination.  */
+    name = GIMPLE_STMT_OPERAND (use_stmt, 0);
+  } while (1);
+
+  if (final_name_p)
+    *final_name_p = name;
+
+  return use_stmt;
 }
 
-/* Forward propagate a single-use variable into COND once.  Return a
-   new condition if successful.  Return NULL_TREE otherwise.  */
+/* Get the statement we can propagate from into NAME skipping
+   trivial copies.  Returns the statement which defines the
+   propagation source or NULL_TREE if there is no such one.
+   If SINGLE_USE_ONLY is set considers only sources which have
+   a single use chain up to NAME.  If SINGLE_USE_P is non-null,
+   it is set to whether the chain to NAME is a single use chain
+   or not.  SINGLE_USE_P is not written to if SINGLE_USE_ONLY is set.  */
 
 static tree
-forward_propagate_into_cond_1 (tree cond, tree *test_var_p)
+get_prop_source_stmt (tree name, bool single_use_only, bool *single_use_p)
 {
-  tree new_cond = NULL_TREE;
-  enum tree_code cond_code = TREE_CODE (cond);
-  tree test_var = NULL_TREE;
-  tree def;
-  tree def_rhs;
-
-  /* If the condition is not a lone variable or an equality test of an
-     SSA_NAME against an integral constant, then we do not have an
-     optimizable case.
-
-     Note these conditions also ensure the COND_EXPR has no
-     virtual operands or other side effects.  */
-  if (cond_code != SSA_NAME
-      && !((cond_code == EQ_EXPR || cond_code == NE_EXPR)
-	   && TREE_CODE (TREE_OPERAND (cond, 0)) == SSA_NAME
-	   && CONSTANT_CLASS_P (TREE_OPERAND (cond, 1))
-	   && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (cond, 1)))))
-    return NULL_TREE;
-
-  /* Extract the single variable used in the test into TEST_VAR.  */
-  if (cond_code == SSA_NAME)
-    test_var = cond;
-  else
-    test_var = TREE_OPERAND (cond, 0);
+  bool single_use = true;
+
+  do {
+    tree def_stmt = SSA_NAME_DEF_STMT (name);
+
+    if (!has_single_use (name))
+      {
+	single_use = false;
+	if (single_use_only)
+	  return NULL_TREE;
+      }
+
+    /* If name is defined by a PHI node or is the default def, bail out.  */
+    if (TREE_CODE (def_stmt) != GIMPLE_MODIFY_STMT)
+      return NULL_TREE;
+
+    /* If name is not a simple copy destination, we found it.  */
+    if (TREE_CODE (GIMPLE_STMT_OPERAND (def_stmt, 1)) != SSA_NAME)
+      {
+	if (!single_use_only && single_use_p)
+	  *single_use_p = single_use;
+
+	return def_stmt;
+      }
+
+    /* Continue searching the def of the copy source name.  */
+    name = GIMPLE_STMT_OPERAND (def_stmt, 1);
+  } while (1);
+}
 
-  /* Now get the defining statement for TEST_VAR.  Skip this case if
-     it's not defined by some MODIFY_EXPR.  */
-  def = SSA_NAME_DEF_STMT (test_var);
-  if (TREE_CODE (def) != MODIFY_EXPR)
-    return NULL_TREE;
+/* Checks if the destination ssa name in DEF_STMT can be used as
+   propagation source.  Returns true if so, otherwise false.  */
 
-  def_rhs = TREE_OPERAND (def, 1);
+static bool
+can_propagate_from (tree def_stmt)
+{
+  tree rhs = GIMPLE_STMT_OPERAND (def_stmt, 1);
 
-  /* If TEST_VAR is set by adding or subtracting a constant
-     from an SSA_NAME, then it is interesting to us as we
-     can adjust the constant in the conditional and thus
-     eliminate the arithmetic operation.  */
-  if (TREE_CODE (def_rhs) == PLUS_EXPR
-      || TREE_CODE (def_rhs) == MINUS_EXPR)
+  /* We cannot propagate ssa names that occur in abnormal phi nodes.  */
+  switch (TREE_CODE_LENGTH (TREE_CODE (rhs)))
     {
-      tree op0 = TREE_OPERAND (def_rhs, 0);
-      tree op1 = TREE_OPERAND (def_rhs, 1);
-
-      /* The first operand must be an SSA_NAME and the second
-	 operand must be a constant.  */
-      if (TREE_CODE (op0) != SSA_NAME
-	  || !CONSTANT_CLASS_P (op1)
-	  || !INTEGRAL_TYPE_P (TREE_TYPE (op1)))
-	return NULL_TREE;
-
-      /* Don't propagate if the first operand occurs in
-	 an abnormal PHI.  */
-      if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (op0))
-	return NULL_TREE;
-
-      if (has_single_use (test_var))
-	{
-	  enum tree_code new_code;
-	  tree t;
-
-	  /* If the variable was defined via X + C, then we must
-	     subtract C from the constant in the conditional.
-	     Otherwise we add C to the constant in the
-	     conditional.  The result must fold into a valid
-	     gimple operand to be optimizable.  */
-	  new_code = (TREE_CODE (def_rhs) == PLUS_EXPR
-		      ? MINUS_EXPR : PLUS_EXPR);
-	  t = int_const_binop (new_code, TREE_OPERAND (cond, 1), op1, 0);
-	  if (!is_gimple_val (t))
-	    return NULL_TREE;
-
-	  new_cond = build2 (cond_code, boolean_type_node, op0, t);
-	}
+    case 3:
+      if (TREE_OPERAND (rhs, 2) != NULL_TREE
+	  && TREE_CODE (TREE_OPERAND (rhs, 2)) == SSA_NAME
+	  && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (TREE_OPERAND (rhs, 2)))
+	return false;
+    case 2:
+      if (TREE_OPERAND (rhs, 1) != NULL_TREE
+	  && TREE_CODE (TREE_OPERAND (rhs, 1)) == SSA_NAME
+	  && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (TREE_OPERAND (rhs, 1)))
+	return false;
+    case 1:
+      if (TREE_OPERAND (rhs, 0) != NULL_TREE
+	  && TREE_CODE (TREE_OPERAND (rhs, 0)) == SSA_NAME
+	  && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (TREE_OPERAND (rhs, 0)))
+	return false;
+      break;
+
+    default:
+      return false;
     }
 
-  /* These cases require comparisons of a naked SSA_NAME or
-     comparison of an SSA_NAME against zero or one.  */
-  else if (TREE_CODE (cond) == SSA_NAME
-	   || integer_zerop (TREE_OPERAND (cond, 1))
-	   || integer_onep (TREE_OPERAND (cond, 1)))
-    {
-      /* If TEST_VAR is set from a relational operation
-	 between two SSA_NAMEs or a combination of an SSA_NAME
-	 and a constant, then it is interesting.  */
-      if (COMPARISON_CLASS_P (def_rhs))
-	{
-	  tree op0 = TREE_OPERAND (def_rhs, 0);
-	  tree op1 = TREE_OPERAND (def_rhs, 1);
-
-	  /* Both operands of DEF_RHS must be SSA_NAMEs or
-	     constants.  */
-	  if ((TREE_CODE (op0) != SSA_NAME
-	       && !is_gimple_min_invariant (op0))
-	      || (TREE_CODE (op1) != SSA_NAME
-		  && !is_gimple_min_invariant (op1)))
-	    return NULL_TREE;
-
-	  /* Don't propagate if the first operand occurs in
-	     an abnormal PHI.  */
-	  if (TREE_CODE (op0) == SSA_NAME
-	      && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (op0))
-	    return NULL_TREE;
-
-	  /* Don't propagate if the second operand occurs in
-	     an abnormal PHI.  */
-	  if (TREE_CODE (op1) == SSA_NAME
-	      && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (op1))
-	    return NULL_TREE;
-
-	  if (has_single_use (test_var))
-	    {
-	      /* TEST_VAR was set from a relational operator.  */
-	      new_cond = build2 (TREE_CODE (def_rhs),
-				 boolean_type_node, op0, op1);
-
-	      /* Invert the conditional if necessary.  */
-	      if ((cond_code == EQ_EXPR
-		   && integer_zerop (TREE_OPERAND (cond, 1)))
-		  || (cond_code == NE_EXPR
-		      && integer_onep (TREE_OPERAND (cond, 1))))
-		{
-		  new_cond = invert_truthvalue (new_cond);
-
-		  /* If we did not get a simple relational
-		     expression or bare SSA_NAME, then we can
-		     not optimize this case.  */
-		  if (!COMPARISON_CLASS_P (new_cond)
-		      && TREE_CODE (new_cond) != SSA_NAME)
-		    new_cond = NULL_TREE;
-		}
-	    }
-	}
-
-      /* If TEST_VAR is set from a TRUTH_NOT_EXPR, then it
-	 is interesting.  */
-      else if (TREE_CODE (def_rhs) == TRUTH_NOT_EXPR)
-	{
-	  enum tree_code new_code;
-
-	  def_rhs = TREE_OPERAND (def_rhs, 0);
-
-	  /* DEF_RHS must be an SSA_NAME or constant.  */
-	  if (TREE_CODE (def_rhs) != SSA_NAME
-	      && !is_gimple_min_invariant (def_rhs))
-	    return NULL_TREE;
-
-	  /* Don't propagate if the operand occurs in
-	     an abnormal PHI.  */
-	  if (TREE_CODE (def_rhs) == SSA_NAME
-	      && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (def_rhs))
-	    return NULL_TREE;
-
-	  if (cond_code == SSA_NAME
-	      || (cond_code == NE_EXPR
-		  && integer_zerop (TREE_OPERAND (cond, 1)))
-	      || (cond_code == EQ_EXPR
-		  && integer_onep (TREE_OPERAND (cond, 1))))
-	    new_code = EQ_EXPR;
-	  else
-	    new_code = NE_EXPR;
-
-	  new_cond = build2 (new_code, boolean_type_node, def_rhs,
-			     fold_convert (TREE_TYPE (def_rhs),
-					   integer_zero_node));
-	}
-
-      /* If TEST_VAR was set from a cast of an integer type
-	 to a boolean type or a cast of a boolean to an
-	 integral, then it is interesting.  */
-      else if (TREE_CODE (def_rhs) == NOP_EXPR
-	       || TREE_CODE (def_rhs) == CONVERT_EXPR)
-	{
-	  tree outer_type;
-	  tree inner_type;
-
-	  outer_type = TREE_TYPE (def_rhs);
-	  inner_type = TREE_TYPE (TREE_OPERAND (def_rhs, 0));
-
-	  if ((TREE_CODE (outer_type) == BOOLEAN_TYPE
-	       && INTEGRAL_TYPE_P (inner_type))
-	      || (TREE_CODE (inner_type) == BOOLEAN_TYPE
-		  && INTEGRAL_TYPE_P (outer_type)))
-	    ;
-	  else if (INTEGRAL_TYPE_P (outer_type)
-		   && INTEGRAL_TYPE_P (inner_type)
-		   && TREE_CODE (TREE_OPERAND (def_rhs, 0)) == SSA_NAME
-		   && ssa_name_defined_by_comparison_p (TREE_OPERAND (def_rhs,
-								      0)))
-	    ;
-	  else
-	    return NULL_TREE;
-
-	  /* Don't propagate if the operand occurs in
-	     an abnormal PHI.  */
-	  if (TREE_CODE (TREE_OPERAND (def_rhs, 0)) == SSA_NAME
-	      && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (TREE_OPERAND
-						  (def_rhs, 0)))
-	    return NULL_TREE;
-
-	  if (has_single_use (test_var))
-	    {
-	      enum tree_code new_code;
-	      tree new_arg;
-
-	      if (cond_code == SSA_NAME
-		  || (cond_code == NE_EXPR
-		      && integer_zerop (TREE_OPERAND (cond, 1)))
-		  || (cond_code == EQ_EXPR
-		      && integer_onep (TREE_OPERAND (cond, 1))))
-		new_code = NE_EXPR;
-	      else
-		new_code = EQ_EXPR;
-
-	      new_arg = TREE_OPERAND (def_rhs, 0);
-	      new_cond = build2 (new_code, boolean_type_node, new_arg,
-				 fold_convert (TREE_TYPE (new_arg),
-					       integer_zero_node));
-	    }
-	}
-    }
+  /* If the definition is a conversion of a pointer to a function type,
+     then we can not apply optimizations as some targets require function
+     pointers to be canonicalized and in this case this optimization could
+     eliminate a necessary canonicalization.  */
+  if ((TREE_CODE (rhs) == NOP_EXPR
+       || TREE_CODE (rhs) == CONVERT_EXPR)
+      && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (rhs, 0)))
+      && TREE_CODE (TREE_TYPE (TREE_TYPE
+			        (TREE_OPERAND (rhs, 0)))) == FUNCTION_TYPE)
+    return false;
 
-  *test_var_p = test_var;
-  return new_cond;
+  return true;
 }
 
-/* COND is a condition of the form:
-
-     x == const or x != const
+/* Remove a copy chain ending in NAME along the defs but not
+   further or including UP_TO_STMT.  If NAME was replaced in
+   its only use then this function can be used to clean up
+   dead stmts.  Returns true if UP_TO_STMT can be removed
+   as well, otherwise false.  */
 
-   Look back to x's defining statement and see if x is defined as
+static bool
+remove_prop_source_from_use (tree name, tree up_to_stmt)
+{
+  block_stmt_iterator bsi;
+  tree stmt;
 
-     x = (type) y;
+  do {
+    if (!has_zero_uses (name))
+      return false;
 
-   If const is unchanged if we convert it to type, then we can build
-   the equivalent expression:
+    stmt = SSA_NAME_DEF_STMT (name);
+    if (stmt == up_to_stmt)
+      return true;
 
+    bsi = bsi_for_stmt (stmt);
+    release_defs (stmt);
+    bsi_remove (&bsi, true);
 
-      y == const or y != const
+    name = GIMPLE_STMT_OPERAND (stmt, 1);
+  } while (TREE_CODE (name) == SSA_NAME);
 
-   Which may allow further optimizations.
+  return false;
+}
 
-   Return the equivalent comparison or NULL if no such equivalent comparison
-   was found.  */
+/* Combine OP0 CODE OP1 in the context of a COND_EXPR.  Returns
+   the folded result in a form suitable for COND_EXPR_COND or
+   NULL_TREE, if there is no suitable simplified form.  If
+   INVARIANT_ONLY is true only gimple_min_invariant results are
+   considered simplified.  */
 
 static tree
-find_equivalent_equality_comparison (tree cond)
+combine_cond_expr_cond (enum tree_code code, tree type,
+			tree op0, tree op1, bool invariant_only)
 {
-  tree op0 = TREE_OPERAND (cond, 0);
-  tree op1 = TREE_OPERAND (cond, 1);
-  tree def_stmt = SSA_NAME_DEF_STMT (op0);
-
-  while (def_stmt
-	 && TREE_CODE (def_stmt) == MODIFY_EXPR
-	 && TREE_CODE (TREE_OPERAND (def_stmt, 1)) == SSA_NAME)
-    def_stmt = SSA_NAME_DEF_STMT (TREE_OPERAND (def_stmt, 1));
-
-  /* OP0 might have been a parameter, so first make sure it
-     was defined by a MODIFY_EXPR.  */
-  if (def_stmt && TREE_CODE (def_stmt) == MODIFY_EXPR)
-    {
-      tree def_rhs = TREE_OPERAND (def_stmt, 1);
-
-      /* If either operand to the comparison is a pointer to
-	 a function, then we can not apply this optimization
-	 as some targets require function pointers to be
-	 canonicalized and in this case this optimization would
-	 eliminate a necessary canonicalization.  */
-      if ((POINTER_TYPE_P (TREE_TYPE (op0))
-	   && TREE_CODE (TREE_TYPE (TREE_TYPE (op0))) == FUNCTION_TYPE)
-	  || (POINTER_TYPE_P (TREE_TYPE (op1))
-	      && TREE_CODE (TREE_TYPE (TREE_TYPE (op1))) == FUNCTION_TYPE))
-	return NULL;
-	      
-      /* Now make sure the RHS of the MODIFY_EXPR is a typecast.  */
-      if ((TREE_CODE (def_rhs) == NOP_EXPR
-	   || TREE_CODE (def_rhs) == CONVERT_EXPR)
-	  && TREE_CODE (TREE_OPERAND (def_rhs, 0)) == SSA_NAME)
-	{
-	  tree def_rhs_inner = TREE_OPERAND (def_rhs, 0);
-	  tree def_rhs_inner_type = TREE_TYPE (def_rhs_inner);
-	  tree new;
-
-	  if (TYPE_PRECISION (def_rhs_inner_type)
-	      > TYPE_PRECISION (TREE_TYPE (def_rhs)))
-	    return NULL;
-
-	  /* If the inner type of the conversion is a pointer to
-	     a function, then we can not apply this optimization
-	     as some targets require function pointers to be
-	     canonicalized.  This optimization would result in
-	     canonicalization of the pointer when it was not originally
-	     needed/intended.  */
-	  if (POINTER_TYPE_P (def_rhs_inner_type)
-	      && TREE_CODE (TREE_TYPE (def_rhs_inner_type)) == FUNCTION_TYPE)
-	    return NULL;
-
-	  /* What we want to prove is that if we convert OP1 to
-	     the type of the object inside the NOP_EXPR that the
-	     result is still equivalent to SRC. 
-
-	     If that is true, the build and return new equivalent
-	     condition which uses the source of the typecast and the
-	     new constant (which has only changed its type).  */
-	  new = fold_build1 (TREE_CODE (def_rhs), def_rhs_inner_type, op1);
-	  STRIP_USELESS_TYPE_CONVERSION (new);
-	  if (is_gimple_val (new) && tree_int_cst_equal (new, op1))
-	    return build2 (TREE_CODE (cond), TREE_TYPE (cond),
-			   def_rhs_inner, new);
-	}
-    }
-  return NULL;
-}
+  tree t;
 
-/* STMT is a COND_EXPR
+  gcc_assert (TREE_CODE_CLASS (code) == tcc_comparison);
 
-   This routine attempts to find equivalent forms of the condition
-   which we may be able to optimize better.  */
+  t = fold_binary (code, type, op0, op1);
+  if (!t)
+    return NULL_TREE;
 
-static void
-simplify_cond (tree stmt)
-{
-  tree cond = COND_EXPR_COND (stmt);
+  /* Require that we got a boolean type out if we put one in.  */
+  gcc_assert (TREE_CODE (TREE_TYPE (t)) == TREE_CODE (type));
 
-  if (COMPARISON_CLASS_P (cond))
+  /* For (bool)x use x != 0.  */
+  if (TREE_CODE (t) == NOP_EXPR
+      && TREE_TYPE (t) == boolean_type_node)
     {
-      tree op0 = TREE_OPERAND (cond, 0);
-      tree op1 = TREE_OPERAND (cond, 1);
-
-      if (TREE_CODE (op0) == SSA_NAME && is_gimple_min_invariant (op1))
-	{
-	  /* First see if we have test of an SSA_NAME against a constant
-	     where the SSA_NAME is defined by an earlier typecast which
-	     is irrelevant when performing tests against the given
-	     constant.  */
-	  if (TREE_CODE (cond) == EQ_EXPR || TREE_CODE (cond) == NE_EXPR)
-	    {
-	      tree new_cond = find_equivalent_equality_comparison (cond);
-
-	      if (new_cond)
-		{
-		  COND_EXPR_COND (stmt) = new_cond;
-		  update_stmt (stmt);
-		}
-	    }
-	}
+      tree top0 = TREE_OPERAND (t, 0);
+      t = build2 (NE_EXPR, type,
+		  top0, build_int_cst (TREE_TYPE (top0), 0));
     }
-}
-
-/* Forward propagate a single-use variable into COND_EXPR as many
-   times as possible.  */
-
-static void
-forward_propagate_into_cond (tree cond_expr)
-{
-  gcc_assert (TREE_CODE (cond_expr) == COND_EXPR);
-
-  while (1)
+  /* For !x use x == 0.  */
+  else if (TREE_CODE (t) == TRUTH_NOT_EXPR)
+    {
+      tree top0 = TREE_OPERAND (t, 0);
+      t = build2 (EQ_EXPR, type,
+		  top0, build_int_cst (TREE_TYPE (top0), 0));
+    }
+  /* For cmp ? 1 : 0 use cmp.  */
+  else if (TREE_CODE (t) == COND_EXPR
+	   && COMPARISON_CLASS_P (TREE_OPERAND (t, 0))
+	   && integer_onep (TREE_OPERAND (t, 1))
+	   && integer_zerop (TREE_OPERAND (t, 2)))
     {
-      tree test_var = NULL_TREE;
-      tree cond = COND_EXPR_COND (cond_expr);
-      tree new_cond = forward_propagate_into_cond_1 (cond, &test_var);
+      tree top0 = TREE_OPERAND (t, 0);
+      t = build2 (TREE_CODE (top0), type,
+		  TREE_OPERAND (top0, 0), TREE_OPERAND (top0, 1));
+    }
 
-      /* Return if unsuccessful.  */
-      if (new_cond == NULL_TREE)
-	break;
+  /* Bail out if we required an invariant but didn't get one.  */
+  if (invariant_only
+      && !is_gimple_min_invariant (t))
+    return NULL_TREE;
 
-      /* Dump details.  */
-      if (dump_file && (dump_flags & TDF_DETAILS))
-	{
-	  fprintf (dump_file, "  Replaced '");
-	  print_generic_expr (dump_file, cond, dump_flags);
-	  fprintf (dump_file, "' with '");
-	  print_generic_expr (dump_file, new_cond, dump_flags);
-	  fprintf (dump_file, "'\n");
-	}
+  /* A valid conditional for a COND_EXPR is either a gimple value
+     or a comparison with two gimple value operands.  */
+  if (is_gimple_val (t)
+      || (COMPARISON_CLASS_P (t)
+	  && is_gimple_val (TREE_OPERAND (t, 0))
+	  && is_gimple_val (TREE_OPERAND (t, 1))))
+    return t;
 
-      COND_EXPR_COND (cond_expr) = new_cond;
-      update_stmt (cond_expr);
+  return NULL_TREE;
+}
 
-      if (has_zero_uses (test_var))
-	{
-	  tree def = SSA_NAME_DEF_STMT (test_var);
-	  block_stmt_iterator bsi = bsi_for_stmt (def);
-	  bsi_remove (&bsi, true);
-	}
-    }
+/* Propagate from the ssa name definition statements of COND_EXPR
+   in statement STMT into the conditional if that simplifies it.
+   Returns zero if no statement was changed, one if there were
+   changes and two if cfg_cleanup needs to run.  */
 
-  /* There are further simplifications that can be performed
-     on COND_EXPRs.  Specifically, when comparing an SSA_NAME
-     against a constant where the SSA_NAME is the result of a
-     conversion.  Perhaps this should be folded into the rest
-     of the COND_EXPR simplification code.  */
-  simplify_cond (cond_expr);
+static int
+forward_propagate_into_cond (tree cond_expr, tree stmt)
+{
+  int did_something = 0;
+
+  do {
+    tree tmp = NULL_TREE;
+    tree cond = COND_EXPR_COND (cond_expr);
+    tree name, def_stmt, rhs;
+    bool single_use_p;
+
+    /* We can do tree combining on SSA_NAME and comparison expressions.  */
+    if (COMPARISON_CLASS_P (cond)
+	&& TREE_CODE (TREE_OPERAND (cond, 0)) == SSA_NAME)
+      {
+	/* For comparisons use the first operand, that is likely to
+	   simplify comparisons against constants.  */
+	name = TREE_OPERAND (cond, 0);
+	def_stmt = get_prop_source_stmt (name, false, &single_use_p);
+	if (def_stmt != NULL_TREE
+	    && can_propagate_from (def_stmt))
+	  {
+	    tree op1 = TREE_OPERAND (cond, 1);
+	    rhs = GIMPLE_STMT_OPERAND (def_stmt, 1);
+	    tmp = combine_cond_expr_cond (TREE_CODE (cond), boolean_type_node,
+				          fold_convert (TREE_TYPE (op1), rhs),
+				          op1, !single_use_p);
+	  }
+	/* If that wasn't successful, try the second operand.  */
+	if (tmp == NULL_TREE
+	    && TREE_CODE (TREE_OPERAND (cond, 1)) == SSA_NAME)
+	  {
+	    tree op0 = TREE_OPERAND (cond, 0);
+	    name = TREE_OPERAND (cond, 1);
+	    def_stmt = get_prop_source_stmt (name, false, &single_use_p);
+	    if (def_stmt == NULL_TREE
+	        || !can_propagate_from (def_stmt))
+	      return did_something;
+
+	    rhs = GIMPLE_STMT_OPERAND (def_stmt, 1);
+	    tmp = combine_cond_expr_cond (TREE_CODE (cond), boolean_type_node,
+					  op0,
+				          fold_convert (TREE_TYPE (op0), rhs),
+					  !single_use_p);
+	  }
+      }
+    else if (TREE_CODE (cond) == SSA_NAME)
+      {
+	name = cond;
+	def_stmt = get_prop_source_stmt (name, true, NULL);
+	if (def_stmt == NULL_TREE
+	    || !can_propagate_from (def_stmt))
+	  return did_something;
+
+	rhs = GIMPLE_STMT_OPERAND (def_stmt, 1);
+	tmp = combine_cond_expr_cond (NE_EXPR, boolean_type_node, rhs,
+				      build_int_cst (TREE_TYPE (rhs), 0),
+				      false);
+      }
+
+    if (tmp)
+      {
+	if (dump_file && tmp)
+	  {
+	    fprintf (dump_file, "  Replaced '");
+	    print_generic_expr (dump_file, cond, 0);
+	    fprintf (dump_file, "' with '");
+	    print_generic_expr (dump_file, tmp, 0);
+	    fprintf (dump_file, "'\n");
+	  }
+
+	COND_EXPR_COND (cond_expr) = unshare_expr (tmp);
+	update_stmt (stmt);
+
+	/* Remove defining statements.  */
+	remove_prop_source_from_use (name, NULL);
+
+	if (is_gimple_min_invariant (tmp))
+	  did_something = 2;
+	else if (did_something == 0)
+	  did_something = 1;
+
+	/* Continue combining.  */
+	continue;
+      }
+
+    break;
+  } while (1);
+
+  return did_something;
 }
 
 /* We've just substituted an ADDR_EXPR into stmt.  Update all the 
@@ -583,14 +476,14 @@ tidy_after_forward_propagate_addr (tree stmt)
       && tree_purge_dead_eh_edges (bb_for_stmt (stmt)))
     cfg_changed = true;
 
-  if (TREE_CODE (TREE_OPERAND (stmt, 1)) == ADDR_EXPR)
-     recompute_tree_invariant_for_addr_expr (TREE_OPERAND (stmt, 1));
+  if (TREE_CODE (GIMPLE_STMT_OPERAND (stmt, 1)) == ADDR_EXPR)
+     recompute_tree_invariant_for_addr_expr (GIMPLE_STMT_OPERAND (stmt, 1));
 
-  mark_new_vars_to_rename (stmt);
+  mark_symbols_for_renaming (stmt);
 }
 
-/* STMT defines LHS which is contains the address of the 0th element
-   in an array.  USE_STMT uses LHS to compute the address of an
+/* DEF_RHS contains the address of the 0th element in an array. 
+   USE_STMT uses type of DEF_RHS to compute the address of an
    arbitrary element within the array.  The (variable) byte offset
    of the element is contained in OFFSET.
 
@@ -605,51 +498,45 @@ tidy_after_forward_propagate_addr (tree stmt)
    with the new address computation.  */
 
 static bool
-forward_propagate_addr_into_variable_array_index (tree offset, tree lhs,
-						  tree stmt, tree use_stmt)
+forward_propagate_addr_into_variable_array_index (tree offset,
+						  tree def_rhs, tree use_stmt)
 {
   tree index;
 
-  /* The offset must be defined by a simple MODIFY_EXPR statement.  */
-  if (TREE_CODE (offset) != MODIFY_EXPR)
-    return false;
-
-  /* The RHS of the statement which defines OFFSET must be a gimple
-     cast of another SSA_NAME.  */
-  offset = TREE_OPERAND (offset, 1);
-  if (!is_gimple_cast (offset))
-    return false;
-
-  offset = TREE_OPERAND (offset, 0);
-  if (TREE_CODE (offset) != SSA_NAME)
-    return false;
-
-  /* Get the defining statement of the offset before type
-     conversion.  */
-  offset = SSA_NAME_DEF_STMT (offset);
-
-  /* The statement which defines OFFSET before type conversion
-     must be a simple MODIFY_EXPR.  */
-  if (TREE_CODE (offset) != MODIFY_EXPR)
-    return false;
-
-  /* The RHS of the statement which defines OFFSET must be a
-     multiplication of an object by the size of the array elements. 
-     This implicitly verifies that the size of the array elements
-     is constant.  */
-  offset = TREE_OPERAND (offset, 1);
-  if (TREE_CODE (offset) != MULT_EXPR
-      || TREE_CODE (TREE_OPERAND (offset, 1)) != INTEGER_CST
-      || !simple_cst_equal (TREE_OPERAND (offset, 1),
-			    TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (lhs)))))
-    return false;
-
-  /* The first operand to the MULT_EXPR is the desired index.  */
-  index = TREE_OPERAND (offset, 0);
+  /* Try to find an expression for a proper index.  This is either
+     a multiplication expression by the element size or just the
+     ssa name we came along in case the element size is one.  */
+  if (integer_onep (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (def_rhs)))))
+    index = offset;
+  else
+    {
+      /* Get the offset's defining statement.  */
+      offset = SSA_NAME_DEF_STMT (offset);
+
+      /* The statement which defines OFFSET before type conversion
+         must be a simple GIMPLE_MODIFY_STMT.  */
+      if (TREE_CODE (offset) != GIMPLE_MODIFY_STMT)
+	return false;
+
+      /* The RHS of the statement which defines OFFSET must be a
+	 multiplication of an object by the size of the array elements. 
+	 This implicitly verifies that the size of the array elements
+	 is constant.  */
+     offset = GIMPLE_STMT_OPERAND (offset, 1);
+      if (TREE_CODE (offset) != MULT_EXPR
+	  || TREE_CODE (TREE_OPERAND (offset, 1)) != INTEGER_CST
+	  || !simple_cst_equal (TREE_OPERAND (offset, 1),
+				TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (def_rhs)))))
+	return false;
+
+      /* The first operand to the MULT_EXPR is the desired index.  */
+      index = TREE_OPERAND (offset, 0);
+    }
 
   /* Replace the pointer addition with array indexing.  */
-  TREE_OPERAND (use_stmt, 1) = unshare_expr (TREE_OPERAND (stmt, 1));
-  TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (use_stmt, 1), 0), 1) = index;
+  GIMPLE_STMT_OPERAND (use_stmt, 1) = unshare_expr (def_rhs);
+  TREE_OPERAND (TREE_OPERAND (GIMPLE_STMT_OPERAND (use_stmt, 1), 0), 1)
+    = index;
 
   /* That should have created gimple, so there is no need to
      record information to undo the propagation.  */
@@ -658,55 +545,68 @@ forward_propagate_addr_into_variable_array_index (tree offset, tree lhs,
   return true;
 }
 
-/* STMT is a statement of the form SSA_NAME = ADDR_EXPR <whatever>.
+/* NAME is a SSA_NAME representing DEF_RHS which is of the form
+   ADDR_EXPR <whatever>.
 
    Try to forward propagate the ADDR_EXPR into the use USE_STMT.
    Often this will allow for removal of an ADDR_EXPR and INDIRECT_REF
    node or for recovery of array indexing from pointer arithmetic.
-   Return true, if the propagation was successful.  */
+   
+   Return true if the propagation was successful (the propagation can
+   be not totally successful, yet things may have been changed).  */
 
 static bool
-forward_propagate_addr_expr_1 (tree stmt, tree use_stmt)
+forward_propagate_addr_expr_1 (tree name, tree def_rhs, tree use_stmt,
+			       bool single_use_p)
 {
-  tree name = TREE_OPERAND (stmt, 0);
   tree lhs, rhs, array_ref;
 
   /* Strip away any outer COMPONENT_REF/ARRAY_REF nodes from the LHS. 
      ADDR_EXPR will not appear on the LHS.  */
-  lhs = TREE_OPERAND (use_stmt, 0);
-  while (TREE_CODE (lhs) == COMPONENT_REF || TREE_CODE (lhs) == ARRAY_REF)
+  lhs = GIMPLE_STMT_OPERAND (use_stmt, 0);
+  while (handled_component_p (lhs))
     lhs = TREE_OPERAND (lhs, 0);
 
+  rhs = GIMPLE_STMT_OPERAND (use_stmt, 1);
+
   /* Now see if the LHS node is an INDIRECT_REF using NAME.  If so, 
      propagate the ADDR_EXPR into the use of NAME and fold the result.  */
   if (TREE_CODE (lhs) == INDIRECT_REF && TREE_OPERAND (lhs, 0) == name)
     {
       /* This should always succeed in creating gimple, so there is
 	 no need to save enough state to undo this propagation.  */
-      TREE_OPERAND (lhs, 0) = unshare_expr (TREE_OPERAND (stmt, 1));
+      TREE_OPERAND (lhs, 0) = unshare_expr (def_rhs);
       fold_stmt_inplace (use_stmt);
       tidy_after_forward_propagate_addr (use_stmt);
+
+      /* Continue propagating into the RHS.  */
     }
 
-  /* Trivial case.  The use statement could be a trivial copy.  We
-     go ahead and handle that case here since it's trivial and
-     removes the need to run copy-prop before this pass to get
-     the best results.  Also note that by handling this case here
-     we can catch some cascading effects, ie the single use is
-     in a copy, and the copy is used later by a single INDIRECT_REF
-     for example.  */
-  else if (TREE_CODE (lhs) == SSA_NAME && TREE_OPERAND (use_stmt, 1) == name)
+  /* Trivial cases.  The use statement could be a trivial copy or a
+     useless conversion.  Recurse to the uses of the lhs as copyprop does
+     not copy through differen variant pointers and FRE does not catch
+     all useless conversions.  Treat the case of a single-use name and
+     a conversion to def_rhs type separate, though.  */
+  else if (TREE_CODE (lhs) == SSA_NAME
+	   && (TREE_CODE (rhs) == NOP_EXPR
+	       || TREE_CODE (rhs) == CONVERT_EXPR)
+	   && TREE_TYPE (rhs) == TREE_TYPE (def_rhs)
+	   && single_use_p)
     {
-      TREE_OPERAND (use_stmt, 1) = unshare_expr (TREE_OPERAND (stmt, 1));
-      tidy_after_forward_propagate_addr (use_stmt);
+      GIMPLE_STMT_OPERAND (use_stmt, 1) = unshare_expr (def_rhs);
       return true;
     }
+  else if ((TREE_CODE (lhs) == SSA_NAME
+      	    && rhs == name)
+	   || ((TREE_CODE (rhs) == NOP_EXPR
+		|| TREE_CODE (rhs) == CONVERT_EXPR)
+	       && useless_type_conversion_p (TREE_TYPE (rhs),
+					    TREE_TYPE (def_rhs))))
+    return forward_propagate_addr_expr (lhs, def_rhs);
 
   /* Strip away any outer COMPONENT_REF, ARRAY_REF or ADDR_EXPR
      nodes from the RHS.  */
-  rhs = TREE_OPERAND (use_stmt, 1);
-  while (TREE_CODE (rhs) == COMPONENT_REF
-	 || TREE_CODE (rhs) == ARRAY_REF
+  while (handled_component_p (rhs)
 	 || TREE_CODE (rhs) == ADDR_EXPR)
     rhs = TREE_OPERAND (rhs, 0);
 
@@ -716,7 +616,7 @@ forward_propagate_addr_expr_1 (tree stmt, tree use_stmt)
     {
       /* This should always succeed in creating gimple, so there is
          no need to save enough state to undo this propagation.  */
-      TREE_OPERAND (rhs, 0) = unshare_expr (TREE_OPERAND (stmt, 1));
+      TREE_OPERAND (rhs, 0) = unshare_expr (def_rhs);
       fold_stmt_inplace (use_stmt);
       tidy_after_forward_propagate_addr (use_stmt);
       return true;
@@ -726,24 +626,24 @@ forward_propagate_addr_expr_1 (tree stmt, tree use_stmt)
      array indexing.  They only apply when we have the address of
      element zero in an array.  If that is not the case then there
      is nothing to do.  */
-  array_ref = TREE_OPERAND (TREE_OPERAND (stmt, 1), 0);
+  array_ref = TREE_OPERAND (def_rhs, 0);
   if (TREE_CODE (array_ref) != ARRAY_REF
       || TREE_CODE (TREE_TYPE (TREE_OPERAND (array_ref, 0))) != ARRAY_TYPE
       || !integer_zerop (TREE_OPERAND (array_ref, 1)))
     return false;
 
-  /* If the use of the ADDR_EXPR must be a PLUS_EXPR, or else there
+  /* If the use of the ADDR_EXPR is not a POINTER_PLUS_EXPR, there
      is nothing to do. */
-  if (TREE_CODE (rhs) != PLUS_EXPR)
+  if (TREE_CODE (rhs) != POINTER_PLUS_EXPR)
     return false;
 
-  /* Try to optimize &x[0] + C where C is a multiple of the size
+  /* Try to optimize &x[0] p+ C where C is a multiple of the size
      of the elements in X into &x[C/element size].  */
   if (TREE_OPERAND (rhs, 0) == name
       && TREE_CODE (TREE_OPERAND (rhs, 1)) == INTEGER_CST)
     {
       tree orig = unshare_expr (rhs);
-      TREE_OPERAND (rhs, 0) = unshare_expr (TREE_OPERAND (stmt, 1));
+      TREE_OPERAND (rhs, 0) = unshare_expr (def_rhs);
 
       /* If folding succeeds, then we have just exposed new variables
 	 in USE_STMT which will need to be renamed.  If folding fails,
@@ -755,13 +655,13 @@ forward_propagate_addr_expr_1 (tree stmt, tree use_stmt)
 	}
       else
 	{
-	  TREE_OPERAND (use_stmt, 1) = orig;
+	  GIMPLE_STMT_OPERAND (use_stmt, 1) = orig;
 	  update_stmt (use_stmt);
 	  return false;
 	}
     }
 
-  /* Try to optimize &x[0] + OFFSET where OFFSET is defined by
+  /* Try to optimize &x[0] p+ OFFSET where OFFSET is defined by
      converting a multiplication of an index by the size of the
      array elements, then the result is converted into the proper
      type for the arithmetic.  */
@@ -769,24 +669,13 @@ forward_propagate_addr_expr_1 (tree stmt, tree use_stmt)
       && TREE_CODE (TREE_OPERAND (rhs, 1)) == SSA_NAME
       /* Avoid problems with IVopts creating PLUS_EXPRs with a
 	 different type than their operands.  */
-      && lang_hooks.types_compatible_p (TREE_TYPE (name), TREE_TYPE (rhs)))
+      && useless_type_conversion_p (TREE_TYPE (rhs), TREE_TYPE (name)))
     {
-      tree offset_stmt = SSA_NAME_DEF_STMT (TREE_OPERAND (rhs, 1));
-      return forward_propagate_addr_into_variable_array_index (offset_stmt, lhs,
-							       stmt, use_stmt);
-    }
-	      
-  /* Same as the previous case, except the operands of the PLUS_EXPR
-     were reversed.  */
-  if (TREE_OPERAND (rhs, 1) == name
-      && TREE_CODE (TREE_OPERAND (rhs, 0)) == SSA_NAME
-      /* Avoid problems with IVopts creating PLUS_EXPRs with a
-	 different type than their operands.  */
-      && lang_hooks.types_compatible_p (TREE_TYPE (name), TREE_TYPE (rhs)))
-    {
-      tree offset_stmt = SSA_NAME_DEF_STMT (TREE_OPERAND (rhs, 0));
-      return forward_propagate_addr_into_variable_array_index (offset_stmt, lhs,
-							       stmt, use_stmt);
+      bool res;
+      
+      res = forward_propagate_addr_into_variable_array_index (TREE_OPERAND (rhs, 1),
+							      def_rhs, use_stmt);
+      return res;
     }
   return false;
 }
@@ -799,27 +688,27 @@ forward_propagate_addr_expr_1 (tree stmt, tree use_stmt)
    Returns true, if all uses have been propagated into.  */
 
 static bool
-forward_propagate_addr_expr (tree stmt)
+forward_propagate_addr_expr (tree name, tree rhs)
 {
-  int stmt_loop_depth = bb_for_stmt (stmt)->loop_depth;
-  tree name = TREE_OPERAND (stmt, 0);
-  use_operand_p imm_use;
+  int stmt_loop_depth = bb_for_stmt (SSA_NAME_DEF_STMT (name))->loop_depth;
   imm_use_iterator iter;
+  tree use_stmt;
   bool all = true;
+  bool single_use_p = has_single_use (name);
 
-  FOR_EACH_IMM_USE_SAFE (imm_use, iter, name)
+  FOR_EACH_IMM_USE_STMT (use_stmt, iter, name)
     {
-      tree use_stmt = USE_STMT (imm_use);
+      bool result;
 
       /* If the use is not in a simple assignment statement, then
 	 there is nothing we can do.  */
-      if (TREE_CODE (use_stmt) != MODIFY_EXPR)
+      if (TREE_CODE (use_stmt) != GIMPLE_MODIFY_STMT)
 	{
 	  all = false;
 	  continue;
 	}
 
-     /* If the use is in a deeper loop nest, then we do not want
+      /* If the use is in a deeper loop nest, then we do not want
 	to propagate the ADDR_EXPR into the loop as that is likely
 	adding expression evaluations into the loop.  */
       if (bb_for_stmt (use_stmt)->loop_depth > stmt_loop_depth)
@@ -828,12 +717,135 @@ forward_propagate_addr_expr (tree stmt)
 	  continue;
 	}
 
-      all = forward_propagate_addr_expr_1 (stmt, use_stmt) && all;
+      /* If the use_stmt has side-effects, don't propagate into it.  */
+      if (stmt_ann (use_stmt)->has_volatile_ops)
+	{
+	  all = false;
+	  continue;
+	}
+
+      push_stmt_changes (&use_stmt);
+
+      result = forward_propagate_addr_expr_1 (name, rhs, use_stmt,
+					      single_use_p);
+      all &= result;
+
+      pop_stmt_changes (&use_stmt);
+
+      /* Remove intermediate now unused copy and conversion chains.  */
+      if (result
+	  && TREE_CODE (GIMPLE_STMT_OPERAND (use_stmt, 0)) == SSA_NAME
+	  && (TREE_CODE (GIMPLE_STMT_OPERAND (use_stmt, 1)) == SSA_NAME
+	      || TREE_CODE (GIMPLE_STMT_OPERAND (use_stmt, 1)) == NOP_EXPR
+	      || TREE_CODE (GIMPLE_STMT_OPERAND (use_stmt, 1)) == CONVERT_EXPR))
+	{
+	  block_stmt_iterator bsi = bsi_for_stmt (use_stmt);
+	  release_defs (use_stmt);
+	  bsi_remove (&bsi, true);
+	}
     }
 
   return all;
 }
 
+/* Forward propagate the comparison COND defined in STMT like
+   cond_1 = x CMP y to uses of the form
+     a_1 = (T')cond_1
+     a_1 = !cond_1
+     a_1 = cond_1 != 0
+   Returns true if stmt is now unused.  */
+
+static bool
+forward_propagate_comparison (tree cond, tree stmt)
+{
+  tree name = GIMPLE_STMT_OPERAND (stmt, 0);
+  tree use_stmt, tmp = NULL_TREE;
+
+  /* Don't propagate ssa names that occur in abnormal phis.  */
+  if ((TREE_CODE (TREE_OPERAND (cond, 0)) == SSA_NAME
+       && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (TREE_OPERAND (cond, 0)))
+      || (TREE_CODE (TREE_OPERAND (cond, 1)) == SSA_NAME
+	  && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (TREE_OPERAND (cond, 1))))
+    return false;
+
+  /* Do not un-cse comparisons.  But propagate through copies.  */
+  use_stmt = get_prop_dest_stmt (name, &name);
+  if (use_stmt == NULL_TREE)
+    return false;
+
+  /* Conversion of the condition result to another integral type.  */
+  if (TREE_CODE (use_stmt) == GIMPLE_MODIFY_STMT
+      && (TREE_CODE (GIMPLE_STMT_OPERAND (use_stmt, 1)) == CONVERT_EXPR
+	  || TREE_CODE (GIMPLE_STMT_OPERAND (use_stmt, 1)) == NOP_EXPR
+          || COMPARISON_CLASS_P (GIMPLE_STMT_OPERAND (use_stmt, 1))
+          || TREE_CODE (GIMPLE_STMT_OPERAND (use_stmt, 1)) == TRUTH_NOT_EXPR)
+      && INTEGRAL_TYPE_P (TREE_TYPE (GIMPLE_STMT_OPERAND (use_stmt, 0))))
+    {
+      tree lhs = GIMPLE_STMT_OPERAND (use_stmt, 0);
+      tree rhs = GIMPLE_STMT_OPERAND (use_stmt, 1);
+
+      /* We can propagate the condition into a conversion.  */
+      if (TREE_CODE (rhs) == CONVERT_EXPR
+	  || TREE_CODE (rhs) == NOP_EXPR)
+	{
+	  /* Avoid using fold here as that may create a COND_EXPR with
+	     non-boolean condition as canonical form.  */
+	  tmp = build2 (TREE_CODE (cond), TREE_TYPE (lhs),
+			TREE_OPERAND (cond, 0), TREE_OPERAND (cond, 1));
+	}
+      /* We can propagate the condition into X op CST where op
+	 is EQ_EXRP or NE_EXPR and CST is either one or zero.  */
+      else if (COMPARISON_CLASS_P (rhs)
+	       && TREE_CODE (TREE_OPERAND (rhs, 0)) == SSA_NAME
+	       && TREE_CODE (TREE_OPERAND (rhs, 1)) == INTEGER_CST)
+	{
+	  enum tree_code code = TREE_CODE (rhs);
+	  tree cst = TREE_OPERAND (rhs, 1);
+
+	  tmp = combine_cond_expr_cond (code, TREE_TYPE (lhs),
+					fold_convert (TREE_TYPE (cst), cond),
+					cst, false);
+	  if (tmp == NULL_TREE)
+	    return false;
+	}
+      /* We can propagate the condition into a statement that
+	 computes the logical negation of the comparison result.  */
+      else if (TREE_CODE (rhs) == TRUTH_NOT_EXPR)
+	{
+	  tree type = TREE_TYPE (TREE_OPERAND (cond, 0));
+	  bool nans = HONOR_NANS (TYPE_MODE (type));
+	  enum tree_code code;
+	  code = invert_tree_comparison (TREE_CODE (cond), nans);
+	  if (code == ERROR_MARK)
+	    return false;
+
+	  tmp = build2 (code, TREE_TYPE (lhs), TREE_OPERAND (cond, 0),
+			TREE_OPERAND (cond, 1));
+	}
+      else
+	return false;
+
+      GIMPLE_STMT_OPERAND (use_stmt, 1) = unshare_expr (tmp);
+      update_stmt (use_stmt);
+
+      /* Remove defining statements.  */
+      remove_prop_source_from_use (name, stmt);
+
+      if (dump_file && (dump_flags & TDF_DETAILS))
+	{
+	  fprintf (dump_file, "  Replaced '");
+	  print_generic_expr (dump_file, rhs, dump_flags);
+	  fprintf (dump_file, "' with '");
+	  print_generic_expr (dump_file, tmp, dump_flags);
+	  fprintf (dump_file, "'\n");
+	}
+
+      return true;
+    }
+
+  return false;
+}
+
 /* If we have lhs = ~x (STMT), look and see if earlier we had x = ~y.
    If so, we can change STMT into lhs = y which can later be copy
    propagated.  Similarly for negation. 
@@ -851,20 +863,21 @@ forward_propagate_addr_expr (tree stmt)
 static void
 simplify_not_neg_expr (tree stmt)
 {
-  tree rhs = TREE_OPERAND (stmt, 1);
+  tree rhs = GIMPLE_STMT_OPERAND (stmt, 1);
   tree rhs_def_stmt = SSA_NAME_DEF_STMT (TREE_OPERAND (rhs, 0));
 
   /* See if the RHS_DEF_STMT has the same form as our statement.  */
-  if (TREE_CODE (rhs_def_stmt) == MODIFY_EXPR
-      && TREE_CODE (TREE_OPERAND (rhs_def_stmt, 1)) == TREE_CODE (rhs))
+  if (TREE_CODE (rhs_def_stmt) == GIMPLE_MODIFY_STMT
+      && TREE_CODE (GIMPLE_STMT_OPERAND (rhs_def_stmt, 1)) == TREE_CODE (rhs))
     {
-      tree rhs_def_operand = TREE_OPERAND (TREE_OPERAND (rhs_def_stmt, 1), 0);
+      tree rhs_def_operand =
+	TREE_OPERAND (GIMPLE_STMT_OPERAND (rhs_def_stmt, 1), 0);
 
       /* Verify that RHS_DEF_OPERAND is a suitable SSA_NAME.  */
       if (TREE_CODE (rhs_def_operand) == SSA_NAME
 	  && ! SSA_NAME_OCCURS_IN_ABNORMAL_PHI (rhs_def_operand))
 	{
-	  TREE_OPERAND (stmt, 1) = rhs_def_operand;
+	  GIMPLE_STMT_OPERAND (stmt, 1) = rhs_def_operand;
 	  update_stmt (stmt);
 	}
     }
@@ -885,9 +898,9 @@ simplify_switch_expr (tree stmt)
   if (TREE_CODE (cond) == SSA_NAME)
     {
       def = SSA_NAME_DEF_STMT (cond);
-      if (TREE_CODE (def) == MODIFY_EXPR)
+      if (TREE_CODE (def) == GIMPLE_MODIFY_STMT)
 	{
-	  def = TREE_OPERAND (def, 1);
+	  def = GIMPLE_STMT_OPERAND (def, 1);
 	  if (TREE_CODE (def) == NOP_EXPR)
 	    {
 	      int need_precision;
@@ -908,7 +921,9 @@ simplify_switch_expr (tree stmt)
 
 	      need_precision = TYPE_PRECISION (ti);
 	      fail = false;
-	      if (TYPE_UNSIGNED (to) && !TYPE_UNSIGNED (ti))
+	      if (! INTEGRAL_TYPE_P (ti))
+		fail = true;
+	      else if (TYPE_UNSIGNED (to) && !TYPE_UNSIGNED (ti))
 		fail = true;
 	      else if (!TYPE_UNSIGNED (to) && TYPE_UNSIGNED (ti))
 		need_precision += 1;
@@ -931,6 +946,7 @@ static unsigned int
 tree_ssa_forward_propagate_single_use_vars (void)
 {
   basic_block bb;
+  unsigned int todoflags = 0;
 
   cfg_changed = false;
 
@@ -945,10 +961,10 @@ tree_ssa_forward_propagate_single_use_vars (void)
 
 	  /* If this statement sets an SSA_NAME to an address,
 	     try to propagate the address into the uses of the SSA_NAME.  */
-	  if (TREE_CODE (stmt) == MODIFY_EXPR)
+	  if (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT)
 	    {
-	      tree lhs = TREE_OPERAND (stmt, 0);
-	      tree rhs = TREE_OPERAND (stmt, 1);
+	      tree lhs = GIMPLE_STMT_OPERAND (stmt, 0);
+	      tree rhs = GIMPLE_STMT_OPERAND (stmt, 1);
 
 
 	      if (TREE_CODE (lhs) != SSA_NAME)
@@ -959,8 +975,12 @@ tree_ssa_forward_propagate_single_use_vars (void)
 
 	      if (TREE_CODE (rhs) == ADDR_EXPR)
 		{
-		  if (forward_propagate_addr_expr (stmt))
-		    bsi_remove (&bsi, true);
+		  if (forward_propagate_addr_expr (lhs, rhs))
+		    {
+		      release_defs (stmt);
+		      todoflags |= TODO_remove_unused_locals;
+		      bsi_remove (&bsi, true);
+		    }
 		  else
 		    bsi_next (&bsi);
 		}
@@ -971,6 +991,28 @@ tree_ssa_forward_propagate_single_use_vars (void)
 		  simplify_not_neg_expr (stmt);
 		  bsi_next (&bsi);
 		}
+              else if (TREE_CODE (rhs) == COND_EXPR)
+                {
+		  int did_something;
+		  fold_defer_overflow_warnings ();
+                  did_something = forward_propagate_into_cond (rhs, stmt);
+		  if (did_something == 2)
+		    cfg_changed = true;
+		  fold_undefer_overflow_warnings (!TREE_NO_WARNING (rhs)
+		    && did_something, stmt, WARN_STRICT_OVERFLOW_CONDITIONAL);
+		  bsi_next (&bsi);
+                }
+	      else if (COMPARISON_CLASS_P (rhs))
+		{
+		  if (forward_propagate_comparison (rhs, stmt))
+		    {
+		      release_defs (stmt);
+		      todoflags |= TODO_remove_unused_locals;
+		      bsi_remove (&bsi, true);
+		    }
+		  else
+		    bsi_next (&bsi);
+		}
 	      else
 		bsi_next (&bsi);
 	    }
@@ -981,7 +1023,14 @@ tree_ssa_forward_propagate_single_use_vars (void)
 	    }
 	  else if (TREE_CODE (stmt) == COND_EXPR)
 	    {
-	      forward_propagate_into_cond (stmt);
+	      int did_something;
+	      fold_defer_overflow_warnings ();
+	      did_something = forward_propagate_into_cond (stmt, stmt);
+	      if (did_something == 2)
+		cfg_changed = true;
+	      fold_undefer_overflow_warnings (!TREE_NO_WARNING (stmt)
+					      && did_something, stmt,
+					      WARN_STRICT_OVERFLOW_CONDITIONAL);
 	      bsi_next (&bsi);
 	    }
 	  else
@@ -990,8 +1039,8 @@ tree_ssa_forward_propagate_single_use_vars (void)
     }
 
   if (cfg_changed)
-    cleanup_tree_cfg ();
-  return 0;
+    todoflags |= TODO_cleanup_cfg;
+  return todoflags;
 }
 
 
@@ -1009,13 +1058,312 @@ struct tree_opt_pass pass_forwprop = {
   NULL,				/* next */
   0,				/* static_pass_number */
   TV_TREE_FORWPROP,		/* tv_id */
-  PROP_cfg | PROP_ssa
-    | PROP_alias,		/* properties_required */
+  PROP_cfg | PROP_ssa,		/* properties_required */
+  0,				/* properties_provided */
+  0,				/* properties_destroyed */
+  0,				/* todo_flags_start */
+  TODO_dump_func
+  | TODO_ggc_collect
+  | TODO_update_ssa
+  | TODO_verify_ssa,		/* todo_flags_finish */
+  0				/* letter */
+};
+
+
+/* Structure to keep track of the value of a dereferenced PHI result
+   and the set of virtual operands used for that dereference.  */
+
+struct phiprop_d
+{
+  tree value;
+  tree vop_stmt;
+};
+
+/* Verify if the value recorded for NAME in PHIVN is still valid at
+   the start of basic block BB.  */
+
+static bool
+phivn_valid_p (struct phiprop_d *phivn, tree name, basic_block bb)
+{
+  tree vop_stmt = phivn[SSA_NAME_VERSION (name)].vop_stmt;
+  ssa_op_iter ui;
+  tree vuse;
+
+  /* The def stmts of all virtual uses need to be post-dominated
+     by bb.  */
+  FOR_EACH_SSA_TREE_OPERAND (vuse, vop_stmt, ui, SSA_OP_VUSE)
+    {
+      tree use_stmt;
+      imm_use_iterator ui2;
+      bool ok = true;
+
+      FOR_EACH_IMM_USE_STMT (use_stmt, ui2, vuse)
+	{
+	  /* If BB does not dominate a VDEF, the value is invalid.  */
+	  if (((TREE_CODE (use_stmt) == GIMPLE_MODIFY_STMT
+	        && !ZERO_SSA_OPERANDS (use_stmt, SSA_OP_VDEF))
+	       || TREE_CODE (use_stmt) == PHI_NODE)
+	      && !dominated_by_p (CDI_DOMINATORS, bb_for_stmt (use_stmt), bb))
+	    {
+	      ok = false;
+	      BREAK_FROM_IMM_USE_STMT (ui2);
+	    }
+	}
+      if (!ok)
+	return false;
+    }
+
+  return true;
+}
+
+/* Insert a new phi node for the dereference of PHI at basic_block
+   BB with the virtual operands from USE_STMT.  */
+
+static tree
+phiprop_insert_phi (basic_block bb, tree phi, tree use_stmt,
+		    struct phiprop_d *phivn, size_t n)
+{
+  tree res, new_phi;
+  edge_iterator ei;
+  edge e;
+
+  /* Build a new PHI node to replace the definition of
+     the indirect reference lhs.  */
+  res = GIMPLE_STMT_OPERAND (use_stmt, 0);
+  SSA_NAME_DEF_STMT (res) = new_phi = create_phi_node (res, bb);
+
+  /* Add PHI arguments for each edge inserting loads of the
+     addressable operands.  */
+  FOR_EACH_EDGE (e, ei, bb->preds)
+    {
+      tree old_arg, new_var, tmp;
+
+      old_arg = PHI_ARG_DEF_FROM_EDGE (phi, e);
+      while (TREE_CODE (old_arg) == SSA_NAME
+	     && (SSA_NAME_VERSION (old_arg) >= n
+	         || phivn[SSA_NAME_VERSION (old_arg)].value == NULL_TREE))
+	{
+	  tree def_stmt = SSA_NAME_DEF_STMT (old_arg);
+	  old_arg = GIMPLE_STMT_OPERAND (def_stmt, 1);
+	}
+
+      if (TREE_CODE (old_arg) == SSA_NAME)
+	/* Reuse a formerly created dereference.  */
+	new_var = phivn[SSA_NAME_VERSION (old_arg)].value;
+      else
+	{
+	  old_arg = TREE_OPERAND (old_arg, 0);
+	  new_var = create_tmp_var (TREE_TYPE (old_arg), NULL);
+	  tmp = build2 (GIMPLE_MODIFY_STMT, void_type_node,
+			NULL_TREE, unshare_expr (old_arg));
+	  if (TREE_CODE (TREE_TYPE (old_arg)) == COMPLEX_TYPE
+	      || TREE_CODE (TREE_TYPE (old_arg)) == VECTOR_TYPE)
+	    DECL_GIMPLE_REG_P (new_var) = 1;
+	  add_referenced_var (new_var);
+	  new_var = make_ssa_name (new_var, tmp);
+	  GIMPLE_STMT_OPERAND (tmp, 0) = new_var;
+
+	  bsi_insert_on_edge (e, tmp);
+
+	  update_stmt (tmp);
+	  mark_symbols_for_renaming (tmp);
+	}
+
+      add_phi_arg (new_phi, new_var, e);
+    }
+
+  update_stmt (new_phi);
+
+  return res;
+}
+
+/* Propagate between the phi node arguments of PHI in BB and phi result
+   users.  For now this matches
+        # p_2 = PHI <&x, &y>
+      <Lx>:;
+	p_3 = p_2;
+	z_2 = *p_3;
+   and converts it to
+	# z_2 = PHI <x, y>
+      <Lx>:;
+   Returns true if a transformation was done and edge insertions
+   need to be committed.  Global data PHIVN and N is used to track
+   past transformation results.  We need to be especially careful here
+   with aliasing issues as we are moving memory reads.  */
+
+static bool
+propagate_with_phi (basic_block bb, tree phi, struct phiprop_d *phivn, size_t n)
+{
+  tree ptr = PHI_RESULT (phi);
+  tree use_stmt, res = NULL_TREE;
+  block_stmt_iterator bsi;
+  imm_use_iterator ui;
+  use_operand_p arg_p, use;
+  ssa_op_iter i;
+  bool phi_inserted;
+
+  if (MTAG_P (SSA_NAME_VAR (ptr))
+      || !POINTER_TYPE_P (TREE_TYPE (ptr))
+      || !is_gimple_reg_type (TREE_TYPE (TREE_TYPE (ptr))))
+    return false;
+
+  /* Check if we can "cheaply" dereference all phi arguments.  */
+  FOR_EACH_PHI_ARG (arg_p, phi, i, SSA_OP_USE)
+    {
+      tree arg = USE_FROM_PTR (arg_p);
+      /* Walk the ssa chain until we reach a ssa name we already
+	 created a value for or we reach a definition of the form
+	 ssa_name_n = &var;  */
+      while (TREE_CODE (arg) == SSA_NAME
+	     && !SSA_NAME_IS_DEFAULT_DEF (arg)
+	     && (SSA_NAME_VERSION (arg) >= n
+	         || phivn[SSA_NAME_VERSION (arg)].value == NULL_TREE))
+	{
+	  tree def_stmt = SSA_NAME_DEF_STMT (arg);
+	  if (TREE_CODE (def_stmt) != GIMPLE_MODIFY_STMT)
+	    return false;
+	  arg = GIMPLE_STMT_OPERAND (def_stmt, 1);
+	}
+      if ((TREE_CODE (arg) != ADDR_EXPR
+	   /* Avoid to have to decay *&a to a[0] later.  */
+	   || !is_gimple_reg_type (TREE_TYPE (TREE_OPERAND (arg, 0))))
+	  && !(TREE_CODE (arg) == SSA_NAME
+	       && phivn[SSA_NAME_VERSION (arg)].value != NULL_TREE
+	       && phivn_valid_p (phivn, arg, bb)))
+	return false;
+    }
+
+  /* Find a dereferencing use.  First follow (single use) ssa
+     copy chains for ptr.  */
+  while (single_imm_use (ptr, &use, &use_stmt)
+	 && TREE_CODE (use_stmt) == GIMPLE_MODIFY_STMT
+	 && GIMPLE_STMT_OPERAND (use_stmt, 1) == ptr
+	 && TREE_CODE (GIMPLE_STMT_OPERAND (use_stmt, 0)) == SSA_NAME)
+    ptr = GIMPLE_STMT_OPERAND (use_stmt, 0);
+
+  /* Replace the first dereference of *ptr if there is one and if we
+     can move the loads to the place of the ptr phi node.  */
+  phi_inserted = false;
+  FOR_EACH_IMM_USE_STMT (use_stmt, ui, ptr)
+    {
+      ssa_op_iter ui2;
+      tree vuse;
+
+      /* Check whether this is a load of *ptr.  */
+      if (!(TREE_CODE (use_stmt) == GIMPLE_MODIFY_STMT
+	    && TREE_CODE (GIMPLE_STMT_OPERAND (use_stmt, 0)) == SSA_NAME 
+	    && TREE_CODE (GIMPLE_STMT_OPERAND (use_stmt, 1)) == INDIRECT_REF
+	    && TREE_OPERAND (GIMPLE_STMT_OPERAND (use_stmt, 1), 0) == ptr
+	    /* We cannot replace a load that may throw or is volatile.  */
+	    && !tree_can_throw_internal (use_stmt)))
+	continue;
+
+      /* Check if we can move the loads.  The def stmts of all virtual uses
+	 need to be post-dominated by bb.  */
+      FOR_EACH_SSA_TREE_OPERAND (vuse, use_stmt, ui2, SSA_OP_VUSE)
+	{
+	  tree def_stmt = SSA_NAME_DEF_STMT (vuse);
+	  if (!SSA_NAME_IS_DEFAULT_DEF (vuse)
+	      && (bb_for_stmt (def_stmt) == bb
+		  || !dominated_by_p (CDI_DOMINATORS,
+				      bb, bb_for_stmt (def_stmt))))
+	    goto next;
+	}
+
+      /* Found a proper dereference.  Insert a phi node if this
+	 is the first load transformation.  */
+      if (!phi_inserted)
+	{
+	  res = phiprop_insert_phi (bb, phi, use_stmt, phivn, n);
+
+	  /* Remember the value we created for *ptr.  */
+	  phivn[SSA_NAME_VERSION (ptr)].value = res;
+	  phivn[SSA_NAME_VERSION (ptr)].vop_stmt = use_stmt;
+
+	  /* Remove old stmt.  The phi is taken care of by DCE, if we
+	     want to delete it here we also have to delete all intermediate
+	     copies.  */
+	  bsi = bsi_for_stmt (use_stmt);
+	  bsi_remove (&bsi, 0);
+
+	  phi_inserted = true;
+	}
+      else
+	{
+	  /* Further replacements are easy, just make a copy out of the
+	     load.  */
+	  GIMPLE_STMT_OPERAND (use_stmt, 1) = res;
+	  update_stmt (use_stmt);
+	}
+
+next:;
+      /* Continue searching for a proper dereference.  */
+    }
+
+  return phi_inserted;
+}
+
+/* Helper walking the dominator tree starting from BB and processing
+   phi nodes with global data PHIVN and N.  */
+
+static bool
+tree_ssa_phiprop_1 (basic_block bb, struct phiprop_d *phivn, size_t n)
+{
+  bool did_something = false; 
+  basic_block son;
+  tree phi;
+
+  for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
+    did_something |= propagate_with_phi (bb, phi, phivn, n);
+
+  for (son = first_dom_son (CDI_DOMINATORS, bb);
+       son;
+       son = next_dom_son (CDI_DOMINATORS, son))
+    did_something |= tree_ssa_phiprop_1 (son, phivn, n);
+
+  return did_something;
+}
+
+/* Main entry for phiprop pass.  */
+
+static unsigned int
+tree_ssa_phiprop (void)
+{
+  struct phiprop_d *phivn;
+
+  calculate_dominance_info (CDI_DOMINATORS);
+
+  phivn = XCNEWVEC (struct phiprop_d, num_ssa_names);
+
+  if (tree_ssa_phiprop_1 (ENTRY_BLOCK_PTR, phivn, num_ssa_names))
+    bsi_commit_edge_inserts ();
+
+  free (phivn);
+
+  return 0;
+}
+
+static bool
+gate_phiprop (void)
+{
+  return 1;
+}
+
+struct tree_opt_pass pass_phiprop = {
+  "phiprop",			/* name */
+  gate_phiprop,			/* gate */
+  tree_ssa_phiprop,		/* execute */
+  NULL,				/* sub */
+  NULL,				/* next */
+  0,				/* static_pass_number */
+  TV_TREE_FORWPROP,		/* tv_id */
+  PROP_cfg | PROP_ssa,		/* properties_required */
   0,				/* properties_provided */
-  PROP_smt_usage,		/* properties_destroyed */
+  0,				/* properties_destroyed */
   0,				/* todo_flags_start */
-  TODO_update_smt_usage |TODO_dump_func /* todo_flags_finish */
+  TODO_dump_func
   | TODO_ggc_collect
-  | TODO_update_ssa | TODO_verify_ssa,
-  0					/* letter */
+  | TODO_update_ssa
+  | TODO_verify_ssa,		/* todo_flags_finish */
+  0				/* letter */
 };