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"
208 #include "diagnostic-core.h"
213 /* Possible lattice values. */
222 /* Array of propagated constant values. After propagation,
223 CONST_VAL[I].VALUE holds the constant value for SSA_NAME(I). If
224 the constant is held in an SSA name representing a memory store
225 (i.e., a VDEF), CONST_VAL[I].MEM_REF will contain the actual
226 memory reference used to store (i.e., the LHS of the assignment
228 static prop_value_t *const_val;
230 static void canonicalize_float_value (prop_value_t *);
231 static bool ccp_fold_stmt (gimple_stmt_iterator *);
233 /* Dump constant propagation value VAL to file OUTF prefixed by PREFIX. */
236 dump_lattice_value (FILE *outf, const char *prefix, prop_value_t val)
238 switch (val.lattice_val)
241 fprintf (outf, "%sUNINITIALIZED", prefix);
244 fprintf (outf, "%sUNDEFINED", prefix);
247 fprintf (outf, "%sVARYING", prefix);
250 fprintf (outf, "%sCONSTANT ", prefix);
251 print_generic_expr (outf, val.value, dump_flags);
259 /* Print lattice value VAL to stderr. */
261 void debug_lattice_value (prop_value_t val);
264 debug_lattice_value (prop_value_t val)
266 dump_lattice_value (stderr, "", val);
267 fprintf (stderr, "\n");
271 /* Compute a default value for variable VAR and store it in the
272 CONST_VAL array. The following rules are used to get default
275 1- Global and static variables that are declared constant are
278 2- Any other value is considered UNDEFINED. This is useful when
279 considering PHI nodes. PHI arguments that are undefined do not
280 change the constant value of the PHI node, which allows for more
281 constants to be propagated.
283 3- Variables defined by statements other than assignments and PHI
284 nodes are considered VARYING.
286 4- Initial values of variables that are not GIMPLE registers are
287 considered VARYING. */
290 get_default_value (tree var)
292 tree sym = SSA_NAME_VAR (var);
293 prop_value_t val = { UNINITIALIZED, NULL_TREE };
296 stmt = SSA_NAME_DEF_STMT (var);
298 if (gimple_nop_p (stmt))
300 /* Variables defined by an empty statement are those used
301 before being initialized. If VAR is a local variable, we
302 can assume initially that it is UNDEFINED, otherwise we must
303 consider it VARYING. */
304 if (is_gimple_reg (sym)
305 && TREE_CODE (sym) == VAR_DECL)
306 val.lattice_val = UNDEFINED;
308 val.lattice_val = VARYING;
310 else if (is_gimple_assign (stmt)
311 /* Value-returning GIMPLE_CALL statements assign to
312 a variable, and are treated similarly to GIMPLE_ASSIGN. */
313 || (is_gimple_call (stmt)
314 && gimple_call_lhs (stmt) != NULL_TREE)
315 || gimple_code (stmt) == GIMPLE_PHI)
318 if (gimple_assign_single_p (stmt)
319 && DECL_P (gimple_assign_rhs1 (stmt))
320 && (cst = get_symbol_constant_value (gimple_assign_rhs1 (stmt))))
322 val.lattice_val = CONSTANT;
326 /* Any other variable defined by an assignment or a PHI node
327 is considered UNDEFINED. */
328 val.lattice_val = UNDEFINED;
332 /* Otherwise, VAR will never take on a constant value. */
333 val.lattice_val = VARYING;
340 /* Get the constant value associated with variable VAR. */
342 static inline prop_value_t *
347 if (const_val == NULL)
350 val = &const_val[SSA_NAME_VERSION (var)];
351 if (val->lattice_val == UNINITIALIZED)
352 *val = get_default_value (var);
354 canonicalize_float_value (val);
359 /* Sets the value associated with VAR to VARYING. */
362 set_value_varying (tree var)
364 prop_value_t *val = &const_val[SSA_NAME_VERSION (var)];
366 val->lattice_val = VARYING;
367 val->value = NULL_TREE;
370 /* For float types, modify the value of VAL to make ccp work correctly
371 for non-standard values (-0, NaN):
373 If HONOR_SIGNED_ZEROS is false, and VAL = -0, we canonicalize it to 0.
374 If HONOR_NANS is false, and VAL is NaN, we canonicalize it to UNDEFINED.
375 This is to fix the following problem (see PR 29921): Suppose we have
379 and we set value of y to NaN. This causes value of x to be set to NaN.
380 When we later determine that y is in fact VARYING, fold uses the fact
381 that HONOR_NANS is false, and we try to change the value of x to 0,
382 causing an ICE. With HONOR_NANS being false, the real appearance of
383 NaN would cause undefined behavior, though, so claiming that y (and x)
384 are UNDEFINED initially is correct. */
387 canonicalize_float_value (prop_value_t *val)
389 enum machine_mode mode;
393 if (val->lattice_val != CONSTANT
394 || TREE_CODE (val->value) != REAL_CST)
397 d = TREE_REAL_CST (val->value);
398 type = TREE_TYPE (val->value);
399 mode = TYPE_MODE (type);
401 if (!HONOR_SIGNED_ZEROS (mode)
402 && REAL_VALUE_MINUS_ZERO (d))
404 val->value = build_real (type, dconst0);
408 if (!HONOR_NANS (mode)
409 && REAL_VALUE_ISNAN (d))
411 val->lattice_val = UNDEFINED;
417 /* Set the value for variable VAR to NEW_VAL. Return true if the new
418 value is different from VAR's previous value. */
421 set_lattice_value (tree var, prop_value_t new_val)
423 prop_value_t *old_val = get_value (var);
425 canonicalize_float_value (&new_val);
427 /* Lattice transitions must always be monotonically increasing in
428 value. If *OLD_VAL and NEW_VAL are the same, return false to
429 inform the caller that this was a non-transition. */
431 gcc_assert (old_val->lattice_val < new_val.lattice_val
432 || (old_val->lattice_val == new_val.lattice_val
433 && ((!old_val->value && !new_val.value)
434 || operand_equal_p (old_val->value, new_val.value, 0))));
436 if (old_val->lattice_val != new_val.lattice_val)
438 if (dump_file && (dump_flags & TDF_DETAILS))
440 dump_lattice_value (dump_file, "Lattice value changed to ", new_val);
441 fprintf (dump_file, ". Adding SSA edges to worklist.\n");
446 gcc_assert (new_val.lattice_val != UNDEFINED);
454 /* Return the likely CCP lattice value for STMT.
456 If STMT has no operands, then return CONSTANT.
458 Else if undefinedness of operands of STMT cause its value to be
459 undefined, then return UNDEFINED.
461 Else if any operands of STMT are constants, then return CONSTANT.
463 Else return VARYING. */
466 likely_value (gimple stmt)
468 bool has_constant_operand, has_undefined_operand, all_undefined_operands;
473 enum gimple_code code = gimple_code (stmt);
475 /* This function appears to be called only for assignments, calls,
476 conditionals, and switches, due to the logic in visit_stmt. */
477 gcc_assert (code == GIMPLE_ASSIGN
478 || code == GIMPLE_CALL
479 || code == GIMPLE_COND
480 || code == GIMPLE_SWITCH);
482 /* If the statement has volatile operands, it won't fold to a
484 if (gimple_has_volatile_ops (stmt))
487 /* Arrive here for more complex cases. */
488 has_constant_operand = false;
489 has_undefined_operand = false;
490 all_undefined_operands = true;
491 FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter, SSA_OP_USE)
493 prop_value_t *val = get_value (use);
495 if (val->lattice_val == UNDEFINED)
496 has_undefined_operand = true;
498 all_undefined_operands = false;
500 if (val->lattice_val == CONSTANT)
501 has_constant_operand = true;
504 /* There may be constants in regular rhs operands. For calls we
505 have to ignore lhs, fndecl and static chain, otherwise only
507 for (i = (is_gimple_call (stmt) ? 2 : 0) + gimple_has_lhs (stmt);
508 i < gimple_num_ops (stmt); ++i)
510 tree op = gimple_op (stmt, i);
511 if (!op || TREE_CODE (op) == SSA_NAME)
513 if (is_gimple_min_invariant (op))
514 has_constant_operand = true;
517 if (has_constant_operand)
518 all_undefined_operands = false;
520 /* If the operation combines operands like COMPLEX_EXPR make sure to
521 not mark the result UNDEFINED if only one part of the result is
523 if (has_undefined_operand && all_undefined_operands)
525 else if (code == GIMPLE_ASSIGN && has_undefined_operand)
527 switch (gimple_assign_rhs_code (stmt))
529 /* Unary operators are handled with all_undefined_operands. */
532 case POINTER_PLUS_EXPR:
533 /* Not MIN_EXPR, MAX_EXPR. One VARYING operand may be selected.
534 Not bitwise operators, one VARYING operand may specify the
535 result completely. Not logical operators for the same reason.
536 Not COMPLEX_EXPR as one VARYING operand makes the result partly
537 not UNDEFINED. Not *DIV_EXPR, comparisons and shifts because
538 the undefined operand may be promoted. */
545 /* If there was an UNDEFINED operand but the result may be not UNDEFINED
546 fall back to VARYING even if there were CONSTANT operands. */
547 if (has_undefined_operand)
550 /* We do not consider virtual operands here -- load from read-only
551 memory may have only VARYING virtual operands, but still be
553 if (has_constant_operand
554 || gimple_references_memory_p (stmt))
560 /* Returns true if STMT cannot be constant. */
563 surely_varying_stmt_p (gimple stmt)
565 /* If the statement has operands that we cannot handle, it cannot be
567 if (gimple_has_volatile_ops (stmt))
570 /* If it is a call and does not return a value or is not a
571 builtin and not an indirect call, it is varying. */
572 if (is_gimple_call (stmt))
575 if (!gimple_call_lhs (stmt)
576 || ((fndecl = gimple_call_fndecl (stmt)) != NULL_TREE
577 && !DECL_BUILT_IN (fndecl)))
581 /* Any other store operation is not interesting. */
582 else if (gimple_vdef (stmt))
585 /* Anything other than assignments and conditional jumps are not
586 interesting for CCP. */
587 if (gimple_code (stmt) != GIMPLE_ASSIGN
588 && gimple_code (stmt) != GIMPLE_COND
589 && gimple_code (stmt) != GIMPLE_SWITCH
590 && gimple_code (stmt) != GIMPLE_CALL)
596 /* Initialize local data structures for CCP. */
599 ccp_initialize (void)
603 const_val = XCNEWVEC (prop_value_t, num_ssa_names);
605 /* Initialize simulation flags for PHI nodes and statements. */
608 gimple_stmt_iterator i;
610 for (i = gsi_start_bb (bb); !gsi_end_p (i); gsi_next (&i))
612 gimple stmt = gsi_stmt (i);
615 /* If the statement is a control insn, then we do not
616 want to avoid simulating the statement once. Failure
617 to do so means that those edges will never get added. */
618 if (stmt_ends_bb_p (stmt))
621 is_varying = surely_varying_stmt_p (stmt);
628 /* If the statement will not produce a constant, mark
629 all its outputs VARYING. */
630 FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_ALL_DEFS)
631 set_value_varying (def);
633 prop_set_simulate_again (stmt, !is_varying);
637 /* Now process PHI nodes. We never clear the simulate_again flag on
638 phi nodes, since we do not know which edges are executable yet,
639 except for phi nodes for virtual operands when we do not do store ccp. */
642 gimple_stmt_iterator i;
644 for (i = gsi_start_phis (bb); !gsi_end_p (i); gsi_next (&i))
646 gimple phi = gsi_stmt (i);
648 if (!is_gimple_reg (gimple_phi_result (phi)))
649 prop_set_simulate_again (phi, false);
651 prop_set_simulate_again (phi, true);
656 /* Debug count support. Reset the values of ssa names
657 VARYING when the total number ssa names analyzed is
658 beyond the debug count specified. */
664 for (i = 0; i < num_ssa_names; i++)
668 const_val[i].lattice_val = VARYING;
669 const_val[i].value = NULL_TREE;
675 /* Do final substitution of propagated values, cleanup the flowgraph and
676 free allocated storage.
678 Return TRUE when something was optimized. */
683 bool something_changed;
686 /* Perform substitutions based on the known constant values. */
687 something_changed = substitute_and_fold (const_val, ccp_fold_stmt, true);
691 return something_changed;;
695 /* Compute the meet operator between *VAL1 and *VAL2. Store the result
698 any M UNDEFINED = any
699 any M VARYING = VARYING
700 Ci M Cj = Ci if (i == j)
701 Ci M Cj = VARYING if (i != j)
705 ccp_lattice_meet (prop_value_t *val1, prop_value_t *val2)
707 if (val1->lattice_val == UNDEFINED)
709 /* UNDEFINED M any = any */
712 else if (val2->lattice_val == UNDEFINED)
714 /* any M UNDEFINED = any
715 Nothing to do. VAL1 already contains the value we want. */
718 else if (val1->lattice_val == VARYING
719 || val2->lattice_val == VARYING)
721 /* any M VARYING = VARYING. */
722 val1->lattice_val = VARYING;
723 val1->value = NULL_TREE;
725 else if (val1->lattice_val == CONSTANT
726 && val2->lattice_val == CONSTANT
727 && simple_cst_equal (val1->value, val2->value) == 1)
729 /* Ci M Cj = Ci if (i == j)
730 Ci M Cj = VARYING if (i != j)
732 If these two values come from memory stores, make sure that
733 they come from the same memory reference. */
734 val1->lattice_val = CONSTANT;
735 val1->value = val1->value;
739 /* Any other combination is VARYING. */
740 val1->lattice_val = VARYING;
741 val1->value = NULL_TREE;
746 /* Loop through the PHI_NODE's parameters for BLOCK and compare their
747 lattice values to determine PHI_NODE's lattice value. The value of a
748 PHI node is determined calling ccp_lattice_meet with all the arguments
749 of the PHI node that are incoming via executable edges. */
751 static enum ssa_prop_result
752 ccp_visit_phi_node (gimple phi)
755 prop_value_t *old_val, new_val;
757 if (dump_file && (dump_flags & TDF_DETAILS))
759 fprintf (dump_file, "\nVisiting PHI node: ");
760 print_gimple_stmt (dump_file, phi, 0, dump_flags);
763 old_val = get_value (gimple_phi_result (phi));
764 switch (old_val->lattice_val)
767 return SSA_PROP_VARYING;
774 new_val.lattice_val = UNDEFINED;
775 new_val.value = NULL_TREE;
782 for (i = 0; i < gimple_phi_num_args (phi); i++)
784 /* Compute the meet operator over all the PHI arguments flowing
785 through executable edges. */
786 edge e = gimple_phi_arg_edge (phi, i);
788 if (dump_file && (dump_flags & TDF_DETAILS))
791 "\n Argument #%d (%d -> %d %sexecutable)\n",
792 i, e->src->index, e->dest->index,
793 (e->flags & EDGE_EXECUTABLE) ? "" : "not ");
796 /* If the incoming edge is executable, Compute the meet operator for
797 the existing value of the PHI node and the current PHI argument. */
798 if (e->flags & EDGE_EXECUTABLE)
800 tree arg = gimple_phi_arg (phi, i)->def;
801 prop_value_t arg_val;
803 if (is_gimple_min_invariant (arg))
805 arg_val.lattice_val = CONSTANT;
809 arg_val = *(get_value (arg));
811 ccp_lattice_meet (&new_val, &arg_val);
813 if (dump_file && (dump_flags & TDF_DETAILS))
815 fprintf (dump_file, "\t");
816 print_generic_expr (dump_file, arg, dump_flags);
817 dump_lattice_value (dump_file, "\tValue: ", arg_val);
818 fprintf (dump_file, "\n");
821 if (new_val.lattice_val == VARYING)
826 if (dump_file && (dump_flags & TDF_DETAILS))
828 dump_lattice_value (dump_file, "\n PHI node value: ", new_val);
829 fprintf (dump_file, "\n\n");
832 /* Make the transition to the new value. */
833 if (set_lattice_value (gimple_phi_result (phi), new_val))
835 if (new_val.lattice_val == VARYING)
836 return SSA_PROP_VARYING;
838 return SSA_PROP_INTERESTING;
841 return SSA_PROP_NOT_INTERESTING;
844 /* Get operand number OPNR from the rhs of STMT. Before returning it,
845 simplify it to a constant if possible. */
848 get_rhs_assign_op_for_ccp (gimple stmt, int opnr)
850 tree op = gimple_op (stmt, opnr);
852 if (TREE_CODE (op) == SSA_NAME)
854 prop_value_t *val = get_value (op);
855 if (val->lattice_val == CONSTANT)
856 op = get_value (op)->value;
861 /* CCP specific front-end to the non-destructive constant folding
864 Attempt to simplify the RHS of STMT knowing that one or more
865 operands are constants.
867 If simplification is possible, return the simplified RHS,
868 otherwise return the original RHS or NULL_TREE. */
871 ccp_fold (gimple stmt)
873 location_t loc = gimple_location (stmt);
874 switch (gimple_code (stmt))
878 enum tree_code subcode = gimple_assign_rhs_code (stmt);
880 switch (get_gimple_rhs_class (subcode))
882 case GIMPLE_SINGLE_RHS:
884 tree rhs = gimple_assign_rhs1 (stmt);
885 enum tree_code_class kind = TREE_CODE_CLASS (subcode);
887 if (TREE_CODE (rhs) == SSA_NAME)
889 /* If the RHS is an SSA_NAME, return its known constant value,
891 return get_value (rhs)->value;
893 /* Handle propagating invariant addresses into address operations.
894 The folding we do here matches that in tree-ssa-forwprop.c. */
895 else if (TREE_CODE (rhs) == ADDR_EXPR)
898 base = &TREE_OPERAND (rhs, 0);
899 while (handled_component_p (*base))
900 base = &TREE_OPERAND (*base, 0);
901 if (TREE_CODE (*base) == MEM_REF
902 && TREE_CODE (TREE_OPERAND (*base, 0)) == SSA_NAME)
904 prop_value_t *val = get_value (TREE_OPERAND (*base, 0));
905 if (val->lattice_val == CONSTANT
906 && TREE_CODE (val->value) == ADDR_EXPR)
908 tree ret, save = *base;
910 new_base = fold_build2 (MEM_REF, TREE_TYPE (*base),
911 unshare_expr (val->value),
912 TREE_OPERAND (*base, 1));
913 /* We need to return a new tree, not modify the IL
914 or share parts of it. So play some tricks to
915 avoid manually building it. */
917 ret = unshare_expr (rhs);
918 recompute_tree_invariant_for_addr_expr (ret);
924 else if (TREE_CODE (rhs) == CONSTRUCTOR
925 && TREE_CODE (TREE_TYPE (rhs)) == VECTOR_TYPE
926 && (CONSTRUCTOR_NELTS (rhs)
927 == TYPE_VECTOR_SUBPARTS (TREE_TYPE (rhs))))
933 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (rhs), i, val)
935 if (TREE_CODE (val) == SSA_NAME
936 && get_value (val)->lattice_val == CONSTANT)
937 val = get_value (val)->value;
938 if (TREE_CODE (val) == INTEGER_CST
939 || TREE_CODE (val) == REAL_CST
940 || TREE_CODE (val) == FIXED_CST)
941 list = tree_cons (NULL_TREE, val, list);
946 return build_vector (TREE_TYPE (rhs), nreverse (list));
949 if (kind == tcc_reference)
951 if ((TREE_CODE (rhs) == VIEW_CONVERT_EXPR
952 || TREE_CODE (rhs) == REALPART_EXPR
953 || TREE_CODE (rhs) == IMAGPART_EXPR)
954 && TREE_CODE (TREE_OPERAND (rhs, 0)) == SSA_NAME)
956 prop_value_t *val = get_value (TREE_OPERAND (rhs, 0));
957 if (val->lattice_val == CONSTANT)
958 return fold_unary_loc (EXPR_LOCATION (rhs),
960 TREE_TYPE (rhs), val->value);
962 else if (TREE_CODE (rhs) == MEM_REF
963 && TREE_CODE (TREE_OPERAND (rhs, 0)) == SSA_NAME)
965 prop_value_t *val = get_value (TREE_OPERAND (rhs, 0));
966 if (val->lattice_val == CONSTANT
967 && TREE_CODE (val->value) == ADDR_EXPR)
969 tree tem = fold_build2 (MEM_REF, TREE_TYPE (rhs),
970 unshare_expr (val->value),
971 TREE_OPERAND (rhs, 1));
976 return fold_const_aggregate_ref (rhs);
978 else if (kind == tcc_declaration)
979 return get_symbol_constant_value (rhs);
983 case GIMPLE_UNARY_RHS:
985 /* Handle unary operators that can appear in GIMPLE form.
986 Note that we know the single operand must be a constant,
987 so this should almost always return a simplified RHS. */
988 tree lhs = gimple_assign_lhs (stmt);
989 tree op0 = get_rhs_assign_op_for_ccp (stmt, 1);
991 /* Conversions are useless for CCP purposes if they are
992 value-preserving. Thus the restrictions that
993 useless_type_conversion_p places for pointer type conversions
994 do not apply here. Substitution later will only substitute to
996 if (CONVERT_EXPR_CODE_P (subcode)
997 && POINTER_TYPE_P (TREE_TYPE (lhs))
998 && POINTER_TYPE_P (TREE_TYPE (op0)))
1001 /* Try to re-construct array references on-the-fly. */
1002 if (!useless_type_conversion_p (TREE_TYPE (lhs),
1004 && ((tem = maybe_fold_offset_to_address
1006 op0, integer_zero_node, TREE_TYPE (lhs)))
1013 fold_unary_ignore_overflow_loc (loc, subcode,
1014 gimple_expr_type (stmt), op0);
1017 case GIMPLE_BINARY_RHS:
1019 /* Handle binary operators that can appear in GIMPLE form. */
1020 tree op0 = get_rhs_assign_op_for_ccp (stmt, 1);
1021 tree op1 = get_rhs_assign_op_for_ccp (stmt, 2);
1023 /* Translate &x + CST into an invariant form suitable for
1024 further propagation. */
1025 if (gimple_assign_rhs_code (stmt) == POINTER_PLUS_EXPR
1026 && TREE_CODE (op0) == ADDR_EXPR
1027 && TREE_CODE (op1) == INTEGER_CST)
1029 tree off = fold_convert (ptr_type_node, op1);
1030 return build_fold_addr_expr
1031 (fold_build2 (MEM_REF,
1032 TREE_TYPE (TREE_TYPE (op0)),
1033 unshare_expr (op0), off));
1036 return fold_binary_loc (loc, subcode,
1037 gimple_expr_type (stmt), op0, op1);
1040 case GIMPLE_TERNARY_RHS:
1042 /* Handle binary operators that can appear in GIMPLE form. */
1043 tree op0 = get_rhs_assign_op_for_ccp (stmt, 1);
1044 tree op1 = get_rhs_assign_op_for_ccp (stmt, 2);
1045 tree op2 = get_rhs_assign_op_for_ccp (stmt, 3);
1047 return fold_ternary_loc (loc, subcode,
1048 gimple_expr_type (stmt), op0, op1, op2);
1059 tree fn = gimple_call_fn (stmt);
1062 if (TREE_CODE (fn) == SSA_NAME)
1064 val = get_value (fn);
1065 if (val->lattice_val == CONSTANT)
1068 if (TREE_CODE (fn) == ADDR_EXPR
1069 && TREE_CODE (TREE_OPERAND (fn, 0)) == FUNCTION_DECL
1070 && DECL_BUILT_IN (TREE_OPERAND (fn, 0)))
1072 tree *args = XALLOCAVEC (tree, gimple_call_num_args (stmt));
1075 for (i = 0; i < gimple_call_num_args (stmt); ++i)
1077 args[i] = gimple_call_arg (stmt, i);
1078 if (TREE_CODE (args[i]) == SSA_NAME)
1080 val = get_value (args[i]);
1081 if (val->lattice_val == CONSTANT)
1082 args[i] = val->value;
1085 call = build_call_array_loc (loc,
1086 gimple_call_return_type (stmt),
1087 fn, gimple_call_num_args (stmt), args);
1088 retval = fold_call_expr (EXPR_LOCATION (call), call, false);
1090 /* fold_call_expr wraps the result inside a NOP_EXPR. */
1091 STRIP_NOPS (retval);
1099 /* Handle comparison operators that can appear in GIMPLE form. */
1100 tree op0 = gimple_cond_lhs (stmt);
1101 tree op1 = gimple_cond_rhs (stmt);
1102 enum tree_code code = gimple_cond_code (stmt);
1104 /* Simplify the operands down to constants when appropriate. */
1105 if (TREE_CODE (op0) == SSA_NAME)
1107 prop_value_t *val = get_value (op0);
1108 if (val->lattice_val == CONSTANT)
1112 if (TREE_CODE (op1) == SSA_NAME)
1114 prop_value_t *val = get_value (op1);
1115 if (val->lattice_val == CONSTANT)
1119 return fold_binary_loc (loc, code, boolean_type_node, op0, op1);
1124 tree rhs = gimple_switch_index (stmt);
1126 if (TREE_CODE (rhs) == SSA_NAME)
1128 /* If the RHS is an SSA_NAME, return its known constant value,
1130 return get_value (rhs)->value;
1142 /* Return the tree representing the element referenced by T if T is an
1143 ARRAY_REF or COMPONENT_REF into constant aggregates. Return
1144 NULL_TREE otherwise. */
1147 fold_const_aggregate_ref (tree t)
1149 prop_value_t *value;
1150 tree base, ctor, idx, field;
1151 unsigned HOST_WIDE_INT cnt;
1154 if (TREE_CODE_CLASS (TREE_CODE (t)) == tcc_declaration)
1155 return get_symbol_constant_value (t);
1157 switch (TREE_CODE (t))
1160 /* Get a CONSTRUCTOR. If BASE is a VAR_DECL, get its
1161 DECL_INITIAL. If BASE is a nested reference into another
1162 ARRAY_REF or COMPONENT_REF, make a recursive call to resolve
1163 the inner reference. */
1164 base = TREE_OPERAND (t, 0);
1165 switch (TREE_CODE (base))
1168 /* ??? We could handle this case. */
1169 if (!integer_zerop (TREE_OPERAND (base, 1)))
1171 base = get_base_address (base);
1173 || TREE_CODE (base) != VAR_DECL)
1178 if (!TREE_READONLY (base)
1179 || TREE_CODE (TREE_TYPE (base)) != ARRAY_TYPE
1180 || !targetm.binds_local_p (base))
1183 ctor = DECL_INITIAL (base);
1188 ctor = fold_const_aggregate_ref (base);
1200 if (ctor == NULL_TREE
1201 || (TREE_CODE (ctor) != CONSTRUCTOR
1202 && TREE_CODE (ctor) != STRING_CST)
1203 || !TREE_STATIC (ctor))
1206 /* Get the index. If we have an SSA_NAME, try to resolve it
1207 with the current lattice value for the SSA_NAME. */
1208 idx = TREE_OPERAND (t, 1);
1209 switch (TREE_CODE (idx))
1212 if ((value = get_value (idx))
1213 && value->lattice_val == CONSTANT
1214 && TREE_CODE (value->value) == INTEGER_CST)
1227 /* Fold read from constant string. */
1228 if (TREE_CODE (ctor) == STRING_CST)
1230 if ((TYPE_MODE (TREE_TYPE (t))
1231 == TYPE_MODE (TREE_TYPE (TREE_TYPE (ctor))))
1232 && (GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_TYPE (ctor))))
1234 && GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (TREE_TYPE (ctor)))) == 1
1235 && compare_tree_int (idx, TREE_STRING_LENGTH (ctor)) < 0)
1236 return build_int_cst_type (TREE_TYPE (t),
1237 (TREE_STRING_POINTER (ctor)
1238 [TREE_INT_CST_LOW (idx)]));
1242 /* Whoo-hoo! I'll fold ya baby. Yeah! */
1243 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (ctor), cnt, cfield, cval)
1244 if (tree_int_cst_equal (cfield, idx))
1247 if (TREE_CODE (cval) == ADDR_EXPR)
1249 tree base = get_base_address (TREE_OPERAND (cval, 0));
1250 if (base && TREE_CODE (base) == VAR_DECL)
1251 add_referenced_var (base);
1258 /* Get a CONSTRUCTOR. If BASE is a VAR_DECL, get its
1259 DECL_INITIAL. If BASE is a nested reference into another
1260 ARRAY_REF or COMPONENT_REF, make a recursive call to resolve
1261 the inner reference. */
1262 base = TREE_OPERAND (t, 0);
1263 switch (TREE_CODE (base))
1266 if (!TREE_READONLY (base)
1267 || TREE_CODE (TREE_TYPE (base)) != RECORD_TYPE
1268 || !targetm.binds_local_p (base))
1271 ctor = DECL_INITIAL (base);
1276 ctor = fold_const_aggregate_ref (base);
1283 if (ctor == NULL_TREE
1284 || TREE_CODE (ctor) != CONSTRUCTOR
1285 || !TREE_STATIC (ctor))
1288 field = TREE_OPERAND (t, 1);
1290 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (ctor), cnt, cfield, cval)
1292 /* FIXME: Handle bit-fields. */
1293 && ! DECL_BIT_FIELD (cfield))
1296 if (TREE_CODE (cval) == ADDR_EXPR)
1298 tree base = get_base_address (TREE_OPERAND (cval, 0));
1299 if (base && TREE_CODE (base) == VAR_DECL)
1300 add_referenced_var (base);
1309 tree c = fold_const_aggregate_ref (TREE_OPERAND (t, 0));
1310 if (c && TREE_CODE (c) == COMPLEX_CST)
1311 return fold_build1_loc (EXPR_LOCATION (t),
1312 TREE_CODE (t), TREE_TYPE (t), c);
1317 /* Get the base object we are accessing. */
1318 base = TREE_OPERAND (t, 0);
1319 if (TREE_CODE (base) == SSA_NAME
1320 && (value = get_value (base))
1321 && value->lattice_val == CONSTANT)
1322 base = value->value;
1323 if (TREE_CODE (base) != ADDR_EXPR)
1325 base = TREE_OPERAND (base, 0);
1326 switch (TREE_CODE (base))
1330 && !AGGREGATE_TYPE_P (TREE_TYPE (base))
1331 && integer_zerop (TREE_OPERAND (t, 1)))
1333 tree res = get_symbol_constant_value (base);
1335 && !useless_type_conversion_p
1336 (TREE_TYPE (t), TREE_TYPE (res)))
1337 res = fold_unary (VIEW_CONVERT_EXPR, TREE_TYPE (t), res);
1341 if (!TREE_READONLY (base)
1342 || TREE_CODE (TREE_TYPE (base)) != ARRAY_TYPE
1343 || !targetm.binds_local_p (base))
1346 ctor = DECL_INITIAL (base);
1358 if (ctor == NULL_TREE
1359 || (TREE_CODE (ctor) != CONSTRUCTOR
1360 && TREE_CODE (ctor) != STRING_CST)
1361 || !TREE_STATIC (ctor))
1364 /* Get the byte offset. */
1365 idx = TREE_OPERAND (t, 1);
1367 /* Fold read from constant string. */
1368 if (TREE_CODE (ctor) == STRING_CST)
1370 if ((TYPE_MODE (TREE_TYPE (t))
1371 == TYPE_MODE (TREE_TYPE (TREE_TYPE (ctor))))
1372 && (GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_TYPE (ctor))))
1374 && GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (TREE_TYPE (ctor)))) == 1
1375 && compare_tree_int (idx, TREE_STRING_LENGTH (ctor)) < 0)
1376 return build_int_cst_type (TREE_TYPE (t),
1377 (TREE_STRING_POINTER (ctor)
1378 [TREE_INT_CST_LOW (idx)]));
1382 /* ??? Implement byte-offset indexing into a non-array CONSTRUCTOR. */
1383 if (TREE_CODE (TREE_TYPE (ctor)) == ARRAY_TYPE
1384 && (TYPE_MODE (TREE_TYPE (t))
1385 == TYPE_MODE (TREE_TYPE (TREE_TYPE (ctor))))
1386 && GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (t))) != 0
1389 (TRUNC_MOD_EXPR, idx,
1390 size_int (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (t)))), 0)))
1392 idx = int_const_binop (TRUNC_DIV_EXPR, idx,
1393 size_int (GET_MODE_SIZE
1394 (TYPE_MODE (TREE_TYPE (t)))), 0);
1395 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (ctor), cnt, cfield, cval)
1396 if (tree_int_cst_equal (cfield, idx))
1399 if (TREE_CODE (cval) == ADDR_EXPR)
1401 tree base = get_base_address (TREE_OPERAND (cval, 0));
1402 if (base && TREE_CODE (base) == VAR_DECL)
1403 add_referenced_var (base);
1405 if (useless_type_conversion_p (TREE_TYPE (t), TREE_TYPE (cval)))
1407 else if (CONSTANT_CLASS_P (cval))
1408 return fold_build1 (VIEW_CONVERT_EXPR, TREE_TYPE (t), cval);
1422 /* Evaluate statement STMT.
1423 Valid only for assignments, calls, conditionals, and switches. */
1426 evaluate_stmt (gimple stmt)
1429 tree simplified = NULL_TREE;
1430 ccp_lattice_t likelyvalue = likely_value (stmt);
1433 fold_defer_overflow_warnings ();
1435 /* If the statement is likely to have a CONSTANT result, then try
1436 to fold the statement to determine the constant value. */
1437 /* FIXME. This is the only place that we call ccp_fold.
1438 Since likely_value never returns CONSTANT for calls, we will
1439 not attempt to fold them, including builtins that may profit. */
1440 if (likelyvalue == CONSTANT)
1441 simplified = ccp_fold (stmt);
1442 /* If the statement is likely to have a VARYING result, then do not
1443 bother folding the statement. */
1444 else if (likelyvalue == VARYING)
1446 enum gimple_code code = gimple_code (stmt);
1447 if (code == GIMPLE_ASSIGN)
1449 enum tree_code subcode = gimple_assign_rhs_code (stmt);
1451 /* Other cases cannot satisfy is_gimple_min_invariant
1453 if (get_gimple_rhs_class (subcode) == GIMPLE_SINGLE_RHS)
1454 simplified = gimple_assign_rhs1 (stmt);
1456 else if (code == GIMPLE_SWITCH)
1457 simplified = gimple_switch_index (stmt);
1459 /* These cannot satisfy is_gimple_min_invariant without folding. */
1460 gcc_assert (code == GIMPLE_CALL || code == GIMPLE_COND);
1463 is_constant = simplified && is_gimple_min_invariant (simplified);
1465 fold_undefer_overflow_warnings (is_constant, stmt, 0);
1467 if (dump_file && (dump_flags & TDF_DETAILS))
1469 fprintf (dump_file, "which is likely ");
1470 switch (likelyvalue)
1473 fprintf (dump_file, "CONSTANT");
1476 fprintf (dump_file, "UNDEFINED");
1479 fprintf (dump_file, "VARYING");
1483 fprintf (dump_file, "\n");
1488 /* The statement produced a constant value. */
1489 val.lattice_val = CONSTANT;
1490 val.value = simplified;
1494 /* The statement produced a nonconstant value. If the statement
1495 had UNDEFINED operands, then the result of the statement
1496 should be UNDEFINED. Otherwise, the statement is VARYING. */
1497 if (likelyvalue == UNDEFINED)
1498 val.lattice_val = likelyvalue;
1500 val.lattice_val = VARYING;
1502 val.value = NULL_TREE;
1508 /* Fold the stmt at *GSI with CCP specific information that propagating
1509 and regular folding does not catch. */
1512 ccp_fold_stmt (gimple_stmt_iterator *gsi)
1514 gimple stmt = gsi_stmt (*gsi);
1516 switch (gimple_code (stmt))
1521 /* Statement evaluation will handle type mismatches in constants
1522 more gracefully than the final propagation. This allows us to
1523 fold more conditionals here. */
1524 val = evaluate_stmt (stmt);
1525 if (val.lattice_val != CONSTANT
1526 || TREE_CODE (val.value) != INTEGER_CST)
1529 if (integer_zerop (val.value))
1530 gimple_cond_make_false (stmt);
1532 gimple_cond_make_true (stmt);
1539 tree lhs = gimple_call_lhs (stmt);
1542 bool changed = false;
1545 /* If the call was folded into a constant make sure it goes
1546 away even if we cannot propagate into all uses because of
1549 && TREE_CODE (lhs) == SSA_NAME
1550 && (val = get_value (lhs))
1551 && val->lattice_val == CONSTANT)
1553 tree new_rhs = unshare_expr (val->value);
1555 if (!useless_type_conversion_p (TREE_TYPE (lhs),
1556 TREE_TYPE (new_rhs)))
1557 new_rhs = fold_convert (TREE_TYPE (lhs), new_rhs);
1558 res = update_call_from_tree (gsi, new_rhs);
1563 /* Propagate into the call arguments. Compared to replace_uses_in
1564 this can use the argument slot types for type verification
1565 instead of the current argument type. We also can safely
1566 drop qualifiers here as we are dealing with constants anyway. */
1567 argt = TYPE_ARG_TYPES (TREE_TYPE (TREE_TYPE (gimple_call_fn (stmt))));
1568 for (i = 0; i < gimple_call_num_args (stmt) && argt;
1569 ++i, argt = TREE_CHAIN (argt))
1571 tree arg = gimple_call_arg (stmt, i);
1572 if (TREE_CODE (arg) == SSA_NAME
1573 && (val = get_value (arg))
1574 && val->lattice_val == CONSTANT
1575 && useless_type_conversion_p
1576 (TYPE_MAIN_VARIANT (TREE_VALUE (argt)),
1577 TYPE_MAIN_VARIANT (TREE_TYPE (val->value))))
1579 gimple_call_set_arg (stmt, i, unshare_expr (val->value));
1589 tree lhs = gimple_assign_lhs (stmt);
1592 /* If we have a load that turned out to be constant replace it
1593 as we cannot propagate into all uses in all cases. */
1594 if (gimple_assign_single_p (stmt)
1595 && TREE_CODE (lhs) == SSA_NAME
1596 && (val = get_value (lhs))
1597 && val->lattice_val == CONSTANT)
1599 tree rhs = unshare_expr (val->value);
1600 if (!useless_type_conversion_p (TREE_TYPE (lhs), TREE_TYPE (rhs)))
1601 rhs = fold_build1 (VIEW_CONVERT_EXPR, TREE_TYPE (lhs), rhs);
1602 gimple_assign_set_rhs_from_tree (gsi, rhs);
1614 /* Visit the assignment statement STMT. Set the value of its LHS to the
1615 value computed by the RHS and store LHS in *OUTPUT_P. If STMT
1616 creates virtual definitions, set the value of each new name to that
1617 of the RHS (if we can derive a constant out of the RHS).
1618 Value-returning call statements also perform an assignment, and
1619 are handled here. */
1621 static enum ssa_prop_result
1622 visit_assignment (gimple stmt, tree *output_p)
1625 enum ssa_prop_result retval;
1627 tree lhs = gimple_get_lhs (stmt);
1629 gcc_assert (gimple_code (stmt) != GIMPLE_CALL
1630 || gimple_call_lhs (stmt) != NULL_TREE);
1632 if (gimple_assign_copy_p (stmt))
1634 tree rhs = gimple_assign_rhs1 (stmt);
1636 if (TREE_CODE (rhs) == SSA_NAME)
1638 /* For a simple copy operation, we copy the lattice values. */
1639 prop_value_t *nval = get_value (rhs);
1643 val = evaluate_stmt (stmt);
1646 /* Evaluate the statement, which could be
1647 either a GIMPLE_ASSIGN or a GIMPLE_CALL. */
1648 val = evaluate_stmt (stmt);
1650 retval = SSA_PROP_NOT_INTERESTING;
1652 /* Set the lattice value of the statement's output. */
1653 if (TREE_CODE (lhs) == SSA_NAME)
1655 /* If STMT is an assignment to an SSA_NAME, we only have one
1657 if (set_lattice_value (lhs, val))
1660 if (val.lattice_val == VARYING)
1661 retval = SSA_PROP_VARYING;
1663 retval = SSA_PROP_INTERESTING;
1671 /* Visit the conditional statement STMT. Return SSA_PROP_INTERESTING
1672 if it can determine which edge will be taken. Otherwise, return
1673 SSA_PROP_VARYING. */
1675 static enum ssa_prop_result
1676 visit_cond_stmt (gimple stmt, edge *taken_edge_p)
1681 block = gimple_bb (stmt);
1682 val = evaluate_stmt (stmt);
1684 /* Find which edge out of the conditional block will be taken and add it
1685 to the worklist. If no single edge can be determined statically,
1686 return SSA_PROP_VARYING to feed all the outgoing edges to the
1687 propagation engine. */
1688 *taken_edge_p = val.value ? find_taken_edge (block, val.value) : 0;
1690 return SSA_PROP_INTERESTING;
1692 return SSA_PROP_VARYING;
1696 /* Evaluate statement STMT. If the statement produces an output value and
1697 its evaluation changes the lattice value of its output, return
1698 SSA_PROP_INTERESTING and set *OUTPUT_P to the SSA_NAME holding the
1701 If STMT is a conditional branch and we can determine its truth
1702 value, set *TAKEN_EDGE_P accordingly. If STMT produces a varying
1703 value, return SSA_PROP_VARYING. */
1705 static enum ssa_prop_result
1706 ccp_visit_stmt (gimple stmt, edge *taken_edge_p, tree *output_p)
1711 if (dump_file && (dump_flags & TDF_DETAILS))
1713 fprintf (dump_file, "\nVisiting statement:\n");
1714 print_gimple_stmt (dump_file, stmt, 0, dump_flags);
1717 switch (gimple_code (stmt))
1720 /* If the statement is an assignment that produces a single
1721 output value, evaluate its RHS to see if the lattice value of
1722 its output has changed. */
1723 return visit_assignment (stmt, output_p);
1726 /* A value-returning call also performs an assignment. */
1727 if (gimple_call_lhs (stmt) != NULL_TREE)
1728 return visit_assignment (stmt, output_p);
1733 /* If STMT is a conditional branch, see if we can determine
1734 which branch will be taken. */
1735 /* FIXME. It appears that we should be able to optimize
1736 computed GOTOs here as well. */
1737 return visit_cond_stmt (stmt, taken_edge_p);
1743 /* Any other kind of statement is not interesting for constant
1744 propagation and, therefore, not worth simulating. */
1745 if (dump_file && (dump_flags & TDF_DETAILS))
1746 fprintf (dump_file, "No interesting values produced. Marked VARYING.\n");
1748 /* Definitions made by statements other than assignments to
1749 SSA_NAMEs represent unknown modifications to their outputs.
1750 Mark them VARYING. */
1751 FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_ALL_DEFS)
1753 prop_value_t v = { VARYING, NULL_TREE };
1754 set_lattice_value (def, v);
1757 return SSA_PROP_VARYING;
1761 /* Main entry point for SSA Conditional Constant Propagation. */
1767 ssa_propagate (ccp_visit_stmt, ccp_visit_phi_node);
1768 if (ccp_finalize ())
1769 return (TODO_cleanup_cfg | TODO_update_ssa | TODO_remove_unused_locals);
1778 return flag_tree_ccp != 0;
1782 struct gimple_opt_pass pass_ccp =
1787 gate_ccp, /* gate */
1788 do_ssa_ccp, /* execute */
1791 0, /* static_pass_number */
1792 TV_TREE_CCP, /* tv_id */
1793 PROP_cfg | PROP_ssa, /* properties_required */
1794 0, /* properties_provided */
1795 0, /* properties_destroyed */
1796 0, /* todo_flags_start */
1797 TODO_dump_func | TODO_verify_ssa
1798 | TODO_verify_stmts | TODO_ggc_collect/* todo_flags_finish */
1804 /* Try to optimize out __builtin_stack_restore. Optimize it out
1805 if there is another __builtin_stack_restore in the same basic
1806 block and no calls or ASM_EXPRs are in between, or if this block's
1807 only outgoing edge is to EXIT_BLOCK and there are no calls or
1808 ASM_EXPRs after this __builtin_stack_restore. */
1811 optimize_stack_restore (gimple_stmt_iterator i)
1816 basic_block bb = gsi_bb (i);
1817 gimple call = gsi_stmt (i);
1819 if (gimple_code (call) != GIMPLE_CALL
1820 || gimple_call_num_args (call) != 1
1821 || TREE_CODE (gimple_call_arg (call, 0)) != SSA_NAME
1822 || !POINTER_TYPE_P (TREE_TYPE (gimple_call_arg (call, 0))))
1825 for (gsi_next (&i); !gsi_end_p (i); gsi_next (&i))
1827 stmt = gsi_stmt (i);
1828 if (gimple_code (stmt) == GIMPLE_ASM)
1830 if (gimple_code (stmt) != GIMPLE_CALL)
1833 callee = gimple_call_fndecl (stmt);
1835 || DECL_BUILT_IN_CLASS (callee) != BUILT_IN_NORMAL
1836 /* All regular builtins are ok, just obviously not alloca. */
1837 || DECL_FUNCTION_CODE (callee) == BUILT_IN_ALLOCA)
1840 if (DECL_FUNCTION_CODE (callee) == BUILT_IN_STACK_RESTORE)
1841 goto second_stack_restore;
1847 /* Allow one successor of the exit block, or zero successors. */
1848 switch (EDGE_COUNT (bb->succs))
1853 if (single_succ_edge (bb)->dest != EXIT_BLOCK_PTR)
1859 second_stack_restore:
1861 /* If there's exactly one use, then zap the call to __builtin_stack_save.
1862 If there are multiple uses, then the last one should remove the call.
1863 In any case, whether the call to __builtin_stack_save can be removed
1864 or not is irrelevant to removing the call to __builtin_stack_restore. */
1865 if (has_single_use (gimple_call_arg (call, 0)))
1867 gimple stack_save = SSA_NAME_DEF_STMT (gimple_call_arg (call, 0));
1868 if (is_gimple_call (stack_save))
1870 callee = gimple_call_fndecl (stack_save);
1872 && DECL_BUILT_IN_CLASS (callee) == BUILT_IN_NORMAL
1873 && DECL_FUNCTION_CODE (callee) == BUILT_IN_STACK_SAVE)
1875 gimple_stmt_iterator stack_save_gsi;
1878 stack_save_gsi = gsi_for_stmt (stack_save);
1879 rhs = build_int_cst (TREE_TYPE (gimple_call_arg (call, 0)), 0);
1880 update_call_from_tree (&stack_save_gsi, rhs);
1885 /* No effect, so the statement will be deleted. */
1886 return integer_zero_node;
1889 /* If va_list type is a simple pointer and nothing special is needed,
1890 optimize __builtin_va_start (&ap, 0) into ap = __builtin_next_arg (0),
1891 __builtin_va_end (&ap) out as NOP and __builtin_va_copy into a simple
1892 pointer assignment. */
1895 optimize_stdarg_builtin (gimple call)
1897 tree callee, lhs, rhs, cfun_va_list;
1898 bool va_list_simple_ptr;
1899 location_t loc = gimple_location (call);
1901 if (gimple_code (call) != GIMPLE_CALL)
1904 callee = gimple_call_fndecl (call);
1906 cfun_va_list = targetm.fn_abi_va_list (callee);
1907 va_list_simple_ptr = POINTER_TYPE_P (cfun_va_list)
1908 && (TREE_TYPE (cfun_va_list) == void_type_node
1909 || TREE_TYPE (cfun_va_list) == char_type_node);
1911 switch (DECL_FUNCTION_CODE (callee))
1913 case BUILT_IN_VA_START:
1914 if (!va_list_simple_ptr
1915 || targetm.expand_builtin_va_start != NULL
1916 || built_in_decls[BUILT_IN_NEXT_ARG] == NULL)
1919 if (gimple_call_num_args (call) != 2)
1922 lhs = gimple_call_arg (call, 0);
1923 if (!POINTER_TYPE_P (TREE_TYPE (lhs))
1924 || TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (lhs)))
1925 != TYPE_MAIN_VARIANT (cfun_va_list))
1928 lhs = build_fold_indirect_ref_loc (loc, lhs);
1929 rhs = build_call_expr_loc (loc, built_in_decls[BUILT_IN_NEXT_ARG],
1930 1, integer_zero_node);
1931 rhs = fold_convert_loc (loc, TREE_TYPE (lhs), rhs);
1932 return build2 (MODIFY_EXPR, TREE_TYPE (lhs), lhs, rhs);
1934 case BUILT_IN_VA_COPY:
1935 if (!va_list_simple_ptr)
1938 if (gimple_call_num_args (call) != 2)
1941 lhs = gimple_call_arg (call, 0);
1942 if (!POINTER_TYPE_P (TREE_TYPE (lhs))
1943 || TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (lhs)))
1944 != TYPE_MAIN_VARIANT (cfun_va_list))
1947 lhs = build_fold_indirect_ref_loc (loc, lhs);
1948 rhs = gimple_call_arg (call, 1);
1949 if (TYPE_MAIN_VARIANT (TREE_TYPE (rhs))
1950 != TYPE_MAIN_VARIANT (cfun_va_list))
1953 rhs = fold_convert_loc (loc, TREE_TYPE (lhs), rhs);
1954 return build2 (MODIFY_EXPR, TREE_TYPE (lhs), lhs, rhs);
1956 case BUILT_IN_VA_END:
1957 /* No effect, so the statement will be deleted. */
1958 return integer_zero_node;
1965 /* A simple pass that attempts to fold all builtin functions. This pass
1966 is run after we've propagated as many constants as we can. */
1969 execute_fold_all_builtins (void)
1971 bool cfg_changed = false;
1973 unsigned int todoflags = 0;
1977 gimple_stmt_iterator i;
1978 for (i = gsi_start_bb (bb); !gsi_end_p (i); )
1980 gimple stmt, old_stmt;
1981 tree callee, result;
1982 enum built_in_function fcode;
1984 stmt = gsi_stmt (i);
1986 if (gimple_code (stmt) != GIMPLE_CALL)
1991 callee = gimple_call_fndecl (stmt);
1992 if (!callee || DECL_BUILT_IN_CLASS (callee) != BUILT_IN_NORMAL)
1997 fcode = DECL_FUNCTION_CODE (callee);
1999 result = gimple_fold_builtin (stmt);
2002 gimple_remove_stmt_histograms (cfun, stmt);
2005 switch (DECL_FUNCTION_CODE (callee))
2007 case BUILT_IN_CONSTANT_P:
2008 /* Resolve __builtin_constant_p. If it hasn't been
2009 folded to integer_one_node by now, it's fairly
2010 certain that the value simply isn't constant. */
2011 result = integer_zero_node;
2014 case BUILT_IN_STACK_RESTORE:
2015 result = optimize_stack_restore (i);
2021 case BUILT_IN_VA_START:
2022 case BUILT_IN_VA_END:
2023 case BUILT_IN_VA_COPY:
2024 /* These shouldn't be folded before pass_stdarg. */
2025 result = optimize_stdarg_builtin (stmt);
2035 if (dump_file && (dump_flags & TDF_DETAILS))
2037 fprintf (dump_file, "Simplified\n ");
2038 print_gimple_stmt (dump_file, stmt, 0, dump_flags);
2042 if (!update_call_from_tree (&i, result))
2044 gimplify_and_update_call_from_tree (&i, result);
2045 todoflags |= TODO_update_address_taken;
2048 stmt = gsi_stmt (i);
2051 if (maybe_clean_or_replace_eh_stmt (old_stmt, stmt)
2052 && gimple_purge_dead_eh_edges (bb))
2055 if (dump_file && (dump_flags & TDF_DETAILS))
2057 fprintf (dump_file, "to\n ");
2058 print_gimple_stmt (dump_file, stmt, 0, dump_flags);
2059 fprintf (dump_file, "\n");
2062 /* Retry the same statement if it changed into another
2063 builtin, there might be new opportunities now. */
2064 if (gimple_code (stmt) != GIMPLE_CALL)
2069 callee = gimple_call_fndecl (stmt);
2071 || DECL_BUILT_IN_CLASS (callee) != BUILT_IN_NORMAL
2072 || DECL_FUNCTION_CODE (callee) == fcode)
2077 /* Delete unreachable blocks. */
2079 todoflags |= TODO_cleanup_cfg;
2085 struct gimple_opt_pass pass_fold_builtins =
2091 execute_fold_all_builtins, /* execute */
2094 0, /* static_pass_number */
2095 TV_NONE, /* tv_id */
2096 PROP_cfg | PROP_ssa, /* properties_required */
2097 0, /* properties_provided */
2098 0, /* properties_destroyed */
2099 0, /* todo_flags_start */
2102 | TODO_update_ssa /* todo_flags_finish */