CbC/CbC_gcc: gcc/tree-ssa-copy.c comparison

comparison gcc/tree-ssa-copy.c @ 111:04ced10e8804

gcc 7

author	kono
date	Fri, 27 Oct 2017 22:46:09 +0900
parents	f6334be47118
children	84e7813d76e9

comparison

equal deleted inserted replaced

-:561a7518be6b
+:04ced10e8804
 /* Copy propagation and SSA_NAME replacement support routines.
-Copyright (C) 2004, 2005, 2006, 2007, 2008, 2010
+Copyright (C) 2004-2017 Free Software Foundation, Inc.
-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
 <http://www.gnu.org/licenses/>.  */
 #include "config.h"
 #include "system.h"
 #include "coretypes.h"
-#include "tm.h"
+#include "backend.h"
 #include "tree.h"
-#include "flags.h"
+#include "gimple.h"
-#include "tm_p.h"
+#include "tree-pass.h"
-#include "basic-block.h"
+#include "ssa.h"
-#include "output.h"
-#include "function.h"
-#include "tree-pretty-print.h"
 #include "gimple-pretty-print.h"
-#include "timevar.h"
+#include "fold-const.h"
-#include "tree-dump.h"
+#include "gimple-iterator.h"
-#include "tree-flow.h"
+#include "tree-cfg.h"
-#include "tree-pass.h"
 #include "tree-ssa-propagate.h"
-#include "langhooks.h"
 #include "cfgloop.h"
+#include "tree-scalar-evolution.h"
+#include "tree-ssa-loop-niter.h"
 /* This file implements the copy propagation pass and provides a
 handful of interfaces for performing const/copy propagation and
 simple expression replacement which keep variable annotations
 up-to-date.
 store operation.
 We enforce these requirements by having all copy propagation and
 replacements of one SSA_NAME with a different SSA_NAME to use the
 APIs defined in this file.  */
-/* Return true if we may propagate ORIG into DEST, false otherwise.  */
-bool
-may_propagate_copy (tree dest, tree orig)
-{
-tree type_d = TREE_TYPE (dest);
-tree type_o = TREE_TYPE (orig);
-/* If ORIG flows in from an abnormal edge, it cannot be propagated.  */
-if (TREE_CODE (orig) == SSA_NAME
-&& SSA_NAME_OCCURS_IN_ABNORMAL_PHI (orig))
-return false;
-/* If DEST is an SSA_NAME that flows from an abnormal edge, then it
-cannot be replaced.  */
-if (TREE_CODE (dest) == SSA_NAME
-&& SSA_NAME_OCCURS_IN_ABNORMAL_PHI (dest))
-return false;
-/* Do not copy between types for which we *do* need a conversion.  */
-if (!useless_type_conversion_p (type_d, type_o))
-return false;
-/* Propagating virtual operands is always ok.  */
-if (TREE_CODE (dest) == SSA_NAME && !is_gimple_reg (dest))
-{
-/* But only between virtual operands.  */
-gcc_assert (TREE_CODE (orig) == SSA_NAME && !is_gimple_reg (orig));
-return true;
-}
-/* Anything else is OK.  */
-return true;
-}
-/* Like may_propagate_copy, but use as the destination expression
-the principal expression (typically, the RHS) contained in
-statement DEST.  This is more efficient when working with the
-gimple tuples representation.  */
-bool
-may_propagate_copy_into_stmt (gimple dest, tree orig)
-{
-tree type_d;
-tree type_o;
-/* If the statement is a switch or a single-rhs assignment,
-then the expression to be replaced by the propagation may
-be an SSA_NAME.  Fortunately, there is an explicit tree
-for the expression, so we delegate to may_propagate_copy.  */
-if (gimple_assign_single_p (dest))
-return may_propagate_copy (gimple_assign_rhs1 (dest), orig);
-else if (gimple_code (dest) == GIMPLE_SWITCH)
-return may_propagate_copy (gimple_switch_index (dest), orig);
-/* In other cases, the expression is not materialized, so there
-is no destination to pass to may_propagate_copy.  On the other
-hand, the expression cannot be an SSA_NAME, so the analysis
-is much simpler.  */
-if (TREE_CODE (orig) == SSA_NAME
-&& SSA_NAME_OCCURS_IN_ABNORMAL_PHI (orig))
-return false;
-if (is_gimple_assign (dest))
-type_d = TREE_TYPE (gimple_assign_lhs (dest));
-else if (gimple_code (dest) == GIMPLE_COND)
-type_d = boolean_type_node;
-else if (is_gimple_call (dest)
-&& gimple_call_lhs (dest) != NULL_TREE)
-type_d = TREE_TYPE (gimple_call_lhs (dest));
-else
-gcc_unreachable ();
-type_o = TREE_TYPE (orig);
-if (!useless_type_conversion_p (type_d, type_o))
-return false;
-return true;
-}
-/* Similarly, but we know that we're propagating into an ASM_EXPR.  */
-bool
-may_propagate_copy_into_asm (tree dest)
-{
-/* Hard register operands of asms are special.  Do not bypass.  */
-return !(TREE_CODE (dest) == SSA_NAME
-	   && TREE_CODE (SSA_NAME_VAR (dest)) == VAR_DECL
-	   && DECL_HARD_REGISTER (SSA_NAME_VAR (dest)));
-}
-/* Common code for propagate_value and replace_exp.
-Replace use operand OP_P with VAL.  FOR_PROPAGATION indicates if the
-replacement is done to propagate a value or not.  */
-static void
-replace_exp_1 (use_operand_p op_p, tree val,
-	       bool for_propagation ATTRIBUTE_UNUSED)
-{
-#if defined ENABLE_CHECKING
-tree op = USE_FROM_PTR (op_p);
-gcc_assert (!(for_propagation
-		&& TREE_CODE (op) == SSA_NAME
-		&& TREE_CODE (val) == SSA_NAME
-		&& !may_propagate_copy (op, val)));
-#endif
-if (TREE_CODE (val) == SSA_NAME)
-SET_USE (op_p, val);
-else
-SET_USE (op_p, unsave_expr_now (val));
-}
-/* Propagate the value VAL (assumed to be a constant or another SSA_NAME)
-into the operand pointed to by OP_P.
-Use this version for const/copy propagation as it will perform additional
-checks to ensure validity of the const/copy propagation.  */
-void
-propagate_value (use_operand_p op_p, tree val)
-{
-replace_exp_1 (op_p, val, true);
-}
-/* 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,
-PRE uses this version when building expressions as they would appear
-in specific blocks taking into account actions of PHI nodes.
-The statement in which an expression has been replaced should be
-folded using fold_stmt_inplace.  */
-void
-replace_exp (use_operand_p op_p, tree val)
-{
-replace_exp_1 (op_p, val, false);
-}
-/* Propagate the value VAL (assumed to be a constant or another SSA_NAME)
-into the tree pointed to by OP_P.
-Use this version for const/copy propagation when SSA operands are not
-available.  It will perform the additional checks to ensure validity of
-the const/copy propagation, but will not update any operand information.
-Be sure to mark the stmt as modified.  */
-void
-propagate_tree_value (tree *op_p, tree val)
-{
-gcc_checking_assert (!(TREE_CODE (val) == SSA_NAME
-			 && *op_p
-			 && TREE_CODE (*op_p) == SSA_NAME
-			 && !may_propagate_copy (*op_p, val)));
-if (TREE_CODE (val) == SSA_NAME)
-*op_p = val;
-else
-*op_p = unsave_expr_now (val);
-}
-/* Like propagate_tree_value, but use as the operand to replace
-the principal expression (typically, the RHS) contained in the
-statement referenced by iterator GSI.  Note that it is not
-always possible to update the statement in-place, so a new
-statement may be created to replace the original.  */
-void
-propagate_tree_value_into_stmt (gimple_stmt_iterator *gsi, tree val)
-{
-gimple stmt = gsi_stmt (*gsi);
-if (is_gimple_assign (stmt))
-{
-tree expr = NULL_TREE;
-if (gimple_assign_single_p (stmt))
-expr = gimple_assign_rhs1 (stmt);
-propagate_tree_value (&expr, val);
-gimple_assign_set_rhs_from_tree (gsi, expr);
-stmt = gsi_stmt (*gsi);
-}
-else if (gimple_code (stmt) == GIMPLE_COND)
-{
-tree lhs = NULL_TREE;
-tree rhs = build_zero_cst (TREE_TYPE (val));
-propagate_tree_value (&lhs, val);
-gimple_cond_set_code (stmt, NE_EXPR);
-gimple_cond_set_lhs (stmt, lhs);
-gimple_cond_set_rhs (stmt, rhs);
-}
-else if (is_gimple_call (stmt)
-&& gimple_call_lhs (stmt) != NULL_TREE)
-{
-gimple new_stmt;
-tree expr = NULL_TREE;
-propagate_tree_value (&expr, val);
-new_stmt = gimple_build_assign (gimple_call_lhs (stmt), expr);
-move_ssa_defining_stmt_for_defs (new_stmt, stmt);
-gsi_replace (gsi, new_stmt, false);
-}
-else if (gimple_code (stmt) == GIMPLE_SWITCH)
-propagate_tree_value (gimple_switch_index_ptr (stmt), val);
-else
-gcc_unreachable ();
-}
 /*---------------------------------------------------------------------------
 				Copy propagation
 ---------------------------------------------------------------------------*/
 /* Lattice for copy-propagation.  The lattice is initialized to
 of that value.
 When visiting a statement or PHI node the lattice value for an
 SSA name can transition from UNDEFINED to COPY to VARYING.  */
-struct prop_value_d {
+struct prop_value_t {
 /* Copy-of value.  */
 tree value;
 };
-typedef struct prop_value_d prop_value_t;
 static prop_value_t *copy_of;
+static unsigned n_copy_of;
 /* Return true if this statement may generate a useful copy.  */
 static bool
-stmt_may_generate_copy (gimple stmt)
+stmt_may_generate_copy (gimple *stmt)
 {
 if (gimple_code (stmt) == GIMPLE_PHI)
 return !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (gimple_phi_result (stmt));
 if (gimple_code (stmt) != GIMPLE_ASSIGN)
 return false;
 /* Otherwise, the only statements that generate useful copies are
 assignments whose RHS is just an SSA name that doesn't flow
 through abnormal edges.  */
-return (gimple_assign_rhs_code (stmt) == SSA_NAME
+return ((gimple_assign_rhs_code (stmt) == SSA_NAME
-	  && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (gimple_assign_rhs1 (stmt)));
+	   && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (gimple_assign_rhs1 (stmt)))
+	  || is_gimple_min_invariant (gimple_assign_rhs1 (stmt)));
 }
 /* Return the copy-of value for VAR.  */
 if (TREE_CODE (var) != SSA_NAME)
 return;
 val = copy_of[SSA_NAME_VERSION (var)].value;
 fprintf (file, " copy-of chain: ");
-print_generic_expr (file, var, 0);
+print_generic_expr (file, var);
 fprintf (file, " ");
 if (!val)
 fprintf (file, "[UNDEFINED]");
 else if (val == var)
 fprintf (file, "[NOT A COPY]");
 else
 {
 fprintf (file, "-> ");
-print_generic_expr (file, val, 0);
+print_generic_expr (file, val);
 fprintf (file, " ");
 fprintf (file, "[COPY]");
 }
 }
 /* Evaluate the RHS of STMT.  If it produces a valid copy, set the LHS
 value and store the LHS into *RESULT_P.  */
 static enum ssa_prop_result
-copy_prop_visit_assignment (gimple stmt, tree *result_p)
+copy_prop_visit_assignment (gimple *stmt, tree *result_p)
 {
 tree lhs, rhs;
 lhs = gimple_assign_lhs (stmt);
 rhs = valueize_val (gimple_assign_rhs1 (stmt));
 /* Visit the GIMPLE_COND STMT.  Return SSA_PROP_INTERESTING
 if it can determine which edge will be taken.  Otherwise, return
 SSA_PROP_VARYING.  */
 static enum ssa_prop_result
-copy_prop_visit_cond_stmt (gimple stmt, edge *taken_edge_p)
+copy_prop_visit_cond_stmt (gimple *stmt, edge *taken_edge_p)
 {
 enum ssa_prop_result retval = SSA_PROP_VARYING;
 location_t loc = gimple_location (stmt);
-tree op0 = gimple_cond_lhs (stmt);
+tree op0 = valueize_val (gimple_cond_lhs (stmt));
-tree op1 = gimple_cond_rhs (stmt);
+tree op1 = valueize_val (gimple_cond_rhs (stmt));
-/* The only conditionals that we may be able to compute statically
+/* See if we can determine the predicate's value.  */
-are predicates involving two SSA_NAMEs.  */
+if (dump_file && (dump_flags & TDF_DETAILS))
-if (TREE_CODE (op0) == SSA_NAME && TREE_CODE (op1) == SSA_NAME)
+{
-{
+fprintf (dump_file, "Trying to determine truth value of ");
-op0 = valueize_val (op0);
+fprintf (dump_file, "predicate ");
-op1 = valueize_val (op1);
+print_gimple_stmt (dump_file, stmt, 0);
+}
-/* See if we can determine the predicate's value.  */
-if (dump_file && (dump_flags & TDF_DETAILS))
+/* Fold COND and see whether we get a useful result.  */
-	{
+tree folded_cond = fold_binary_loc (loc, gimple_cond_code (stmt),
-	  fprintf (dump_file, "Trying to determine truth value of ");
+				      boolean_type_node, op0, op1);
-	  fprintf (dump_file, "predicate ");
+if (folded_cond)
-	  print_gimple_stmt (dump_file, stmt, 0, 0);
+{
-	}
+basic_block bb = gimple_bb (stmt);
+*taken_edge_p = find_taken_edge (bb, folded_cond);
-/* We can fold COND and get a useful result only when we have
+if (*taken_edge_p)
-	 the same SSA_NAME on both sides of a comparison operator.  */
+	retval = SSA_PROP_INTERESTING;
-if (op0 == op1)
-	{
-	  tree folded_cond = fold_binary_loc (loc, gimple_cond_code (stmt),
-boolean_type_node, op0, op1);
-	  if (folded_cond)
-	    {
-	      basic_block bb = gimple_bb (stmt);
-	      *taken_edge_p = find_taken_edge (bb, folded_cond);
-	      if (*taken_edge_p)
-		retval = SSA_PROP_INTERESTING;
-	    }
-	}
 }
 if (dump_file && (dump_flags & TDF_DETAILS) && *taken_edge_p)
 fprintf (dump_file, "\nConditional will always take edge %d->%d\n",
 	     (*taken_edge_p)->src->index, (*taken_edge_p)->dest->index);
 If the new value produced by STMT is varying, return
 SSA_PROP_VARYING.  */
 static enum ssa_prop_result
-copy_prop_visit_stmt (gimple stmt, edge *taken_edge_p, tree *result_p)
+copy_prop_visit_stmt (gimple *stmt, edge *taken_edge_p, tree *result_p)
 {
 enum ssa_prop_result retval;
 if (dump_file && (dump_flags & TDF_DETAILS))
 {
 /* Visit PHI node PHI.  If all the arguments produce the same value,
 set it to be the value of the LHS of PHI.  */
 static enum ssa_prop_result
-copy_prop_visit_phi_node (gimple phi)
+copy_prop_visit_phi_node (gphi *phi)
 {
 enum ssa_prop_result retval;
 unsigned i;
 prop_value_t phi_val = { NULL_TREE };
 }
 for (i = 0; i < gimple_phi_num_args (phi); i++)
 {
 prop_value_t *arg_val;
+tree arg_value;
 tree arg = gimple_phi_arg_def (phi, i);
 edge e = gimple_phi_arg_edge (phi, i);
 /* We don't care about values flowing through non-executable
 	 edges.  */
 if (!(e->flags & EDGE_EXECUTABLE))
 	continue;
-/* Constants in the argument list never generate a useful copy.
+/* Names that flow through abnormal edges cannot be used to
-	 Similarly, names that flow through abnormal edges cannot be
+	 derive copies.  */
-	 used to derive copies.  */
+if (TREE_CODE (arg) == SSA_NAME && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (arg))
-if (TREE_CODE (arg) != SSA_NAME || SSA_NAME_OCCURS_IN_ABNORMAL_PHI (arg))
-	{
-	  phi_val.value = lhs;
-	  break;
-	}
-/* Avoid copy propagation from an inner into an outer loop.
-	 Otherwise, this may move loop variant variables outside of
-	 their loops and prevent coalescing opportunities.  If the
-	 value was loop invariant, it will be hoisted by LICM and
-	 exposed for copy propagation.  Not a problem for virtual
-	 operands though.
-	 ???  The value will be always loop invariant.  */
-if (is_gimple_reg (lhs)
-	  && loop_depth_of_name (arg) > loop_depth_of_name (lhs))
 	{
 	  phi_val.value = lhs;
 	  break;
 	}
 	  fprintf (dump_file, "\tArgument #%d: ", i);
 	  dump_copy_of (dump_file, arg);
 	  fprintf (dump_file, "\n");
 	}
-arg_val = get_copy_of_val (arg);
+if (TREE_CODE (arg) == SSA_NAME)
+	{
-/* If we didn't visit the definition of arg yet treat it as
+	  arg_val = get_copy_of_val (arg);
-UNDEFINED.  This also handles PHI arguments that are the
-	 same as lhs.  We'll come here again.  */
+	  /* If we didn't visit the definition of arg yet treat it as
-if (!arg_val->value)
+	     UNDEFINED.  This also handles PHI arguments that are the
-	continue;
+	     same as lhs.  We'll come here again.  */
+	  if (!arg_val->value)
+	    continue;
+	  arg_value = arg_val->value;
+	}
+else
+	arg_value = valueize_val (arg);
+/* In loop-closed SSA form do not copy-propagate SSA-names across
+	 loop exit edges.  */
+if (loops_state_satisfies_p (LOOP_CLOSED_SSA)
+	  && TREE_CODE (arg_value) == SSA_NAME
+	  && loop_exit_edge_p (e->src->loop_father, e))
+	{
+	  phi_val.value = lhs;
+	  break;
+	}
 /* If the LHS didn't have a value yet, make it a copy of the
 	 first argument we find.   */
 if (phi_val.value == NULL_TREE)
 	{
-	  phi_val.value = arg_val->value;
+	  phi_val.value = arg_value;
 	  continue;
 	}
 /* If PHI_VAL and ARG don't have a common copy-of chain, then
 	 this PHI node cannot be a copy operation.  */
-if (phi_val.value != arg_val->value
+if (phi_val.value != arg_value
-	  && !operand_equal_p (phi_val.value, arg_val->value, 0))
+	  && !operand_equal_p (phi_val.value, arg_value, 0))
 	{
 	  phi_val.value = lhs;
 	  break;
 	}
 }
 static void
 init_copy_prop (void)
 {
 basic_block bb;
-copy_of = XCNEWVEC (prop_value_t, num_ssa_names);
+n_copy_of = num_ssa_names;
+copy_of = XCNEWVEC (prop_value_t, n_copy_of);
-FOR_EACH_BB (bb)
-{
+FOR_EACH_BB_FN (bb, cfun)
-gimple_stmt_iterator si;
+{
-int depth = bb->loop_depth;
+for (gimple_stmt_iterator si = gsi_start_bb (bb); !gsi_end_p (si);
-bool loop_exit_p = false;
+	   gsi_next (&si))
+	{
-for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
+	  gimple *stmt = gsi_stmt (si);
-	{
-	  gimple stmt = gsi_stmt (si);
 	  ssa_op_iter iter;
 tree def;
 	  /* The only statements that we care about are those that may
 	     generate useful copies.  We also need to mark conditional
 	     jumps so that their outgoing edges are added to the work
-	     lists of the propagator.
+	     lists of the propagator.  */
-	     Avoid copy propagation from an inner into an outer loop.
-	     Otherwise, this may move loop variant variables outside of
-	     their loops and prevent coalescing opportunities.  If the
-	     value was loop invariant, it will be hoisted by LICM and
-	     exposed for copy propagation.
-	     ???  This doesn't make sense.  */
 	  if (stmt_ends_bb_p (stmt))
 prop_set_simulate_again (stmt, true);
-	  else if (stmt_may_generate_copy (stmt)
+	  else if (stmt_may_generate_copy (stmt))
-/* Since we are iterating over the statements in
-BB, not the phi nodes, STMT will always be an
-assignment.  */
-&& loop_depth_of_name (gimple_assign_rhs1 (stmt)) <= depth)
 prop_set_simulate_again (stmt, true);
 	  else
 prop_set_simulate_again (stmt, false);
 	  /* Mark all the outputs of this statement as not being
 	  FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_ALL_DEFS)
 if (!prop_simulate_again_p (stmt))
 	      set_copy_of_val (def, def);
 	}
-/* In loop-closed SSA form do not copy-propagate through
+for (gphi_iterator si = gsi_start_phis (bb); !gsi_end_p (si);
-	 PHI nodes in blocks with a loop exit edge predecessor.  */
+	   gsi_next (&si))
-if (current_loops
+	{
-	  && loops_state_satisfies_p (LOOP_CLOSED_SSA))
+gphi *phi = si.phi ();
-	{
-	  edge_iterator ei;
-	  edge e;
-	  FOR_EACH_EDGE (e, ei, bb->preds)
-	    if (loop_exit_edge_p (e->src->loop_father, e))
-	      loop_exit_p = true;
-	}
-for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
-	{
-gimple phi = gsi_stmt (si);
 tree def;
 	  def = gimple_phi_result (phi);
-	  if (!is_gimple_reg (def)
+	  if (virtual_operand_p (def))
-	      || loop_exit_p)
 prop_set_simulate_again (phi, false);
 	  else
 prop_set_simulate_again (phi, true);
 	  if (!prop_simulate_again_p (phi))
 /* Callback for substitute_and_fold to get at the final copy-of values.  */
 static tree
 get_value (tree name)
 {
-tree val = copy_of[SSA_NAME_VERSION (name)].value;
+tree val;
+if (SSA_NAME_VERSION (name) >= n_copy_of)
+return NULL_TREE;
+val = copy_of[SSA_NAME_VERSION (name)].value;
 if (val && val != name)
 return val;
 return NULL_TREE;
 }
 /* Deallocate memory used in copy propagation and do final
 substitution.  */
-static void
+static bool
 fini_copy_prop (void)
 {
 unsigned i;
+tree var;
 /* Set the final copy-of value for each variable by traversing the
 copy-of chains.  */
-for (i = 1; i < num_ssa_names; i++)
+FOR_EACH_SSA_NAME (i, var, cfun)
 {
-tree var = ssa_name (i);
+if (!copy_of[i].value
-if (!var
-	  || !copy_of[i].value
 	  || copy_of[i].value == var)
 	continue;
 /* In theory the points-to solution of all members of the
 copy chain is their intersection.  For now we do not bother
 	 to compute this but only make sure we do not lose points-to
 	 information completely by setting the points-to solution
 	 of the representative to the first solution we find if
 	 it doesn't have one already.  */
 if (copy_of[i].value != var
-	  && POINTER_TYPE_P (TREE_TYPE (var))
+	  && TREE_CODE (copy_of[i].value) == SSA_NAME)
-	  && SSA_NAME_PTR_INFO (var)
+	{
-	  && !SSA_NAME_PTR_INFO (copy_of[i].value))
+	  basic_block copy_of_bb
-	duplicate_ssa_name_ptr_info (copy_of[i].value, SSA_NAME_PTR_INFO (var));
+	    = gimple_bb (SSA_NAME_DEF_STMT (copy_of[i].value));
-}
+	  basic_block var_bb = gimple_bb (SSA_NAME_DEF_STMT (var));
+	  if (POINTER_TYPE_P (TREE_TYPE (var))
-/* Don't do DCE if we have loops.  That's the simplest way to not
+	      && SSA_NAME_PTR_INFO (var)
-destroy the scev cache.  */
+	      && !SSA_NAME_PTR_INFO (copy_of[i].value))
-substitute_and_fold (get_value, NULL, !current_loops);
+	    {
+	      duplicate_ssa_name_ptr_info (copy_of[i].value,
+					   SSA_NAME_PTR_INFO (var));
+	      /* Points-to information is cfg insensitive,
+		 but alignment info might be cfg sensitive, if it
+		 e.g. is derived from VRP derived non-zero bits.
+		 So, do not copy alignment info if the two SSA_NAMEs
+		 aren't defined in the same basic block.  */
+	      if (var_bb != copy_of_bb)
+		mark_ptr_info_alignment_unknown
+				(SSA_NAME_PTR_INFO (copy_of[i].value));
+	    }
+	  else if (!POINTER_TYPE_P (TREE_TYPE (var))
+		   && SSA_NAME_RANGE_INFO (var)
+		   && !SSA_NAME_RANGE_INFO (copy_of[i].value)
+		   && var_bb == copy_of_bb)
+	    duplicate_ssa_name_range_info (copy_of[i].value,
+					   SSA_NAME_RANGE_TYPE (var),
+					   SSA_NAME_RANGE_INFO (var));
+	}
+}
+bool changed = substitute_and_fold (get_value, NULL);
+if (changed)
+{
+free_numbers_of_iterations_estimates (cfun);
+if (scev_initialized_p ())
+	scev_reset ();
+}
 free (copy_of);
+return changed;
 }
 /* Main entry point to the copy propagator.
 static unsigned int
 execute_copy_prop (void)
 {
 init_copy_prop ();
 ssa_propagate (copy_prop_visit_stmt, copy_prop_visit_phi_node);
-fini_copy_prop ();
+if (fini_copy_prop ())
+return TODO_cleanup_cfg;
 return 0;
 }
-static bool
+namespace {
-gate_copy_prop (void)
-{
+const pass_data pass_data_copy_prop =
-return flag_tree_copy_prop != 0;
+{
-}
+GIMPLE_PASS, /* type */
+"copyprop", /* name */
-struct gimple_opt_pass pass_copy_prop =
+OPTGROUP_NONE, /* optinfo_flags */
-{
+TV_TREE_COPY_PROP, /* tv_id */
-{
+( PROP_ssa | PROP_cfg ), /* properties_required */
-GIMPLE_PASS,
+0, /* properties_provided */
-"copyprop",				/* name */
+0, /* properties_destroyed */
-gate_copy_prop,			/* gate */
+0, /* todo_flags_start */
-execute_copy_prop,			/* execute */
+0, /* todo_flags_finish */
-NULL,					/* sub */
-NULL,					/* next */
-0,					/* static_pass_number */
-TV_TREE_COPY_PROP,			/* tv_id */
-PROP_ssa | PROP_cfg,			/* properties_required */
-0,					/* properties_provided */
-0,					/* properties_destroyed */
-0,					/* todo_flags_start */
-TODO_cleanup_cfg
-| TODO_dump_func
-| TODO_ggc_collect
-| TODO_verify_ssa
-| TODO_update_ssa			/* todo_flags_finish */
-}
 };
+class pass_copy_prop : public gimple_opt_pass
+{
+public:
+pass_copy_prop (gcc::context *ctxt)
+: gimple_opt_pass (pass_data_copy_prop, ctxt)
+{}
+/* opt_pass methods: */
+opt_pass * clone () { return new pass_copy_prop (m_ctxt); }
+virtual bool gate (function *) { return flag_tree_copy_prop != 0; }
+virtual unsigned int execute (function *) { return execute_copy_prop (); }
+}; // class pass_copy_prop
+} // anon namespace
+gimple_opt_pass *
+make_pass_copy_prop (gcc::context *ctxt)
+{
+return new pass_copy_prop (ctxt);
+}

Mercurial > hg > CbC > CbC_gcc

comparison gcc/tree-ssa-copy.c @ 111:04ced10e8804