1 /* Conditional constant propagation pass for the GNU compiler.
2 Copyright (C) 2000-2016 Free Software Foundation, Inc.
3 Adapted from original RTL SSA-CCP by Daniel Berlin <dberlin@dberlin.org>
4 Adapted to GIMPLE trees by Diego Novillo <dnovillo@redhat.com>
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it
9 under the terms of the GNU General Public License as published by the
10 Free Software Foundation; either version 3, or (at your option) any
13 GCC is distributed in the hope that it will be useful, but WITHOUT
14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
22 /* Conditional constant propagation (CCP) is based on the SSA
23 propagation engine (tree-ssa-propagate.c). Constant assignments of
24 the form VAR = CST are propagated from the assignments into uses of
25 VAR, which in turn may generate new constants. The simulation uses
26 a four level lattice to keep track of constant values associated
27 with SSA names. Given an SSA name V_i, it may take one of the
30 UNINITIALIZED -> the initial state of the value. This value
31 is replaced with a correct initial value
32 the first time the value is used, so the
33 rest of the pass does not need to care about
34 it. Using this value simplifies initialization
35 of the pass, and prevents us from needlessly
36 scanning statements that are never reached.
38 UNDEFINED -> V_i is a local variable whose definition
39 has not been processed yet. Therefore we
40 don't yet know if its value is a constant
43 CONSTANT -> V_i has been found to hold a constant
46 VARYING -> V_i cannot take a constant value, or if it
47 does, it is not possible to determine it
50 The core of SSA-CCP is in ccp_visit_stmt and ccp_visit_phi_node:
52 1- In ccp_visit_stmt, we are interested in assignments whose RHS
53 evaluates into a constant and conditional jumps whose predicate
54 evaluates into a boolean true or false. When an assignment of
55 the form V_i = CONST is found, V_i's lattice value is set to
56 CONSTANT and CONST is associated with it. This causes the
57 propagation engine to add all the SSA edges coming out the
58 assignment into the worklists, so that statements that use V_i
61 If the statement is a conditional with a constant predicate, we
62 mark the outgoing edges as executable or not executable
63 depending on the predicate's value. This is then used when
64 visiting PHI nodes to know when a PHI argument can be ignored.
67 2- In ccp_visit_phi_node, if all the PHI arguments evaluate to the
68 same constant C, then the LHS of the PHI is set to C. This
69 evaluation is known as the "meet operation". Since one of the
70 goals of this evaluation is to optimistically return constant
71 values as often as possible, it uses two main short cuts:
73 - If an argument is flowing in through a non-executable edge, it
74 is ignored. This is useful in cases like this:
80 a_11 = PHI (a_9, a_10)
82 If PRED is known to always evaluate to false, then we can
83 assume that a_11 will always take its value from a_10, meaning
84 that instead of consider it VARYING (a_9 and a_10 have
85 different values), we can consider it CONSTANT 100.
87 - If an argument has an UNDEFINED value, then it does not affect
88 the outcome of the meet operation. If a variable V_i has an
89 UNDEFINED value, it means that either its defining statement
90 hasn't been visited yet or V_i has no defining statement, in
91 which case the original symbol 'V' is being used
92 uninitialized. Since 'V' is a local variable, the compiler
93 may assume any initial value for it.
96 After propagation, every variable V_i that ends up with a lattice
97 value of CONSTANT will have the associated constant value in the
98 array CONST_VAL[i].VALUE. That is fed into substitute_and_fold for
99 final substitution and folding.
101 This algorithm uses wide-ints at the max precision of the target.
102 This means that, with one uninteresting exception, variables with
103 UNSIGNED types never go to VARYING because the bits above the
104 precision of the type of the variable are always zero. The
105 uninteresting case is a variable of UNSIGNED type that has the
106 maximum precision of the target. Such variables can go to VARYING,
107 but this causes no loss of infomation since these variables will
112 Constant propagation with conditional branches,
113 Wegman and Zadeck, ACM TOPLAS 13(2):181-210.
115 Building an Optimizing Compiler,
116 Robert Morgan, Butterworth-Heinemann, 1998, Section 8.9.
118 Advanced Compiler Design and Implementation,
119 Steven Muchnick, Morgan Kaufmann, 1997, Section 12.6 */
123 #include "coretypes.h"
128 #include "tree-pass.h"
130 #include "gimple-pretty-print.h"
131 #include "fold-const.h"
132 #include "gimple-fold.h"
134 #include "gimplify.h"
135 #include "gimple-iterator.h"
136 #include "tree-cfg.h"
137 #include "tree-ssa-propagate.h"
140 #include "builtins.h"
141 #include "tree-chkp.h"
143 #include "stor-layout.h"
144 #include "optabs-query.h"
145 #include "tree-ssa-ccp.h"
146 #include "tree-dfa.h"
148 /* Possible lattice values. */
157 struct ccp_prop_value_t
{
159 ccp_lattice_t lattice_val
;
161 /* Propagated value. */
164 /* Mask that applies to the propagated value during CCP. For X
165 with a CONSTANT lattice value X & ~mask == value & ~mask. The
166 zero bits in the mask cover constant values. The ones mean no
171 /* Array of propagated constant values. After propagation,
172 CONST_VAL[I].VALUE holds the constant value for SSA_NAME(I). If
173 the constant is held in an SSA name representing a memory store
174 (i.e., a VDEF), CONST_VAL[I].MEM_REF will contain the actual
175 memory reference used to store (i.e., the LHS of the assignment
177 static ccp_prop_value_t
*const_val
;
178 static unsigned n_const_val
;
180 static void canonicalize_value (ccp_prop_value_t
*);
181 static bool ccp_fold_stmt (gimple_stmt_iterator
*);
182 static void ccp_lattice_meet (ccp_prop_value_t
*, ccp_prop_value_t
*);
184 /* Dump constant propagation value VAL to file OUTF prefixed by PREFIX. */
187 dump_lattice_value (FILE *outf
, const char *prefix
, ccp_prop_value_t val
)
189 switch (val
.lattice_val
)
192 fprintf (outf
, "%sUNINITIALIZED", prefix
);
195 fprintf (outf
, "%sUNDEFINED", prefix
);
198 fprintf (outf
, "%sVARYING", prefix
);
201 if (TREE_CODE (val
.value
) != INTEGER_CST
204 fprintf (outf
, "%sCONSTANT ", prefix
);
205 print_generic_expr (outf
, val
.value
, dump_flags
);
209 widest_int cval
= wi::bit_and_not (wi::to_widest (val
.value
),
211 fprintf (outf
, "%sCONSTANT ", prefix
);
212 print_hex (cval
, outf
);
213 fprintf (outf
, " (");
214 print_hex (val
.mask
, outf
);
224 /* Print lattice value VAL to stderr. */
226 void debug_lattice_value (ccp_prop_value_t val
);
229 debug_lattice_value (ccp_prop_value_t val
)
231 dump_lattice_value (stderr
, "", val
);
232 fprintf (stderr
, "\n");
235 /* Extend NONZERO_BITS to a full mask, based on sgn. */
238 extend_mask (const wide_int
&nonzero_bits
, signop sgn
)
240 return widest_int::from (nonzero_bits
, sgn
);
243 /* Compute a default value for variable VAR and store it in the
244 CONST_VAL array. The following rules are used to get default
247 1- Global and static variables that are declared constant are
250 2- Any other value is considered UNDEFINED. This is useful when
251 considering PHI nodes. PHI arguments that are undefined do not
252 change the constant value of the PHI node, which allows for more
253 constants to be propagated.
255 3- Variables defined by statements other than assignments and PHI
256 nodes are considered VARYING.
258 4- Initial values of variables that are not GIMPLE registers are
259 considered VARYING. */
261 static ccp_prop_value_t
262 get_default_value (tree var
)
264 ccp_prop_value_t val
= { UNINITIALIZED
, NULL_TREE
, 0 };
267 stmt
= SSA_NAME_DEF_STMT (var
);
269 if (gimple_nop_p (stmt
))
271 /* Variables defined by an empty statement are those used
272 before being initialized. If VAR is a local variable, we
273 can assume initially that it is UNDEFINED, otherwise we must
274 consider it VARYING. */
275 if (!virtual_operand_p (var
)
276 && SSA_NAME_VAR (var
)
277 && TREE_CODE (SSA_NAME_VAR (var
)) == VAR_DECL
)
278 val
.lattice_val
= UNDEFINED
;
281 val
.lattice_val
= VARYING
;
283 if (flag_tree_bit_ccp
)
285 wide_int nonzero_bits
= get_nonzero_bits (var
);
286 if (nonzero_bits
!= -1)
288 val
.lattice_val
= CONSTANT
;
289 val
.value
= build_zero_cst (TREE_TYPE (var
));
290 val
.mask
= extend_mask (nonzero_bits
, TYPE_SIGN (TREE_TYPE (var
)));
295 else if (is_gimple_assign (stmt
))
298 if (gimple_assign_single_p (stmt
)
299 && DECL_P (gimple_assign_rhs1 (stmt
))
300 && (cst
= get_symbol_constant_value (gimple_assign_rhs1 (stmt
))))
302 val
.lattice_val
= CONSTANT
;
307 /* Any other variable defined by an assignment is considered
309 val
.lattice_val
= UNDEFINED
;
312 else if ((is_gimple_call (stmt
)
313 && gimple_call_lhs (stmt
) != NULL_TREE
)
314 || gimple_code (stmt
) == GIMPLE_PHI
)
316 /* A variable defined by a call or a PHI node is considered
318 val
.lattice_val
= UNDEFINED
;
322 /* Otherwise, VAR will never take on a constant value. */
323 val
.lattice_val
= VARYING
;
331 /* Get the constant value associated with variable VAR. */
333 static inline ccp_prop_value_t
*
336 ccp_prop_value_t
*val
;
338 if (const_val
== NULL
339 || SSA_NAME_VERSION (var
) >= n_const_val
)
342 val
= &const_val
[SSA_NAME_VERSION (var
)];
343 if (val
->lattice_val
== UNINITIALIZED
)
344 *val
= get_default_value (var
);
346 canonicalize_value (val
);
351 /* Return the constant tree value associated with VAR. */
354 get_constant_value (tree var
)
356 ccp_prop_value_t
*val
;
357 if (TREE_CODE (var
) != SSA_NAME
)
359 if (is_gimple_min_invariant (var
))
363 val
= get_value (var
);
365 && val
->lattice_val
== CONSTANT
366 && (TREE_CODE (val
->value
) != INTEGER_CST
372 /* Sets the value associated with VAR to VARYING. */
375 set_value_varying (tree var
)
377 ccp_prop_value_t
*val
= &const_val
[SSA_NAME_VERSION (var
)];
379 val
->lattice_val
= VARYING
;
380 val
->value
= NULL_TREE
;
384 /* For integer constants, make sure to drop TREE_OVERFLOW. */
387 canonicalize_value (ccp_prop_value_t
*val
)
389 if (val
->lattice_val
!= CONSTANT
)
392 if (TREE_OVERFLOW_P (val
->value
))
393 val
->value
= drop_tree_overflow (val
->value
);
396 /* Return whether the lattice transition is valid. */
399 valid_lattice_transition (ccp_prop_value_t old_val
, ccp_prop_value_t new_val
)
401 /* Lattice transitions must always be monotonically increasing in
403 if (old_val
.lattice_val
< new_val
.lattice_val
)
406 if (old_val
.lattice_val
!= new_val
.lattice_val
)
409 if (!old_val
.value
&& !new_val
.value
)
412 /* Now both lattice values are CONSTANT. */
414 /* Allow arbitrary copy changes as we might look through PHI <a_1, ...>
415 when only a single copy edge is executable. */
416 if (TREE_CODE (old_val
.value
) == SSA_NAME
417 && TREE_CODE (new_val
.value
) == SSA_NAME
)
420 /* Allow transitioning from a constant to a copy. */
421 if (is_gimple_min_invariant (old_val
.value
)
422 && TREE_CODE (new_val
.value
) == SSA_NAME
)
425 /* Allow transitioning from PHI <&x, not executable> == &x
426 to PHI <&x, &y> == common alignment. */
427 if (TREE_CODE (old_val
.value
) != INTEGER_CST
428 && TREE_CODE (new_val
.value
) == INTEGER_CST
)
431 /* Bit-lattices have to agree in the still valid bits. */
432 if (TREE_CODE (old_val
.value
) == INTEGER_CST
433 && TREE_CODE (new_val
.value
) == INTEGER_CST
)
434 return (wi::bit_and_not (wi::to_widest (old_val
.value
), new_val
.mask
)
435 == wi::bit_and_not (wi::to_widest (new_val
.value
), new_val
.mask
));
437 /* Otherwise constant values have to agree. */
438 if (operand_equal_p (old_val
.value
, new_val
.value
, 0))
441 /* At least the kinds and types should agree now. */
442 if (TREE_CODE (old_val
.value
) != TREE_CODE (new_val
.value
)
443 || !types_compatible_p (TREE_TYPE (old_val
.value
),
444 TREE_TYPE (new_val
.value
)))
447 /* For floats and !HONOR_NANS allow transitions from (partial) NaN
449 tree type
= TREE_TYPE (new_val
.value
);
450 if (SCALAR_FLOAT_TYPE_P (type
)
451 && !HONOR_NANS (type
))
453 if (REAL_VALUE_ISNAN (TREE_REAL_CST (old_val
.value
)))
456 else if (VECTOR_FLOAT_TYPE_P (type
)
457 && !HONOR_NANS (type
))
459 for (unsigned i
= 0; i
< VECTOR_CST_NELTS (old_val
.value
); ++i
)
460 if (!REAL_VALUE_ISNAN
461 (TREE_REAL_CST (VECTOR_CST_ELT (old_val
.value
, i
)))
462 && !operand_equal_p (VECTOR_CST_ELT (old_val
.value
, i
),
463 VECTOR_CST_ELT (new_val
.value
, i
), 0))
467 else if (COMPLEX_FLOAT_TYPE_P (type
)
468 && !HONOR_NANS (type
))
470 if (!REAL_VALUE_ISNAN (TREE_REAL_CST (TREE_REALPART (old_val
.value
)))
471 && !operand_equal_p (TREE_REALPART (old_val
.value
),
472 TREE_REALPART (new_val
.value
), 0))
474 if (!REAL_VALUE_ISNAN (TREE_REAL_CST (TREE_IMAGPART (old_val
.value
)))
475 && !operand_equal_p (TREE_IMAGPART (old_val
.value
),
476 TREE_IMAGPART (new_val
.value
), 0))
483 /* Set the value for variable VAR to NEW_VAL. Return true if the new
484 value is different from VAR's previous value. */
487 set_lattice_value (tree var
, ccp_prop_value_t
*new_val
)
489 /* We can deal with old UNINITIALIZED values just fine here. */
490 ccp_prop_value_t
*old_val
= &const_val
[SSA_NAME_VERSION (var
)];
492 canonicalize_value (new_val
);
494 /* We have to be careful to not go up the bitwise lattice
495 represented by the mask. Instead of dropping to VARYING
496 use the meet operator to retain a conservative value.
497 Missed optimizations like PR65851 makes this necessary.
498 It also ensures we converge to a stable lattice solution. */
499 if (new_val
->lattice_val
== CONSTANT
500 && old_val
->lattice_val
== CONSTANT
501 && TREE_CODE (new_val
->value
) != SSA_NAME
)
502 ccp_lattice_meet (new_val
, old_val
);
504 gcc_checking_assert (valid_lattice_transition (*old_val
, *new_val
));
506 /* If *OLD_VAL and NEW_VAL are the same, return false to inform the
507 caller that this was a non-transition. */
508 if (old_val
->lattice_val
!= new_val
->lattice_val
509 || (new_val
->lattice_val
== CONSTANT
510 && (TREE_CODE (new_val
->value
) != TREE_CODE (old_val
->value
)
511 || (TREE_CODE (new_val
->value
) == INTEGER_CST
512 && (new_val
->mask
!= old_val
->mask
513 || (wi::bit_and_not (wi::to_widest (old_val
->value
),
515 != wi::bit_and_not (wi::to_widest (new_val
->value
),
517 || (TREE_CODE (new_val
->value
) != INTEGER_CST
518 && !operand_equal_p (new_val
->value
, old_val
->value
, 0)))))
520 /* ??? We would like to delay creation of INTEGER_CSTs from
521 partially constants here. */
523 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
525 dump_lattice_value (dump_file
, "Lattice value changed to ", *new_val
);
526 fprintf (dump_file
, ". Adding SSA edges to worklist.\n");
531 gcc_assert (new_val
->lattice_val
!= UNINITIALIZED
);
538 static ccp_prop_value_t
get_value_for_expr (tree
, bool);
539 static ccp_prop_value_t
bit_value_binop (enum tree_code
, tree
, tree
, tree
);
540 void bit_value_binop (enum tree_code
, signop
, int, widest_int
*, widest_int
*,
541 signop
, int, const widest_int
&, const widest_int
&,
542 signop
, int, const widest_int
&, const widest_int
&);
544 /* Return a widest_int that can be used for bitwise simplifications
548 value_to_wide_int (ccp_prop_value_t val
)
551 && TREE_CODE (val
.value
) == INTEGER_CST
)
552 return wi::to_widest (val
.value
);
557 /* Return the value for the address expression EXPR based on alignment
560 static ccp_prop_value_t
561 get_value_from_alignment (tree expr
)
563 tree type
= TREE_TYPE (expr
);
564 ccp_prop_value_t val
;
565 unsigned HOST_WIDE_INT bitpos
;
568 gcc_assert (TREE_CODE (expr
) == ADDR_EXPR
);
570 get_pointer_alignment_1 (expr
, &align
, &bitpos
);
571 val
.mask
= (POINTER_TYPE_P (type
) || TYPE_UNSIGNED (type
)
572 ? wi::mask
<widest_int
> (TYPE_PRECISION (type
), false)
573 : -1).and_not (align
/ BITS_PER_UNIT
- 1);
575 = wi::sext (val
.mask
, TYPE_PRECISION (type
)) == -1 ? VARYING
: CONSTANT
;
576 if (val
.lattice_val
== CONSTANT
)
577 val
.value
= build_int_cstu (type
, bitpos
/ BITS_PER_UNIT
);
579 val
.value
= NULL_TREE
;
584 /* Return the value for the tree operand EXPR. If FOR_BITS_P is true
585 return constant bits extracted from alignment information for
586 invariant addresses. */
588 static ccp_prop_value_t
589 get_value_for_expr (tree expr
, bool for_bits_p
)
591 ccp_prop_value_t val
;
593 if (TREE_CODE (expr
) == SSA_NAME
)
595 ccp_prop_value_t
*val_
= get_value (expr
);
600 val
.lattice_val
= VARYING
;
601 val
.value
= NULL_TREE
;
605 && val
.lattice_val
== CONSTANT
606 && TREE_CODE (val
.value
) == ADDR_EXPR
)
607 val
= get_value_from_alignment (val
.value
);
608 /* Fall back to a copy value. */
610 && val
.lattice_val
== VARYING
611 && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (expr
))
613 val
.lattice_val
= CONSTANT
;
618 else if (is_gimple_min_invariant (expr
)
619 && (!for_bits_p
|| TREE_CODE (expr
) != ADDR_EXPR
))
621 val
.lattice_val
= CONSTANT
;
624 canonicalize_value (&val
);
626 else if (TREE_CODE (expr
) == ADDR_EXPR
)
627 val
= get_value_from_alignment (expr
);
630 val
.lattice_val
= VARYING
;
632 val
.value
= NULL_TREE
;
635 if (val
.lattice_val
== VARYING
636 && TYPE_UNSIGNED (TREE_TYPE (expr
)))
637 val
.mask
= wi::zext (val
.mask
, TYPE_PRECISION (TREE_TYPE (expr
)));
642 /* Return the likely CCP lattice value for STMT.
644 If STMT has no operands, then return CONSTANT.
646 Else if undefinedness of operands of STMT cause its value to be
647 undefined, then return UNDEFINED.
649 Else if any operands of STMT are constants, then return CONSTANT.
651 Else return VARYING. */
654 likely_value (gimple
*stmt
)
656 bool has_constant_operand
, has_undefined_operand
, all_undefined_operands
;
657 bool has_nsa_operand
;
662 enum gimple_code code
= gimple_code (stmt
);
664 /* This function appears to be called only for assignments, calls,
665 conditionals, and switches, due to the logic in visit_stmt. */
666 gcc_assert (code
== GIMPLE_ASSIGN
667 || code
== GIMPLE_CALL
668 || code
== GIMPLE_COND
669 || code
== GIMPLE_SWITCH
);
671 /* If the statement has volatile operands, it won't fold to a
673 if (gimple_has_volatile_ops (stmt
))
676 /* Arrive here for more complex cases. */
677 has_constant_operand
= false;
678 has_undefined_operand
= false;
679 all_undefined_operands
= true;
680 has_nsa_operand
= false;
681 FOR_EACH_SSA_TREE_OPERAND (use
, stmt
, iter
, SSA_OP_USE
)
683 ccp_prop_value_t
*val
= get_value (use
);
685 if (val
&& val
->lattice_val
== UNDEFINED
)
686 has_undefined_operand
= true;
688 all_undefined_operands
= false;
690 if (val
&& val
->lattice_val
== CONSTANT
)
691 has_constant_operand
= true;
693 if (SSA_NAME_IS_DEFAULT_DEF (use
)
694 || !prop_simulate_again_p (SSA_NAME_DEF_STMT (use
)))
695 has_nsa_operand
= true;
698 /* There may be constants in regular rhs operands. For calls we
699 have to ignore lhs, fndecl and static chain, otherwise only
701 for (i
= (is_gimple_call (stmt
) ? 2 : 0) + gimple_has_lhs (stmt
);
702 i
< gimple_num_ops (stmt
); ++i
)
704 tree op
= gimple_op (stmt
, i
);
705 if (!op
|| TREE_CODE (op
) == SSA_NAME
)
707 if (is_gimple_min_invariant (op
))
708 has_constant_operand
= true;
711 if (has_constant_operand
)
712 all_undefined_operands
= false;
714 if (has_undefined_operand
715 && code
== GIMPLE_CALL
716 && gimple_call_internal_p (stmt
))
717 switch (gimple_call_internal_fn (stmt
))
719 /* These 3 builtins use the first argument just as a magic
720 way how to find out a decl uid. */
721 case IFN_GOMP_SIMD_LANE
:
722 case IFN_GOMP_SIMD_VF
:
723 case IFN_GOMP_SIMD_LAST_LANE
:
724 has_undefined_operand
= false;
730 /* If the operation combines operands like COMPLEX_EXPR make sure to
731 not mark the result UNDEFINED if only one part of the result is
733 if (has_undefined_operand
&& all_undefined_operands
)
735 else if (code
== GIMPLE_ASSIGN
&& has_undefined_operand
)
737 switch (gimple_assign_rhs_code (stmt
))
739 /* Unary operators are handled with all_undefined_operands. */
742 case POINTER_PLUS_EXPR
:
743 /* Not MIN_EXPR, MAX_EXPR. One VARYING operand may be selected.
744 Not bitwise operators, one VARYING operand may specify the
745 result completely. Not logical operators for the same reason.
746 Not COMPLEX_EXPR as one VARYING operand makes the result partly
747 not UNDEFINED. Not *DIV_EXPR, comparisons and shifts because
748 the undefined operand may be promoted. */
752 /* If any part of an address is UNDEFINED, like the index
753 of an ARRAY_EXPR, then treat the result as UNDEFINED. */
760 /* If there was an UNDEFINED operand but the result may be not UNDEFINED
761 fall back to CONSTANT. During iteration UNDEFINED may still drop
763 if (has_undefined_operand
)
766 /* We do not consider virtual operands here -- load from read-only
767 memory may have only VARYING virtual operands, but still be
768 constant. Also we can combine the stmt with definitions from
769 operands whose definitions are not simulated again. */
770 if (has_constant_operand
772 || gimple_references_memory_p (stmt
))
778 /* Returns true if STMT cannot be constant. */
781 surely_varying_stmt_p (gimple
*stmt
)
783 /* If the statement has operands that we cannot handle, it cannot be
785 if (gimple_has_volatile_ops (stmt
))
788 /* If it is a call and does not return a value or is not a
789 builtin and not an indirect call or a call to function with
790 assume_aligned/alloc_align attribute, it is varying. */
791 if (is_gimple_call (stmt
))
793 tree fndecl
, fntype
= gimple_call_fntype (stmt
);
794 if (!gimple_call_lhs (stmt
)
795 || ((fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
796 && !DECL_BUILT_IN (fndecl
)
797 && !lookup_attribute ("assume_aligned",
798 TYPE_ATTRIBUTES (fntype
))
799 && !lookup_attribute ("alloc_align",
800 TYPE_ATTRIBUTES (fntype
))))
804 /* Any other store operation is not interesting. */
805 else if (gimple_vdef (stmt
))
808 /* Anything other than assignments and conditional jumps are not
809 interesting for CCP. */
810 if (gimple_code (stmt
) != GIMPLE_ASSIGN
811 && gimple_code (stmt
) != GIMPLE_COND
812 && gimple_code (stmt
) != GIMPLE_SWITCH
813 && gimple_code (stmt
) != GIMPLE_CALL
)
819 /* Initialize local data structures for CCP. */
822 ccp_initialize (void)
826 n_const_val
= num_ssa_names
;
827 const_val
= XCNEWVEC (ccp_prop_value_t
, n_const_val
);
829 /* Initialize simulation flags for PHI nodes and statements. */
830 FOR_EACH_BB_FN (bb
, cfun
)
832 gimple_stmt_iterator i
;
834 for (i
= gsi_start_bb (bb
); !gsi_end_p (i
); gsi_next (&i
))
836 gimple
*stmt
= gsi_stmt (i
);
839 /* If the statement is a control insn, then we do not
840 want to avoid simulating the statement once. Failure
841 to do so means that those edges will never get added. */
842 if (stmt_ends_bb_p (stmt
))
845 is_varying
= surely_varying_stmt_p (stmt
);
852 /* If the statement will not produce a constant, mark
853 all its outputs VARYING. */
854 FOR_EACH_SSA_TREE_OPERAND (def
, stmt
, iter
, SSA_OP_ALL_DEFS
)
855 set_value_varying (def
);
857 prop_set_simulate_again (stmt
, !is_varying
);
861 /* Now process PHI nodes. We never clear the simulate_again flag on
862 phi nodes, since we do not know which edges are executable yet,
863 except for phi nodes for virtual operands when we do not do store ccp. */
864 FOR_EACH_BB_FN (bb
, cfun
)
868 for (i
= gsi_start_phis (bb
); !gsi_end_p (i
); gsi_next (&i
))
870 gphi
*phi
= i
.phi ();
872 if (virtual_operand_p (gimple_phi_result (phi
)))
873 prop_set_simulate_again (phi
, false);
875 prop_set_simulate_again (phi
, true);
880 /* Debug count support. Reset the values of ssa names
881 VARYING when the total number ssa names analyzed is
882 beyond the debug count specified. */
888 for (i
= 0; i
< num_ssa_names
; i
++)
892 const_val
[i
].lattice_val
= VARYING
;
893 const_val
[i
].mask
= -1;
894 const_val
[i
].value
= NULL_TREE
;
900 /* Do final substitution of propagated values, cleanup the flowgraph and
901 free allocated storage. If NONZERO_P, record nonzero bits.
903 Return TRUE when something was optimized. */
906 ccp_finalize (bool nonzero_p
)
908 bool something_changed
;
914 /* Derive alignment and misalignment information from partially
915 constant pointers in the lattice or nonzero bits from partially
916 constant integers. */
917 FOR_EACH_SSA_NAME (i
, name
, cfun
)
919 ccp_prop_value_t
*val
;
920 unsigned int tem
, align
;
922 if (!POINTER_TYPE_P (TREE_TYPE (name
))
923 && (!INTEGRAL_TYPE_P (TREE_TYPE (name
))
924 /* Don't record nonzero bits before IPA to avoid
925 using too much memory. */
929 val
= get_value (name
);
930 if (val
->lattice_val
!= CONSTANT
931 || TREE_CODE (val
->value
) != INTEGER_CST
935 if (POINTER_TYPE_P (TREE_TYPE (name
)))
937 /* Trailing mask bits specify the alignment, trailing value
938 bits the misalignment. */
939 tem
= val
->mask
.to_uhwi ();
940 align
= least_bit_hwi (tem
);
942 set_ptr_info_alignment (get_ptr_info (name
), align
,
943 (TREE_INT_CST_LOW (val
->value
)
948 unsigned int precision
= TYPE_PRECISION (TREE_TYPE (val
->value
));
949 wide_int nonzero_bits
= wide_int::from (val
->mask
, precision
,
950 UNSIGNED
) | val
->value
;
951 nonzero_bits
&= get_nonzero_bits (name
);
952 set_nonzero_bits (name
, nonzero_bits
);
956 /* Perform substitutions based on the known constant values. */
957 something_changed
= substitute_and_fold (get_constant_value
, ccp_fold_stmt
);
961 return something_changed
;;
965 /* Compute the meet operator between *VAL1 and *VAL2. Store the result
968 any M UNDEFINED = any
969 any M VARYING = VARYING
970 Ci M Cj = Ci if (i == j)
971 Ci M Cj = VARYING if (i != j)
975 ccp_lattice_meet (ccp_prop_value_t
*val1
, ccp_prop_value_t
*val2
)
977 if (val1
->lattice_val
== UNDEFINED
978 /* For UNDEFINED M SSA we can't always SSA because its definition
979 may not dominate the PHI node. Doing optimistic copy propagation
980 also causes a lot of gcc.dg/uninit-pred*.c FAILs. */
981 && (val2
->lattice_val
!= CONSTANT
982 || TREE_CODE (val2
->value
) != SSA_NAME
))
984 /* UNDEFINED M any = any */
987 else if (val2
->lattice_val
== UNDEFINED
989 && (val1
->lattice_val
!= CONSTANT
990 || TREE_CODE (val1
->value
) != SSA_NAME
))
992 /* any M UNDEFINED = any
993 Nothing to do. VAL1 already contains the value we want. */
996 else if (val1
->lattice_val
== VARYING
997 || val2
->lattice_val
== VARYING
)
999 /* any M VARYING = VARYING. */
1000 val1
->lattice_val
= VARYING
;
1002 val1
->value
= NULL_TREE
;
1004 else if (val1
->lattice_val
== CONSTANT
1005 && val2
->lattice_val
== CONSTANT
1006 && TREE_CODE (val1
->value
) == INTEGER_CST
1007 && TREE_CODE (val2
->value
) == INTEGER_CST
)
1009 /* Ci M Cj = Ci if (i == j)
1010 Ci M Cj = VARYING if (i != j)
1012 For INTEGER_CSTs mask unequal bits. If no equal bits remain,
1014 val1
->mask
= (val1
->mask
| val2
->mask
1015 | (wi::to_widest (val1
->value
)
1016 ^ wi::to_widest (val2
->value
)));
1017 if (wi::sext (val1
->mask
, TYPE_PRECISION (TREE_TYPE (val1
->value
))) == -1)
1019 val1
->lattice_val
= VARYING
;
1020 val1
->value
= NULL_TREE
;
1023 else if (val1
->lattice_val
== CONSTANT
1024 && val2
->lattice_val
== CONSTANT
1025 && operand_equal_p (val1
->value
, val2
->value
, 0))
1027 /* Ci M Cj = Ci if (i == j)
1028 Ci M Cj = VARYING if (i != j)
1030 VAL1 already contains the value we want for equivalent values. */
1032 else if (val1
->lattice_val
== CONSTANT
1033 && val2
->lattice_val
== CONSTANT
1034 && (TREE_CODE (val1
->value
) == ADDR_EXPR
1035 || TREE_CODE (val2
->value
) == ADDR_EXPR
))
1037 /* When not equal addresses are involved try meeting for
1039 ccp_prop_value_t tem
= *val2
;
1040 if (TREE_CODE (val1
->value
) == ADDR_EXPR
)
1041 *val1
= get_value_for_expr (val1
->value
, true);
1042 if (TREE_CODE (val2
->value
) == ADDR_EXPR
)
1043 tem
= get_value_for_expr (val2
->value
, true);
1044 ccp_lattice_meet (val1
, &tem
);
1048 /* Any other combination is VARYING. */
1049 val1
->lattice_val
= VARYING
;
1051 val1
->value
= NULL_TREE
;
1056 /* Loop through the PHI_NODE's parameters for BLOCK and compare their
1057 lattice values to determine PHI_NODE's lattice value. The value of a
1058 PHI node is determined calling ccp_lattice_meet with all the arguments
1059 of the PHI node that are incoming via executable edges. */
1061 static enum ssa_prop_result
1062 ccp_visit_phi_node (gphi
*phi
)
1065 ccp_prop_value_t new_val
;
1067 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1069 fprintf (dump_file
, "\nVisiting PHI node: ");
1070 print_gimple_stmt (dump_file
, phi
, 0, dump_flags
);
1073 new_val
.lattice_val
= UNDEFINED
;
1074 new_val
.value
= NULL_TREE
;
1078 bool non_exec_edge
= false;
1079 for (i
= 0; i
< gimple_phi_num_args (phi
); i
++)
1081 /* Compute the meet operator over all the PHI arguments flowing
1082 through executable edges. */
1083 edge e
= gimple_phi_arg_edge (phi
, i
);
1085 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1088 "\n Argument #%d (%d -> %d %sexecutable)\n",
1089 i
, e
->src
->index
, e
->dest
->index
,
1090 (e
->flags
& EDGE_EXECUTABLE
) ? "" : "not ");
1093 /* If the incoming edge is executable, Compute the meet operator for
1094 the existing value of the PHI node and the current PHI argument. */
1095 if (e
->flags
& EDGE_EXECUTABLE
)
1097 tree arg
= gimple_phi_arg (phi
, i
)->def
;
1098 ccp_prop_value_t arg_val
= get_value_for_expr (arg
, false);
1106 ccp_lattice_meet (&new_val
, &arg_val
);
1108 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1110 fprintf (dump_file
, "\t");
1111 print_generic_expr (dump_file
, arg
, dump_flags
);
1112 dump_lattice_value (dump_file
, "\tValue: ", arg_val
);
1113 fprintf (dump_file
, "\n");
1116 if (new_val
.lattice_val
== VARYING
)
1120 non_exec_edge
= true;
1123 /* In case there were non-executable edges and the value is a copy
1124 make sure its definition dominates the PHI node. */
1126 && new_val
.lattice_val
== CONSTANT
1127 && TREE_CODE (new_val
.value
) == SSA_NAME
1128 && ! SSA_NAME_IS_DEFAULT_DEF (new_val
.value
)
1129 && ! dominated_by_p (CDI_DOMINATORS
, gimple_bb (phi
),
1130 gimple_bb (SSA_NAME_DEF_STMT (new_val
.value
))))
1132 new_val
.lattice_val
= VARYING
;
1133 new_val
.value
= NULL_TREE
;
1137 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1139 dump_lattice_value (dump_file
, "\n PHI node value: ", new_val
);
1140 fprintf (dump_file
, "\n\n");
1143 /* Make the transition to the new value. */
1144 if (set_lattice_value (gimple_phi_result (phi
), &new_val
))
1146 if (new_val
.lattice_val
== VARYING
)
1147 return SSA_PROP_VARYING
;
1149 return SSA_PROP_INTERESTING
;
1152 return SSA_PROP_NOT_INTERESTING
;
1155 /* Return the constant value for OP or OP otherwise. */
1158 valueize_op (tree op
)
1160 if (TREE_CODE (op
) == SSA_NAME
)
1162 tree tem
= get_constant_value (op
);
1169 /* Return the constant value for OP, but signal to not follow SSA
1170 edges if the definition may be simulated again. */
1173 valueize_op_1 (tree op
)
1175 if (TREE_CODE (op
) == SSA_NAME
)
1177 /* If the definition may be simulated again we cannot follow
1178 this SSA edge as the SSA propagator does not necessarily
1179 re-visit the use. */
1180 gimple
*def_stmt
= SSA_NAME_DEF_STMT (op
);
1181 if (!gimple_nop_p (def_stmt
)
1182 && prop_simulate_again_p (def_stmt
))
1184 tree tem
= get_constant_value (op
);
1191 /* CCP specific front-end to the non-destructive constant folding
1194 Attempt to simplify the RHS of STMT knowing that one or more
1195 operands are constants.
1197 If simplification is possible, return the simplified RHS,
1198 otherwise return the original RHS or NULL_TREE. */
1201 ccp_fold (gimple
*stmt
)
1203 location_t loc
= gimple_location (stmt
);
1204 switch (gimple_code (stmt
))
1208 /* Handle comparison operators that can appear in GIMPLE form. */
1209 tree op0
= valueize_op (gimple_cond_lhs (stmt
));
1210 tree op1
= valueize_op (gimple_cond_rhs (stmt
));
1211 enum tree_code code
= gimple_cond_code (stmt
);
1212 return fold_binary_loc (loc
, code
, boolean_type_node
, op0
, op1
);
1217 /* Return the constant switch index. */
1218 return valueize_op (gimple_switch_index (as_a
<gswitch
*> (stmt
)));
1223 return gimple_fold_stmt_to_constant_1 (stmt
,
1224 valueize_op
, valueize_op_1
);
1231 /* Apply the operation CODE in type TYPE to the value, mask pair
1232 RVAL and RMASK representing a value of type RTYPE and set
1233 the value, mask pair *VAL and *MASK to the result. */
1236 bit_value_unop (enum tree_code code
, signop type_sgn
, int type_precision
,
1237 widest_int
*val
, widest_int
*mask
,
1238 signop rtype_sgn
, int rtype_precision
,
1239 const widest_int
&rval
, const widest_int
&rmask
)
1250 widest_int temv
, temm
;
1251 /* Return ~rval + 1. */
1252 bit_value_unop (BIT_NOT_EXPR
, type_sgn
, type_precision
, &temv
, &temm
,
1253 type_sgn
, type_precision
, rval
, rmask
);
1254 bit_value_binop (PLUS_EXPR
, type_sgn
, type_precision
, val
, mask
,
1255 type_sgn
, type_precision
, temv
, temm
,
1256 type_sgn
, type_precision
, 1, 0);
1262 /* First extend mask and value according to the original type. */
1263 *mask
= wi::ext (rmask
, rtype_precision
, rtype_sgn
);
1264 *val
= wi::ext (rval
, rtype_precision
, rtype_sgn
);
1266 /* Then extend mask and value according to the target type. */
1267 *mask
= wi::ext (*mask
, type_precision
, type_sgn
);
1268 *val
= wi::ext (*val
, type_precision
, type_sgn
);
1278 /* Apply the operation CODE in type TYPE to the value, mask pairs
1279 R1VAL, R1MASK and R2VAL, R2MASK representing a values of type R1TYPE
1280 and R2TYPE and set the value, mask pair *VAL and *MASK to the result. */
1283 bit_value_binop (enum tree_code code
, signop sgn
, int width
,
1284 widest_int
*val
, widest_int
*mask
,
1285 signop r1type_sgn
, int r1type_precision
,
1286 const widest_int
&r1val
, const widest_int
&r1mask
,
1287 signop r2type_sgn
, int r2type_precision
,
1288 const widest_int
&r2val
, const widest_int
&r2mask
)
1290 bool swap_p
= false;
1292 /* Assume we'll get a constant result. Use an initial non varying
1293 value, we fall back to varying in the end if necessary. */
1299 /* The mask is constant where there is a known not
1300 set bit, (m1 | m2) & ((v1 | m1) & (v2 | m2)) */
1301 *mask
= (r1mask
| r2mask
) & (r1val
| r1mask
) & (r2val
| r2mask
);
1302 *val
= r1val
& r2val
;
1306 /* The mask is constant where there is a known
1307 set bit, (m1 | m2) & ~((v1 & ~m1) | (v2 & ~m2)). */
1308 *mask
= (r1mask
| r2mask
)
1309 .and_not (r1val
.and_not (r1mask
) | r2val
.and_not (r2mask
));
1310 *val
= r1val
| r2val
;
1315 *mask
= r1mask
| r2mask
;
1316 *val
= r1val
^ r2val
;
1323 widest_int shift
= r2val
;
1331 if (wi::neg_p (shift
))
1334 if (code
== RROTATE_EXPR
)
1335 code
= LROTATE_EXPR
;
1337 code
= RROTATE_EXPR
;
1339 if (code
== RROTATE_EXPR
)
1341 *mask
= wi::rrotate (r1mask
, shift
, width
);
1342 *val
= wi::rrotate (r1val
, shift
, width
);
1346 *mask
= wi::lrotate (r1mask
, shift
, width
);
1347 *val
= wi::lrotate (r1val
, shift
, width
);
1355 /* ??? We can handle partially known shift counts if we know
1356 its sign. That way we can tell that (x << (y | 8)) & 255
1360 widest_int shift
= r2val
;
1368 if (wi::neg_p (shift
))
1371 if (code
== RSHIFT_EXPR
)
1376 if (code
== RSHIFT_EXPR
)
1378 *mask
= wi::rshift (wi::ext (r1mask
, width
, sgn
), shift
, sgn
);
1379 *val
= wi::rshift (wi::ext (r1val
, width
, sgn
), shift
, sgn
);
1383 *mask
= wi::ext (r1mask
<< shift
, width
, sgn
);
1384 *val
= wi::ext (r1val
<< shift
, width
, sgn
);
1391 case POINTER_PLUS_EXPR
:
1393 /* Do the addition with unknown bits set to zero, to give carry-ins of
1394 zero wherever possible. */
1395 widest_int lo
= r1val
.and_not (r1mask
) + r2val
.and_not (r2mask
);
1396 lo
= wi::ext (lo
, width
, sgn
);
1397 /* Do the addition with unknown bits set to one, to give carry-ins of
1398 one wherever possible. */
1399 widest_int hi
= (r1val
| r1mask
) + (r2val
| r2mask
);
1400 hi
= wi::ext (hi
, width
, sgn
);
1401 /* Each bit in the result is known if (a) the corresponding bits in
1402 both inputs are known, and (b) the carry-in to that bit position
1403 is known. We can check condition (b) by seeing if we got the same
1404 result with minimised carries as with maximised carries. */
1405 *mask
= r1mask
| r2mask
| (lo
^ hi
);
1406 *mask
= wi::ext (*mask
, width
, sgn
);
1407 /* It shouldn't matter whether we choose lo or hi here. */
1414 widest_int temv
, temm
;
1415 bit_value_unop (NEGATE_EXPR
, r2type_sgn
, r2type_precision
, &temv
, &temm
,
1416 r2type_sgn
, r2type_precision
, r2val
, r2mask
);
1417 bit_value_binop (PLUS_EXPR
, sgn
, width
, val
, mask
,
1418 r1type_sgn
, r1type_precision
, r1val
, r1mask
,
1419 r2type_sgn
, r2type_precision
, temv
, temm
);
1425 /* Just track trailing zeros in both operands and transfer
1426 them to the other. */
1427 int r1tz
= wi::ctz (r1val
| r1mask
);
1428 int r2tz
= wi::ctz (r2val
| r2mask
);
1429 if (r1tz
+ r2tz
>= width
)
1434 else if (r1tz
+ r2tz
> 0)
1436 *mask
= wi::ext (wi::mask
<widest_int
> (r1tz
+ r2tz
, true),
1446 widest_int m
= r1mask
| r2mask
;
1447 if (r1val
.and_not (m
) != r2val
.and_not (m
))
1450 *val
= ((code
== EQ_EXPR
) ? 0 : 1);
1454 /* We know the result of a comparison is always one or zero. */
1464 code
= swap_tree_comparison (code
);
1471 const widest_int
&o1val
= swap_p
? r2val
: r1val
;
1472 const widest_int
&o1mask
= swap_p
? r2mask
: r1mask
;
1473 const widest_int
&o2val
= swap_p
? r1val
: r2val
;
1474 const widest_int
&o2mask
= swap_p
? r1mask
: r2mask
;
1476 /* If the most significant bits are not known we know nothing. */
1477 if (wi::neg_p (o1mask
) || wi::neg_p (o2mask
))
1480 /* For comparisons the signedness is in the comparison operands. */
1483 /* If we know the most significant bits we know the values
1484 value ranges by means of treating varying bits as zero
1485 or one. Do a cross comparison of the max/min pairs. */
1486 maxmin
= wi::cmp (o1val
| o1mask
, o2val
.and_not (o2mask
), sgn
);
1487 minmax
= wi::cmp (o1val
.and_not (o1mask
), o2val
| o2mask
, sgn
);
1488 if (maxmin
< 0) /* o1 is less than o2. */
1493 else if (minmax
> 0) /* o1 is not less or equal to o2. */
1498 else if (maxmin
== minmax
) /* o1 and o2 are equal. */
1500 /* This probably should never happen as we'd have
1501 folded the thing during fully constant value folding. */
1503 *val
= (code
== LE_EXPR
? 1 : 0);
1507 /* We know the result of a comparison is always one or zero. */
1518 /* Return the propagation value when applying the operation CODE to
1519 the value RHS yielding type TYPE. */
1521 static ccp_prop_value_t
1522 bit_value_unop (enum tree_code code
, tree type
, tree rhs
)
1524 ccp_prop_value_t rval
= get_value_for_expr (rhs
, true);
1525 widest_int value
, mask
;
1526 ccp_prop_value_t val
;
1528 if (rval
.lattice_val
== UNDEFINED
)
1531 gcc_assert ((rval
.lattice_val
== CONSTANT
1532 && TREE_CODE (rval
.value
) == INTEGER_CST
)
1533 || wi::sext (rval
.mask
, TYPE_PRECISION (TREE_TYPE (rhs
))) == -1);
1534 bit_value_unop (code
, TYPE_SIGN (type
), TYPE_PRECISION (type
), &value
, &mask
,
1535 TYPE_SIGN (TREE_TYPE (rhs
)), TYPE_PRECISION (TREE_TYPE (rhs
)),
1536 value_to_wide_int (rval
), rval
.mask
);
1537 if (wi::sext (mask
, TYPE_PRECISION (type
)) != -1)
1539 val
.lattice_val
= CONSTANT
;
1541 /* ??? Delay building trees here. */
1542 val
.value
= wide_int_to_tree (type
, value
);
1546 val
.lattice_val
= VARYING
;
1547 val
.value
= NULL_TREE
;
1553 /* Return the propagation value when applying the operation CODE to
1554 the values RHS1 and RHS2 yielding type TYPE. */
1556 static ccp_prop_value_t
1557 bit_value_binop (enum tree_code code
, tree type
, tree rhs1
, tree rhs2
)
1559 ccp_prop_value_t r1val
= get_value_for_expr (rhs1
, true);
1560 ccp_prop_value_t r2val
= get_value_for_expr (rhs2
, true);
1561 widest_int value
, mask
;
1562 ccp_prop_value_t val
;
1564 if (r1val
.lattice_val
== UNDEFINED
1565 || r2val
.lattice_val
== UNDEFINED
)
1567 val
.lattice_val
= VARYING
;
1568 val
.value
= NULL_TREE
;
1573 gcc_assert ((r1val
.lattice_val
== CONSTANT
1574 && TREE_CODE (r1val
.value
) == INTEGER_CST
)
1575 || wi::sext (r1val
.mask
,
1576 TYPE_PRECISION (TREE_TYPE (rhs1
))) == -1);
1577 gcc_assert ((r2val
.lattice_val
== CONSTANT
1578 && TREE_CODE (r2val
.value
) == INTEGER_CST
)
1579 || wi::sext (r2val
.mask
,
1580 TYPE_PRECISION (TREE_TYPE (rhs2
))) == -1);
1581 bit_value_binop (code
, TYPE_SIGN (type
), TYPE_PRECISION (type
), &value
, &mask
,
1582 TYPE_SIGN (TREE_TYPE (rhs1
)), TYPE_PRECISION (TREE_TYPE (rhs1
)),
1583 value_to_wide_int (r1val
), r1val
.mask
,
1584 TYPE_SIGN (TREE_TYPE (rhs2
)), TYPE_PRECISION (TREE_TYPE (rhs2
)),
1585 value_to_wide_int (r2val
), r2val
.mask
);
1587 if (wi::sext (mask
, TYPE_PRECISION (type
)) != -1)
1589 val
.lattice_val
= CONSTANT
;
1591 /* ??? Delay building trees here. */
1592 val
.value
= wide_int_to_tree (type
, value
);
1596 val
.lattice_val
= VARYING
;
1597 val
.value
= NULL_TREE
;
1603 /* Return the propagation value for __builtin_assume_aligned
1604 and functions with assume_aligned or alloc_aligned attribute.
1605 For __builtin_assume_aligned, ATTR is NULL_TREE,
1606 for assume_aligned attribute ATTR is non-NULL and ALLOC_ALIGNED
1607 is false, for alloc_aligned attribute ATTR is non-NULL and
1608 ALLOC_ALIGNED is true. */
1610 static ccp_prop_value_t
1611 bit_value_assume_aligned (gimple
*stmt
, tree attr
, ccp_prop_value_t ptrval
,
1614 tree align
, misalign
= NULL_TREE
, type
;
1615 unsigned HOST_WIDE_INT aligni
, misaligni
= 0;
1616 ccp_prop_value_t alignval
;
1617 widest_int value
, mask
;
1618 ccp_prop_value_t val
;
1620 if (attr
== NULL_TREE
)
1622 tree ptr
= gimple_call_arg (stmt
, 0);
1623 type
= TREE_TYPE (ptr
);
1624 ptrval
= get_value_for_expr (ptr
, true);
1628 tree lhs
= gimple_call_lhs (stmt
);
1629 type
= TREE_TYPE (lhs
);
1632 if (ptrval
.lattice_val
== UNDEFINED
)
1634 gcc_assert ((ptrval
.lattice_val
== CONSTANT
1635 && TREE_CODE (ptrval
.value
) == INTEGER_CST
)
1636 || wi::sext (ptrval
.mask
, TYPE_PRECISION (type
)) == -1);
1637 if (attr
== NULL_TREE
)
1639 /* Get aligni and misaligni from __builtin_assume_aligned. */
1640 align
= gimple_call_arg (stmt
, 1);
1641 if (!tree_fits_uhwi_p (align
))
1643 aligni
= tree_to_uhwi (align
);
1644 if (gimple_call_num_args (stmt
) > 2)
1646 misalign
= gimple_call_arg (stmt
, 2);
1647 if (!tree_fits_uhwi_p (misalign
))
1649 misaligni
= tree_to_uhwi (misalign
);
1654 /* Get aligni and misaligni from assume_aligned or
1655 alloc_align attributes. */
1656 if (TREE_VALUE (attr
) == NULL_TREE
)
1658 attr
= TREE_VALUE (attr
);
1659 align
= TREE_VALUE (attr
);
1660 if (!tree_fits_uhwi_p (align
))
1662 aligni
= tree_to_uhwi (align
);
1665 if (aligni
== 0 || aligni
> gimple_call_num_args (stmt
))
1667 align
= gimple_call_arg (stmt
, aligni
- 1);
1668 if (!tree_fits_uhwi_p (align
))
1670 aligni
= tree_to_uhwi (align
);
1672 else if (TREE_CHAIN (attr
) && TREE_VALUE (TREE_CHAIN (attr
)))
1674 misalign
= TREE_VALUE (TREE_CHAIN (attr
));
1675 if (!tree_fits_uhwi_p (misalign
))
1677 misaligni
= tree_to_uhwi (misalign
);
1680 if (aligni
<= 1 || (aligni
& (aligni
- 1)) != 0 || misaligni
>= aligni
)
1683 align
= build_int_cst_type (type
, -aligni
);
1684 alignval
= get_value_for_expr (align
, true);
1685 bit_value_binop (BIT_AND_EXPR
, TYPE_SIGN (type
), TYPE_PRECISION (type
), &value
, &mask
,
1686 TYPE_SIGN (type
), TYPE_PRECISION (type
), value_to_wide_int (ptrval
), ptrval
.mask
,
1687 TYPE_SIGN (type
), TYPE_PRECISION (type
), value_to_wide_int (alignval
), alignval
.mask
);
1689 if (wi::sext (mask
, TYPE_PRECISION (type
)) != -1)
1691 val
.lattice_val
= CONSTANT
;
1693 gcc_assert ((mask
.to_uhwi () & (aligni
- 1)) == 0);
1694 gcc_assert ((value
.to_uhwi () & (aligni
- 1)) == 0);
1696 /* ??? Delay building trees here. */
1697 val
.value
= wide_int_to_tree (type
, value
);
1701 val
.lattice_val
= VARYING
;
1702 val
.value
= NULL_TREE
;
1708 /* Evaluate statement STMT.
1709 Valid only for assignments, calls, conditionals, and switches. */
1711 static ccp_prop_value_t
1712 evaluate_stmt (gimple
*stmt
)
1714 ccp_prop_value_t val
;
1715 tree simplified
= NULL_TREE
;
1716 ccp_lattice_t likelyvalue
= likely_value (stmt
);
1717 bool is_constant
= false;
1720 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1722 fprintf (dump_file
, "which is likely ");
1723 switch (likelyvalue
)
1726 fprintf (dump_file
, "CONSTANT");
1729 fprintf (dump_file
, "UNDEFINED");
1732 fprintf (dump_file
, "VARYING");
1736 fprintf (dump_file
, "\n");
1739 /* If the statement is likely to have a CONSTANT result, then try
1740 to fold the statement to determine the constant value. */
1741 /* FIXME. This is the only place that we call ccp_fold.
1742 Since likely_value never returns CONSTANT for calls, we will
1743 not attempt to fold them, including builtins that may profit. */
1744 if (likelyvalue
== CONSTANT
)
1746 fold_defer_overflow_warnings ();
1747 simplified
= ccp_fold (stmt
);
1749 && TREE_CODE (simplified
) == SSA_NAME
1750 /* We may not use values of something that may be simulated again,
1751 see valueize_op_1. */
1752 && (SSA_NAME_IS_DEFAULT_DEF (simplified
)
1753 || ! prop_simulate_again_p (SSA_NAME_DEF_STMT (simplified
))))
1755 ccp_prop_value_t
*val
= get_value (simplified
);
1756 if (val
&& val
->lattice_val
!= VARYING
)
1758 fold_undefer_overflow_warnings (true, stmt
, 0);
1762 is_constant
= simplified
&& is_gimple_min_invariant (simplified
);
1763 fold_undefer_overflow_warnings (is_constant
, stmt
, 0);
1766 /* The statement produced a constant value. */
1767 val
.lattice_val
= CONSTANT
;
1768 val
.value
= simplified
;
1773 /* If the statement is likely to have a VARYING result, then do not
1774 bother folding the statement. */
1775 else if (likelyvalue
== VARYING
)
1777 enum gimple_code code
= gimple_code (stmt
);
1778 if (code
== GIMPLE_ASSIGN
)
1780 enum tree_code subcode
= gimple_assign_rhs_code (stmt
);
1782 /* Other cases cannot satisfy is_gimple_min_invariant
1784 if (get_gimple_rhs_class (subcode
) == GIMPLE_SINGLE_RHS
)
1785 simplified
= gimple_assign_rhs1 (stmt
);
1787 else if (code
== GIMPLE_SWITCH
)
1788 simplified
= gimple_switch_index (as_a
<gswitch
*> (stmt
));
1790 /* These cannot satisfy is_gimple_min_invariant without folding. */
1791 gcc_assert (code
== GIMPLE_CALL
|| code
== GIMPLE_COND
);
1792 is_constant
= simplified
&& is_gimple_min_invariant (simplified
);
1795 /* The statement produced a constant value. */
1796 val
.lattice_val
= CONSTANT
;
1797 val
.value
= simplified
;
1801 /* If the statement result is likely UNDEFINED, make it so. */
1802 else if (likelyvalue
== UNDEFINED
)
1804 val
.lattice_val
= UNDEFINED
;
1805 val
.value
= NULL_TREE
;
1810 /* Resort to simplification for bitwise tracking. */
1811 if (flag_tree_bit_ccp
1812 && (likelyvalue
== CONSTANT
|| is_gimple_call (stmt
)
1813 || (gimple_assign_single_p (stmt
)
1814 && gimple_assign_rhs_code (stmt
) == ADDR_EXPR
))
1817 enum gimple_code code
= gimple_code (stmt
);
1818 val
.lattice_val
= VARYING
;
1819 val
.value
= NULL_TREE
;
1821 if (code
== GIMPLE_ASSIGN
)
1823 enum tree_code subcode
= gimple_assign_rhs_code (stmt
);
1824 tree rhs1
= gimple_assign_rhs1 (stmt
);
1825 tree lhs
= gimple_assign_lhs (stmt
);
1826 if ((INTEGRAL_TYPE_P (TREE_TYPE (lhs
))
1827 || POINTER_TYPE_P (TREE_TYPE (lhs
)))
1828 && (INTEGRAL_TYPE_P (TREE_TYPE (rhs1
))
1829 || POINTER_TYPE_P (TREE_TYPE (rhs1
))))
1830 switch (get_gimple_rhs_class (subcode
))
1832 case GIMPLE_SINGLE_RHS
:
1833 val
= get_value_for_expr (rhs1
, true);
1836 case GIMPLE_UNARY_RHS
:
1837 val
= bit_value_unop (subcode
, TREE_TYPE (lhs
), rhs1
);
1840 case GIMPLE_BINARY_RHS
:
1841 val
= bit_value_binop (subcode
, TREE_TYPE (lhs
), rhs1
,
1842 gimple_assign_rhs2 (stmt
));
1848 else if (code
== GIMPLE_COND
)
1850 enum tree_code code
= gimple_cond_code (stmt
);
1851 tree rhs1
= gimple_cond_lhs (stmt
);
1852 tree rhs2
= gimple_cond_rhs (stmt
);
1853 if (INTEGRAL_TYPE_P (TREE_TYPE (rhs1
))
1854 || POINTER_TYPE_P (TREE_TYPE (rhs1
)))
1855 val
= bit_value_binop (code
, TREE_TYPE (rhs1
), rhs1
, rhs2
);
1857 else if (gimple_call_builtin_p (stmt
, BUILT_IN_NORMAL
))
1859 tree fndecl
= gimple_call_fndecl (stmt
);
1860 switch (DECL_FUNCTION_CODE (fndecl
))
1862 case BUILT_IN_MALLOC
:
1863 case BUILT_IN_REALLOC
:
1864 case BUILT_IN_CALLOC
:
1865 case BUILT_IN_STRDUP
:
1866 case BUILT_IN_STRNDUP
:
1867 val
.lattice_val
= CONSTANT
;
1868 val
.value
= build_int_cst (TREE_TYPE (gimple_get_lhs (stmt
)), 0);
1869 val
.mask
= ~((HOST_WIDE_INT
) MALLOC_ABI_ALIGNMENT
1870 / BITS_PER_UNIT
- 1);
1873 case BUILT_IN_ALLOCA
:
1874 case BUILT_IN_ALLOCA_WITH_ALIGN
:
1875 align
= (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_ALLOCA_WITH_ALIGN
1876 ? TREE_INT_CST_LOW (gimple_call_arg (stmt
, 1))
1877 : BIGGEST_ALIGNMENT
);
1878 val
.lattice_val
= CONSTANT
;
1879 val
.value
= build_int_cst (TREE_TYPE (gimple_get_lhs (stmt
)), 0);
1880 val
.mask
= ~((HOST_WIDE_INT
) align
/ BITS_PER_UNIT
- 1);
1883 /* These builtins return their first argument, unmodified. */
1884 case BUILT_IN_MEMCPY
:
1885 case BUILT_IN_MEMMOVE
:
1886 case BUILT_IN_MEMSET
:
1887 case BUILT_IN_STRCPY
:
1888 case BUILT_IN_STRNCPY
:
1889 case BUILT_IN_MEMCPY_CHK
:
1890 case BUILT_IN_MEMMOVE_CHK
:
1891 case BUILT_IN_MEMSET_CHK
:
1892 case BUILT_IN_STRCPY_CHK
:
1893 case BUILT_IN_STRNCPY_CHK
:
1894 val
= get_value_for_expr (gimple_call_arg (stmt
, 0), true);
1897 case BUILT_IN_ASSUME_ALIGNED
:
1898 val
= bit_value_assume_aligned (stmt
, NULL_TREE
, val
, false);
1901 case BUILT_IN_ALIGNED_ALLOC
:
1903 tree align
= get_constant_value (gimple_call_arg (stmt
, 0));
1905 && tree_fits_uhwi_p (align
))
1907 unsigned HOST_WIDE_INT aligni
= tree_to_uhwi (align
);
1909 /* align must be power-of-two */
1910 && (aligni
& (aligni
- 1)) == 0)
1912 val
.lattice_val
= CONSTANT
;
1913 val
.value
= build_int_cst (ptr_type_node
, 0);
1923 if (is_gimple_call (stmt
) && gimple_call_lhs (stmt
))
1925 tree fntype
= gimple_call_fntype (stmt
);
1928 tree attrs
= lookup_attribute ("assume_aligned",
1929 TYPE_ATTRIBUTES (fntype
));
1931 val
= bit_value_assume_aligned (stmt
, attrs
, val
, false);
1932 attrs
= lookup_attribute ("alloc_align",
1933 TYPE_ATTRIBUTES (fntype
));
1935 val
= bit_value_assume_aligned (stmt
, attrs
, val
, true);
1938 is_constant
= (val
.lattice_val
== CONSTANT
);
1941 if (flag_tree_bit_ccp
1942 && ((is_constant
&& TREE_CODE (val
.value
) == INTEGER_CST
)
1944 && gimple_get_lhs (stmt
)
1945 && TREE_CODE (gimple_get_lhs (stmt
)) == SSA_NAME
)
1947 tree lhs
= gimple_get_lhs (stmt
);
1948 wide_int nonzero_bits
= get_nonzero_bits (lhs
);
1949 if (nonzero_bits
!= -1)
1953 val
.lattice_val
= CONSTANT
;
1954 val
.value
= build_zero_cst (TREE_TYPE (lhs
));
1955 val
.mask
= extend_mask (nonzero_bits
, TYPE_SIGN (TREE_TYPE (lhs
)));
1960 if (wi::bit_and_not (val
.value
, nonzero_bits
) != 0)
1961 val
.value
= wide_int_to_tree (TREE_TYPE (lhs
),
1962 nonzero_bits
& val
.value
);
1963 if (nonzero_bits
== 0)
1966 val
.mask
= val
.mask
& extend_mask (nonzero_bits
,
1967 TYPE_SIGN (TREE_TYPE (lhs
)));
1972 /* The statement produced a nonconstant value. */
1975 /* The statement produced a copy. */
1976 if (simplified
&& TREE_CODE (simplified
) == SSA_NAME
1977 && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (simplified
))
1979 val
.lattice_val
= CONSTANT
;
1980 val
.value
= simplified
;
1983 /* The statement is VARYING. */
1986 val
.lattice_val
= VARYING
;
1987 val
.value
= NULL_TREE
;
1995 typedef hash_table
<nofree_ptr_hash
<gimple
> > gimple_htab
;
1997 /* Given a BUILT_IN_STACK_SAVE value SAVED_VAL, insert a clobber of VAR before
1998 each matching BUILT_IN_STACK_RESTORE. Mark visited phis in VISITED. */
2001 insert_clobber_before_stack_restore (tree saved_val
, tree var
,
2002 gimple_htab
**visited
)
2005 gassign
*clobber_stmt
;
2007 imm_use_iterator iter
;
2008 gimple_stmt_iterator i
;
2011 FOR_EACH_IMM_USE_STMT (stmt
, iter
, saved_val
)
2012 if (gimple_call_builtin_p (stmt
, BUILT_IN_STACK_RESTORE
))
2014 clobber
= build_constructor (TREE_TYPE (var
),
2016 TREE_THIS_VOLATILE (clobber
) = 1;
2017 clobber_stmt
= gimple_build_assign (var
, clobber
);
2019 i
= gsi_for_stmt (stmt
);
2020 gsi_insert_before (&i
, clobber_stmt
, GSI_SAME_STMT
);
2022 else if (gimple_code (stmt
) == GIMPLE_PHI
)
2025 *visited
= new gimple_htab (10);
2027 slot
= (*visited
)->find_slot (stmt
, INSERT
);
2032 insert_clobber_before_stack_restore (gimple_phi_result (stmt
), var
,
2035 else if (gimple_assign_ssa_name_copy_p (stmt
))
2036 insert_clobber_before_stack_restore (gimple_assign_lhs (stmt
), var
,
2038 else if (chkp_gimple_call_builtin_p (stmt
, BUILT_IN_CHKP_BNDRET
))
2041 gcc_assert (is_gimple_debug (stmt
));
2044 /* Advance the iterator to the previous non-debug gimple statement in the same
2045 or dominating basic block. */
2048 gsi_prev_dom_bb_nondebug (gimple_stmt_iterator
*i
)
2052 gsi_prev_nondebug (i
);
2053 while (gsi_end_p (*i
))
2055 dom
= get_immediate_dominator (CDI_DOMINATORS
, i
->bb
);
2056 if (dom
== NULL
|| dom
== ENTRY_BLOCK_PTR_FOR_FN (cfun
))
2059 *i
= gsi_last_bb (dom
);
2063 /* Find a BUILT_IN_STACK_SAVE dominating gsi_stmt (I), and insert
2064 a clobber of VAR before each matching BUILT_IN_STACK_RESTORE.
2066 It is possible that BUILT_IN_STACK_SAVE cannot be find in a dominator when a
2067 previous pass (such as DOM) duplicated it along multiple paths to a BB. In
2068 that case the function gives up without inserting the clobbers. */
2071 insert_clobbers_for_var (gimple_stmt_iterator i
, tree var
)
2075 gimple_htab
*visited
= NULL
;
2077 for (; !gsi_end_p (i
); gsi_prev_dom_bb_nondebug (&i
))
2079 stmt
= gsi_stmt (i
);
2081 if (!gimple_call_builtin_p (stmt
, BUILT_IN_STACK_SAVE
))
2084 saved_val
= gimple_call_lhs (stmt
);
2085 if (saved_val
== NULL_TREE
)
2088 insert_clobber_before_stack_restore (saved_val
, var
, &visited
);
2095 /* Detects a __builtin_alloca_with_align with constant size argument. Declares
2096 fixed-size array and returns the address, if found, otherwise returns
2100 fold_builtin_alloca_with_align (gimple
*stmt
)
2102 unsigned HOST_WIDE_INT size
, threshold
, n_elem
;
2103 tree lhs
, arg
, block
, var
, elem_type
, array_type
;
2106 lhs
= gimple_call_lhs (stmt
);
2107 if (lhs
== NULL_TREE
)
2110 /* Detect constant argument. */
2111 arg
= get_constant_value (gimple_call_arg (stmt
, 0));
2112 if (arg
== NULL_TREE
2113 || TREE_CODE (arg
) != INTEGER_CST
2114 || !tree_fits_uhwi_p (arg
))
2117 size
= tree_to_uhwi (arg
);
2119 /* Heuristic: don't fold large allocas. */
2120 threshold
= (unsigned HOST_WIDE_INT
)PARAM_VALUE (PARAM_LARGE_STACK_FRAME
);
2121 /* In case the alloca is located at function entry, it has the same lifetime
2122 as a declared array, so we allow a larger size. */
2123 block
= gimple_block (stmt
);
2124 if (!(cfun
->after_inlining
2126 && TREE_CODE (BLOCK_SUPERCONTEXT (block
)) == FUNCTION_DECL
))
2128 if (size
> threshold
)
2131 /* Declare array. */
2132 elem_type
= build_nonstandard_integer_type (BITS_PER_UNIT
, 1);
2133 n_elem
= size
* 8 / BITS_PER_UNIT
;
2134 array_type
= build_array_type_nelts (elem_type
, n_elem
);
2135 var
= create_tmp_var (array_type
);
2136 SET_DECL_ALIGN (var
, TREE_INT_CST_LOW (gimple_call_arg (stmt
, 1)));
2138 struct ptr_info_def
*pi
= SSA_NAME_PTR_INFO (lhs
);
2139 if (pi
!= NULL
&& !pi
->pt
.anything
)
2143 singleton_p
= pt_solution_singleton_or_null_p (&pi
->pt
, &uid
);
2144 gcc_assert (singleton_p
);
2145 SET_DECL_PT_UID (var
, uid
);
2149 /* Fold alloca to the address of the array. */
2150 return fold_convert (TREE_TYPE (lhs
), build_fold_addr_expr (var
));
2153 /* Fold the stmt at *GSI with CCP specific information that propagating
2154 and regular folding does not catch. */
2157 ccp_fold_stmt (gimple_stmt_iterator
*gsi
)
2159 gimple
*stmt
= gsi_stmt (*gsi
);
2161 switch (gimple_code (stmt
))
2165 gcond
*cond_stmt
= as_a
<gcond
*> (stmt
);
2166 ccp_prop_value_t val
;
2167 /* Statement evaluation will handle type mismatches in constants
2168 more gracefully than the final propagation. This allows us to
2169 fold more conditionals here. */
2170 val
= evaluate_stmt (stmt
);
2171 if (val
.lattice_val
!= CONSTANT
2177 fprintf (dump_file
, "Folding predicate ");
2178 print_gimple_expr (dump_file
, stmt
, 0, 0);
2179 fprintf (dump_file
, " to ");
2180 print_generic_expr (dump_file
, val
.value
, 0);
2181 fprintf (dump_file
, "\n");
2184 if (integer_zerop (val
.value
))
2185 gimple_cond_make_false (cond_stmt
);
2187 gimple_cond_make_true (cond_stmt
);
2194 tree lhs
= gimple_call_lhs (stmt
);
2195 int flags
= gimple_call_flags (stmt
);
2198 bool changed
= false;
2201 /* If the call was folded into a constant make sure it goes
2202 away even if we cannot propagate into all uses because of
2205 && TREE_CODE (lhs
) == SSA_NAME
2206 && (val
= get_constant_value (lhs
))
2207 /* Don't optimize away calls that have side-effects. */
2208 && (flags
& (ECF_CONST
|ECF_PURE
)) != 0
2209 && (flags
& ECF_LOOPING_CONST_OR_PURE
) == 0)
2211 tree new_rhs
= unshare_expr (val
);
2213 if (!useless_type_conversion_p (TREE_TYPE (lhs
),
2214 TREE_TYPE (new_rhs
)))
2215 new_rhs
= fold_convert (TREE_TYPE (lhs
), new_rhs
);
2216 res
= update_call_from_tree (gsi
, new_rhs
);
2221 /* Internal calls provide no argument types, so the extra laxity
2222 for normal calls does not apply. */
2223 if (gimple_call_internal_p (stmt
))
2226 /* The heuristic of fold_builtin_alloca_with_align differs before and
2227 after inlining, so we don't require the arg to be changed into a
2228 constant for folding, but just to be constant. */
2229 if (gimple_call_builtin_p (stmt
, BUILT_IN_ALLOCA_WITH_ALIGN
))
2231 tree new_rhs
= fold_builtin_alloca_with_align (stmt
);
2234 bool res
= update_call_from_tree (gsi
, new_rhs
);
2235 tree var
= TREE_OPERAND (TREE_OPERAND (new_rhs
, 0),0);
2237 insert_clobbers_for_var (*gsi
, var
);
2242 /* Propagate into the call arguments. Compared to replace_uses_in
2243 this can use the argument slot types for type verification
2244 instead of the current argument type. We also can safely
2245 drop qualifiers here as we are dealing with constants anyway. */
2246 argt
= TYPE_ARG_TYPES (gimple_call_fntype (stmt
));
2247 for (i
= 0; i
< gimple_call_num_args (stmt
) && argt
;
2248 ++i
, argt
= TREE_CHAIN (argt
))
2250 tree arg
= gimple_call_arg (stmt
, i
);
2251 if (TREE_CODE (arg
) == SSA_NAME
2252 && (val
= get_constant_value (arg
))
2253 && useless_type_conversion_p
2254 (TYPE_MAIN_VARIANT (TREE_VALUE (argt
)),
2255 TYPE_MAIN_VARIANT (TREE_TYPE (val
))))
2257 gimple_call_set_arg (stmt
, i
, unshare_expr (val
));
2267 tree lhs
= gimple_assign_lhs (stmt
);
2270 /* If we have a load that turned out to be constant replace it
2271 as we cannot propagate into all uses in all cases. */
2272 if (gimple_assign_single_p (stmt
)
2273 && TREE_CODE (lhs
) == SSA_NAME
2274 && (val
= get_constant_value (lhs
)))
2276 tree rhs
= unshare_expr (val
);
2277 if (!useless_type_conversion_p (TREE_TYPE (lhs
), TREE_TYPE (rhs
)))
2278 rhs
= fold_build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (lhs
), rhs
);
2279 gimple_assign_set_rhs_from_tree (gsi
, rhs
);
2291 /* Visit the assignment statement STMT. Set the value of its LHS to the
2292 value computed by the RHS and store LHS in *OUTPUT_P. If STMT
2293 creates virtual definitions, set the value of each new name to that
2294 of the RHS (if we can derive a constant out of the RHS).
2295 Value-returning call statements also perform an assignment, and
2296 are handled here. */
2298 static enum ssa_prop_result
2299 visit_assignment (gimple
*stmt
, tree
*output_p
)
2301 ccp_prop_value_t val
;
2302 enum ssa_prop_result retval
= SSA_PROP_NOT_INTERESTING
;
2304 tree lhs
= gimple_get_lhs (stmt
);
2305 if (TREE_CODE (lhs
) == SSA_NAME
)
2307 /* Evaluate the statement, which could be
2308 either a GIMPLE_ASSIGN or a GIMPLE_CALL. */
2309 val
= evaluate_stmt (stmt
);
2311 /* If STMT is an assignment to an SSA_NAME, we only have one
2313 if (set_lattice_value (lhs
, &val
))
2316 if (val
.lattice_val
== VARYING
)
2317 retval
= SSA_PROP_VARYING
;
2319 retval
= SSA_PROP_INTERESTING
;
2327 /* Visit the conditional statement STMT. Return SSA_PROP_INTERESTING
2328 if it can determine which edge will be taken. Otherwise, return
2329 SSA_PROP_VARYING. */
2331 static enum ssa_prop_result
2332 visit_cond_stmt (gimple
*stmt
, edge
*taken_edge_p
)
2334 ccp_prop_value_t val
;
2337 block
= gimple_bb (stmt
);
2338 val
= evaluate_stmt (stmt
);
2339 if (val
.lattice_val
!= CONSTANT
2341 return SSA_PROP_VARYING
;
2343 /* Find which edge out of the conditional block will be taken and add it
2344 to the worklist. If no single edge can be determined statically,
2345 return SSA_PROP_VARYING to feed all the outgoing edges to the
2346 propagation engine. */
2347 *taken_edge_p
= find_taken_edge (block
, val
.value
);
2349 return SSA_PROP_INTERESTING
;
2351 return SSA_PROP_VARYING
;
2355 /* Evaluate statement STMT. If the statement produces an output value and
2356 its evaluation changes the lattice value of its output, return
2357 SSA_PROP_INTERESTING and set *OUTPUT_P to the SSA_NAME holding the
2360 If STMT is a conditional branch and we can determine its truth
2361 value, set *TAKEN_EDGE_P accordingly. If STMT produces a varying
2362 value, return SSA_PROP_VARYING. */
2364 static enum ssa_prop_result
2365 ccp_visit_stmt (gimple
*stmt
, edge
*taken_edge_p
, tree
*output_p
)
2370 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2372 fprintf (dump_file
, "\nVisiting statement:\n");
2373 print_gimple_stmt (dump_file
, stmt
, 0, dump_flags
);
2376 switch (gimple_code (stmt
))
2379 /* If the statement is an assignment that produces a single
2380 output value, evaluate its RHS to see if the lattice value of
2381 its output has changed. */
2382 return visit_assignment (stmt
, output_p
);
2385 /* A value-returning call also performs an assignment. */
2386 if (gimple_call_lhs (stmt
) != NULL_TREE
)
2387 return visit_assignment (stmt
, output_p
);
2392 /* If STMT is a conditional branch, see if we can determine
2393 which branch will be taken. */
2394 /* FIXME. It appears that we should be able to optimize
2395 computed GOTOs here as well. */
2396 return visit_cond_stmt (stmt
, taken_edge_p
);
2402 /* Any other kind of statement is not interesting for constant
2403 propagation and, therefore, not worth simulating. */
2404 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2405 fprintf (dump_file
, "No interesting values produced. Marked VARYING.\n");
2407 /* Definitions made by statements other than assignments to
2408 SSA_NAMEs represent unknown modifications to their outputs.
2409 Mark them VARYING. */
2410 FOR_EACH_SSA_TREE_OPERAND (def
, stmt
, iter
, SSA_OP_ALL_DEFS
)
2411 set_value_varying (def
);
2413 return SSA_PROP_VARYING
;
2417 /* Main entry point for SSA Conditional Constant Propagation. If NONZERO_P,
2418 record nonzero bits. */
2421 do_ssa_ccp (bool nonzero_p
)
2423 unsigned int todo
= 0;
2424 calculate_dominance_info (CDI_DOMINATORS
);
2427 ssa_propagate (ccp_visit_stmt
, ccp_visit_phi_node
);
2428 if (ccp_finalize (nonzero_p
|| flag_ipa_bit_cp
))
2430 todo
= (TODO_cleanup_cfg
| TODO_update_ssa
);
2432 /* ccp_finalize does not preserve loop-closed ssa. */
2433 loops_state_clear (LOOP_CLOSED_SSA
);
2436 free_dominance_info (CDI_DOMINATORS
);
2443 const pass_data pass_data_ccp
=
2445 GIMPLE_PASS
, /* type */
2447 OPTGROUP_NONE
, /* optinfo_flags */
2448 TV_TREE_CCP
, /* tv_id */
2449 ( PROP_cfg
| PROP_ssa
), /* properties_required */
2450 0, /* properties_provided */
2451 0, /* properties_destroyed */
2452 0, /* todo_flags_start */
2453 TODO_update_address_taken
, /* todo_flags_finish */
2456 class pass_ccp
: public gimple_opt_pass
2459 pass_ccp (gcc::context
*ctxt
)
2460 : gimple_opt_pass (pass_data_ccp
, ctxt
), nonzero_p (false)
2463 /* opt_pass methods: */
2464 opt_pass
* clone () { return new pass_ccp (m_ctxt
); }
2465 void set_pass_param (unsigned int n
, bool param
)
2467 gcc_assert (n
== 0);
2470 virtual bool gate (function
*) { return flag_tree_ccp
!= 0; }
2471 virtual unsigned int execute (function
*) { return do_ssa_ccp (nonzero_p
); }
2474 /* Determines whether the pass instance records nonzero bits. */
2476 }; // class pass_ccp
2481 make_pass_ccp (gcc::context
*ctxt
)
2483 return new pass_ccp (ctxt
);
2488 /* Try to optimize out __builtin_stack_restore. Optimize it out
2489 if there is another __builtin_stack_restore in the same basic
2490 block and no calls or ASM_EXPRs are in between, or if this block's
2491 only outgoing edge is to EXIT_BLOCK and there are no calls or
2492 ASM_EXPRs after this __builtin_stack_restore. */
2495 optimize_stack_restore (gimple_stmt_iterator i
)
2500 basic_block bb
= gsi_bb (i
);
2501 gimple
*call
= gsi_stmt (i
);
2503 if (gimple_code (call
) != GIMPLE_CALL
2504 || gimple_call_num_args (call
) != 1
2505 || TREE_CODE (gimple_call_arg (call
, 0)) != SSA_NAME
2506 || !POINTER_TYPE_P (TREE_TYPE (gimple_call_arg (call
, 0))))
2509 for (gsi_next (&i
); !gsi_end_p (i
); gsi_next (&i
))
2511 stmt
= gsi_stmt (i
);
2512 if (gimple_code (stmt
) == GIMPLE_ASM
)
2514 if (gimple_code (stmt
) != GIMPLE_CALL
)
2517 callee
= gimple_call_fndecl (stmt
);
2519 || DECL_BUILT_IN_CLASS (callee
) != BUILT_IN_NORMAL
2520 /* All regular builtins are ok, just obviously not alloca. */
2521 || DECL_FUNCTION_CODE (callee
) == BUILT_IN_ALLOCA
2522 || DECL_FUNCTION_CODE (callee
) == BUILT_IN_ALLOCA_WITH_ALIGN
)
2525 if (DECL_FUNCTION_CODE (callee
) == BUILT_IN_STACK_RESTORE
)
2526 goto second_stack_restore
;
2532 /* Allow one successor of the exit block, or zero successors. */
2533 switch (EDGE_COUNT (bb
->succs
))
2538 if (single_succ_edge (bb
)->dest
!= EXIT_BLOCK_PTR_FOR_FN (cfun
))
2544 second_stack_restore
:
2546 /* If there's exactly one use, then zap the call to __builtin_stack_save.
2547 If there are multiple uses, then the last one should remove the call.
2548 In any case, whether the call to __builtin_stack_save can be removed
2549 or not is irrelevant to removing the call to __builtin_stack_restore. */
2550 if (has_single_use (gimple_call_arg (call
, 0)))
2552 gimple
*stack_save
= SSA_NAME_DEF_STMT (gimple_call_arg (call
, 0));
2553 if (is_gimple_call (stack_save
))
2555 callee
= gimple_call_fndecl (stack_save
);
2557 && DECL_BUILT_IN_CLASS (callee
) == BUILT_IN_NORMAL
2558 && DECL_FUNCTION_CODE (callee
) == BUILT_IN_STACK_SAVE
)
2560 gimple_stmt_iterator stack_save_gsi
;
2563 stack_save_gsi
= gsi_for_stmt (stack_save
);
2564 rhs
= build_int_cst (TREE_TYPE (gimple_call_arg (call
, 0)), 0);
2565 update_call_from_tree (&stack_save_gsi
, rhs
);
2570 /* No effect, so the statement will be deleted. */
2571 return integer_zero_node
;
2574 /* If va_list type is a simple pointer and nothing special is needed,
2575 optimize __builtin_va_start (&ap, 0) into ap = __builtin_next_arg (0),
2576 __builtin_va_end (&ap) out as NOP and __builtin_va_copy into a simple
2577 pointer assignment. */
2580 optimize_stdarg_builtin (gimple
*call
)
2582 tree callee
, lhs
, rhs
, cfun_va_list
;
2583 bool va_list_simple_ptr
;
2584 location_t loc
= gimple_location (call
);
2586 if (gimple_code (call
) != GIMPLE_CALL
)
2589 callee
= gimple_call_fndecl (call
);
2591 cfun_va_list
= targetm
.fn_abi_va_list (callee
);
2592 va_list_simple_ptr
= POINTER_TYPE_P (cfun_va_list
)
2593 && (TREE_TYPE (cfun_va_list
) == void_type_node
2594 || TREE_TYPE (cfun_va_list
) == char_type_node
);
2596 switch (DECL_FUNCTION_CODE (callee
))
2598 case BUILT_IN_VA_START
:
2599 if (!va_list_simple_ptr
2600 || targetm
.expand_builtin_va_start
!= NULL
2601 || !builtin_decl_explicit_p (BUILT_IN_NEXT_ARG
))
2604 if (gimple_call_num_args (call
) != 2)
2607 lhs
= gimple_call_arg (call
, 0);
2608 if (!POINTER_TYPE_P (TREE_TYPE (lhs
))
2609 || TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (lhs
)))
2610 != TYPE_MAIN_VARIANT (cfun_va_list
))
2613 lhs
= build_fold_indirect_ref_loc (loc
, lhs
);
2614 rhs
= build_call_expr_loc (loc
, builtin_decl_explicit (BUILT_IN_NEXT_ARG
),
2615 1, integer_zero_node
);
2616 rhs
= fold_convert_loc (loc
, TREE_TYPE (lhs
), rhs
);
2617 return build2 (MODIFY_EXPR
, TREE_TYPE (lhs
), lhs
, rhs
);
2619 case BUILT_IN_VA_COPY
:
2620 if (!va_list_simple_ptr
)
2623 if (gimple_call_num_args (call
) != 2)
2626 lhs
= gimple_call_arg (call
, 0);
2627 if (!POINTER_TYPE_P (TREE_TYPE (lhs
))
2628 || TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (lhs
)))
2629 != TYPE_MAIN_VARIANT (cfun_va_list
))
2632 lhs
= build_fold_indirect_ref_loc (loc
, lhs
);
2633 rhs
= gimple_call_arg (call
, 1);
2634 if (TYPE_MAIN_VARIANT (TREE_TYPE (rhs
))
2635 != TYPE_MAIN_VARIANT (cfun_va_list
))
2638 rhs
= fold_convert_loc (loc
, TREE_TYPE (lhs
), rhs
);
2639 return build2 (MODIFY_EXPR
, TREE_TYPE (lhs
), lhs
, rhs
);
2641 case BUILT_IN_VA_END
:
2642 /* No effect, so the statement will be deleted. */
2643 return integer_zero_node
;
2650 /* Attemp to make the block of __builtin_unreachable I unreachable by changing
2651 the incoming jumps. Return true if at least one jump was changed. */
2654 optimize_unreachable (gimple_stmt_iterator i
)
2656 basic_block bb
= gsi_bb (i
);
2657 gimple_stmt_iterator gsi
;
2663 if (flag_sanitize
& SANITIZE_UNREACHABLE
)
2666 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
2668 stmt
= gsi_stmt (gsi
);
2670 if (is_gimple_debug (stmt
))
2673 if (glabel
*label_stmt
= dyn_cast
<glabel
*> (stmt
))
2675 /* Verify we do not need to preserve the label. */
2676 if (FORCED_LABEL (gimple_label_label (label_stmt
)))
2682 /* Only handle the case that __builtin_unreachable is the first statement
2683 in the block. We rely on DCE to remove stmts without side-effects
2684 before __builtin_unreachable. */
2685 if (gsi_stmt (gsi
) != gsi_stmt (i
))
2690 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
2692 gsi
= gsi_last_bb (e
->src
);
2693 if (gsi_end_p (gsi
))
2696 stmt
= gsi_stmt (gsi
);
2697 if (gcond
*cond_stmt
= dyn_cast
<gcond
*> (stmt
))
2699 if (e
->flags
& EDGE_TRUE_VALUE
)
2700 gimple_cond_make_false (cond_stmt
);
2701 else if (e
->flags
& EDGE_FALSE_VALUE
)
2702 gimple_cond_make_true (cond_stmt
);
2705 update_stmt (cond_stmt
);
2709 /* Todo: handle other cases, f.i. switch statement. */
2720 mask_2 = 1 << cnt_1;
2721 _4 = __atomic_fetch_or_* (ptr_6, mask_2, _3);
2724 _4 = ATOMIC_BIT_TEST_AND_SET (ptr_6, cnt_1, 0, _3);
2726 If _5 is only used in _5 != 0 or _5 == 0 comparisons, 1
2727 is passed instead of 0, and the builtin just returns a zero
2728 or 1 value instead of the actual bit.
2729 Similarly for __sync_fetch_and_or_* (without the ", _3" part
2730 in there), and/or if mask_2 is a power of 2 constant.
2731 Similarly for xor instead of or, use ATOMIC_BIT_TEST_AND_COMPLEMENT
2732 in that case. And similarly for and instead of or, except that
2733 the second argument to the builtin needs to be one's complement
2734 of the mask instead of mask. */
2737 optimize_atomic_bit_test_and (gimple_stmt_iterator
*gsip
,
2738 enum internal_fn fn
, bool has_model_arg
,
2741 gimple
*call
= gsi_stmt (*gsip
);
2742 tree lhs
= gimple_call_lhs (call
);
2743 use_operand_p use_p
;
2748 if (!flag_inline_atomics
2750 || !gimple_call_builtin_p (call
, BUILT_IN_NORMAL
)
2752 || SSA_NAME_OCCURS_IN_ABNORMAL_PHI (lhs
)
2753 || !single_imm_use (lhs
, &use_p
, &use_stmt
)
2754 || !is_gimple_assign (use_stmt
)
2755 || gimple_assign_rhs_code (use_stmt
) != BIT_AND_EXPR
2756 || !gimple_vdef (call
))
2761 case IFN_ATOMIC_BIT_TEST_AND_SET
:
2762 optab
= atomic_bit_test_and_set_optab
;
2764 case IFN_ATOMIC_BIT_TEST_AND_COMPLEMENT
:
2765 optab
= atomic_bit_test_and_complement_optab
;
2767 case IFN_ATOMIC_BIT_TEST_AND_RESET
:
2768 optab
= atomic_bit_test_and_reset_optab
;
2774 if (optab_handler (optab
, TYPE_MODE (TREE_TYPE (lhs
))) == CODE_FOR_nothing
)
2777 mask
= gimple_call_arg (call
, 1);
2778 tree use_lhs
= gimple_assign_lhs (use_stmt
);
2782 if (TREE_CODE (mask
) == INTEGER_CST
)
2784 if (fn
== IFN_ATOMIC_BIT_TEST_AND_RESET
)
2785 mask
= const_unop (BIT_NOT_EXPR
, TREE_TYPE (mask
), mask
);
2786 mask
= fold_convert (TREE_TYPE (lhs
), mask
);
2787 int ibit
= tree_log2 (mask
);
2790 bit
= build_int_cst (TREE_TYPE (lhs
), ibit
);
2792 else if (TREE_CODE (mask
) == SSA_NAME
)
2794 gimple
*g
= SSA_NAME_DEF_STMT (mask
);
2795 if (fn
== IFN_ATOMIC_BIT_TEST_AND_RESET
)
2797 if (!is_gimple_assign (g
)
2798 || gimple_assign_rhs_code (g
) != BIT_NOT_EXPR
)
2800 mask
= gimple_assign_rhs1 (g
);
2801 if (TREE_CODE (mask
) != SSA_NAME
)
2803 g
= SSA_NAME_DEF_STMT (mask
);
2805 if (!is_gimple_assign (g
)
2806 || gimple_assign_rhs_code (g
) != LSHIFT_EXPR
2807 || !integer_onep (gimple_assign_rhs1 (g
)))
2809 bit
= gimple_assign_rhs2 (g
);
2814 if (gimple_assign_rhs1 (use_stmt
) == lhs
)
2816 if (!operand_equal_p (gimple_assign_rhs2 (use_stmt
), mask
, 0))
2819 else if (gimple_assign_rhs2 (use_stmt
) != lhs
2820 || !operand_equal_p (gimple_assign_rhs1 (use_stmt
), mask
, 0))
2823 bool use_bool
= true;
2824 bool has_debug_uses
= false;
2825 imm_use_iterator iter
;
2828 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (use_lhs
))
2830 FOR_EACH_IMM_USE_STMT (g
, iter
, use_lhs
)
2832 enum tree_code code
= ERROR_MARK
;
2833 tree op0
= NULL_TREE
, op1
= NULL_TREE
;
2834 if (is_gimple_debug (g
))
2836 has_debug_uses
= true;
2839 else if (is_gimple_assign (g
))
2840 switch (gimple_assign_rhs_code (g
))
2843 op1
= gimple_assign_rhs1 (g
);
2844 code
= TREE_CODE (op1
);
2845 op0
= TREE_OPERAND (op1
, 0);
2846 op1
= TREE_OPERAND (op1
, 1);
2850 code
= gimple_assign_rhs_code (g
);
2851 op0
= gimple_assign_rhs1 (g
);
2852 op1
= gimple_assign_rhs2 (g
);
2857 else if (gimple_code (g
) == GIMPLE_COND
)
2859 code
= gimple_cond_code (g
);
2860 op0
= gimple_cond_lhs (g
);
2861 op1
= gimple_cond_rhs (g
);
2864 if ((code
== EQ_EXPR
|| code
== NE_EXPR
)
2866 && integer_zerop (op1
))
2868 use_operand_p use_p
;
2870 FOR_EACH_IMM_USE_ON_STMT (use_p
, iter
)
2877 BREAK_FROM_IMM_USE_STMT (iter
);
2880 tree new_lhs
= make_ssa_name (TREE_TYPE (lhs
));
2881 tree flag
= build_int_cst (TREE_TYPE (lhs
), use_bool
);
2883 g
= gimple_build_call_internal (fn
, 4, gimple_call_arg (call
, 0),
2884 bit
, flag
, gimple_call_arg (call
, 2));
2886 g
= gimple_build_call_internal (fn
, 3, gimple_call_arg (call
, 0),
2888 gimple_call_set_lhs (g
, new_lhs
);
2889 gimple_set_location (g
, gimple_location (call
));
2890 gimple_set_vuse (g
, gimple_vuse (call
));
2891 gimple_set_vdef (g
, gimple_vdef (call
));
2892 SSA_NAME_DEF_STMT (gimple_vdef (call
)) = g
;
2893 gimple_stmt_iterator gsi
= *gsip
;
2894 gsi_insert_after (&gsi
, g
, GSI_NEW_STMT
);
2897 /* The internal function returns the value of the specified bit
2898 before the atomic operation. If we are interested in the value
2899 of the specified bit after the atomic operation (makes only sense
2900 for xor, otherwise the bit content is compile time known),
2901 we need to invert the bit. */
2902 g
= gimple_build_assign (make_ssa_name (TREE_TYPE (lhs
)),
2903 BIT_XOR_EXPR
, new_lhs
,
2904 use_bool
? build_int_cst (TREE_TYPE (lhs
), 1)
2906 new_lhs
= gimple_assign_lhs (g
);
2907 gsi_insert_after (&gsi
, g
, GSI_NEW_STMT
);
2909 if (use_bool
&& has_debug_uses
)
2911 tree temp
= make_node (DEBUG_EXPR_DECL
);
2912 DECL_ARTIFICIAL (temp
) = 1;
2913 TREE_TYPE (temp
) = TREE_TYPE (lhs
);
2914 SET_DECL_MODE (temp
, TYPE_MODE (TREE_TYPE (lhs
)));
2915 tree t
= build2 (LSHIFT_EXPR
, TREE_TYPE (lhs
), new_lhs
, bit
);
2916 g
= gimple_build_debug_bind (temp
, t
, g
);
2917 gsi_insert_after (&gsi
, g
, GSI_NEW_STMT
);
2918 FOR_EACH_IMM_USE_STMT (g
, iter
, use_lhs
)
2919 if (is_gimple_debug (g
))
2921 use_operand_p use_p
;
2922 FOR_EACH_IMM_USE_ON_STMT (use_p
, iter
)
2923 SET_USE (use_p
, temp
);
2927 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (new_lhs
)
2928 = SSA_NAME_OCCURS_IN_ABNORMAL_PHI (use_lhs
);
2929 replace_uses_by (use_lhs
, new_lhs
);
2930 gsi
= gsi_for_stmt (use_stmt
);
2931 gsi_remove (&gsi
, true);
2932 release_defs (use_stmt
);
2933 gsi_remove (gsip
, true);
2934 release_ssa_name (lhs
);
2943 Similarly for memset (&a, ..., sizeof (a)); instead of a = {};
2944 and/or memcpy (&b, &a, sizeof (a)); instead of b = a; */
2947 optimize_memcpy (gimple_stmt_iterator
*gsip
, tree dest
, tree src
, tree len
)
2949 gimple
*stmt
= gsi_stmt (*gsip
);
2950 if (gimple_has_volatile_ops (stmt
))
2953 tree vuse
= gimple_vuse (stmt
);
2957 gimple
*defstmt
= SSA_NAME_DEF_STMT (vuse
);
2958 tree src2
= NULL_TREE
, len2
= NULL_TREE
;
2959 HOST_WIDE_INT offset
, offset2
;
2960 tree val
= integer_zero_node
;
2961 if (gimple_store_p (defstmt
)
2962 && gimple_assign_single_p (defstmt
)
2963 && TREE_CODE (gimple_assign_rhs1 (defstmt
)) == CONSTRUCTOR
2964 && !gimple_clobber_p (defstmt
))
2965 src2
= gimple_assign_lhs (defstmt
);
2966 else if (gimple_call_builtin_p (defstmt
, BUILT_IN_MEMSET
)
2967 && TREE_CODE (gimple_call_arg (defstmt
, 0)) == ADDR_EXPR
2968 && TREE_CODE (gimple_call_arg (defstmt
, 1)) == INTEGER_CST
)
2970 src2
= TREE_OPERAND (gimple_call_arg (defstmt
, 0), 0);
2971 len2
= gimple_call_arg (defstmt
, 2);
2972 val
= gimple_call_arg (defstmt
, 1);
2973 /* For non-0 val, we'd have to transform stmt from assignment
2974 into memset (only if dest is addressable). */
2975 if (!integer_zerop (val
) && is_gimple_assign (stmt
))
2979 if (src2
== NULL_TREE
)
2982 if (len
== NULL_TREE
)
2983 len
= (TREE_CODE (src
) == COMPONENT_REF
2984 ? DECL_SIZE_UNIT (TREE_OPERAND (src
, 1))
2985 : TYPE_SIZE_UNIT (TREE_TYPE (src
)));
2986 if (len2
== NULL_TREE
)
2987 len2
= (TREE_CODE (src2
) == COMPONENT_REF
2988 ? DECL_SIZE_UNIT (TREE_OPERAND (src2
, 1))
2989 : TYPE_SIZE_UNIT (TREE_TYPE (src2
)));
2990 if (len
== NULL_TREE
2991 || TREE_CODE (len
) != INTEGER_CST
2992 || len2
== NULL_TREE
2993 || TREE_CODE (len2
) != INTEGER_CST
)
2996 src
= get_addr_base_and_unit_offset (src
, &offset
);
2997 src2
= get_addr_base_and_unit_offset (src2
, &offset2
);
2998 if (src
== NULL_TREE
2999 || src2
== NULL_TREE
3000 || offset
< offset2
)
3003 if (!operand_equal_p (src
, src2
, 0))
3006 /* [ src + offset2, src + offset2 + len2 - 1 ] is set to val.
3008 [ src + offset, src + offset + len - 1 ] is a subset of that. */
3009 if (wi::to_offset (len
) + (offset
- offset2
) > wi::to_offset (len2
))
3012 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
3014 fprintf (dump_file
, "Simplified\n ");
3015 print_gimple_stmt (dump_file
, stmt
, 0, dump_flags
);
3016 fprintf (dump_file
, "after previous\n ");
3017 print_gimple_stmt (dump_file
, defstmt
, 0, dump_flags
);
3020 /* For simplicity, don't change the kind of the stmt,
3021 turn dest = src; into dest = {}; and memcpy (&dest, &src, len);
3022 into memset (&dest, val, len);
3023 In theory we could change dest = src into memset if dest
3024 is addressable (maybe beneficial if val is not 0), or
3025 memcpy (&dest, &src, len) into dest = {} if len is the size
3026 of dest, dest isn't volatile. */
3027 if (is_gimple_assign (stmt
))
3029 tree ctor
= build_constructor (TREE_TYPE (dest
), NULL
);
3030 gimple_assign_set_rhs_from_tree (gsip
, ctor
);
3033 else /* If stmt is memcpy, transform it into memset. */
3035 gcall
*call
= as_a
<gcall
*> (stmt
);
3036 tree fndecl
= builtin_decl_implicit (BUILT_IN_MEMSET
);
3037 gimple_call_set_fndecl (call
, fndecl
);
3038 gimple_call_set_fntype (call
, TREE_TYPE (fndecl
));
3039 gimple_call_set_arg (call
, 1, val
);
3043 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
3045 fprintf (dump_file
, "into\n ");
3046 print_gimple_stmt (dump_file
, stmt
, 0, dump_flags
);
3050 /* A simple pass that attempts to fold all builtin functions. This pass
3051 is run after we've propagated as many constants as we can. */
3055 const pass_data pass_data_fold_builtins
=
3057 GIMPLE_PASS
, /* type */
3059 OPTGROUP_NONE
, /* optinfo_flags */
3060 TV_NONE
, /* tv_id */
3061 ( PROP_cfg
| PROP_ssa
), /* properties_required */
3062 0, /* properties_provided */
3063 0, /* properties_destroyed */
3064 0, /* todo_flags_start */
3065 TODO_update_ssa
, /* todo_flags_finish */
3068 class pass_fold_builtins
: public gimple_opt_pass
3071 pass_fold_builtins (gcc::context
*ctxt
)
3072 : gimple_opt_pass (pass_data_fold_builtins
, ctxt
)
3075 /* opt_pass methods: */
3076 opt_pass
* clone () { return new pass_fold_builtins (m_ctxt
); }
3077 virtual unsigned int execute (function
*);
3079 }; // class pass_fold_builtins
3082 pass_fold_builtins::execute (function
*fun
)
3084 bool cfg_changed
= false;
3086 unsigned int todoflags
= 0;
3088 FOR_EACH_BB_FN (bb
, fun
)
3090 gimple_stmt_iterator i
;
3091 for (i
= gsi_start_bb (bb
); !gsi_end_p (i
); )
3093 gimple
*stmt
, *old_stmt
;
3095 enum built_in_function fcode
;
3097 stmt
= gsi_stmt (i
);
3099 if (gimple_code (stmt
) != GIMPLE_CALL
)
3101 /* Remove all *ssaname_N ={v} {CLOBBER}; stmts,
3102 after the last GIMPLE DSE they aren't needed and might
3103 unnecessarily keep the SSA_NAMEs live. */
3104 if (gimple_clobber_p (stmt
))
3106 tree lhs
= gimple_assign_lhs (stmt
);
3107 if (TREE_CODE (lhs
) == MEM_REF
3108 && TREE_CODE (TREE_OPERAND (lhs
, 0)) == SSA_NAME
)
3110 unlink_stmt_vdef (stmt
);
3111 gsi_remove (&i
, true);
3112 release_defs (stmt
);
3116 else if (gimple_assign_load_p (stmt
) && gimple_store_p (stmt
))
3117 optimize_memcpy (&i
, gimple_assign_lhs (stmt
),
3118 gimple_assign_rhs1 (stmt
), NULL_TREE
);
3123 callee
= gimple_call_fndecl (stmt
);
3124 if (!callee
|| DECL_BUILT_IN_CLASS (callee
) != BUILT_IN_NORMAL
)
3130 fcode
= DECL_FUNCTION_CODE (callee
);
3135 tree result
= NULL_TREE
;
3136 switch (DECL_FUNCTION_CODE (callee
))
3138 case BUILT_IN_CONSTANT_P
:
3139 /* Resolve __builtin_constant_p. If it hasn't been
3140 folded to integer_one_node by now, it's fairly
3141 certain that the value simply isn't constant. */
3142 result
= integer_zero_node
;
3145 case BUILT_IN_ASSUME_ALIGNED
:
3146 /* Remove __builtin_assume_aligned. */
3147 result
= gimple_call_arg (stmt
, 0);
3150 case BUILT_IN_STACK_RESTORE
:
3151 result
= optimize_stack_restore (i
);
3157 case BUILT_IN_UNREACHABLE
:
3158 if (optimize_unreachable (i
))
3162 case BUILT_IN_ATOMIC_FETCH_OR_1
:
3163 case BUILT_IN_ATOMIC_FETCH_OR_2
:
3164 case BUILT_IN_ATOMIC_FETCH_OR_4
:
3165 case BUILT_IN_ATOMIC_FETCH_OR_8
:
3166 case BUILT_IN_ATOMIC_FETCH_OR_16
:
3167 optimize_atomic_bit_test_and (&i
,
3168 IFN_ATOMIC_BIT_TEST_AND_SET
,
3171 case BUILT_IN_SYNC_FETCH_AND_OR_1
:
3172 case BUILT_IN_SYNC_FETCH_AND_OR_2
:
3173 case BUILT_IN_SYNC_FETCH_AND_OR_4
:
3174 case BUILT_IN_SYNC_FETCH_AND_OR_8
:
3175 case BUILT_IN_SYNC_FETCH_AND_OR_16
:
3176 optimize_atomic_bit_test_and (&i
,
3177 IFN_ATOMIC_BIT_TEST_AND_SET
,
3181 case BUILT_IN_ATOMIC_FETCH_XOR_1
:
3182 case BUILT_IN_ATOMIC_FETCH_XOR_2
:
3183 case BUILT_IN_ATOMIC_FETCH_XOR_4
:
3184 case BUILT_IN_ATOMIC_FETCH_XOR_8
:
3185 case BUILT_IN_ATOMIC_FETCH_XOR_16
:
3186 optimize_atomic_bit_test_and
3187 (&i
, IFN_ATOMIC_BIT_TEST_AND_COMPLEMENT
, true, false);
3189 case BUILT_IN_SYNC_FETCH_AND_XOR_1
:
3190 case BUILT_IN_SYNC_FETCH_AND_XOR_2
:
3191 case BUILT_IN_SYNC_FETCH_AND_XOR_4
:
3192 case BUILT_IN_SYNC_FETCH_AND_XOR_8
:
3193 case BUILT_IN_SYNC_FETCH_AND_XOR_16
:
3194 optimize_atomic_bit_test_and
3195 (&i
, IFN_ATOMIC_BIT_TEST_AND_COMPLEMENT
, false, false);
3198 case BUILT_IN_ATOMIC_XOR_FETCH_1
:
3199 case BUILT_IN_ATOMIC_XOR_FETCH_2
:
3200 case BUILT_IN_ATOMIC_XOR_FETCH_4
:
3201 case BUILT_IN_ATOMIC_XOR_FETCH_8
:
3202 case BUILT_IN_ATOMIC_XOR_FETCH_16
:
3203 optimize_atomic_bit_test_and
3204 (&i
, IFN_ATOMIC_BIT_TEST_AND_COMPLEMENT
, true, true);
3206 case BUILT_IN_SYNC_XOR_AND_FETCH_1
:
3207 case BUILT_IN_SYNC_XOR_AND_FETCH_2
:
3208 case BUILT_IN_SYNC_XOR_AND_FETCH_4
:
3209 case BUILT_IN_SYNC_XOR_AND_FETCH_8
:
3210 case BUILT_IN_SYNC_XOR_AND_FETCH_16
:
3211 optimize_atomic_bit_test_and
3212 (&i
, IFN_ATOMIC_BIT_TEST_AND_COMPLEMENT
, false, true);
3215 case BUILT_IN_ATOMIC_FETCH_AND_1
:
3216 case BUILT_IN_ATOMIC_FETCH_AND_2
:
3217 case BUILT_IN_ATOMIC_FETCH_AND_4
:
3218 case BUILT_IN_ATOMIC_FETCH_AND_8
:
3219 case BUILT_IN_ATOMIC_FETCH_AND_16
:
3220 optimize_atomic_bit_test_and (&i
,
3221 IFN_ATOMIC_BIT_TEST_AND_RESET
,
3224 case BUILT_IN_SYNC_FETCH_AND_AND_1
:
3225 case BUILT_IN_SYNC_FETCH_AND_AND_2
:
3226 case BUILT_IN_SYNC_FETCH_AND_AND_4
:
3227 case BUILT_IN_SYNC_FETCH_AND_AND_8
:
3228 case BUILT_IN_SYNC_FETCH_AND_AND_16
:
3229 optimize_atomic_bit_test_and (&i
,
3230 IFN_ATOMIC_BIT_TEST_AND_RESET
,
3234 case BUILT_IN_MEMCPY
:
3235 if (gimple_call_builtin_p (stmt
, BUILT_IN_NORMAL
)
3236 && TREE_CODE (gimple_call_arg (stmt
, 0)) == ADDR_EXPR
3237 && TREE_CODE (gimple_call_arg (stmt
, 1)) == ADDR_EXPR
3238 && TREE_CODE (gimple_call_arg (stmt
, 2)) == INTEGER_CST
)
3240 tree dest
= TREE_OPERAND (gimple_call_arg (stmt
, 0), 0);
3241 tree src
= TREE_OPERAND (gimple_call_arg (stmt
, 1), 0);
3242 tree len
= gimple_call_arg (stmt
, 2);
3243 optimize_memcpy (&i
, dest
, src
, len
);
3247 case BUILT_IN_VA_START
:
3248 case BUILT_IN_VA_END
:
3249 case BUILT_IN_VA_COPY
:
3250 /* These shouldn't be folded before pass_stdarg. */
3251 result
= optimize_stdarg_builtin (stmt
);
3263 if (!update_call_from_tree (&i
, result
))
3264 gimplify_and_update_call_from_tree (&i
, result
);
3267 todoflags
|= TODO_update_address_taken
;
3269 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
3271 fprintf (dump_file
, "Simplified\n ");
3272 print_gimple_stmt (dump_file
, stmt
, 0, dump_flags
);
3276 stmt
= gsi_stmt (i
);
3279 if (maybe_clean_or_replace_eh_stmt (old_stmt
, stmt
)
3280 && gimple_purge_dead_eh_edges (bb
))
3283 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
3285 fprintf (dump_file
, "to\n ");
3286 print_gimple_stmt (dump_file
, stmt
, 0, dump_flags
);
3287 fprintf (dump_file
, "\n");
3290 /* Retry the same statement if it changed into another
3291 builtin, there might be new opportunities now. */
3292 if (gimple_code (stmt
) != GIMPLE_CALL
)
3297 callee
= gimple_call_fndecl (stmt
);
3299 || DECL_BUILT_IN_CLASS (callee
) != BUILT_IN_NORMAL
3300 || DECL_FUNCTION_CODE (callee
) == fcode
)
3305 /* Delete unreachable blocks. */
3307 todoflags
|= TODO_cleanup_cfg
;
3315 make_pass_fold_builtins (gcc::context
*ctxt
)
3317 return new pass_fold_builtins (ctxt
);