+ 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;
+
+ /* If the statement has volatile operands, it won't generate a
+ useful copy. */
+ if (gimple_has_volatile_ops (stmt))
+ return false;
+
+ /* Statements with loads and/or stores will never generate a useful copy. */
+ if (gimple_vuse (stmt))
+ 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
+ && !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. */
+
+static inline prop_value_t *
+get_copy_of_val (tree var)
+{
+ prop_value_t *val = ©_of[SSA_NAME_VERSION (var)];
+
+ if (val->value == NULL_TREE
+ && !stmt_may_generate_copy (SSA_NAME_DEF_STMT (var)))
+ {
+ /* If the variable will never generate a useful copy relation,
+ make it its own copy. */
+ val->value = var;
+ }
+
+ return val;
+}
+
+/* Return the variable VAR is a copy of or VAR if VAR isn't the result
+ of a copy. */
+
+static inline tree
+valueize_val (tree var)
+{
+ if (TREE_CODE (var) == SSA_NAME)
+ {
+ tree val = get_copy_of_val (var)->value;
+ if (val)
+ return val;
+ }
+ return var;
+}
+
+/* Set VAL to be the copy of VAR. If that changed return true. */
+
+static inline bool
+set_copy_of_val (tree var, tree val)
+{
+ unsigned int ver = SSA_NAME_VERSION (var);
+ tree old;
+
+ /* Set FIRST to be the first link in COPY_OF[DEST]. If that
+ changed, return true. */
+ old = copy_of[ver].value;
+ copy_of[ver].value = val;
+
+ if (old != val
+ || (val && !operand_equal_p (old, val, 0)))
+ return true;
+
+ return false;
+}
+
+
+/* Dump the copy-of value for variable VAR to FILE. */
+
+static void
+dump_copy_of (FILE *file, tree var)
+{
+ tree val;
+
+ print_generic_expr (file, var, dump_flags);
+ 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);
+ 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);
+ 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)
+{
+ tree lhs, rhs;
+
+ lhs = gimple_assign_lhs (stmt);
+ rhs = valueize_val (gimple_assign_rhs1 (stmt));
+
+ if (TREE_CODE (lhs) == SSA_NAME)
+ {
+ /* Straight copy between two SSA names. First, make sure that
+ we can propagate the RHS into uses of LHS. */
+ if (!may_propagate_copy (lhs, rhs))
+ return SSA_PROP_VARYING;
+
+ *result_p = lhs;
+ if (set_copy_of_val (*result_p, rhs))
+ return SSA_PROP_INTERESTING;
+ else
+ return SSA_PROP_NOT_INTERESTING;
+ }
+
+ return SSA_PROP_VARYING;
+}
+
+
+/* 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)
+{
+ enum ssa_prop_result retval = SSA_PROP_VARYING;
+ location_t loc = gimple_location (stmt);
+
+ tree op0 = gimple_cond_lhs (stmt);
+ tree op1 = gimple_cond_rhs (stmt);
+
+ /* The only conditionals that we may be able to compute statically
+ are predicates involving two SSA_NAMEs. */
+ if (TREE_CODE (op0) == SSA_NAME && TREE_CODE (op1) == SSA_NAME)
+ {
+ op0 = valueize_val (op0);
+ op1 = valueize_val (op1);
+
+ /* See if we can determine the predicate's value. */
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ {
+ fprintf (dump_file, "Trying to determine truth value of ");
+ fprintf (dump_file, "predicate ");
+ print_gimple_stmt (dump_file, stmt, 0, 0);
+ }
+
+ /* We can fold COND and get a useful result only when we have
+ the same SSA_NAME on both sides of a comparison operator. */
+ 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);
+
+ return retval;
+}
+
+
+/* Evaluate statement STMT. If the statement produces a new output
+ value, return SSA_PROP_INTERESTING and store the SSA_NAME holding
+ the new value in *RESULT_P.
+
+ If STMT is a conditional branch and we can determine its truth
+ value, set *TAKEN_EDGE_P accordingly.
+
+ 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)
+{
+ enum ssa_prop_result retval;
+
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ {
+ fprintf (dump_file, "\nVisiting statement:\n");
+ print_gimple_stmt (dump_file, stmt, 0, dump_flags);
+ fprintf (dump_file, "\n");
+ }
+
+ if (gimple_assign_single_p (stmt)
+ && TREE_CODE (gimple_assign_lhs (stmt)) == SSA_NAME
+ && (TREE_CODE (gimple_assign_rhs1 (stmt)) == SSA_NAME
+ || is_gimple_min_invariant (gimple_assign_rhs1 (stmt))))
+ {
+ /* If the statement is a copy assignment, evaluate its RHS to
+ see if the lattice value of its output has changed. */
+ retval = copy_prop_visit_assignment (stmt, result_p);
+ }
+ else if (gimple_code (stmt) == GIMPLE_COND)
+ {
+ /* See if we can determine which edge goes out of a conditional
+ jump. */
+ retval = copy_prop_visit_cond_stmt (stmt, taken_edge_p);
+ }
+ else
+ retval = SSA_PROP_VARYING;
+
+ if (retval == SSA_PROP_VARYING)
+ {
+ tree def;
+ ssa_op_iter i;
+
+ /* Any other kind of statement is not interesting for constant
+ propagation and, therefore, not worth simulating. */
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ fprintf (dump_file, "No interesting values produced.\n");
+
+ /* The assignment is not a copy operation. Don't visit this
+ statement again and mark all the definitions in the statement
+ to be copies of nothing. */
+ FOR_EACH_SSA_TREE_OPERAND (def, stmt, i, SSA_OP_ALL_DEFS)
+ set_copy_of_val (def, def);
+ }
+
+ return retval;
+}
+
+
+/* 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)
+{
+ enum ssa_prop_result retval;
+ unsigned i;
+ prop_value_t phi_val = { NULL_TREE };
+
+ tree lhs = gimple_phi_result (phi);
+
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ {
+ fprintf (dump_file, "\nVisiting PHI node: ");
+ print_gimple_stmt (dump_file, phi, 0, dump_flags);
+ }
+
+ 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;
+
+ /* Names that flow through abnormal edges cannot be used to
+ derive copies. */
+ if (TREE_CODE (arg) == SSA_NAME && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (arg))
+ {
+ phi_val.value = lhs;
+ break;
+ }
+
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ {
+ fprintf (dump_file, "\tArgument #%d: ", i);
+ dump_copy_of (dump_file, arg);
+ fprintf (dump_file, "\n");
+ }
+
+ if (TREE_CODE (arg) == SSA_NAME)
+ {
+ arg_val = get_copy_of_val (arg);
+
+ /* If we didn't visit the definition of arg yet treat it as
+ UNDEFINED. This also handles PHI arguments that are the
+ same as lhs. We'll come here again. */
+ if (!arg_val->value)
+ continue;
+
+ arg_value = arg_val->value;
+ }
+ else
+ arg_value = valueize_val (arg);
+
+ /* 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.
+ ??? The value will be always loop invariant.
+ In loop-closed SSA form do not copy-propagate through
+ PHI nodes in blocks with a loop exit edge predecessor. */
+ if (current_loops
+ && TREE_CODE (arg_value) == SSA_NAME
+ && (loop_depth_of_name (arg_value) > loop_depth_of_name (lhs)
+ || (loops_state_satisfies_p (LOOP_CLOSED_SSA)
+ && 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_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_value
+ && !operand_equal_p (phi_val.value, arg_value, 0))
+ {
+ phi_val.value = lhs;
+ break;
+ }
+ }
+
+ if (phi_val.value
+ && may_propagate_copy (lhs, phi_val.value)
+ && set_copy_of_val (lhs, phi_val.value))
+ retval = (phi_val.value != lhs) ? SSA_PROP_INTERESTING : SSA_PROP_VARYING;
+ else
+ retval = SSA_PROP_NOT_INTERESTING;
+
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ {
+ fprintf (dump_file, "PHI node ");
+ dump_copy_of (dump_file, lhs);
+ fprintf (dump_file, "\nTelling the propagator to ");
+ if (retval == SSA_PROP_INTERESTING)
+ fprintf (dump_file, "add SSA edges out of this PHI and continue.");
+ else if (retval == SSA_PROP_VARYING)
+ fprintf (dump_file, "add SSA edges out of this PHI and never visit again.");
+ else
+ fprintf (dump_file, "do nothing with SSA edges and keep iterating.");
+ fprintf (dump_file, "\n\n");
+ }
+
+ return retval;
+}
+
+
+/* Initialize structures used for copy propagation. */
+
+static void
+init_copy_prop (void)
+{
+ basic_block bb;
+
+ copy_of = XCNEWVEC (prop_value_t, num_ssa_names);
+
+ FOR_EACH_BB (bb)
+ {
+ gimple_stmt_iterator si;
+ int depth = bb->loop_depth;
+
+ for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&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.
+
+ 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)
+ /* 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
+ the copy of anything. */
+ FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_ALL_DEFS)
+ if (!prop_simulate_again_p (stmt))
+ set_copy_of_val (def, def);
+ }
+
+ 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))
+ prop_set_simulate_again (phi, false);
+ else
+ prop_set_simulate_again (phi, true);
+
+ if (!prop_simulate_again_p (phi))
+ set_copy_of_val (def, def);
+ }
+ }
+}
+
+/* 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;
+ if (val && val != name)
+ return val;
+ return NULL_TREE;