1 /* Copy propagation and SSA_NAME replacement support routines.
2 Copyright (C) 2004, 2005, 2006, 2007, 2008, 2010
3 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
28 #include "basic-block.h"
30 #include "gimple-pretty-print.h"
31 #include "tree-flow.h"
32 #include "tree-pass.h"
33 #include "tree-ssa-propagate.h"
34 #include "langhooks.h"
37 /* This file implements the copy propagation pass and provides a
38 handful of interfaces for performing const/copy propagation and
39 simple expression replacement which keep variable annotations
42 We require that for any copy operation where the RHS and LHS have
43 a non-null memory tag the memory tag be the same. It is OK
44 for one or both of the memory tags to be NULL.
46 We also require tracking if a variable is dereferenced in a load or
49 We enforce these requirements by having all copy propagation and
50 replacements of one SSA_NAME with a different SSA_NAME to use the
51 APIs defined in this file. */
53 /* Return true if we may propagate ORIG into DEST, false otherwise. */
56 may_propagate_copy (tree dest
, tree orig
)
58 tree type_d
= TREE_TYPE (dest
);
59 tree type_o
= TREE_TYPE (orig
);
61 /* If ORIG flows in from an abnormal edge, it cannot be propagated. */
62 if (TREE_CODE (orig
) == SSA_NAME
63 && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (orig
))
66 /* If DEST is an SSA_NAME that flows from an abnormal edge, then it
67 cannot be replaced. */
68 if (TREE_CODE (dest
) == SSA_NAME
69 && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (dest
))
72 /* Do not copy between types for which we *do* need a conversion. */
73 if (!useless_type_conversion_p (type_d
, type_o
))
76 /* Propagating virtual operands is always ok. */
77 if (TREE_CODE (dest
) == SSA_NAME
&& !is_gimple_reg (dest
))
79 /* But only between virtual operands. */
80 gcc_assert (TREE_CODE (orig
) == SSA_NAME
&& !is_gimple_reg (orig
));
85 /* Anything else is OK. */
89 /* Like may_propagate_copy, but use as the destination expression
90 the principal expression (typically, the RHS) contained in
91 statement DEST. This is more efficient when working with the
92 gimple tuples representation. */
95 may_propagate_copy_into_stmt (gimple dest
, tree orig
)
100 /* If the statement is a switch or a single-rhs assignment,
101 then the expression to be replaced by the propagation may
102 be an SSA_NAME. Fortunately, there is an explicit tree
103 for the expression, so we delegate to may_propagate_copy. */
105 if (gimple_assign_single_p (dest
))
106 return may_propagate_copy (gimple_assign_rhs1 (dest
), orig
);
107 else if (gimple_code (dest
) == GIMPLE_SWITCH
)
108 return may_propagate_copy (gimple_switch_index (dest
), orig
);
110 /* In other cases, the expression is not materialized, so there
111 is no destination to pass to may_propagate_copy. On the other
112 hand, the expression cannot be an SSA_NAME, so the analysis
115 if (TREE_CODE (orig
) == SSA_NAME
116 && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (orig
))
119 if (is_gimple_assign (dest
))
120 type_d
= TREE_TYPE (gimple_assign_lhs (dest
));
121 else if (gimple_code (dest
) == GIMPLE_COND
)
122 type_d
= boolean_type_node
;
123 else if (is_gimple_call (dest
)
124 && gimple_call_lhs (dest
) != NULL_TREE
)
125 type_d
= TREE_TYPE (gimple_call_lhs (dest
));
129 type_o
= TREE_TYPE (orig
);
131 if (!useless_type_conversion_p (type_d
, type_o
))
137 /* Similarly, but we know that we're propagating into an ASM_EXPR. */
140 may_propagate_copy_into_asm (tree dest
)
142 /* Hard register operands of asms are special. Do not bypass. */
143 return !(TREE_CODE (dest
) == SSA_NAME
144 && TREE_CODE (SSA_NAME_VAR (dest
)) == VAR_DECL
145 && DECL_HARD_REGISTER (SSA_NAME_VAR (dest
)));
149 /* Common code for propagate_value and replace_exp.
151 Replace use operand OP_P with VAL. FOR_PROPAGATION indicates if the
152 replacement is done to propagate a value or not. */
155 replace_exp_1 (use_operand_p op_p
, tree val
,
156 bool for_propagation ATTRIBUTE_UNUSED
)
158 #if defined ENABLE_CHECKING
159 tree op
= USE_FROM_PTR (op_p
);
161 gcc_assert (!(for_propagation
162 && TREE_CODE (op
) == SSA_NAME
163 && TREE_CODE (val
) == SSA_NAME
164 && !may_propagate_copy (op
, val
)));
167 if (TREE_CODE (val
) == SSA_NAME
)
170 SET_USE (op_p
, unsave_expr_now (val
));
174 /* Propagate the value VAL (assumed to be a constant or another SSA_NAME)
175 into the operand pointed to by OP_P.
177 Use this version for const/copy propagation as it will perform additional
178 checks to ensure validity of the const/copy propagation. */
181 propagate_value (use_operand_p op_p
, tree val
)
183 replace_exp_1 (op_p
, val
, true);
186 /* Replace *OP_P with value VAL (assumed to be a constant or another SSA_NAME).
188 Use this version when not const/copy propagating values. For example,
189 PRE uses this version when building expressions as they would appear
190 in specific blocks taking into account actions of PHI nodes.
192 The statement in which an expression has been replaced should be
193 folded using fold_stmt_inplace. */
196 replace_exp (use_operand_p op_p
, tree val
)
198 replace_exp_1 (op_p
, val
, false);
202 /* Propagate the value VAL (assumed to be a constant or another SSA_NAME)
203 into the tree pointed to by OP_P.
205 Use this version for const/copy propagation when SSA operands are not
206 available. It will perform the additional checks to ensure validity of
207 the const/copy propagation, but will not update any operand information.
208 Be sure to mark the stmt as modified. */
211 propagate_tree_value (tree
*op_p
, tree val
)
213 gcc_checking_assert (!(TREE_CODE (val
) == SSA_NAME
215 && TREE_CODE (*op_p
) == SSA_NAME
216 && !may_propagate_copy (*op_p
, val
)));
218 if (TREE_CODE (val
) == SSA_NAME
)
221 *op_p
= unsave_expr_now (val
);
225 /* Like propagate_tree_value, but use as the operand to replace
226 the principal expression (typically, the RHS) contained in the
227 statement referenced by iterator GSI. Note that it is not
228 always possible to update the statement in-place, so a new
229 statement may be created to replace the original. */
232 propagate_tree_value_into_stmt (gimple_stmt_iterator
*gsi
, tree val
)
234 gimple stmt
= gsi_stmt (*gsi
);
236 if (is_gimple_assign (stmt
))
238 tree expr
= NULL_TREE
;
239 if (gimple_assign_single_p (stmt
))
240 expr
= gimple_assign_rhs1 (stmt
);
241 propagate_tree_value (&expr
, val
);
242 gimple_assign_set_rhs_from_tree (gsi
, expr
);
244 else if (gimple_code (stmt
) == GIMPLE_COND
)
246 tree lhs
= NULL_TREE
;
247 tree rhs
= build_zero_cst (TREE_TYPE (val
));
248 propagate_tree_value (&lhs
, val
);
249 gimple_cond_set_code (stmt
, NE_EXPR
);
250 gimple_cond_set_lhs (stmt
, lhs
);
251 gimple_cond_set_rhs (stmt
, rhs
);
253 else if (is_gimple_call (stmt
)
254 && gimple_call_lhs (stmt
) != NULL_TREE
)
256 tree expr
= NULL_TREE
;
258 propagate_tree_value (&expr
, val
);
259 res
= update_call_from_tree (gsi
, expr
);
262 else if (gimple_code (stmt
) == GIMPLE_SWITCH
)
263 propagate_tree_value (gimple_switch_index_ptr (stmt
), val
);
268 /*---------------------------------------------------------------------------
270 ---------------------------------------------------------------------------*/
271 /* Lattice for copy-propagation. The lattice is initialized to
272 UNDEFINED (value == NULL) for SSA names that can become a copy
273 of something or VARYING (value == self) if not (see get_copy_of_val
274 and stmt_may_generate_copy). Other values make the name a COPY
277 When visiting a statement or PHI node the lattice value for an
278 SSA name can transition from UNDEFINED to COPY to VARYING. */
280 struct prop_value_d
{
284 typedef struct prop_value_d prop_value_t
;
286 static prop_value_t
*copy_of
;
289 /* Return true if this statement may generate a useful copy. */
292 stmt_may_generate_copy (gimple stmt
)
294 if (gimple_code (stmt
) == GIMPLE_PHI
)
295 return !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (gimple_phi_result (stmt
));
297 if (gimple_code (stmt
) != GIMPLE_ASSIGN
)
300 /* If the statement has volatile operands, it won't generate a
302 if (gimple_has_volatile_ops (stmt
))
305 /* Statements with loads and/or stores will never generate a useful copy. */
306 if (gimple_vuse (stmt
))
309 /* Otherwise, the only statements that generate useful copies are
310 assignments whose RHS is just an SSA name that doesn't flow
311 through abnormal edges. */
312 return ((gimple_assign_rhs_code (stmt
) == SSA_NAME
313 && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (gimple_assign_rhs1 (stmt
)))
314 || is_gimple_min_invariant (gimple_assign_rhs1 (stmt
)));
318 /* Return the copy-of value for VAR. */
320 static inline prop_value_t
*
321 get_copy_of_val (tree var
)
323 prop_value_t
*val
= ©_of
[SSA_NAME_VERSION (var
)];
325 if (val
->value
== NULL_TREE
326 && !stmt_may_generate_copy (SSA_NAME_DEF_STMT (var
)))
328 /* If the variable will never generate a useful copy relation,
329 make it its own copy. */
336 /* Return the variable VAR is a copy of or VAR if VAR isn't the result
340 valueize_val (tree var
)
342 if (TREE_CODE (var
) == SSA_NAME
)
344 tree val
= get_copy_of_val (var
)->value
;
351 /* Set VAL to be the copy of VAR. If that changed return true. */
354 set_copy_of_val (tree var
, tree val
)
356 unsigned int ver
= SSA_NAME_VERSION (var
);
359 /* Set FIRST to be the first link in COPY_OF[DEST]. If that
360 changed, return true. */
361 old
= copy_of
[ver
].value
;
362 copy_of
[ver
].value
= val
;
365 || (val
&& !operand_equal_p (old
, val
, 0)))
372 /* Dump the copy-of value for variable VAR to FILE. */
375 dump_copy_of (FILE *file
, tree var
)
379 print_generic_expr (file
, var
, dump_flags
);
380 if (TREE_CODE (var
) != SSA_NAME
)
383 val
= copy_of
[SSA_NAME_VERSION (var
)].value
;
384 fprintf (file
, " copy-of chain: ");
385 print_generic_expr (file
, var
, 0);
388 fprintf (file
, "[UNDEFINED]");
390 fprintf (file
, "[NOT A COPY]");
393 fprintf (file
, "-> ");
394 print_generic_expr (file
, val
, 0);
396 fprintf (file
, "[COPY]");
401 /* Evaluate the RHS of STMT. If it produces a valid copy, set the LHS
402 value and store the LHS into *RESULT_P. */
404 static enum ssa_prop_result
405 copy_prop_visit_assignment (gimple stmt
, tree
*result_p
)
409 lhs
= gimple_assign_lhs (stmt
);
410 rhs
= valueize_val (gimple_assign_rhs1 (stmt
));
412 if (TREE_CODE (lhs
) == SSA_NAME
)
414 /* Straight copy between two SSA names. First, make sure that
415 we can propagate the RHS into uses of LHS. */
416 if (!may_propagate_copy (lhs
, rhs
))
417 return SSA_PROP_VARYING
;
420 if (set_copy_of_val (*result_p
, rhs
))
421 return SSA_PROP_INTERESTING
;
423 return SSA_PROP_NOT_INTERESTING
;
426 return SSA_PROP_VARYING
;
430 /* Visit the GIMPLE_COND STMT. Return SSA_PROP_INTERESTING
431 if it can determine which edge will be taken. Otherwise, return
434 static enum ssa_prop_result
435 copy_prop_visit_cond_stmt (gimple stmt
, edge
*taken_edge_p
)
437 enum ssa_prop_result retval
= SSA_PROP_VARYING
;
438 location_t loc
= gimple_location (stmt
);
440 tree op0
= gimple_cond_lhs (stmt
);
441 tree op1
= gimple_cond_rhs (stmt
);
443 /* The only conditionals that we may be able to compute statically
444 are predicates involving two SSA_NAMEs. */
445 if (TREE_CODE (op0
) == SSA_NAME
&& TREE_CODE (op1
) == SSA_NAME
)
447 op0
= valueize_val (op0
);
448 op1
= valueize_val (op1
);
450 /* See if we can determine the predicate's value. */
451 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
453 fprintf (dump_file
, "Trying to determine truth value of ");
454 fprintf (dump_file
, "predicate ");
455 print_gimple_stmt (dump_file
, stmt
, 0, 0);
458 /* We can fold COND and get a useful result only when we have
459 the same SSA_NAME on both sides of a comparison operator. */
462 tree folded_cond
= fold_binary_loc (loc
, gimple_cond_code (stmt
),
463 boolean_type_node
, op0
, op1
);
466 basic_block bb
= gimple_bb (stmt
);
467 *taken_edge_p
= find_taken_edge (bb
, folded_cond
);
469 retval
= SSA_PROP_INTERESTING
;
474 if (dump_file
&& (dump_flags
& TDF_DETAILS
) && *taken_edge_p
)
475 fprintf (dump_file
, "\nConditional will always take edge %d->%d\n",
476 (*taken_edge_p
)->src
->index
, (*taken_edge_p
)->dest
->index
);
482 /* Evaluate statement STMT. If the statement produces a new output
483 value, return SSA_PROP_INTERESTING and store the SSA_NAME holding
484 the new value in *RESULT_P.
486 If STMT is a conditional branch and we can determine its truth
487 value, set *TAKEN_EDGE_P accordingly.
489 If the new value produced by STMT is varying, return
492 static enum ssa_prop_result
493 copy_prop_visit_stmt (gimple stmt
, edge
*taken_edge_p
, tree
*result_p
)
495 enum ssa_prop_result retval
;
497 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
499 fprintf (dump_file
, "\nVisiting statement:\n");
500 print_gimple_stmt (dump_file
, stmt
, 0, dump_flags
);
501 fprintf (dump_file
, "\n");
504 if (gimple_assign_single_p (stmt
)
505 && TREE_CODE (gimple_assign_lhs (stmt
)) == SSA_NAME
506 && (TREE_CODE (gimple_assign_rhs1 (stmt
)) == SSA_NAME
507 || is_gimple_min_invariant (gimple_assign_rhs1 (stmt
))))
509 /* If the statement is a copy assignment, evaluate its RHS to
510 see if the lattice value of its output has changed. */
511 retval
= copy_prop_visit_assignment (stmt
, result_p
);
513 else if (gimple_code (stmt
) == GIMPLE_COND
)
515 /* See if we can determine which edge goes out of a conditional
517 retval
= copy_prop_visit_cond_stmt (stmt
, taken_edge_p
);
520 retval
= SSA_PROP_VARYING
;
522 if (retval
== SSA_PROP_VARYING
)
527 /* Any other kind of statement is not interesting for constant
528 propagation and, therefore, not worth simulating. */
529 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
530 fprintf (dump_file
, "No interesting values produced.\n");
532 /* The assignment is not a copy operation. Don't visit this
533 statement again and mark all the definitions in the statement
534 to be copies of nothing. */
535 FOR_EACH_SSA_TREE_OPERAND (def
, stmt
, i
, SSA_OP_ALL_DEFS
)
536 set_copy_of_val (def
, def
);
543 /* Visit PHI node PHI. If all the arguments produce the same value,
544 set it to be the value of the LHS of PHI. */
546 static enum ssa_prop_result
547 copy_prop_visit_phi_node (gimple phi
)
549 enum ssa_prop_result retval
;
551 prop_value_t phi_val
= { NULL_TREE
};
553 tree lhs
= gimple_phi_result (phi
);
555 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
557 fprintf (dump_file
, "\nVisiting PHI node: ");
558 print_gimple_stmt (dump_file
, phi
, 0, dump_flags
);
561 for (i
= 0; i
< gimple_phi_num_args (phi
); i
++)
563 prop_value_t
*arg_val
;
565 tree arg
= gimple_phi_arg_def (phi
, i
);
566 edge e
= gimple_phi_arg_edge (phi
, i
);
568 /* We don't care about values flowing through non-executable
570 if (!(e
->flags
& EDGE_EXECUTABLE
))
573 /* Names that flow through abnormal edges cannot be used to
575 if (TREE_CODE (arg
) == SSA_NAME
&& SSA_NAME_OCCURS_IN_ABNORMAL_PHI (arg
))
581 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
583 fprintf (dump_file
, "\tArgument #%d: ", i
);
584 dump_copy_of (dump_file
, arg
);
585 fprintf (dump_file
, "\n");
588 if (TREE_CODE (arg
) == SSA_NAME
)
590 arg_val
= get_copy_of_val (arg
);
592 /* If we didn't visit the definition of arg yet treat it as
593 UNDEFINED. This also handles PHI arguments that are the
594 same as lhs. We'll come here again. */
598 arg_value
= arg_val
->value
;
601 arg_value
= valueize_val (arg
);
603 /* Avoid copy propagation from an inner into an outer loop.
604 Otherwise, this may move loop variant variables outside of
605 their loops and prevent coalescing opportunities. If the
606 value was loop invariant, it will be hoisted by LICM and
607 exposed for copy propagation.
608 ??? The value will be always loop invariant.
609 In loop-closed SSA form do not copy-propagate through
610 PHI nodes in blocks with a loop exit edge predecessor. */
612 && TREE_CODE (arg_value
) == SSA_NAME
613 && (loop_depth_of_name (arg_value
) > loop_depth_of_name (lhs
)
614 || (loops_state_satisfies_p (LOOP_CLOSED_SSA
)
615 && loop_exit_edge_p (e
->src
->loop_father
, e
))))
621 /* If the LHS didn't have a value yet, make it a copy of the
622 first argument we find. */
623 if (phi_val
.value
== NULL_TREE
)
625 phi_val
.value
= arg_value
;
629 /* If PHI_VAL and ARG don't have a common copy-of chain, then
630 this PHI node cannot be a copy operation. */
631 if (phi_val
.value
!= arg_value
632 && !operand_equal_p (phi_val
.value
, arg_value
, 0))
640 && may_propagate_copy (lhs
, phi_val
.value
)
641 && set_copy_of_val (lhs
, phi_val
.value
))
642 retval
= (phi_val
.value
!= lhs
) ? SSA_PROP_INTERESTING
: SSA_PROP_VARYING
;
644 retval
= SSA_PROP_NOT_INTERESTING
;
646 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
648 fprintf (dump_file
, "PHI node ");
649 dump_copy_of (dump_file
, lhs
);
650 fprintf (dump_file
, "\nTelling the propagator to ");
651 if (retval
== SSA_PROP_INTERESTING
)
652 fprintf (dump_file
, "add SSA edges out of this PHI and continue.");
653 else if (retval
== SSA_PROP_VARYING
)
654 fprintf (dump_file
, "add SSA edges out of this PHI and never visit again.");
656 fprintf (dump_file
, "do nothing with SSA edges and keep iterating.");
657 fprintf (dump_file
, "\n\n");
664 /* Initialize structures used for copy propagation. */
667 init_copy_prop (void)
671 copy_of
= XCNEWVEC (prop_value_t
, num_ssa_names
);
675 gimple_stmt_iterator si
;
676 int depth
= bb
->loop_depth
;
678 for (si
= gsi_start_bb (bb
); !gsi_end_p (si
); gsi_next (&si
))
680 gimple stmt
= gsi_stmt (si
);
684 /* The only statements that we care about are those that may
685 generate useful copies. We also need to mark conditional
686 jumps so that their outgoing edges are added to the work
687 lists of the propagator.
689 Avoid copy propagation from an inner into an outer loop.
690 Otherwise, this may move loop variant variables outside of
691 their loops and prevent coalescing opportunities. If the
692 value was loop invariant, it will be hoisted by LICM and
693 exposed for copy propagation.
694 ??? This doesn't make sense. */
695 if (stmt_ends_bb_p (stmt
))
696 prop_set_simulate_again (stmt
, true);
697 else if (stmt_may_generate_copy (stmt
)
698 /* Since we are iterating over the statements in
699 BB, not the phi nodes, STMT will always be an
701 && loop_depth_of_name (gimple_assign_rhs1 (stmt
)) <= depth
)
702 prop_set_simulate_again (stmt
, true);
704 prop_set_simulate_again (stmt
, false);
706 /* Mark all the outputs of this statement as not being
707 the copy of anything. */
708 FOR_EACH_SSA_TREE_OPERAND (def
, stmt
, iter
, SSA_OP_ALL_DEFS
)
709 if (!prop_simulate_again_p (stmt
))
710 set_copy_of_val (def
, def
);
713 for (si
= gsi_start_phis (bb
); !gsi_end_p (si
); gsi_next (&si
))
715 gimple phi
= gsi_stmt (si
);
718 def
= gimple_phi_result (phi
);
719 if (!is_gimple_reg (def
))
720 prop_set_simulate_again (phi
, false);
722 prop_set_simulate_again (phi
, true);
724 if (!prop_simulate_again_p (phi
))
725 set_copy_of_val (def
, def
);
730 /* Callback for substitute_and_fold to get at the final copy-of values. */
733 get_value (tree name
)
735 tree val
= copy_of
[SSA_NAME_VERSION (name
)].value
;
736 if (val
&& val
!= name
)
741 /* Deallocate memory used in copy propagation and do final
745 fini_copy_prop (void)
749 /* Set the final copy-of value for each variable by traversing the
751 for (i
= 1; i
< num_ssa_names
; i
++)
753 tree var
= ssa_name (i
);
756 || copy_of
[i
].value
== var
)
759 /* In theory the points-to solution of all members of the
760 copy chain is their intersection. For now we do not bother
761 to compute this but only make sure we do not lose points-to
762 information completely by setting the points-to solution
763 of the representative to the first solution we find if
764 it doesn't have one already. */
765 if (copy_of
[i
].value
!= var
766 && TREE_CODE (copy_of
[i
].value
) == SSA_NAME
767 && POINTER_TYPE_P (TREE_TYPE (var
))
768 && SSA_NAME_PTR_INFO (var
)
769 && !SSA_NAME_PTR_INFO (copy_of
[i
].value
))
770 duplicate_ssa_name_ptr_info (copy_of
[i
].value
, SSA_NAME_PTR_INFO (var
));
773 /* Don't do DCE if we have loops. That's the simplest way to not
774 destroy the scev cache. */
775 substitute_and_fold (get_value
, NULL
, !current_loops
);
781 /* Main entry point to the copy propagator.
783 PHIS_ONLY is true if we should only consider PHI nodes as generating
784 copy propagation opportunities.
786 The algorithm propagates the value COPY-OF using ssa_propagate. For
787 every variable X_i, COPY-OF(X_i) indicates which variable is X_i created
788 from. The following example shows how the algorithm proceeds at a
792 2 a_2 = PHI <a_24, x_1>
794 4 x_1 = PHI <x_298, a_5, a_2>
796 The end result should be that a_2, a_5, a_24 and x_1 are a copy of
797 x_298. Propagation proceeds as follows.
799 Visit #1: a_24 is copy-of x_1. Value changed.
800 Visit #2: a_2 is copy-of x_1. Value changed.
801 Visit #3: a_5 is copy-of x_1. Value changed.
802 Visit #4: x_1 is copy-of x_298. Value changed.
803 Visit #1: a_24 is copy-of x_298. Value changed.
804 Visit #2: a_2 is copy-of x_298. Value changed.
805 Visit #3: a_5 is copy-of x_298. Value changed.
806 Visit #4: x_1 is copy-of x_298. Stable state reached.
808 When visiting PHI nodes, we only consider arguments that flow
809 through edges marked executable by the propagation engine. So,
810 when visiting statement #2 for the first time, we will only look at
811 the first argument (a_24) and optimistically assume that its value
812 is the copy of a_24 (x_1). */
815 execute_copy_prop (void)
818 ssa_propagate (copy_prop_visit_stmt
, copy_prop_visit_phi_node
);
824 gate_copy_prop (void)
826 return flag_tree_copy_prop
!= 0;
829 struct gimple_opt_pass pass_copy_prop
=
833 "copyprop", /* name */
834 gate_copy_prop
, /* gate */
835 execute_copy_prop
, /* execute */
838 0, /* static_pass_number */
839 TV_TREE_COPY_PROP
, /* tv_id */
840 PROP_ssa
| PROP_cfg
, /* properties_required */
841 0, /* properties_provided */
842 0, /* properties_destroyed */
843 0, /* todo_flags_start */
847 | TODO_update_ssa
/* todo_flags_finish */