1 /* Conditional constant propagation pass for the GNU compiler.
2 Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
3 2010 Free Software Foundation, Inc.
4 Adapted from original RTL SSA-CCP by Daniel Berlin <dberlin@dberlin.org>
5 Adapted to GIMPLE trees by Diego Novillo <dnovillo@redhat.com>
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it
10 under the terms of the GNU General Public License as published by the
11 Free Software Foundation; either version 3, or (at your option) any
14 GCC is distributed in the hope that it will be useful, but WITHOUT
15 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
23 /* Conditional constant propagation (CCP) is based on the SSA
24 propagation engine (tree-ssa-propagate.c). Constant assignments of
25 the form VAR = CST are propagated from the assignments into uses of
26 VAR, which in turn may generate new constants. The simulation uses
27 a four level lattice to keep track of constant values associated
28 with SSA names. Given an SSA name V_i, it may take one of the
31 UNINITIALIZED -> the initial state of the value. This value
32 is replaced with a correct initial value
33 the first time the value is used, so the
34 rest of the pass does not need to care about
35 it. Using this value simplifies initialization
36 of the pass, and prevents us from needlessly
37 scanning statements that are never reached.
39 UNDEFINED -> V_i is a local variable whose definition
40 has not been processed yet. Therefore we
41 don't yet know if its value is a constant
44 CONSTANT -> V_i has been found to hold a constant
47 VARYING -> V_i cannot take a constant value, or if it
48 does, it is not possible to determine it
51 The core of SSA-CCP is in ccp_visit_stmt and ccp_visit_phi_node:
53 1- In ccp_visit_stmt, we are interested in assignments whose RHS
54 evaluates into a constant and conditional jumps whose predicate
55 evaluates into a boolean true or false. When an assignment of
56 the form V_i = CONST is found, V_i's lattice value is set to
57 CONSTANT and CONST is associated with it. This causes the
58 propagation engine to add all the SSA edges coming out the
59 assignment into the worklists, so that statements that use V_i
62 If the statement is a conditional with a constant predicate, we
63 mark the outgoing edges as executable or not executable
64 depending on the predicate's value. This is then used when
65 visiting PHI nodes to know when a PHI argument can be ignored.
68 2- In ccp_visit_phi_node, if all the PHI arguments evaluate to the
69 same constant C, then the LHS of the PHI is set to C. This
70 evaluation is known as the "meet operation". Since one of the
71 goals of this evaluation is to optimistically return constant
72 values as often as possible, it uses two main short cuts:
74 - If an argument is flowing in through a non-executable edge, it
75 is ignored. This is useful in cases like this:
81 a_11 = PHI (a_9, a_10)
83 If PRED is known to always evaluate to false, then we can
84 assume that a_11 will always take its value from a_10, meaning
85 that instead of consider it VARYING (a_9 and a_10 have
86 different values), we can consider it CONSTANT 100.
88 - If an argument has an UNDEFINED value, then it does not affect
89 the outcome of the meet operation. If a variable V_i has an
90 UNDEFINED value, it means that either its defining statement
91 hasn't been visited yet or V_i has no defining statement, in
92 which case the original symbol 'V' is being used
93 uninitialized. Since 'V' is a local variable, the compiler
94 may assume any initial value for it.
97 After propagation, every variable V_i that ends up with a lattice
98 value of CONSTANT will have the associated constant value in the
99 array CONST_VAL[i].VALUE. That is fed into substitute_and_fold for
100 final substitution and folding.
103 Constant propagation in stores and loads (STORE-CCP)
104 ----------------------------------------------------
106 While CCP has all the logic to propagate constants in GIMPLE
107 registers, it is missing the ability to associate constants with
108 stores and loads (i.e., pointer dereferences, structures and
109 global/aliased variables). We don't keep loads and stores in
110 SSA, but we do build a factored use-def web for them (in the
113 For instance, consider the following code fragment:
132 We should be able to deduce that the predicate 'a.a != B' is always
133 false. To achieve this, we associate constant values to the SSA
134 names in the VDEF operands for each store. Additionally,
135 since we also glob partial loads/stores with the base symbol, we
136 also keep track of the memory reference where the constant value
137 was stored (in the MEM_REF field of PROP_VALUE_T). For instance,
145 In the example above, CCP will associate value '2' with 'a_5', but
146 it would be wrong to replace the load from 'a.b' with '2', because
147 '2' had been stored into a.a.
149 Note that the initial value of virtual operands is VARYING, not
150 UNDEFINED. Consider, for instance global variables:
158 # A_5 = PHI (A_4, A_2);
166 The value of A_2 cannot be assumed to be UNDEFINED, as it may have
167 been defined outside of foo. If we were to assume it UNDEFINED, we
168 would erroneously optimize the above into 'return 3;'.
170 Though STORE-CCP is not too expensive, it does have to do more work
171 than regular CCP, so it is only enabled at -O2. Both regular CCP
172 and STORE-CCP use the exact same algorithm. The only distinction
173 is that when doing STORE-CCP, the boolean variable DO_STORE_CCP is
174 set to true. This affects the evaluation of statements and PHI
179 Constant propagation with conditional branches,
180 Wegman and Zadeck, ACM TOPLAS 13(2):181-210.
182 Building an Optimizing Compiler,
183 Robert Morgan, Butterworth-Heinemann, 1998, Section 8.9.
185 Advanced Compiler Design and Implementation,
186 Steven Muchnick, Morgan Kaufmann, 1997, Section 12.6 */
190 #include "coretypes.h"
195 #include "basic-block.h"
197 #include "function.h"
198 #include "tree-pretty-print.h"
199 #include "gimple-pretty-print.h"
201 #include "tree-dump.h"
202 #include "tree-flow.h"
203 #include "tree-pass.h"
204 #include "tree-ssa-propagate.h"
205 #include "value-prof.h"
206 #include "langhooks.h"
212 /* Possible lattice values. */
221 /* Array of propagated constant values. After propagation,
222 CONST_VAL[I].VALUE holds the constant value for SSA_NAME(I). If
223 the constant is held in an SSA name representing a memory store
224 (i.e., a VDEF), CONST_VAL[I].MEM_REF will contain the actual
225 memory reference used to store (i.e., the LHS of the assignment
227 static prop_value_t
*const_val
;
229 static void canonicalize_float_value (prop_value_t
*);
230 static bool ccp_fold_stmt (gimple_stmt_iterator
*);
232 /* Dump constant propagation value VAL to file OUTF prefixed by PREFIX. */
235 dump_lattice_value (FILE *outf
, const char *prefix
, prop_value_t val
)
237 switch (val
.lattice_val
)
240 fprintf (outf
, "%sUNINITIALIZED", prefix
);
243 fprintf (outf
, "%sUNDEFINED", prefix
);
246 fprintf (outf
, "%sVARYING", prefix
);
249 fprintf (outf
, "%sCONSTANT ", prefix
);
250 print_generic_expr (outf
, val
.value
, dump_flags
);
258 /* Print lattice value VAL to stderr. */
260 void debug_lattice_value (prop_value_t val
);
263 debug_lattice_value (prop_value_t val
)
265 dump_lattice_value (stderr
, "", val
);
266 fprintf (stderr
, "\n");
270 /* Compute a default value for variable VAR and store it in the
271 CONST_VAL array. The following rules are used to get default
274 1- Global and static variables that are declared constant are
277 2- Any other value is considered UNDEFINED. This is useful when
278 considering PHI nodes. PHI arguments that are undefined do not
279 change the constant value of the PHI node, which allows for more
280 constants to be propagated.
282 3- Variables defined by statements other than assignments and PHI
283 nodes are considered VARYING.
285 4- Initial values of variables that are not GIMPLE registers are
286 considered VARYING. */
289 get_default_value (tree var
)
291 tree sym
= SSA_NAME_VAR (var
);
292 prop_value_t val
= { UNINITIALIZED
, NULL_TREE
};
295 stmt
= SSA_NAME_DEF_STMT (var
);
297 if (gimple_nop_p (stmt
))
299 /* Variables defined by an empty statement are those used
300 before being initialized. If VAR is a local variable, we
301 can assume initially that it is UNDEFINED, otherwise we must
302 consider it VARYING. */
303 if (is_gimple_reg (sym
) && TREE_CODE (sym
) != PARM_DECL
)
304 val
.lattice_val
= UNDEFINED
;
306 val
.lattice_val
= VARYING
;
308 else if (is_gimple_assign (stmt
)
309 /* Value-returning GIMPLE_CALL statements assign to
310 a variable, and are treated similarly to GIMPLE_ASSIGN. */
311 || (is_gimple_call (stmt
)
312 && gimple_call_lhs (stmt
) != NULL_TREE
)
313 || gimple_code (stmt
) == GIMPLE_PHI
)
316 if (gimple_assign_single_p (stmt
)
317 && DECL_P (gimple_assign_rhs1 (stmt
))
318 && (cst
= get_symbol_constant_value (gimple_assign_rhs1 (stmt
))))
320 val
.lattice_val
= CONSTANT
;
324 /* Any other variable defined by an assignment or a PHI node
325 is considered UNDEFINED. */
326 val
.lattice_val
= UNDEFINED
;
330 /* Otherwise, VAR will never take on a constant value. */
331 val
.lattice_val
= VARYING
;
338 /* Get the constant value associated with variable VAR. */
340 static inline prop_value_t
*
345 if (const_val
== NULL
)
348 val
= &const_val
[SSA_NAME_VERSION (var
)];
349 if (val
->lattice_val
== UNINITIALIZED
)
350 *val
= get_default_value (var
);
352 canonicalize_float_value (val
);
357 /* Sets the value associated with VAR to VARYING. */
360 set_value_varying (tree var
)
362 prop_value_t
*val
= &const_val
[SSA_NAME_VERSION (var
)];
364 val
->lattice_val
= VARYING
;
365 val
->value
= NULL_TREE
;
368 /* For float types, modify the value of VAL to make ccp work correctly
369 for non-standard values (-0, NaN):
371 If HONOR_SIGNED_ZEROS is false, and VAL = -0, we canonicalize it to 0.
372 If HONOR_NANS is false, and VAL is NaN, we canonicalize it to UNDEFINED.
373 This is to fix the following problem (see PR 29921): Suppose we have
377 and we set value of y to NaN. This causes value of x to be set to NaN.
378 When we later determine that y is in fact VARYING, fold uses the fact
379 that HONOR_NANS is false, and we try to change the value of x to 0,
380 causing an ICE. With HONOR_NANS being false, the real appearance of
381 NaN would cause undefined behavior, though, so claiming that y (and x)
382 are UNDEFINED initially is correct. */
385 canonicalize_float_value (prop_value_t
*val
)
387 enum machine_mode mode
;
391 if (val
->lattice_val
!= CONSTANT
392 || TREE_CODE (val
->value
) != REAL_CST
)
395 d
= TREE_REAL_CST (val
->value
);
396 type
= TREE_TYPE (val
->value
);
397 mode
= TYPE_MODE (type
);
399 if (!HONOR_SIGNED_ZEROS (mode
)
400 && REAL_VALUE_MINUS_ZERO (d
))
402 val
->value
= build_real (type
, dconst0
);
406 if (!HONOR_NANS (mode
)
407 && REAL_VALUE_ISNAN (d
))
409 val
->lattice_val
= UNDEFINED
;
415 /* Set the value for variable VAR to NEW_VAL. Return true if the new
416 value is different from VAR's previous value. */
419 set_lattice_value (tree var
, prop_value_t new_val
)
421 prop_value_t
*old_val
= get_value (var
);
423 canonicalize_float_value (&new_val
);
425 /* Lattice transitions must always be monotonically increasing in
426 value. If *OLD_VAL and NEW_VAL are the same, return false to
427 inform the caller that this was a non-transition. */
429 gcc_assert (old_val
->lattice_val
< new_val
.lattice_val
430 || (old_val
->lattice_val
== new_val
.lattice_val
431 && ((!old_val
->value
&& !new_val
.value
)
432 || operand_equal_p (old_val
->value
, new_val
.value
, 0))));
434 if (old_val
->lattice_val
!= new_val
.lattice_val
)
436 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
438 dump_lattice_value (dump_file
, "Lattice value changed to ", new_val
);
439 fprintf (dump_file
, ". Adding SSA edges to worklist.\n");
444 gcc_assert (new_val
.lattice_val
!= UNDEFINED
);
452 /* Return the likely CCP lattice value for STMT.
454 If STMT has no operands, then return CONSTANT.
456 Else if undefinedness of operands of STMT cause its value to be
457 undefined, then return UNDEFINED.
459 Else if any operands of STMT are constants, then return CONSTANT.
461 Else return VARYING. */
464 likely_value (gimple stmt
)
466 bool has_constant_operand
, has_undefined_operand
, all_undefined_operands
;
471 enum gimple_code code
= gimple_code (stmt
);
473 /* This function appears to be called only for assignments, calls,
474 conditionals, and switches, due to the logic in visit_stmt. */
475 gcc_assert (code
== GIMPLE_ASSIGN
476 || code
== GIMPLE_CALL
477 || code
== GIMPLE_COND
478 || code
== GIMPLE_SWITCH
);
480 /* If the statement has volatile operands, it won't fold to a
482 if (gimple_has_volatile_ops (stmt
))
485 /* Arrive here for more complex cases. */
486 has_constant_operand
= false;
487 has_undefined_operand
= false;
488 all_undefined_operands
= true;
489 FOR_EACH_SSA_TREE_OPERAND (use
, stmt
, iter
, SSA_OP_USE
)
491 prop_value_t
*val
= get_value (use
);
493 if (val
->lattice_val
== UNDEFINED
)
494 has_undefined_operand
= true;
496 all_undefined_operands
= false;
498 if (val
->lattice_val
== CONSTANT
)
499 has_constant_operand
= true;
502 /* There may be constants in regular rhs operands. For calls we
503 have to ignore lhs, fndecl and static chain, otherwise only
505 for (i
= (is_gimple_call (stmt
) ? 2 : 0) + gimple_has_lhs (stmt
);
506 i
< gimple_num_ops (stmt
); ++i
)
508 tree op
= gimple_op (stmt
, i
);
509 if (!op
|| TREE_CODE (op
) == SSA_NAME
)
511 if (is_gimple_min_invariant (op
))
512 has_constant_operand
= true;
515 if (has_constant_operand
)
516 all_undefined_operands
= false;
518 /* If the operation combines operands like COMPLEX_EXPR make sure to
519 not mark the result UNDEFINED if only one part of the result is
521 if (has_undefined_operand
&& all_undefined_operands
)
523 else if (code
== GIMPLE_ASSIGN
&& has_undefined_operand
)
525 switch (gimple_assign_rhs_code (stmt
))
527 /* Unary operators are handled with all_undefined_operands. */
530 case POINTER_PLUS_EXPR
:
531 /* Not MIN_EXPR, MAX_EXPR. One VARYING operand may be selected.
532 Not bitwise operators, one VARYING operand may specify the
533 result completely. Not logical operators for the same reason.
534 Not COMPLEX_EXPR as one VARYING operand makes the result partly
535 not UNDEFINED. Not *DIV_EXPR, comparisons and shifts because
536 the undefined operand may be promoted. */
543 /* If there was an UNDEFINED operand but the result may be not UNDEFINED
544 fall back to VARYING even if there were CONSTANT operands. */
545 if (has_undefined_operand
)
548 /* We do not consider virtual operands here -- load from read-only
549 memory may have only VARYING virtual operands, but still be
551 if (has_constant_operand
552 || gimple_references_memory_p (stmt
))
558 /* Returns true if STMT cannot be constant. */
561 surely_varying_stmt_p (gimple stmt
)
563 /* If the statement has operands that we cannot handle, it cannot be
565 if (gimple_has_volatile_ops (stmt
))
568 /* If it is a call and does not return a value or is not a
569 builtin and not an indirect call, it is varying. */
570 if (is_gimple_call (stmt
))
573 if (!gimple_call_lhs (stmt
)
574 || ((fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
575 && !DECL_BUILT_IN (fndecl
)))
579 /* Any other store operation is not interesting. */
580 else if (gimple_vdef (stmt
))
583 /* Anything other than assignments and conditional jumps are not
584 interesting for CCP. */
585 if (gimple_code (stmt
) != GIMPLE_ASSIGN
586 && gimple_code (stmt
) != GIMPLE_COND
587 && gimple_code (stmt
) != GIMPLE_SWITCH
588 && gimple_code (stmt
) != GIMPLE_CALL
)
594 /* Initialize local data structures for CCP. */
597 ccp_initialize (void)
601 const_val
= XCNEWVEC (prop_value_t
, num_ssa_names
);
603 /* Initialize simulation flags for PHI nodes and statements. */
606 gimple_stmt_iterator i
;
608 for (i
= gsi_start_bb (bb
); !gsi_end_p (i
); gsi_next (&i
))
610 gimple stmt
= gsi_stmt (i
);
613 /* If the statement is a control insn, then we do not
614 want to avoid simulating the statement once. Failure
615 to do so means that those edges will never get added. */
616 if (stmt_ends_bb_p (stmt
))
619 is_varying
= surely_varying_stmt_p (stmt
);
626 /* If the statement will not produce a constant, mark
627 all its outputs VARYING. */
628 FOR_EACH_SSA_TREE_OPERAND (def
, stmt
, iter
, SSA_OP_ALL_DEFS
)
629 set_value_varying (def
);
631 prop_set_simulate_again (stmt
, !is_varying
);
635 /* Now process PHI nodes. We never clear the simulate_again flag on
636 phi nodes, since we do not know which edges are executable yet,
637 except for phi nodes for virtual operands when we do not do store ccp. */
640 gimple_stmt_iterator i
;
642 for (i
= gsi_start_phis (bb
); !gsi_end_p (i
); gsi_next (&i
))
644 gimple phi
= gsi_stmt (i
);
646 if (!is_gimple_reg (gimple_phi_result (phi
)))
647 prop_set_simulate_again (phi
, false);
649 prop_set_simulate_again (phi
, true);
654 /* Debug count support. Reset the values of ssa names
655 VARYING when the total number ssa names analyzed is
656 beyond the debug count specified. */
662 for (i
= 0; i
< num_ssa_names
; i
++)
666 const_val
[i
].lattice_val
= VARYING
;
667 const_val
[i
].value
= NULL_TREE
;
673 /* Do final substitution of propagated values, cleanup the flowgraph and
674 free allocated storage.
676 Return TRUE when something was optimized. */
681 bool something_changed
;
684 /* Perform substitutions based on the known constant values. */
685 something_changed
= substitute_and_fold (const_val
, ccp_fold_stmt
, true);
689 return something_changed
;;
693 /* Compute the meet operator between *VAL1 and *VAL2. Store the result
696 any M UNDEFINED = any
697 any M VARYING = VARYING
698 Ci M Cj = Ci if (i == j)
699 Ci M Cj = VARYING if (i != j)
703 ccp_lattice_meet (prop_value_t
*val1
, prop_value_t
*val2
)
705 if (val1
->lattice_val
== UNDEFINED
)
707 /* UNDEFINED M any = any */
710 else if (val2
->lattice_val
== UNDEFINED
)
712 /* any M UNDEFINED = any
713 Nothing to do. VAL1 already contains the value we want. */
716 else if (val1
->lattice_val
== VARYING
717 || val2
->lattice_val
== VARYING
)
719 /* any M VARYING = VARYING. */
720 val1
->lattice_val
= VARYING
;
721 val1
->value
= NULL_TREE
;
723 else if (val1
->lattice_val
== CONSTANT
724 && val2
->lattice_val
== CONSTANT
725 && simple_cst_equal (val1
->value
, val2
->value
) == 1)
727 /* Ci M Cj = Ci if (i == j)
728 Ci M Cj = VARYING if (i != j)
730 If these two values come from memory stores, make sure that
731 they come from the same memory reference. */
732 val1
->lattice_val
= CONSTANT
;
733 val1
->value
= val1
->value
;
737 /* Any other combination is VARYING. */
738 val1
->lattice_val
= VARYING
;
739 val1
->value
= NULL_TREE
;
744 /* Loop through the PHI_NODE's parameters for BLOCK and compare their
745 lattice values to determine PHI_NODE's lattice value. The value of a
746 PHI node is determined calling ccp_lattice_meet with all the arguments
747 of the PHI node that are incoming via executable edges. */
749 static enum ssa_prop_result
750 ccp_visit_phi_node (gimple phi
)
753 prop_value_t
*old_val
, new_val
;
755 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
757 fprintf (dump_file
, "\nVisiting PHI node: ");
758 print_gimple_stmt (dump_file
, phi
, 0, dump_flags
);
761 old_val
= get_value (gimple_phi_result (phi
));
762 switch (old_val
->lattice_val
)
765 return SSA_PROP_VARYING
;
772 new_val
.lattice_val
= UNDEFINED
;
773 new_val
.value
= NULL_TREE
;
780 for (i
= 0; i
< gimple_phi_num_args (phi
); i
++)
782 /* Compute the meet operator over all the PHI arguments flowing
783 through executable edges. */
784 edge e
= gimple_phi_arg_edge (phi
, i
);
786 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
789 "\n Argument #%d (%d -> %d %sexecutable)\n",
790 i
, e
->src
->index
, e
->dest
->index
,
791 (e
->flags
& EDGE_EXECUTABLE
) ? "" : "not ");
794 /* If the incoming edge is executable, Compute the meet operator for
795 the existing value of the PHI node and the current PHI argument. */
796 if (e
->flags
& EDGE_EXECUTABLE
)
798 tree arg
= gimple_phi_arg (phi
, i
)->def
;
799 prop_value_t arg_val
;
801 if (is_gimple_min_invariant (arg
))
803 arg_val
.lattice_val
= CONSTANT
;
807 arg_val
= *(get_value (arg
));
809 ccp_lattice_meet (&new_val
, &arg_val
);
811 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
813 fprintf (dump_file
, "\t");
814 print_generic_expr (dump_file
, arg
, dump_flags
);
815 dump_lattice_value (dump_file
, "\tValue: ", arg_val
);
816 fprintf (dump_file
, "\n");
819 if (new_val
.lattice_val
== VARYING
)
824 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
826 dump_lattice_value (dump_file
, "\n PHI node value: ", new_val
);
827 fprintf (dump_file
, "\n\n");
830 /* Make the transition to the new value. */
831 if (set_lattice_value (gimple_phi_result (phi
), new_val
))
833 if (new_val
.lattice_val
== VARYING
)
834 return SSA_PROP_VARYING
;
836 return SSA_PROP_INTERESTING
;
839 return SSA_PROP_NOT_INTERESTING
;
842 /* Get operand number OPNR from the rhs of STMT. Before returning it,
843 simplify it to a constant if possible. */
846 get_rhs_assign_op_for_ccp (gimple stmt
, int opnr
)
848 tree op
= gimple_op (stmt
, opnr
);
850 if (TREE_CODE (op
) == SSA_NAME
)
852 prop_value_t
*val
= get_value (op
);
853 if (val
->lattice_val
== CONSTANT
)
854 op
= get_value (op
)->value
;
859 /* CCP specific front-end to the non-destructive constant folding
862 Attempt to simplify the RHS of STMT knowing that one or more
863 operands are constants.
865 If simplification is possible, return the simplified RHS,
866 otherwise return the original RHS or NULL_TREE. */
869 ccp_fold (gimple stmt
)
871 location_t loc
= gimple_location (stmt
);
872 switch (gimple_code (stmt
))
876 enum tree_code subcode
= gimple_assign_rhs_code (stmt
);
878 switch (get_gimple_rhs_class (subcode
))
880 case GIMPLE_SINGLE_RHS
:
882 tree rhs
= gimple_assign_rhs1 (stmt
);
883 enum tree_code_class kind
= TREE_CODE_CLASS (subcode
);
885 if (TREE_CODE (rhs
) == SSA_NAME
)
887 /* If the RHS is an SSA_NAME, return its known constant value,
889 return get_value (rhs
)->value
;
891 /* Handle propagating invariant addresses into address operations.
892 The folding we do here matches that in tree-ssa-forwprop.c. */
893 else if (TREE_CODE (rhs
) == ADDR_EXPR
)
896 base
= &TREE_OPERAND (rhs
, 0);
897 while (handled_component_p (*base
))
898 base
= &TREE_OPERAND (*base
, 0);
899 if (TREE_CODE (*base
) == INDIRECT_REF
900 && TREE_CODE (TREE_OPERAND (*base
, 0)) == SSA_NAME
)
902 prop_value_t
*val
= get_value (TREE_OPERAND (*base
, 0));
903 if (val
->lattice_val
== CONSTANT
904 && TREE_CODE (val
->value
) == ADDR_EXPR
905 && may_propagate_address_into_dereference
908 /* We need to return a new tree, not modify the IL
909 or share parts of it. So play some tricks to
910 avoid manually building it. */
911 tree ret
, save
= *base
;
912 *base
= TREE_OPERAND (val
->value
, 0);
913 ret
= unshare_expr (rhs
);
914 recompute_tree_invariant_for_addr_expr (ret
);
920 else if (TREE_CODE (rhs
) == CONSTRUCTOR
921 && TREE_CODE (TREE_TYPE (rhs
)) == VECTOR_TYPE
922 && (CONSTRUCTOR_NELTS (rhs
)
923 == TYPE_VECTOR_SUBPARTS (TREE_TYPE (rhs
))))
929 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (rhs
), i
, val
)
931 if (TREE_CODE (val
) == SSA_NAME
932 && get_value (val
)->lattice_val
== CONSTANT
)
933 val
= get_value (val
)->value
;
934 if (TREE_CODE (val
) == INTEGER_CST
935 || TREE_CODE (val
) == REAL_CST
936 || TREE_CODE (val
) == FIXED_CST
)
937 list
= tree_cons (NULL_TREE
, val
, list
);
942 return build_vector (TREE_TYPE (rhs
), nreverse (list
));
945 if (kind
== tcc_reference
)
947 if ((TREE_CODE (rhs
) == VIEW_CONVERT_EXPR
948 || TREE_CODE (rhs
) == REALPART_EXPR
949 || TREE_CODE (rhs
) == IMAGPART_EXPR
)
950 && TREE_CODE (TREE_OPERAND (rhs
, 0)) == SSA_NAME
)
952 prop_value_t
*val
= get_value (TREE_OPERAND (rhs
, 0));
953 if (val
->lattice_val
== CONSTANT
)
954 return fold_unary_loc (EXPR_LOCATION (rhs
),
956 TREE_TYPE (rhs
), val
->value
);
958 else if (TREE_CODE (rhs
) == INDIRECT_REF
959 && TREE_CODE (TREE_OPERAND (rhs
, 0)) == SSA_NAME
)
961 prop_value_t
*val
= get_value (TREE_OPERAND (rhs
, 0));
962 if (val
->lattice_val
== CONSTANT
963 && TREE_CODE (val
->value
) == ADDR_EXPR
964 && useless_type_conversion_p (TREE_TYPE (rhs
),
965 TREE_TYPE (TREE_TYPE (val
->value
))))
966 rhs
= TREE_OPERAND (val
->value
, 0);
968 return fold_const_aggregate_ref (rhs
);
970 else if (kind
== tcc_declaration
)
971 return get_symbol_constant_value (rhs
);
975 case GIMPLE_UNARY_RHS
:
977 /* Handle unary operators that can appear in GIMPLE form.
978 Note that we know the single operand must be a constant,
979 so this should almost always return a simplified RHS. */
980 tree lhs
= gimple_assign_lhs (stmt
);
981 tree op0
= get_rhs_assign_op_for_ccp (stmt
, 1);
983 /* Conversions are useless for CCP purposes if they are
984 value-preserving. Thus the restrictions that
985 useless_type_conversion_p places for pointer type conversions
986 do not apply here. Substitution later will only substitute to
988 if (CONVERT_EXPR_CODE_P (subcode
)
989 && POINTER_TYPE_P (TREE_TYPE (lhs
))
990 && POINTER_TYPE_P (TREE_TYPE (op0
))
991 /* Do not allow differences in volatile qualification
992 as this might get us confused as to whether a
993 propagation destination statement is volatile
994 or not. See PR36988. */
995 && (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (lhs
)))
996 == TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (op0
)))))
999 /* Still try to generate a constant of correct type. */
1000 if (!useless_type_conversion_p (TREE_TYPE (lhs
),
1002 && ((tem
= maybe_fold_offset_to_address
1004 op0
, integer_zero_node
, TREE_TYPE (lhs
)))
1011 fold_unary_ignore_overflow_loc (loc
, subcode
,
1012 gimple_expr_type (stmt
), op0
);
1015 case GIMPLE_BINARY_RHS
:
1017 /* Handle binary operators that can appear in GIMPLE form. */
1018 tree op0
= get_rhs_assign_op_for_ccp (stmt
, 1);
1019 tree op1
= get_rhs_assign_op_for_ccp (stmt
, 2);
1021 /* Fold &foo + CST into an invariant reference if possible. */
1022 if (gimple_assign_rhs_code (stmt
) == POINTER_PLUS_EXPR
1023 && TREE_CODE (op0
) == ADDR_EXPR
1024 && TREE_CODE (op1
) == INTEGER_CST
)
1026 tree tem
= maybe_fold_offset_to_address
1027 (loc
, op0
, op1
, TREE_TYPE (op0
));
1028 if (tem
!= NULL_TREE
)
1032 return fold_binary_loc (loc
, subcode
,
1033 gimple_expr_type (stmt
), op0
, op1
);
1036 case GIMPLE_TERNARY_RHS
:
1038 /* Handle binary operators that can appear in GIMPLE form. */
1039 tree op0
= get_rhs_assign_op_for_ccp (stmt
, 1);
1040 tree op1
= get_rhs_assign_op_for_ccp (stmt
, 2);
1041 tree op2
= get_rhs_assign_op_for_ccp (stmt
, 3);
1043 return fold_ternary_loc (loc
, subcode
,
1044 gimple_expr_type (stmt
), op0
, op1
, op2
);
1055 tree fn
= gimple_call_fn (stmt
);
1058 if (TREE_CODE (fn
) == SSA_NAME
)
1060 val
= get_value (fn
);
1061 if (val
->lattice_val
== CONSTANT
)
1064 if (TREE_CODE (fn
) == ADDR_EXPR
1065 && TREE_CODE (TREE_OPERAND (fn
, 0)) == FUNCTION_DECL
1066 && DECL_BUILT_IN (TREE_OPERAND (fn
, 0)))
1068 tree
*args
= XALLOCAVEC (tree
, gimple_call_num_args (stmt
));
1071 for (i
= 0; i
< gimple_call_num_args (stmt
); ++i
)
1073 args
[i
] = gimple_call_arg (stmt
, i
);
1074 if (TREE_CODE (args
[i
]) == SSA_NAME
)
1076 val
= get_value (args
[i
]);
1077 if (val
->lattice_val
== CONSTANT
)
1078 args
[i
] = val
->value
;
1081 call
= build_call_array_loc (loc
,
1082 gimple_call_return_type (stmt
),
1083 fn
, gimple_call_num_args (stmt
), args
);
1084 retval
= fold_call_expr (EXPR_LOCATION (call
), call
, false);
1086 /* fold_call_expr wraps the result inside a NOP_EXPR. */
1087 STRIP_NOPS (retval
);
1095 /* Handle comparison operators that can appear in GIMPLE form. */
1096 tree op0
= gimple_cond_lhs (stmt
);
1097 tree op1
= gimple_cond_rhs (stmt
);
1098 enum tree_code code
= gimple_cond_code (stmt
);
1100 /* Simplify the operands down to constants when appropriate. */
1101 if (TREE_CODE (op0
) == SSA_NAME
)
1103 prop_value_t
*val
= get_value (op0
);
1104 if (val
->lattice_val
== CONSTANT
)
1108 if (TREE_CODE (op1
) == SSA_NAME
)
1110 prop_value_t
*val
= get_value (op1
);
1111 if (val
->lattice_val
== CONSTANT
)
1115 return fold_binary_loc (loc
, code
, boolean_type_node
, op0
, op1
);
1120 tree rhs
= gimple_switch_index (stmt
);
1122 if (TREE_CODE (rhs
) == SSA_NAME
)
1124 /* If the RHS is an SSA_NAME, return its known constant value,
1126 return get_value (rhs
)->value
;
1138 /* Return the tree representing the element referenced by T if T is an
1139 ARRAY_REF or COMPONENT_REF into constant aggregates. Return
1140 NULL_TREE otherwise. */
1143 fold_const_aggregate_ref (tree t
)
1145 prop_value_t
*value
;
1146 tree base
, ctor
, idx
, field
;
1147 unsigned HOST_WIDE_INT cnt
;
1150 if (TREE_CODE_CLASS (TREE_CODE (t
)) == tcc_declaration
)
1151 return get_symbol_constant_value (t
);
1153 switch (TREE_CODE (t
))
1156 /* Get a CONSTRUCTOR. If BASE is a VAR_DECL, get its
1157 DECL_INITIAL. If BASE is a nested reference into another
1158 ARRAY_REF or COMPONENT_REF, make a recursive call to resolve
1159 the inner reference. */
1160 base
= TREE_OPERAND (t
, 0);
1161 switch (TREE_CODE (base
))
1164 if (!TREE_READONLY (base
)
1165 || TREE_CODE (TREE_TYPE (base
)) != ARRAY_TYPE
1166 || !targetm
.binds_local_p (base
))
1169 ctor
= DECL_INITIAL (base
);
1174 ctor
= fold_const_aggregate_ref (base
);
1186 if (ctor
== NULL_TREE
1187 || (TREE_CODE (ctor
) != CONSTRUCTOR
1188 && TREE_CODE (ctor
) != STRING_CST
)
1189 || !TREE_STATIC (ctor
))
1192 /* Get the index. If we have an SSA_NAME, try to resolve it
1193 with the current lattice value for the SSA_NAME. */
1194 idx
= TREE_OPERAND (t
, 1);
1195 switch (TREE_CODE (idx
))
1198 if ((value
= get_value (idx
))
1199 && value
->lattice_val
== CONSTANT
1200 && TREE_CODE (value
->value
) == INTEGER_CST
)
1213 /* Fold read from constant string. */
1214 if (TREE_CODE (ctor
) == STRING_CST
)
1216 if ((TYPE_MODE (TREE_TYPE (t
))
1217 == TYPE_MODE (TREE_TYPE (TREE_TYPE (ctor
))))
1218 && (GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_TYPE (ctor
))))
1220 && GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (TREE_TYPE (ctor
)))) == 1
1221 && compare_tree_int (idx
, TREE_STRING_LENGTH (ctor
)) < 0)
1222 return build_int_cst_type (TREE_TYPE (t
),
1223 (TREE_STRING_POINTER (ctor
)
1224 [TREE_INT_CST_LOW (idx
)]));
1228 /* Whoo-hoo! I'll fold ya baby. Yeah! */
1229 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (ctor
), cnt
, cfield
, cval
)
1230 if (tree_int_cst_equal (cfield
, idx
))
1233 if (TREE_CODE (cval
) == ADDR_EXPR
)
1235 tree base
= get_base_address (TREE_OPERAND (cval
, 0));
1236 if (base
&& TREE_CODE (base
) == VAR_DECL
)
1237 add_referenced_var (base
);
1244 /* Get a CONSTRUCTOR. If BASE is a VAR_DECL, get its
1245 DECL_INITIAL. If BASE is a nested reference into another
1246 ARRAY_REF or COMPONENT_REF, make a recursive call to resolve
1247 the inner reference. */
1248 base
= TREE_OPERAND (t
, 0);
1249 switch (TREE_CODE (base
))
1252 if (!TREE_READONLY (base
)
1253 || TREE_CODE (TREE_TYPE (base
)) != RECORD_TYPE
1254 || !targetm
.binds_local_p (base
))
1257 ctor
= DECL_INITIAL (base
);
1262 ctor
= fold_const_aggregate_ref (base
);
1269 if (ctor
== NULL_TREE
1270 || TREE_CODE (ctor
) != CONSTRUCTOR
1271 || !TREE_STATIC (ctor
))
1274 field
= TREE_OPERAND (t
, 1);
1276 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (ctor
), cnt
, cfield
, cval
)
1278 /* FIXME: Handle bit-fields. */
1279 && ! DECL_BIT_FIELD (cfield
))
1282 if (TREE_CODE (cval
) == ADDR_EXPR
)
1284 tree base
= get_base_address (TREE_OPERAND (cval
, 0));
1285 if (base
&& TREE_CODE (base
) == VAR_DECL
)
1286 add_referenced_var (base
);
1295 tree c
= fold_const_aggregate_ref (TREE_OPERAND (t
, 0));
1296 if (c
&& TREE_CODE (c
) == COMPLEX_CST
)
1297 return fold_build1_loc (EXPR_LOCATION (t
),
1298 TREE_CODE (t
), TREE_TYPE (t
), c
);
1304 tree base
= TREE_OPERAND (t
, 0);
1305 if (TREE_CODE (base
) == SSA_NAME
1306 && (value
= get_value (base
))
1307 && value
->lattice_val
== CONSTANT
1308 && TREE_CODE (value
->value
) == ADDR_EXPR
1309 && useless_type_conversion_p (TREE_TYPE (t
),
1310 TREE_TYPE (TREE_TYPE (value
->value
))))
1311 return fold_const_aggregate_ref (TREE_OPERAND (value
->value
, 0));
1322 /* Evaluate statement STMT.
1323 Valid only for assignments, calls, conditionals, and switches. */
1326 evaluate_stmt (gimple stmt
)
1329 tree simplified
= NULL_TREE
;
1330 ccp_lattice_t likelyvalue
= likely_value (stmt
);
1333 fold_defer_overflow_warnings ();
1335 /* If the statement is likely to have a CONSTANT result, then try
1336 to fold the statement to determine the constant value. */
1337 /* FIXME. This is the only place that we call ccp_fold.
1338 Since likely_value never returns CONSTANT for calls, we will
1339 not attempt to fold them, including builtins that may profit. */
1340 if (likelyvalue
== CONSTANT
)
1341 simplified
= ccp_fold (stmt
);
1342 /* If the statement is likely to have a VARYING result, then do not
1343 bother folding the statement. */
1344 else if (likelyvalue
== VARYING
)
1346 enum gimple_code code
= gimple_code (stmt
);
1347 if (code
== GIMPLE_ASSIGN
)
1349 enum tree_code subcode
= gimple_assign_rhs_code (stmt
);
1351 /* Other cases cannot satisfy is_gimple_min_invariant
1353 if (get_gimple_rhs_class (subcode
) == GIMPLE_SINGLE_RHS
)
1354 simplified
= gimple_assign_rhs1 (stmt
);
1356 else if (code
== GIMPLE_SWITCH
)
1357 simplified
= gimple_switch_index (stmt
);
1359 /* These cannot satisfy is_gimple_min_invariant without folding. */
1360 gcc_assert (code
== GIMPLE_CALL
|| code
== GIMPLE_COND
);
1363 is_constant
= simplified
&& is_gimple_min_invariant (simplified
);
1365 fold_undefer_overflow_warnings (is_constant
, stmt
, 0);
1367 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1369 fprintf (dump_file
, "which is likely ");
1370 switch (likelyvalue
)
1373 fprintf (dump_file
, "CONSTANT");
1376 fprintf (dump_file
, "UNDEFINED");
1379 fprintf (dump_file
, "VARYING");
1383 fprintf (dump_file
, "\n");
1388 /* The statement produced a constant value. */
1389 val
.lattice_val
= CONSTANT
;
1390 val
.value
= simplified
;
1394 /* The statement produced a nonconstant value. If the statement
1395 had UNDEFINED operands, then the result of the statement
1396 should be UNDEFINED. Otherwise, the statement is VARYING. */
1397 if (likelyvalue
== UNDEFINED
)
1398 val
.lattice_val
= likelyvalue
;
1400 val
.lattice_val
= VARYING
;
1402 val
.value
= NULL_TREE
;
1408 /* Fold the stmt at *GSI with CCP specific information that propagating
1409 and regular folding does not catch. */
1412 ccp_fold_stmt (gimple_stmt_iterator
*gsi
)
1414 gimple stmt
= gsi_stmt (*gsi
);
1416 switch (gimple_code (stmt
))
1421 /* Statement evaluation will handle type mismatches in constants
1422 more gracefully than the final propagation. This allows us to
1423 fold more conditionals here. */
1424 val
= evaluate_stmt (stmt
);
1425 if (val
.lattice_val
!= CONSTANT
1426 || TREE_CODE (val
.value
) != INTEGER_CST
)
1429 if (integer_zerop (val
.value
))
1430 gimple_cond_make_false (stmt
);
1432 gimple_cond_make_true (stmt
);
1439 tree lhs
= gimple_call_lhs (stmt
);
1442 bool changed
= false;
1445 /* If the call was folded into a constant make sure it goes
1446 away even if we cannot propagate into all uses because of
1449 && TREE_CODE (lhs
) == SSA_NAME
1450 && (val
= get_value (lhs
))
1451 && val
->lattice_val
== CONSTANT
)
1453 tree new_rhs
= unshare_expr (val
->value
);
1455 if (!useless_type_conversion_p (TREE_TYPE (lhs
),
1456 TREE_TYPE (new_rhs
)))
1457 new_rhs
= fold_convert (TREE_TYPE (lhs
), new_rhs
);
1458 res
= update_call_from_tree (gsi
, new_rhs
);
1463 /* Propagate into the call arguments. Compared to replace_uses_in
1464 this can use the argument slot types for type verification
1465 instead of the current argument type. We also can safely
1466 drop qualifiers here as we are dealing with constants anyway. */
1467 argt
= TYPE_ARG_TYPES (TREE_TYPE (TREE_TYPE (gimple_call_fn (stmt
))));
1468 for (i
= 0; i
< gimple_call_num_args (stmt
) && argt
;
1469 ++i
, argt
= TREE_CHAIN (argt
))
1471 tree arg
= gimple_call_arg (stmt
, i
);
1472 if (TREE_CODE (arg
) == SSA_NAME
1473 && (val
= get_value (arg
))
1474 && val
->lattice_val
== CONSTANT
1475 && useless_type_conversion_p
1476 (TYPE_MAIN_VARIANT (TREE_VALUE (argt
)),
1477 TYPE_MAIN_VARIANT (TREE_TYPE (val
->value
))))
1479 gimple_call_set_arg (stmt
, i
, unshare_expr (val
->value
));
1489 tree lhs
= gimple_assign_lhs (stmt
);
1492 /* If we have a load that turned out to be constant replace it
1493 as we cannot propagate into all uses in all cases. */
1494 if (gimple_assign_single_p (stmt
)
1495 && TREE_CODE (lhs
) == SSA_NAME
1496 && (val
= get_value (lhs
))
1497 && val
->lattice_val
== CONSTANT
)
1499 tree rhs
= unshare_expr (val
->value
);
1500 if (!useless_type_conversion_p (TREE_TYPE (lhs
), TREE_TYPE (rhs
)))
1501 rhs
= fold_convert (TREE_TYPE (lhs
), rhs
);
1502 gimple_assign_set_rhs_from_tree (gsi
, rhs
);
1514 /* Visit the assignment statement STMT. Set the value of its LHS to the
1515 value computed by the RHS and store LHS in *OUTPUT_P. If STMT
1516 creates virtual definitions, set the value of each new name to that
1517 of the RHS (if we can derive a constant out of the RHS).
1518 Value-returning call statements also perform an assignment, and
1519 are handled here. */
1521 static enum ssa_prop_result
1522 visit_assignment (gimple stmt
, tree
*output_p
)
1525 enum ssa_prop_result retval
;
1527 tree lhs
= gimple_get_lhs (stmt
);
1529 gcc_assert (gimple_code (stmt
) != GIMPLE_CALL
1530 || gimple_call_lhs (stmt
) != NULL_TREE
);
1532 if (gimple_assign_copy_p (stmt
))
1534 tree rhs
= gimple_assign_rhs1 (stmt
);
1536 if (TREE_CODE (rhs
) == SSA_NAME
)
1538 /* For a simple copy operation, we copy the lattice values. */
1539 prop_value_t
*nval
= get_value (rhs
);
1543 val
= evaluate_stmt (stmt
);
1546 /* Evaluate the statement, which could be
1547 either a GIMPLE_ASSIGN or a GIMPLE_CALL. */
1548 val
= evaluate_stmt (stmt
);
1550 retval
= SSA_PROP_NOT_INTERESTING
;
1552 /* Set the lattice value of the statement's output. */
1553 if (TREE_CODE (lhs
) == SSA_NAME
)
1555 /* If STMT is an assignment to an SSA_NAME, we only have one
1557 if (set_lattice_value (lhs
, val
))
1560 if (val
.lattice_val
== VARYING
)
1561 retval
= SSA_PROP_VARYING
;
1563 retval
= SSA_PROP_INTERESTING
;
1571 /* Visit the conditional statement STMT. Return SSA_PROP_INTERESTING
1572 if it can determine which edge will be taken. Otherwise, return
1573 SSA_PROP_VARYING. */
1575 static enum ssa_prop_result
1576 visit_cond_stmt (gimple stmt
, edge
*taken_edge_p
)
1581 block
= gimple_bb (stmt
);
1582 val
= evaluate_stmt (stmt
);
1584 /* Find which edge out of the conditional block will be taken and add it
1585 to the worklist. If no single edge can be determined statically,
1586 return SSA_PROP_VARYING to feed all the outgoing edges to the
1587 propagation engine. */
1588 *taken_edge_p
= val
.value
? find_taken_edge (block
, val
.value
) : 0;
1590 return SSA_PROP_INTERESTING
;
1592 return SSA_PROP_VARYING
;
1596 /* Evaluate statement STMT. If the statement produces an output value and
1597 its evaluation changes the lattice value of its output, return
1598 SSA_PROP_INTERESTING and set *OUTPUT_P to the SSA_NAME holding the
1601 If STMT is a conditional branch and we can determine its truth
1602 value, set *TAKEN_EDGE_P accordingly. If STMT produces a varying
1603 value, return SSA_PROP_VARYING. */
1605 static enum ssa_prop_result
1606 ccp_visit_stmt (gimple stmt
, edge
*taken_edge_p
, tree
*output_p
)
1611 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1613 fprintf (dump_file
, "\nVisiting statement:\n");
1614 print_gimple_stmt (dump_file
, stmt
, 0, dump_flags
);
1617 switch (gimple_code (stmt
))
1620 /* If the statement is an assignment that produces a single
1621 output value, evaluate its RHS to see if the lattice value of
1622 its output has changed. */
1623 return visit_assignment (stmt
, output_p
);
1626 /* A value-returning call also performs an assignment. */
1627 if (gimple_call_lhs (stmt
) != NULL_TREE
)
1628 return visit_assignment (stmt
, output_p
);
1633 /* If STMT is a conditional branch, see if we can determine
1634 which branch will be taken. */
1635 /* FIXME. It appears that we should be able to optimize
1636 computed GOTOs here as well. */
1637 return visit_cond_stmt (stmt
, taken_edge_p
);
1643 /* Any other kind of statement is not interesting for constant
1644 propagation and, therefore, not worth simulating. */
1645 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1646 fprintf (dump_file
, "No interesting values produced. Marked VARYING.\n");
1648 /* Definitions made by statements other than assignments to
1649 SSA_NAMEs represent unknown modifications to their outputs.
1650 Mark them VARYING. */
1651 FOR_EACH_SSA_TREE_OPERAND (def
, stmt
, iter
, SSA_OP_ALL_DEFS
)
1653 prop_value_t v
= { VARYING
, NULL_TREE
};
1654 set_lattice_value (def
, v
);
1657 return SSA_PROP_VARYING
;
1661 /* Main entry point for SSA Conditional Constant Propagation. */
1667 ssa_propagate (ccp_visit_stmt
, ccp_visit_phi_node
);
1668 if (ccp_finalize ())
1669 return (TODO_cleanup_cfg
| TODO_update_ssa
| TODO_remove_unused_locals
);
1678 return flag_tree_ccp
!= 0;
1682 struct gimple_opt_pass pass_ccp
=
1687 gate_ccp
, /* gate */
1688 do_ssa_ccp
, /* execute */
1691 0, /* static_pass_number */
1692 TV_TREE_CCP
, /* tv_id */
1693 PROP_cfg
| PROP_ssa
, /* properties_required */
1694 0, /* properties_provided */
1695 0, /* properties_destroyed */
1696 0, /* todo_flags_start */
1697 TODO_dump_func
| TODO_verify_ssa
1698 | TODO_verify_stmts
| TODO_ggc_collect
/* todo_flags_finish */
1704 /* Try to optimize out __builtin_stack_restore. Optimize it out
1705 if there is another __builtin_stack_restore in the same basic
1706 block and no calls or ASM_EXPRs are in between, or if this block's
1707 only outgoing edge is to EXIT_BLOCK and there are no calls or
1708 ASM_EXPRs after this __builtin_stack_restore. */
1711 optimize_stack_restore (gimple_stmt_iterator i
)
1716 basic_block bb
= gsi_bb (i
);
1717 gimple call
= gsi_stmt (i
);
1719 if (gimple_code (call
) != GIMPLE_CALL
1720 || gimple_call_num_args (call
) != 1
1721 || TREE_CODE (gimple_call_arg (call
, 0)) != SSA_NAME
1722 || !POINTER_TYPE_P (TREE_TYPE (gimple_call_arg (call
, 0))))
1725 for (gsi_next (&i
); !gsi_end_p (i
); gsi_next (&i
))
1727 stmt
= gsi_stmt (i
);
1728 if (gimple_code (stmt
) == GIMPLE_ASM
)
1730 if (gimple_code (stmt
) != GIMPLE_CALL
)
1733 callee
= gimple_call_fndecl (stmt
);
1735 || DECL_BUILT_IN_CLASS (callee
) != BUILT_IN_NORMAL
1736 /* All regular builtins are ok, just obviously not alloca. */
1737 || DECL_FUNCTION_CODE (callee
) == BUILT_IN_ALLOCA
)
1740 if (DECL_FUNCTION_CODE (callee
) == BUILT_IN_STACK_RESTORE
)
1741 goto second_stack_restore
;
1747 /* Allow one successor of the exit block, or zero successors. */
1748 switch (EDGE_COUNT (bb
->succs
))
1753 if (single_succ_edge (bb
)->dest
!= EXIT_BLOCK_PTR
)
1759 second_stack_restore
:
1761 /* If there's exactly one use, then zap the call to __builtin_stack_save.
1762 If there are multiple uses, then the last one should remove the call.
1763 In any case, whether the call to __builtin_stack_save can be removed
1764 or not is irrelevant to removing the call to __builtin_stack_restore. */
1765 if (has_single_use (gimple_call_arg (call
, 0)))
1767 gimple stack_save
= SSA_NAME_DEF_STMT (gimple_call_arg (call
, 0));
1768 if (is_gimple_call (stack_save
))
1770 callee
= gimple_call_fndecl (stack_save
);
1772 && DECL_BUILT_IN_CLASS (callee
) == BUILT_IN_NORMAL
1773 && DECL_FUNCTION_CODE (callee
) == BUILT_IN_STACK_SAVE
)
1775 gimple_stmt_iterator stack_save_gsi
;
1778 stack_save_gsi
= gsi_for_stmt (stack_save
);
1779 rhs
= build_int_cst (TREE_TYPE (gimple_call_arg (call
, 0)), 0);
1780 update_call_from_tree (&stack_save_gsi
, rhs
);
1785 /* No effect, so the statement will be deleted. */
1786 return integer_zero_node
;
1789 /* If va_list type is a simple pointer and nothing special is needed,
1790 optimize __builtin_va_start (&ap, 0) into ap = __builtin_next_arg (0),
1791 __builtin_va_end (&ap) out as NOP and __builtin_va_copy into a simple
1792 pointer assignment. */
1795 optimize_stdarg_builtin (gimple call
)
1797 tree callee
, lhs
, rhs
, cfun_va_list
;
1798 bool va_list_simple_ptr
;
1799 location_t loc
= gimple_location (call
);
1801 if (gimple_code (call
) != GIMPLE_CALL
)
1804 callee
= gimple_call_fndecl (call
);
1806 cfun_va_list
= targetm
.fn_abi_va_list (callee
);
1807 va_list_simple_ptr
= POINTER_TYPE_P (cfun_va_list
)
1808 && (TREE_TYPE (cfun_va_list
) == void_type_node
1809 || TREE_TYPE (cfun_va_list
) == char_type_node
);
1811 switch (DECL_FUNCTION_CODE (callee
))
1813 case BUILT_IN_VA_START
:
1814 if (!va_list_simple_ptr
1815 || targetm
.expand_builtin_va_start
!= NULL
1816 || built_in_decls
[BUILT_IN_NEXT_ARG
] == NULL
)
1819 if (gimple_call_num_args (call
) != 2)
1822 lhs
= gimple_call_arg (call
, 0);
1823 if (!POINTER_TYPE_P (TREE_TYPE (lhs
))
1824 || TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (lhs
)))
1825 != TYPE_MAIN_VARIANT (cfun_va_list
))
1828 lhs
= build_fold_indirect_ref_loc (loc
, lhs
);
1829 rhs
= build_call_expr_loc (loc
, built_in_decls
[BUILT_IN_NEXT_ARG
],
1830 1, integer_zero_node
);
1831 rhs
= fold_convert_loc (loc
, TREE_TYPE (lhs
), rhs
);
1832 return build2 (MODIFY_EXPR
, TREE_TYPE (lhs
), lhs
, rhs
);
1834 case BUILT_IN_VA_COPY
:
1835 if (!va_list_simple_ptr
)
1838 if (gimple_call_num_args (call
) != 2)
1841 lhs
= gimple_call_arg (call
, 0);
1842 if (!POINTER_TYPE_P (TREE_TYPE (lhs
))
1843 || TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (lhs
)))
1844 != TYPE_MAIN_VARIANT (cfun_va_list
))
1847 lhs
= build_fold_indirect_ref_loc (loc
, lhs
);
1848 rhs
= gimple_call_arg (call
, 1);
1849 if (TYPE_MAIN_VARIANT (TREE_TYPE (rhs
))
1850 != TYPE_MAIN_VARIANT (cfun_va_list
))
1853 rhs
= fold_convert_loc (loc
, TREE_TYPE (lhs
), rhs
);
1854 return build2 (MODIFY_EXPR
, TREE_TYPE (lhs
), lhs
, rhs
);
1856 case BUILT_IN_VA_END
:
1857 /* No effect, so the statement will be deleted. */
1858 return integer_zero_node
;
1865 /* A simple pass that attempts to fold all builtin functions. This pass
1866 is run after we've propagated as many constants as we can. */
1869 execute_fold_all_builtins (void)
1871 bool cfg_changed
= false;
1873 unsigned int todoflags
= 0;
1877 gimple_stmt_iterator i
;
1878 for (i
= gsi_start_bb (bb
); !gsi_end_p (i
); )
1880 gimple stmt
, old_stmt
;
1881 tree callee
, result
;
1882 enum built_in_function fcode
;
1884 stmt
= gsi_stmt (i
);
1886 if (gimple_code (stmt
) != GIMPLE_CALL
)
1891 callee
= gimple_call_fndecl (stmt
);
1892 if (!callee
|| DECL_BUILT_IN_CLASS (callee
) != BUILT_IN_NORMAL
)
1897 fcode
= DECL_FUNCTION_CODE (callee
);
1899 result
= gimple_fold_builtin (stmt
);
1902 gimple_remove_stmt_histograms (cfun
, stmt
);
1905 switch (DECL_FUNCTION_CODE (callee
))
1907 case BUILT_IN_CONSTANT_P
:
1908 /* Resolve __builtin_constant_p. If it hasn't been
1909 folded to integer_one_node by now, it's fairly
1910 certain that the value simply isn't constant. */
1911 result
= integer_zero_node
;
1914 case BUILT_IN_STACK_RESTORE
:
1915 result
= optimize_stack_restore (i
);
1921 case BUILT_IN_VA_START
:
1922 case BUILT_IN_VA_END
:
1923 case BUILT_IN_VA_COPY
:
1924 /* These shouldn't be folded before pass_stdarg. */
1925 result
= optimize_stdarg_builtin (stmt
);
1935 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1937 fprintf (dump_file
, "Simplified\n ");
1938 print_gimple_stmt (dump_file
, stmt
, 0, dump_flags
);
1942 if (!update_call_from_tree (&i
, result
))
1944 gimplify_and_update_call_from_tree (&i
, result
);
1945 todoflags
|= TODO_update_address_taken
;
1948 stmt
= gsi_stmt (i
);
1951 if (maybe_clean_or_replace_eh_stmt (old_stmt
, stmt
)
1952 && gimple_purge_dead_eh_edges (bb
))
1955 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1957 fprintf (dump_file
, "to\n ");
1958 print_gimple_stmt (dump_file
, stmt
, 0, dump_flags
);
1959 fprintf (dump_file
, "\n");
1962 /* Retry the same statement if it changed into another
1963 builtin, there might be new opportunities now. */
1964 if (gimple_code (stmt
) != GIMPLE_CALL
)
1969 callee
= gimple_call_fndecl (stmt
);
1971 || DECL_BUILT_IN_CLASS (callee
) != BUILT_IN_NORMAL
1972 || DECL_FUNCTION_CODE (callee
) == fcode
)
1977 /* Delete unreachable blocks. */
1979 todoflags
|= TODO_cleanup_cfg
;
1985 struct gimple_opt_pass pass_fold_builtins
=
1991 execute_fold_all_builtins
, /* execute */
1994 0, /* static_pass_number */
1995 TV_NONE
, /* tv_id */
1996 PROP_cfg
| PROP_ssa
, /* properties_required */
1997 0, /* properties_provided */
1998 0, /* properties_destroyed */
1999 0, /* todo_flags_start */
2002 | TODO_update_ssa
/* todo_flags_finish */