Index: gcc/tree-ssa-forwprop.c
===================================================================
--- gcc/tree-ssa-forwprop.c	(revision 217279)
+++ gcc/tree-ssa-forwprop.c	(working copy)
@@ -1214,78 +1214,6 @@ bailout:
 }
 
 
-/* GSI_P points to a statement which performs a narrowing integral
-   conversion.
-
-   Look for cases like:
-
-     t = x & c;
-     y = (T) t;
-
-   Turn them into:
-
-     t = x & c;
-     y = (T) x;
-
-   If T is narrower than X's type and C merely masks off bits outside
-   of (T) and nothing else.
-
-   Normally we'd let DCE remove the dead statement.  But no DCE runs
-   after the last forwprop/combine pass, so we remove the obviously
-   dead code ourselves.
-
-   Return TRUE if a change was made, FALSE otherwise.  */
-
-static bool 
-simplify_conversion_from_bitmask (gimple_stmt_iterator *gsi_p)
-{
-  gimple stmt = gsi_stmt (*gsi_p);
-  gimple rhs_def_stmt = SSA_NAME_DEF_STMT (gimple_assign_rhs1 (stmt));
-
-  /* See if the input for the conversion was set via a BIT_AND_EXPR and
-     the only use of the BIT_AND_EXPR result is the conversion.  */
-  if (is_gimple_assign (rhs_def_stmt)
-      && gimple_assign_rhs_code (rhs_def_stmt) == BIT_AND_EXPR
-      && has_single_use (gimple_assign_lhs (rhs_def_stmt)))
-    {
-      tree rhs_def_operand1 = gimple_assign_rhs1 (rhs_def_stmt);
-      tree rhs_def_operand2 = gimple_assign_rhs2 (rhs_def_stmt);
-      tree lhs_type = TREE_TYPE (gimple_assign_lhs (stmt));
-
-      /* Now verify suitability of the BIT_AND_EXPR's operands.
-	 The first must be an SSA_NAME that we can propagate and the
-	 second must be an integer constant that masks out all the
-	 bits outside the final result's type, but nothing else.  */
-      if (TREE_CODE (rhs_def_operand1) == SSA_NAME
-	  && ! SSA_NAME_OCCURS_IN_ABNORMAL_PHI (rhs_def_operand1)
-	  && TREE_CODE (rhs_def_operand2) == INTEGER_CST
-	  && operand_equal_p (rhs_def_operand2,
-			      build_low_bits_mask (TREE_TYPE (rhs_def_operand2),
-			       			   TYPE_PRECISION (lhs_type)),
-						   0))
-	{
-	  /* This is an optimizable case.  Replace the source operand
-	     in the conversion with the first source operand of the
-	     BIT_AND_EXPR.  */
-	  gimple_assign_set_rhs1 (stmt, rhs_def_operand1);
-	  stmt = gsi_stmt (*gsi_p);
-	  update_stmt (stmt);
-
-	  /* There is no DCE after the last forwprop pass.  It's
-	     easy to clean up the first order effects here.  */
-	  gimple_stmt_iterator si;
-	  si = gsi_for_stmt (rhs_def_stmt);
-	  gsi_remove (&si, true);
-	  fwprop_invalidate_lattice (gimple_get_lhs (rhs_def_stmt));
-	  release_defs (rhs_def_stmt);
-	  return true;
-	}
-    }
-
-  return false;
-}
-
-
 /* Helper function for simplify_gimple_switch.  Remove case labels that
    have values outside the range of the new type.  */
 
@@ -1992,467 +1920,6 @@ simplify_rotate (gimple_stmt_iterator *g
   return true;
 }
 
-/* Perform re-associations of the plus or minus statement STMT that are
-   always permitted.  Returns true if the CFG was changed.  */
-
-static bool
-associate_plusminus (gimple_stmt_iterator *gsi)
-{
-  gimple stmt = gsi_stmt (*gsi);
-  tree rhs1 = gimple_assign_rhs1 (stmt);
-  tree rhs2 = gimple_assign_rhs2 (stmt);
-  enum tree_code code = gimple_assign_rhs_code (stmt);
-  bool changed;
-
-  /* We can't reassociate at all for saturating types.  */
-  if (TYPE_SATURATING (TREE_TYPE (rhs1)))
-    return false;
-
-  /* First contract negates.  */
-  do
-    {
-      changed = false;
-
-      /* A +- (-B) -> A -+ B.  */
-      if (TREE_CODE (rhs2) == SSA_NAME)
-	{
-	  gimple def_stmt = SSA_NAME_DEF_STMT (rhs2);
-	  if (is_gimple_assign (def_stmt)
-	      && gimple_assign_rhs_code (def_stmt) == NEGATE_EXPR
-	      && can_propagate_from (def_stmt))
-	    {
-	      code = (code == MINUS_EXPR) ? PLUS_EXPR : MINUS_EXPR;
-	      gimple_assign_set_rhs_code (stmt, code);
-	      rhs2 = gimple_assign_rhs1 (def_stmt);
-	      gimple_assign_set_rhs2 (stmt, rhs2);
-	      gimple_set_modified (stmt, true);
-	      changed = true;
-	    }
-	}
-
-      /* (-A) + B -> B - A.  */
-      if (TREE_CODE (rhs1) == SSA_NAME
-	  && code == PLUS_EXPR)
-	{
-	  gimple def_stmt = SSA_NAME_DEF_STMT (rhs1);
-	  if (is_gimple_assign (def_stmt)
-	      && gimple_assign_rhs_code (def_stmt) == NEGATE_EXPR
-	      && can_propagate_from (def_stmt))
-	    {
-	      code = MINUS_EXPR;
-	      gimple_assign_set_rhs_code (stmt, code);
-	      rhs1 = rhs2;
-	      gimple_assign_set_rhs1 (stmt, rhs1);
-	      rhs2 = gimple_assign_rhs1 (def_stmt);
-	      gimple_assign_set_rhs2 (stmt, rhs2);
-	      gimple_set_modified (stmt, true);
-	      changed = true;
-	    }
-	}
-    }
-  while (changed);
-
-  /* We can't reassociate floating-point or fixed-point plus or minus
-     because of saturation to +-Inf.  */
-  if (FLOAT_TYPE_P (TREE_TYPE (rhs1))
-      || FIXED_POINT_TYPE_P (TREE_TYPE (rhs1)))
-    goto out;
-
-  /* Second match patterns that allow contracting a plus-minus pair
-     irrespective of overflow issues.
-
-	(A +- B) - A       ->  +- B
-	(A +- B) -+ B      ->  A
-	(CST +- A) +- CST  ->  CST +- A
-	(A +- CST) +- CST  ->  A +- CST
-	~A + A             ->  -1
-	~A + 1             ->  -A 
-	A - (A +- B)       ->  -+ B
-	A +- (B +- A)      ->  +- B
-	CST +- (CST +- A)  ->  CST +- A
-	CST +- (A +- CST)  ->  CST +- A
-	A + ~A             ->  -1
-	(T)(P + A) - (T)P  -> (T)A
-
-     via commutating the addition and contracting operations to zero
-     by reassociation.  */
-
-  if (TREE_CODE (rhs1) == SSA_NAME)
-    {
-      gimple def_stmt = SSA_NAME_DEF_STMT (rhs1);
-      if (is_gimple_assign (def_stmt) && can_propagate_from (def_stmt))
-	{
-	  enum tree_code def_code = gimple_assign_rhs_code (def_stmt);
-	  if (def_code == PLUS_EXPR
-	      || def_code == MINUS_EXPR)
-	    {
-	      tree def_rhs1 = gimple_assign_rhs1 (def_stmt);
-	      tree def_rhs2 = gimple_assign_rhs2 (def_stmt);
-	      if (operand_equal_p (def_rhs1, rhs2, 0)
-		  && code == MINUS_EXPR)
-		{
-		  /* (A +- B) - A -> +- B.  */
-		  code = ((def_code == PLUS_EXPR)
-			  ? TREE_CODE (def_rhs2) : NEGATE_EXPR);
-		  rhs1 = def_rhs2;
-		  rhs2 = NULL_TREE;
-		  gimple_assign_set_rhs_with_ops (gsi, code, rhs1, NULL_TREE);
-		  gcc_assert (gsi_stmt (*gsi) == stmt);
-		  gimple_set_modified (stmt, true);
-		}
-	      else if (operand_equal_p (def_rhs2, rhs2, 0)
-		       && code != def_code)
-		{
-		  /* (A +- B) -+ B -> A.  */
-		  code = TREE_CODE (def_rhs1);
-		  rhs1 = def_rhs1;
-		  rhs2 = NULL_TREE;
-		  gimple_assign_set_rhs_with_ops (gsi, code, rhs1, NULL_TREE);
-		  gcc_assert (gsi_stmt (*gsi) == stmt);
-		  gimple_set_modified (stmt, true);
-		}
-	      else if (CONSTANT_CLASS_P (rhs2)
-		       && CONSTANT_CLASS_P (def_rhs1))
-		{
-		  /* (CST +- A) +- CST -> CST +- A.  */
-		  tree cst = fold_binary (code, TREE_TYPE (rhs1),
-					  def_rhs1, rhs2);
-		  if (cst && !TREE_OVERFLOW (cst))
-		    {
-		      code = def_code;
-		      gimple_assign_set_rhs_code (stmt, code);
-		      rhs1 = cst;
-		      gimple_assign_set_rhs1 (stmt, rhs1);
-		      rhs2 = def_rhs2;
-		      gimple_assign_set_rhs2 (stmt, rhs2);
-		      gimple_set_modified (stmt, true);
-		    }
-		}
-	      else if (CONSTANT_CLASS_P (rhs2)
-		       && CONSTANT_CLASS_P (def_rhs2))
-		{
-		  /* (A +- CST) +- CST -> A +- CST.  */
-		  enum tree_code mix = (code == def_code)
-				       ? PLUS_EXPR : MINUS_EXPR;
-		  tree cst = fold_binary (mix, TREE_TYPE (rhs1),
-					  def_rhs2, rhs2);
-		  if (cst && !TREE_OVERFLOW (cst))
-		    {
-		      code = def_code;
-		      gimple_assign_set_rhs_code (stmt, code);
-		      rhs1 = def_rhs1;
-		      gimple_assign_set_rhs1 (stmt, rhs1);
-		      rhs2 = cst;
-		      gimple_assign_set_rhs2 (stmt, rhs2);
-		      gimple_set_modified (stmt, true);
-		    }
-		}
-	    }
-	  else if (def_code == BIT_NOT_EXPR && code == PLUS_EXPR)
-	    {
-	      tree def_rhs1 = gimple_assign_rhs1 (def_stmt);
-	      if (operand_equal_p (def_rhs1, rhs2, 0))
-		{
-		  /* ~A + A -> -1.  */
-		  rhs1 = build_all_ones_cst (TREE_TYPE (rhs2));
-		  rhs2 = NULL_TREE;
-		  code = TREE_CODE (rhs1);
-		  gimple_assign_set_rhs_with_ops (gsi, code, rhs1, NULL_TREE);
-		  gcc_assert (gsi_stmt (*gsi) == stmt);
-		  gimple_set_modified (stmt, true);
-		}
-	      else if ((TREE_CODE (TREE_TYPE (rhs2)) != COMPLEX_TYPE
-			&& integer_onep (rhs2))
-		       || (TREE_CODE (rhs2) == COMPLEX_CST
-			   && integer_onep (TREE_REALPART (rhs2))
-			   && integer_onep (TREE_IMAGPART (rhs2))))
-		{
-		  /* ~A + 1 -> -A.  */
-		  code = NEGATE_EXPR;
-		  rhs1 = def_rhs1;
-		  rhs2 = NULL_TREE;
-		  gimple_assign_set_rhs_with_ops (gsi, code, rhs1, NULL_TREE);
-		  gcc_assert (gsi_stmt (*gsi) == stmt);
-		  gimple_set_modified (stmt, true);
-		}
-	    }
-	  else if (code == MINUS_EXPR
-		   && CONVERT_EXPR_CODE_P (def_code)
-		   && TREE_CODE (gimple_assign_rhs1 (def_stmt)) == SSA_NAME
-		   && TREE_CODE (rhs2) == SSA_NAME)
-	    {
-	      /* (T)(P + A) - (T)P -> (T)A.  */
-	      gimple def_stmt2 = SSA_NAME_DEF_STMT (rhs2);
-	      if (is_gimple_assign (def_stmt2)
-		  && can_propagate_from (def_stmt2)
-		  && CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def_stmt2))
-		  && TREE_CODE (gimple_assign_rhs1 (def_stmt2)) == SSA_NAME)
-		{
-		  /* Now we have (T)X - (T)P.  */
-		  tree p = gimple_assign_rhs1 (def_stmt2);
-		  def_stmt2 = SSA_NAME_DEF_STMT (gimple_assign_rhs1 (def_stmt));
-		  if (is_gimple_assign (def_stmt2)
-		      && can_propagate_from (def_stmt2)
-		      && (gimple_assign_rhs_code (def_stmt2) == POINTER_PLUS_EXPR
-			  || gimple_assign_rhs_code (def_stmt2) == PLUS_EXPR)
-		      && gimple_assign_rhs1 (def_stmt2) == p)
-		    {
-		      /* And finally (T)(P + A) - (T)P.  */
-		      tree a = gimple_assign_rhs2 (def_stmt2);
-		      if (TYPE_PRECISION (TREE_TYPE (rhs1))
-			  <= TYPE_PRECISION (TREE_TYPE (a))
-			  /* For integer types, if A has a smaller type
-			     than T the result depends on the possible
-			     overflow in P + A.
-			     E.g. T=size_t, A=(unsigned)429497295, P>0.
-			     However, if an overflow in P + A would cause
-			     undefined behavior, we can assume that there
-			     is no overflow.  */
-			  || (INTEGRAL_TYPE_P (TREE_TYPE (p))
-			      && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (p)))
-			  /* For pointer types, if the conversion of A to the
-			     final type requires a sign- or zero-extension,
-			     then we have to punt - it is not defined which
-			     one is correct.  */
-			  || (POINTER_TYPE_P (TREE_TYPE (p))
-			      && TREE_CODE (a) == INTEGER_CST
-			      && tree_int_cst_sign_bit (a) == 0))
-			{
-			  if (issue_strict_overflow_warning
-			      (WARN_STRICT_OVERFLOW_MISC)
-			      && TYPE_PRECISION (TREE_TYPE (rhs1))
-				 > TYPE_PRECISION (TREE_TYPE (a))
-			      && INTEGRAL_TYPE_P (TREE_TYPE (p)))
-			    warning_at (gimple_location (stmt),
-					OPT_Wstrict_overflow,
-					"assuming signed overflow does not "
-					"occur when assuming that "
-					"(T)(P + A) - (T)P is always (T)A");
-			  if (useless_type_conversion_p (TREE_TYPE (rhs1),
-							 TREE_TYPE (a)))
-			    code = TREE_CODE (a);
-			  else
-			    code = NOP_EXPR;
-			  rhs1 = a;
-			  rhs2 = NULL_TREE;
-			  gimple_assign_set_rhs_with_ops (gsi, code, rhs1,
-							  rhs2);
-			  gcc_assert (gsi_stmt (*gsi) == stmt);
-			  gimple_set_modified (stmt, true);
-			}
-		    }
-		}
-	    }
-	}
-    }
-
-  if (rhs2 && TREE_CODE (rhs2) == SSA_NAME)
-    {
-      gimple def_stmt = SSA_NAME_DEF_STMT (rhs2);
-      if (is_gimple_assign (def_stmt) && can_propagate_from (def_stmt))
-	{
-	  enum tree_code def_code = gimple_assign_rhs_code (def_stmt);
-	  if (def_code == PLUS_EXPR
-	      || def_code == MINUS_EXPR)
-	    {
-	      tree def_rhs1 = gimple_assign_rhs1 (def_stmt);
-	      tree def_rhs2 = gimple_assign_rhs2 (def_stmt);
-	      if (operand_equal_p (def_rhs1, rhs1, 0)
-		  && code == MINUS_EXPR)
-		{
-		  /* A - (A +- B) -> -+ B.  */
-		  code = ((def_code == PLUS_EXPR)
-			  ? NEGATE_EXPR : TREE_CODE (def_rhs2));
-		  rhs1 = def_rhs2;
-		  rhs2 = NULL_TREE;
-		  gimple_assign_set_rhs_with_ops (gsi, code, rhs1, NULL_TREE);
-		  gcc_assert (gsi_stmt (*gsi) == stmt);
-		  gimple_set_modified (stmt, true);
-		}
-	      else if (operand_equal_p (def_rhs2, rhs1, 0)
-		       && code != def_code)
-		{
-		  /* A +- (B +- A) -> +- B.  */
-		  code = ((code == PLUS_EXPR)
-			  ? TREE_CODE (def_rhs1) : NEGATE_EXPR);
-		  rhs1 = def_rhs1;
-		  rhs2 = NULL_TREE;
-		  gimple_assign_set_rhs_with_ops (gsi, code, rhs1, NULL_TREE);
-		  gcc_assert (gsi_stmt (*gsi) == stmt);
-		  gimple_set_modified (stmt, true);
-		}
-	      else if (CONSTANT_CLASS_P (rhs1)
-		       && CONSTANT_CLASS_P (def_rhs1))
-		{
-		  /* CST +- (CST +- A) -> CST +- A.  */
-		  tree cst = fold_binary (code, TREE_TYPE (rhs2),
-					  rhs1, def_rhs1);
-		  if (cst && !TREE_OVERFLOW (cst))
-		    {
-		      code = (code == def_code ? PLUS_EXPR : MINUS_EXPR);
-		      gimple_assign_set_rhs_code (stmt, code);
-		      rhs1 = cst;
-		      gimple_assign_set_rhs1 (stmt, rhs1);
-		      rhs2 = def_rhs2;
-		      gimple_assign_set_rhs2 (stmt, rhs2);
-		      gimple_set_modified (stmt, true);
-		    }
-		}
-	      else if (CONSTANT_CLASS_P (rhs1)
-		       && CONSTANT_CLASS_P (def_rhs2))
-		{
-		  /* CST +- (A +- CST) -> CST +- A.  */
-		  tree cst = fold_binary (def_code == code
-					  ? PLUS_EXPR : MINUS_EXPR,
-					  TREE_TYPE (rhs2),
-					  rhs1, def_rhs2);
-		  if (cst && !TREE_OVERFLOW (cst))
-		    {
-		      rhs1 = cst;
-		      gimple_assign_set_rhs1 (stmt, rhs1);
-		      rhs2 = def_rhs1;
-		      gimple_assign_set_rhs2 (stmt, rhs2);
-		      gimple_set_modified (stmt, true);
-		    }
-		}
-	    }
-	  else if (def_code == BIT_NOT_EXPR)
-	    {
-	      tree def_rhs1 = gimple_assign_rhs1 (def_stmt);
-	      if (code == PLUS_EXPR
-		  && operand_equal_p (def_rhs1, rhs1, 0))
-		{
-		  /* A + ~A -> -1.  */
-		  rhs1 = build_all_ones_cst (TREE_TYPE (rhs1));
-		  rhs2 = NULL_TREE;
-		  code = TREE_CODE (rhs1);
-		  gimple_assign_set_rhs_with_ops (gsi, code, rhs1, NULL_TREE);
-		  gcc_assert (gsi_stmt (*gsi) == stmt);
-		  gimple_set_modified (stmt, true);
-		}
-	    }
-	}
-    }
-
-out:
-  if (gimple_modified_p (stmt))
-    {
-      fold_stmt_inplace (gsi);
-      update_stmt (stmt);
-      return true;
-    }
-
-  return false;
-}
-
-/* Combine two conversions in a row for the second conversion at *GSI.
-   Returns 1 if there were any changes made, 2 if cfg-cleanup needs to
-   run.  Else it returns 0.  */
- 
-static int
-combine_conversions (gimple_stmt_iterator *gsi)
-{
-  gimple stmt = gsi_stmt (*gsi);
-  gimple def_stmt;
-  tree op0, lhs;
-  enum tree_code code = gimple_assign_rhs_code (stmt);
-  enum tree_code code2;
-
-  gcc_checking_assert (CONVERT_EXPR_CODE_P (code)
-		       || code == FLOAT_EXPR
-		       || code == FIX_TRUNC_EXPR);
-
-  lhs = gimple_assign_lhs (stmt);
-  op0 = gimple_assign_rhs1 (stmt);
-  if (useless_type_conversion_p (TREE_TYPE (lhs), TREE_TYPE (op0)))
-    {
-      gimple_assign_set_rhs_code (stmt, TREE_CODE (op0));
-      return 1;
-    }
-
-  if (TREE_CODE (op0) != SSA_NAME)
-    return 0;
-
-  def_stmt = SSA_NAME_DEF_STMT (op0);
-  if (!is_gimple_assign (def_stmt))
-    return 0;
-
-  code2 = gimple_assign_rhs_code (def_stmt);
-
-  if (CONVERT_EXPR_CODE_P (code2) || code2 == FLOAT_EXPR)
-    {
-      tree defop0 = gimple_assign_rhs1 (def_stmt);
-      tree type = TREE_TYPE (lhs);
-      tree inside_type = TREE_TYPE (defop0);
-      tree inter_type = TREE_TYPE (op0);
-      int inside_int = INTEGRAL_TYPE_P (inside_type);
-      unsigned int inside_prec = TYPE_PRECISION (inside_type);
-      int inside_unsignedp = TYPE_UNSIGNED (inside_type);
-      int inter_int = INTEGRAL_TYPE_P (inter_type);
-      int inter_float = FLOAT_TYPE_P (inter_type);
-      unsigned int inter_prec = TYPE_PRECISION (inter_type);
-      int inter_unsignedp = TYPE_UNSIGNED (inter_type);
-      int final_int = INTEGRAL_TYPE_P (type);
-      unsigned int final_prec = TYPE_PRECISION (type);
-
-      /* Don't propagate ssa names that occur in abnormal phis.  */
-      if (TREE_CODE (defop0) == SSA_NAME
-	  && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (defop0))
-	return 0;
-
-      /* A truncation to an unsigned type should be canonicalized as
-	 bitwise and of a mask.  */
-      if (final_int && inter_int && inside_int
-	  && final_prec == inside_prec
-	  && final_prec > inter_prec
-	  && inter_unsignedp)
-	{
-	  tree tem;
-	  tem = fold_build2 (BIT_AND_EXPR, inside_type,
-			     defop0,
-			     wide_int_to_tree
-			     (inside_type,
-			      wi::mask (inter_prec, false,
-					TYPE_PRECISION (inside_type))));
-	  if (!useless_type_conversion_p (type, inside_type))
-	    {
-	      tem = force_gimple_operand_gsi (gsi, tem, true, NULL_TREE, true,
-					      GSI_SAME_STMT);
-	      gimple_assign_set_rhs1 (stmt, tem);
-	    }
-	  else
-	    gimple_assign_set_rhs_from_tree (gsi, tem);
-	  update_stmt (gsi_stmt (*gsi));
-	  return 1;
-	}
-
-      /* If we are converting an integer to a floating-point that can
-	 represent it exactly and back to an integer, we can skip the
-	 floating-point conversion.  */
-      if (inside_int && inter_float && final_int &&
-          (unsigned) significand_size (TYPE_MODE (inter_type))
-          >= inside_prec - !inside_unsignedp)
-        {
-	  if (useless_type_conversion_p (type, inside_type))
-	    {
-	      gimple_assign_set_rhs1 (stmt, unshare_expr (defop0));
-	      gimple_assign_set_rhs_code (stmt, TREE_CODE (defop0));
-	      update_stmt (stmt);
-	      return remove_prop_source_from_use (op0) ? 2 : 1;
-	    }
-	  else
-	    {
-	      gimple_assign_set_rhs1 (stmt, defop0);
-	      gimple_assign_set_rhs_code (stmt, CONVERT_EXPR);
-	      update_stmt (stmt);
-	      return remove_prop_source_from_use (op0) ? 2 : 1;
-	    }
-	}
-    }
-
-  return 0;
-}
-
 /* Combine an element access with a shuffle.  Returns true if there were
    any changes made, else it returns false.  */
  
@@ -2768,54 +2235,6 @@ simplify_vector_constructor (gimple_stmt
   return true;
 }
 
-/* Simplify multiplications.
-   Return true if a transformation applied, otherwise return false.  */
-
-static bool
-simplify_mult (gimple_stmt_iterator *gsi)
-{
-  gimple stmt = gsi_stmt (*gsi);
-  tree arg1 = gimple_assign_rhs1 (stmt);
-  tree arg2 = gimple_assign_rhs2 (stmt);
-
-  if (TREE_CODE (arg1) != SSA_NAME)
-    return false;
-
-  gimple def_stmt = SSA_NAME_DEF_STMT (arg1);
-  if (!is_gimple_assign (def_stmt))
-    return false;
-
-  /* Look through a sign-changing conversion.  */
-  if (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def_stmt)))
-    {
-      if (TYPE_PRECISION (TREE_TYPE (gimple_assign_lhs (def_stmt)))
-	  != TYPE_PRECISION (TREE_TYPE (gimple_assign_rhs1 (def_stmt)))
-	  || TREE_CODE (gimple_assign_rhs1 (def_stmt)) != SSA_NAME)
-	return false;
-      def_stmt = SSA_NAME_DEF_STMT (gimple_assign_rhs1 (def_stmt));
-      if (!is_gimple_assign (def_stmt))
-	return false;
-    }
-
-  if (gimple_assign_rhs_code (def_stmt) == EXACT_DIV_EXPR)
-    {
-      if (operand_equal_p (gimple_assign_rhs2 (def_stmt), arg2, 0))
-	{
-	  tree res = gimple_assign_rhs1 (def_stmt);
-	  if (useless_type_conversion_p (TREE_TYPE (arg1), TREE_TYPE (res)))
-	    gimple_assign_set_rhs_with_ops (gsi, TREE_CODE (res), res,
-					    NULL_TREE);
-	  else
-	    gimple_assign_set_rhs_with_ops (gsi, NOP_EXPR, res, NULL_TREE);
-	  gcc_assert (gsi_stmt (*gsi) == stmt);
-	  update_stmt (stmt);
-	  return true;
-	}
-    }
-
-  return false;
-}
-
 
 /* Primitive "lattice" function for gimple_simplify.  */
 
@@ -3033,48 +2452,6 @@ pass_forwprop::execute (function *fun)
 			  || code == BIT_XOR_EXPR)
 			 && simplify_rotate (&gsi))
 		  changed = true;
-		else if (code == MULT_EXPR)
-		  {
-		    changed = simplify_mult (&gsi);
-		    if (changed
-			&& maybe_clean_or_replace_eh_stmt (stmt, stmt))
-		      bitmap_set_bit (to_purge, bb->index);
-		  }
-		else if (code == PLUS_EXPR
-			 || code == MINUS_EXPR)
-		  {
-		    changed = associate_plusminus (&gsi);
-		    if (changed
-			&& maybe_clean_or_replace_eh_stmt (stmt, stmt))
-		      bitmap_set_bit (to_purge, bb->index);
-		  }
-		else if (CONVERT_EXPR_CODE_P (code)
-			 || code == FLOAT_EXPR
-			 || code == FIX_TRUNC_EXPR)
-		  {
-		    int did_something = combine_conversions (&gsi);
-		    if (did_something == 2)
-		      cfg_changed = true;
-
-		    /* If we have a narrowing conversion to an integral
-		       type that is fed by a BIT_AND_EXPR, we might be
-		       able to remove the BIT_AND_EXPR if it merely
-		       masks off bits outside the final type (and nothing
-		       else.  */
-		    if (! did_something)
-		      {
-			tree outer_type = TREE_TYPE (gimple_assign_lhs (stmt));
-			tree inner_type = TREE_TYPE (gimple_assign_rhs1 (stmt));
-			if (TREE_CODE (gimple_assign_rhs1 (stmt)) == SSA_NAME
-			    && INTEGRAL_TYPE_P (outer_type)
-			    && INTEGRAL_TYPE_P (inner_type)
-			    && (TYPE_PRECISION (outer_type)
-				<= TYPE_PRECISION (inner_type)))
-			  did_something = simplify_conversion_from_bitmask (&gsi);
-		      }
-		      
-		    changed = did_something != 0;
-		  }
 		else if (code == VEC_PERM_EXPR)
 		  {
 		    int did_something = simplify_permutation (&gsi);
Index: gcc/gimple-fold.c
===================================================================
--- gcc/gimple-fold.c	(revision 217279)
+++ gcc/gimple-fold.c	(working copy)
@@ -465,12 +465,6 @@ fold_gimple_assign (gimple_stmt_iterator
 	    }
 	}
 
-      if (!result)
-        result = fold_binary_loc (loc, subcode,
-				  TREE_TYPE (gimple_assign_lhs (stmt)),
-				  gimple_assign_rhs1 (stmt),
-				  gimple_assign_rhs2 (stmt));
-
       if (result)
         {
           STRIP_USELESS_TYPE_CONVERSION (result);
@@ -480,56 +474,6 @@ fold_gimple_assign (gimple_stmt_iterator
       break;
 
     case GIMPLE_TERNARY_RHS:
-      /* Try to fold a conditional expression.  */
-      if (gimple_assign_rhs_code (stmt) == COND_EXPR)
-	{
-	  tree op0 = gimple_assign_rhs1 (stmt);
-	  tree tem;
-	  bool set = false;
-	  location_t cond_loc = gimple_location (stmt);
-
-	  if (COMPARISON_CLASS_P (op0))
-	    {
-	      fold_defer_overflow_warnings ();
-	      tem = fold_binary_loc (cond_loc,
-				     TREE_CODE (op0), TREE_TYPE (op0),
-				     TREE_OPERAND (op0, 0),
-				     TREE_OPERAND (op0, 1));
-	      /* This is actually a conditional expression, not a GIMPLE
-		 conditional statement, however, the valid_gimple_rhs_p
-		 test still applies.  */
-	      set = (tem && is_gimple_condexpr (tem)
-		     && valid_gimple_rhs_p (tem));
-	      fold_undefer_overflow_warnings (set, stmt, 0);
-	    }
-	  else if (is_gimple_min_invariant (op0))
-	    {
-	      tem = op0;
-	      set = true;
-	    }
-	  else
-	    return NULL_TREE;
-
-	  if (set)
-	    result = fold_build3_loc (cond_loc, COND_EXPR,
-				      TREE_TYPE (gimple_assign_lhs (stmt)), tem,
-				      gimple_assign_rhs2 (stmt),
-				      gimple_assign_rhs3 (stmt));
-	}
-
-      if (!result)
-	result = fold_ternary_loc (loc, subcode,
-				   TREE_TYPE (gimple_assign_lhs (stmt)),
-				   gimple_assign_rhs1 (stmt),
-				   gimple_assign_rhs2 (stmt),
-				   gimple_assign_rhs3 (stmt));
-
-      if (result)
-        {
-          STRIP_USELESS_TYPE_CONVERSION (result);
-          if (valid_gimple_rhs_p (result))
-	    return result;
-        }
       break;
 
     case GIMPLE_INVALID_RHS:
@@ -4528,33 +4472,11 @@ gimple_fold_stmt_to_constant_1 (gimple s
 					 unshare_expr (op0), off));
 		}
 
-              return fold_binary_loc (loc, subcode,
-				      gimple_expr_type (stmt), op0, op1);
+              return NULL_TREE;
             }
 
           case GIMPLE_TERNARY_RHS:
-            {
-              /* Handle ternary operators that can appear in GIMPLE form.  */
-              tree op0 = (*valueize) (gimple_assign_rhs1 (stmt));
-              tree op1 = (*valueize) (gimple_assign_rhs2 (stmt));
-              tree op2 = (*valueize) (gimple_assign_rhs3 (stmt));
-
-	      /* Fold embedded expressions in ternary codes.  */
-	      if ((subcode == COND_EXPR
-		   || subcode == VEC_COND_EXPR)
-		  && COMPARISON_CLASS_P (op0))
-		{
-		  tree op00 = (*valueize) (TREE_OPERAND (op0, 0));
-		  tree op01 = (*valueize) (TREE_OPERAND (op0, 1));
-		  tree tem = fold_binary_loc (loc, TREE_CODE (op0),
-					      TREE_TYPE (op0), op00, op01);
-		  if (tem)
-		    op0 = tem;
-		}
-
-              return fold_ternary_loc (loc, subcode,
-				       gimple_expr_type (stmt), op0, op1, op2);
-            }
+	    return NULL_TREE;
 
           default:
             gcc_unreachable ();
