1 files changed, 3 insertions, 233 deletions

diff --git a/gcc/tree-ssa-copy.c b/gcc/tree-ssa-copy.c
index 32db3fa3d86..12aaff81d94 100644
--- a/gcc/tree-ssa-copy.c
+++ b/gcc/tree-ssa-copy.c
@@ -111,6 +111,7 @@ replace_exp_1 (use_operand_p op_p, tree val, bool for_propagation)
     SET_USE (op_p, lhd_unsave_expr_now (val));
 }
 
+
 /* Propagate the value VAL (assumed to be a constant or another SSA_NAME)
    into the operand pointed by OP_P.
 
@@ -123,6 +124,7 @@ propagate_value (use_operand_p op_p, tree val)
   replace_exp_1 (op_p, val, true);
 }
 
+
 /* Propagate the value VAL (assumed to be a constant or another SSA_NAME)
    into the tree pointed by OP_P.
 
@@ -144,6 +146,7 @@ propagate_tree_value (tree *op_p, tree val)
     *op_p = lhd_unsave_expr_now (val);
 }
 
+
 /* Replace *OP_P with value VAL (assumed to be a constant or another SSA_NAME).
 
    Use this version when not const/copy propagating values.  For example,
@@ -155,236 +158,3 @@ replace_exp (use_operand_p op_p, tree val)
 {
   replace_exp_1 (op_p, val, false);
 }
-
-/* Replace *OP_P in STMT with any known equivalent value for *OP_P from
-   CONST_AND_COPIES.  */
-
-static bool
-cprop_operand (stmt_ann_t ann, use_operand_p op_p, varray_type const_and_copies)
-{
-  bool may_have_exposed_new_symbols = false;
-  tree val;
-  tree op = USE_FROM_PTR (op_p);
-
-  /* If the operand has a known constant value or it is known to be a
-     copy of some other variable, use the value or copy stored in
-     CONST_AND_COPIES.  */
-  val = VARRAY_TREE (const_and_copies, SSA_NAME_VERSION (op));
-  if (val)
-    {
-      tree op_type, val_type;
-
-      /* Do not change the base variable in the virtual operand
-	 tables.  That would make it impossible to reconstruct
-	 the renamed virtual operand if we later modify this
-	 statement.  Also only allow the new value to be an SSA_NAME
-	 for propagation into virtual operands.  */
-      if (!is_gimple_reg (op)
-	  && (get_virtual_var (val) != get_virtual_var (op)
-	      || TREE_CODE (val) != SSA_NAME))
-	return false;
-
-      /* Get the toplevel type of each operand.  */
-      op_type = TREE_TYPE (op);
-      val_type = TREE_TYPE (val);
-
-      /* While both types are pointers, get the type of the object
-	 pointed to.  */
-      while (POINTER_TYPE_P (op_type) && POINTER_TYPE_P (val_type))
-	{
-	  op_type = TREE_TYPE (op_type);
-	  val_type = TREE_TYPE (val_type);
-	}
-
-      /* Make sure underlying types match before propagating a
-	 constant by converting the constant to the proper type.  Note
-	 that convert may return a non-gimple expression, in which case
-	 we ignore this propagation opportunity.  */
-     if (!lang_hooks.types_compatible_p (op_type, val_type)
-           && TREE_CODE (val) != SSA_NAME)
-	{
-	  val = fold_convert (TREE_TYPE (op), val);
-	  if (!is_gimple_min_invariant (val)
-	      && TREE_CODE (val) != SSA_NAME)
-	    return false;
-	}
-
-      /* Certain operands are not allowed to be copy propagated due
-	 to their interaction with exception handling and some GCC
-	 extensions.  */
-      if (TREE_CODE (val) == SSA_NAME
-	  && !may_propagate_copy (op, val))
-	return false;
-
-      /* Dump details.  */
-      if (dump_file && (dump_flags & TDF_DETAILS))
-	{
-	  fprintf (dump_file, "  Replaced '");
-	  print_generic_expr (dump_file, op, dump_flags);
-	  fprintf (dump_file, "' with %s '",
-		   (TREE_CODE (val) != SSA_NAME ? "constant" : "variable"));
-	  print_generic_expr (dump_file, val, dump_flags);
-	  fprintf (dump_file, "'\n");
-	}
-
-      /* If VAL is an ADDR_EXPR or a constant of pointer type, note
-	 that we may have exposed a new symbol for SSA renaming.  */
-      if (TREE_CODE (val) == ADDR_EXPR
-	  || (POINTER_TYPE_P (TREE_TYPE (op))
-	      && is_gimple_min_invariant (val)))
-	may_have_exposed_new_symbols = true;
-
-      propagate_value (op_p, val);
-
-      /* And note that we modified this statement.  This is now
-	 safe, even if we changed virtual operands since we will
-	 rescan the statement and rewrite its operands again.  */
-      ann->modified = 1;
-    }
-  return may_have_exposed_new_symbols;
-}
-
-/* CONST_AND_COPIES is a table which maps an SSA_NAME to the current
-   known value for that SSA_NAME (or NULL if no value is known).  
-
-   Propagate values from CONST_AND_COPIES into the uses, vuses and
-   v_may_def_ops of STMT.  */
-
-bool
-cprop_into_stmt (tree stmt, varray_type const_and_copies)
-{
-  bool may_have_exposed_new_symbols = false;
-  stmt_ann_t ann = stmt_ann (stmt);
-  size_t i, num_uses, num_vuses, num_v_may_defs;
-  vuse_optype vuses;
-  v_may_def_optype v_may_defs;
-  use_optype uses;
-
-  uses = USE_OPS (ann);
-  num_uses = NUM_USES (uses);
-  for (i = 0; i < num_uses; i++)
-    {
-      use_operand_p op_p = USE_OP_PTR (uses, i);
-      if (TREE_CODE (USE_FROM_PTR (op_p)) == SSA_NAME)
-	may_have_exposed_new_symbols
-	  |= cprop_operand (ann, op_p, const_and_copies);
-    }
-
-  vuses = VUSE_OPS (ann);
-  num_vuses = NUM_VUSES (vuses);
-  for (i = 0; i < num_vuses; i++)
-    {
-      use_operand_p op_p = VUSE_OP_PTR (vuses, i);
-      if (TREE_CODE (USE_FROM_PTR (op_p)) == SSA_NAME)
-	may_have_exposed_new_symbols
-	  |= cprop_operand (ann, op_p, const_and_copies);
-    }
-
-  v_may_defs = V_MAY_DEF_OPS (ann);
-  num_v_may_defs = NUM_V_MAY_DEFS (v_may_defs);
-  for (i = 0; i < num_v_may_defs; i++)
-    {
-      use_operand_p op_p = V_MAY_DEF_OP_PTR (v_may_defs, i);
-      if (TREE_CODE (USE_FROM_PTR (op_p)) == SSA_NAME)
-	may_have_exposed_new_symbols
-	  |= cprop_operand (ann, op_p, const_and_copies);
-    }
-  return may_have_exposed_new_symbols;
-}
-
-/* CONST_AND_COPIES is a table which maps an SSA_NAME to the current
-   known value for that SSA_NAME (or NULL if no value is known).  
-
-   NONZERO_VARS is the set SSA_NAMES known to have a nonzero value,
-   even if we don't know their precise value.
-
-   Propagate values from CONST_AND_COPIES and NONZERO_VARS into the PHI
-   nodes of the successors of BB.  */
-
-void
-cprop_into_successor_phis (basic_block bb,
-			   varray_type const_and_copies,
-			   bitmap nonzero_vars)
-{
-  edge e;
-
-  /* This can get rather expensive if the implementation is naive in
-     how it finds the phi alternative associated with a particular edge.  */
-  for (e = bb->succ; e; e = e->succ_next)
-    {
-      tree phi;
-      int phi_num_args;
-      int hint;
-
-      /* If this is an abnormal edge, then we do not want to copy propagate
-	 into the PHI alternative associated with this edge.  */
-      if (e->flags & EDGE_ABNORMAL)
-	continue;
-
-      phi = phi_nodes (e->dest);
-      if (! phi)
-	continue;
-
-      /* There is no guarantee that for any two PHI nodes in a block that
-	 the phi alternative associated with a particular edge will be
-	 at the same index in the phi alternative array.
-
-	 However, it is very likely they will be the same.  So we keep
-	 track of the index of the alternative where we found the edge in
-	 the previous phi node and check that index first in the next
-	 phi node.  If that hint fails, then we actually search all
-	 the entries.  */
-      phi_num_args = PHI_NUM_ARGS (phi);
-      hint = phi_num_args;
-      for ( ; phi; phi = PHI_CHAIN (phi))
-	{
-	  int i;
-	  tree new;
-	  use_operand_p orig_p;
-	  tree orig;
-
-	  /* If the hint is valid (!= phi_num_args), see if it points
-	     us to the desired phi alternative.  */
-	  if (hint != phi_num_args && PHI_ARG_EDGE (phi, hint) == e)
-	    ;
-	  else
-	    {
-	      /* The hint was either invalid or did not point to the
-		 correct phi alternative.  Search all the alternatives
-		 for the correct one.  Update the hint.  */
-	      for (i = 0; i < phi_num_args; i++)
-		if (PHI_ARG_EDGE (phi, i) == e)
-		  break;
-	      hint = i;
-	    }
-
-#ifdef ENABLE_CHECKING
-	  /* If we did not find the proper alternative, then something is
-	     horribly wrong.  */
-	  if (hint == phi_num_args)
-	    abort ();
-#endif
-
-	  /* The alternative may be associated with a constant, so verify
-	     it is an SSA_NAME before doing anything with it.  */
-	  orig_p = PHI_ARG_DEF_PTR (phi, hint);
-	  orig = USE_FROM_PTR (orig_p);
-	  if (TREE_CODE (orig) != SSA_NAME)
-	    continue;
-
-	  /* If the alternative is known to have a nonzero value, record
-	     that fact in the PHI node itself for future use.  */
-	  if (bitmap_bit_p (nonzero_vars, SSA_NAME_VERSION (orig)))
-	    PHI_ARG_NONZERO (phi, hint) = true;
-
-	  /* If we have *ORIG_P in our constant/copy table, then replace
-	     ORIG_P with its value in our constant/copy table.  */
-	  new = VARRAY_TREE (const_and_copies, SSA_NAME_VERSION (orig));
-	  if (new
-	      && (TREE_CODE (new) == SSA_NAME
-		  || is_gimple_min_invariant (new))
-	      && may_propagate_copy (orig, new))
-	    propagate_value (orig_p, new);
-	}
-    }
-}