1 /* Conditional constant propagation pass for the GNU compiler.
2 Copyright (C) 2000-2019 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"
142 #include "stor-layout.h"
143 #include "optabs-query.h"
144 #include "tree-ssa-ccp.h"
145 #include "tree-dfa.h"
146 #include "diagnostic-core.h"
147 #include "stringpool.h"
149 #include "tree-vector-builder.h"
151 /* Possible lattice values. */
160 class ccp_prop_value_t
{
163 ccp_lattice_t lattice_val
;
165 /* Propagated value. */
168 /* Mask that applies to the propagated value during CCP. For X
169 with a CONSTANT lattice value X & ~mask == value & ~mask. The
170 zero bits in the mask cover constant values. The ones mean no
175 class ccp_propagate
: public ssa_propagation_engine
178 enum ssa_prop_result
visit_stmt (gimple
*, edge
*, tree
*) FINAL OVERRIDE
;
179 enum ssa_prop_result
visit_phi (gphi
*) FINAL OVERRIDE
;
182 /* Array of propagated constant values. After propagation,
183 CONST_VAL[I].VALUE holds the constant value for SSA_NAME(I). If
184 the constant is held in an SSA name representing a memory store
185 (i.e., a VDEF), CONST_VAL[I].MEM_REF will contain the actual
186 memory reference used to store (i.e., the LHS of the assignment
188 static ccp_prop_value_t
*const_val
;
189 static unsigned n_const_val
;
191 static void canonicalize_value (ccp_prop_value_t
*);
192 static void ccp_lattice_meet (ccp_prop_value_t
*, ccp_prop_value_t
*);
194 /* Dump constant propagation value VAL to file OUTF prefixed by PREFIX. */
197 dump_lattice_value (FILE *outf
, const char *prefix
, ccp_prop_value_t val
)
199 switch (val
.lattice_val
)
202 fprintf (outf
, "%sUNINITIALIZED", prefix
);
205 fprintf (outf
, "%sUNDEFINED", prefix
);
208 fprintf (outf
, "%sVARYING", prefix
);
211 if (TREE_CODE (val
.value
) != INTEGER_CST
214 fprintf (outf
, "%sCONSTANT ", prefix
);
215 print_generic_expr (outf
, val
.value
, dump_flags
);
219 widest_int cval
= wi::bit_and_not (wi::to_widest (val
.value
),
221 fprintf (outf
, "%sCONSTANT ", prefix
);
222 print_hex (cval
, outf
);
223 fprintf (outf
, " (");
224 print_hex (val
.mask
, outf
);
234 /* Print lattice value VAL to stderr. */
236 void debug_lattice_value (ccp_prop_value_t val
);
239 debug_lattice_value (ccp_prop_value_t val
)
241 dump_lattice_value (stderr
, "", val
);
242 fprintf (stderr
, "\n");
245 /* Extend NONZERO_BITS to a full mask, based on sgn. */
248 extend_mask (const wide_int
&nonzero_bits
, signop sgn
)
250 return widest_int::from (nonzero_bits
, sgn
);
253 /* Compute a default value for variable VAR and store it in the
254 CONST_VAL array. The following rules are used to get default
257 1- Global and static variables that are declared constant are
260 2- Any other value is considered UNDEFINED. This is useful when
261 considering PHI nodes. PHI arguments that are undefined do not
262 change the constant value of the PHI node, which allows for more
263 constants to be propagated.
265 3- Variables defined by statements other than assignments and PHI
266 nodes are considered VARYING.
268 4- Initial values of variables that are not GIMPLE registers are
269 considered VARYING. */
271 static ccp_prop_value_t
272 get_default_value (tree var
)
274 ccp_prop_value_t val
= { UNINITIALIZED
, NULL_TREE
, 0 };
277 stmt
= SSA_NAME_DEF_STMT (var
);
279 if (gimple_nop_p (stmt
))
281 /* Variables defined by an empty statement are those used
282 before being initialized. If VAR is a local variable, we
283 can assume initially that it is UNDEFINED, otherwise we must
284 consider it VARYING. */
285 if (!virtual_operand_p (var
)
286 && SSA_NAME_VAR (var
)
287 && TREE_CODE (SSA_NAME_VAR (var
)) == VAR_DECL
)
288 val
.lattice_val
= UNDEFINED
;
291 val
.lattice_val
= VARYING
;
293 if (flag_tree_bit_ccp
)
295 wide_int nonzero_bits
= get_nonzero_bits (var
);
296 if (nonzero_bits
!= -1)
298 val
.lattice_val
= CONSTANT
;
299 val
.value
= build_zero_cst (TREE_TYPE (var
));
300 val
.mask
= extend_mask (nonzero_bits
, TYPE_SIGN (TREE_TYPE (var
)));
305 else if (is_gimple_assign (stmt
))
308 if (gimple_assign_single_p (stmt
)
309 && DECL_P (gimple_assign_rhs1 (stmt
))
310 && (cst
= get_symbol_constant_value (gimple_assign_rhs1 (stmt
))))
312 val
.lattice_val
= CONSTANT
;
317 /* Any other variable defined by an assignment is considered
319 val
.lattice_val
= UNDEFINED
;
322 else if ((is_gimple_call (stmt
)
323 && gimple_call_lhs (stmt
) != NULL_TREE
)
324 || gimple_code (stmt
) == GIMPLE_PHI
)
326 /* A variable defined by a call or a PHI node is considered
328 val
.lattice_val
= UNDEFINED
;
332 /* Otherwise, VAR will never take on a constant value. */
333 val
.lattice_val
= VARYING
;
341 /* Get the constant value associated with variable VAR. */
343 static inline ccp_prop_value_t
*
346 ccp_prop_value_t
*val
;
348 if (const_val
== NULL
349 || SSA_NAME_VERSION (var
) >= n_const_val
)
352 val
= &const_val
[SSA_NAME_VERSION (var
)];
353 if (val
->lattice_val
== UNINITIALIZED
)
354 *val
= get_default_value (var
);
356 canonicalize_value (val
);
361 /* Return the constant tree value associated with VAR. */
364 get_constant_value (tree var
)
366 ccp_prop_value_t
*val
;
367 if (TREE_CODE (var
) != SSA_NAME
)
369 if (is_gimple_min_invariant (var
))
373 val
= get_value (var
);
375 && val
->lattice_val
== CONSTANT
376 && (TREE_CODE (val
->value
) != INTEGER_CST
382 /* Sets the value associated with VAR to VARYING. */
385 set_value_varying (tree var
)
387 ccp_prop_value_t
*val
= &const_val
[SSA_NAME_VERSION (var
)];
389 val
->lattice_val
= VARYING
;
390 val
->value
= NULL_TREE
;
394 /* For integer constants, make sure to drop TREE_OVERFLOW. */
397 canonicalize_value (ccp_prop_value_t
*val
)
399 if (val
->lattice_val
!= CONSTANT
)
402 if (TREE_OVERFLOW_P (val
->value
))
403 val
->value
= drop_tree_overflow (val
->value
);
406 /* Return whether the lattice transition is valid. */
409 valid_lattice_transition (ccp_prop_value_t old_val
, ccp_prop_value_t new_val
)
411 /* Lattice transitions must always be monotonically increasing in
413 if (old_val
.lattice_val
< new_val
.lattice_val
)
416 if (old_val
.lattice_val
!= new_val
.lattice_val
)
419 if (!old_val
.value
&& !new_val
.value
)
422 /* Now both lattice values are CONSTANT. */
424 /* Allow arbitrary copy changes as we might look through PHI <a_1, ...>
425 when only a single copy edge is executable. */
426 if (TREE_CODE (old_val
.value
) == SSA_NAME
427 && TREE_CODE (new_val
.value
) == SSA_NAME
)
430 /* Allow transitioning from a constant to a copy. */
431 if (is_gimple_min_invariant (old_val
.value
)
432 && TREE_CODE (new_val
.value
) == SSA_NAME
)
435 /* Allow transitioning from PHI <&x, not executable> == &x
436 to PHI <&x, &y> == common alignment. */
437 if (TREE_CODE (old_val
.value
) != INTEGER_CST
438 && TREE_CODE (new_val
.value
) == INTEGER_CST
)
441 /* Bit-lattices have to agree in the still valid bits. */
442 if (TREE_CODE (old_val
.value
) == INTEGER_CST
443 && TREE_CODE (new_val
.value
) == INTEGER_CST
)
444 return (wi::bit_and_not (wi::to_widest (old_val
.value
), new_val
.mask
)
445 == wi::bit_and_not (wi::to_widest (new_val
.value
), new_val
.mask
));
447 /* Otherwise constant values have to agree. */
448 if (operand_equal_p (old_val
.value
, new_val
.value
, 0))
451 /* At least the kinds and types should agree now. */
452 if (TREE_CODE (old_val
.value
) != TREE_CODE (new_val
.value
)
453 || !types_compatible_p (TREE_TYPE (old_val
.value
),
454 TREE_TYPE (new_val
.value
)))
457 /* For floats and !HONOR_NANS allow transitions from (partial) NaN
459 tree type
= TREE_TYPE (new_val
.value
);
460 if (SCALAR_FLOAT_TYPE_P (type
)
461 && !HONOR_NANS (type
))
463 if (REAL_VALUE_ISNAN (TREE_REAL_CST (old_val
.value
)))
466 else if (VECTOR_FLOAT_TYPE_P (type
)
467 && !HONOR_NANS (type
))
470 = tree_vector_builder::binary_encoded_nelts (old_val
.value
,
472 for (unsigned int i
= 0; i
< count
; ++i
)
473 if (!REAL_VALUE_ISNAN
474 (TREE_REAL_CST (VECTOR_CST_ENCODED_ELT (old_val
.value
, i
)))
475 && !operand_equal_p (VECTOR_CST_ENCODED_ELT (old_val
.value
, i
),
476 VECTOR_CST_ENCODED_ELT (new_val
.value
, i
), 0))
480 else if (COMPLEX_FLOAT_TYPE_P (type
)
481 && !HONOR_NANS (type
))
483 if (!REAL_VALUE_ISNAN (TREE_REAL_CST (TREE_REALPART (old_val
.value
)))
484 && !operand_equal_p (TREE_REALPART (old_val
.value
),
485 TREE_REALPART (new_val
.value
), 0))
487 if (!REAL_VALUE_ISNAN (TREE_REAL_CST (TREE_IMAGPART (old_val
.value
)))
488 && !operand_equal_p (TREE_IMAGPART (old_val
.value
),
489 TREE_IMAGPART (new_val
.value
), 0))
496 /* Set the value for variable VAR to NEW_VAL. Return true if the new
497 value is different from VAR's previous value. */
500 set_lattice_value (tree var
, ccp_prop_value_t
*new_val
)
502 /* We can deal with old UNINITIALIZED values just fine here. */
503 ccp_prop_value_t
*old_val
= &const_val
[SSA_NAME_VERSION (var
)];
505 canonicalize_value (new_val
);
507 /* We have to be careful to not go up the bitwise lattice
508 represented by the mask. Instead of dropping to VARYING
509 use the meet operator to retain a conservative value.
510 Missed optimizations like PR65851 makes this necessary.
511 It also ensures we converge to a stable lattice solution. */
512 if (old_val
->lattice_val
!= UNINITIALIZED
)
513 ccp_lattice_meet (new_val
, old_val
);
515 gcc_checking_assert (valid_lattice_transition (*old_val
, *new_val
));
517 /* If *OLD_VAL and NEW_VAL are the same, return false to inform the
518 caller that this was a non-transition. */
519 if (old_val
->lattice_val
!= new_val
->lattice_val
520 || (new_val
->lattice_val
== CONSTANT
521 && (TREE_CODE (new_val
->value
) != TREE_CODE (old_val
->value
)
522 || (TREE_CODE (new_val
->value
) == INTEGER_CST
523 && (new_val
->mask
!= old_val
->mask
524 || (wi::bit_and_not (wi::to_widest (old_val
->value
),
526 != wi::bit_and_not (wi::to_widest (new_val
->value
),
528 || (TREE_CODE (new_val
->value
) != INTEGER_CST
529 && !operand_equal_p (new_val
->value
, old_val
->value
, 0)))))
531 /* ??? We would like to delay creation of INTEGER_CSTs from
532 partially constants here. */
534 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
536 dump_lattice_value (dump_file
, "Lattice value changed to ", *new_val
);
537 fprintf (dump_file
, ". Adding SSA edges to worklist.\n");
542 gcc_assert (new_val
->lattice_val
!= UNINITIALIZED
);
549 static ccp_prop_value_t
get_value_for_expr (tree
, bool);
550 static ccp_prop_value_t
bit_value_binop (enum tree_code
, tree
, tree
, tree
);
551 void bit_value_binop (enum tree_code
, signop
, int, widest_int
*, widest_int
*,
552 signop
, int, const widest_int
&, const widest_int
&,
553 signop
, int, const widest_int
&, const widest_int
&);
555 /* Return a widest_int that can be used for bitwise simplifications
559 value_to_wide_int (ccp_prop_value_t val
)
562 && TREE_CODE (val
.value
) == INTEGER_CST
)
563 return wi::to_widest (val
.value
);
568 /* Return the value for the address expression EXPR based on alignment
571 static ccp_prop_value_t
572 get_value_from_alignment (tree expr
)
574 tree type
= TREE_TYPE (expr
);
575 ccp_prop_value_t val
;
576 unsigned HOST_WIDE_INT bitpos
;
579 gcc_assert (TREE_CODE (expr
) == ADDR_EXPR
);
581 get_pointer_alignment_1 (expr
, &align
, &bitpos
);
582 val
.mask
= wi::bit_and_not
583 (POINTER_TYPE_P (type
) || TYPE_UNSIGNED (type
)
584 ? wi::mask
<widest_int
> (TYPE_PRECISION (type
), false)
586 align
/ BITS_PER_UNIT
- 1);
588 = wi::sext (val
.mask
, TYPE_PRECISION (type
)) == -1 ? VARYING
: CONSTANT
;
589 if (val
.lattice_val
== CONSTANT
)
590 val
.value
= build_int_cstu (type
, bitpos
/ BITS_PER_UNIT
);
592 val
.value
= NULL_TREE
;
597 /* Return the value for the tree operand EXPR. If FOR_BITS_P is true
598 return constant bits extracted from alignment information for
599 invariant addresses. */
601 static ccp_prop_value_t
602 get_value_for_expr (tree expr
, bool for_bits_p
)
604 ccp_prop_value_t val
;
606 if (TREE_CODE (expr
) == SSA_NAME
)
608 ccp_prop_value_t
*val_
= get_value (expr
);
613 val
.lattice_val
= VARYING
;
614 val
.value
= NULL_TREE
;
618 && val
.lattice_val
== CONSTANT
)
620 if (TREE_CODE (val
.value
) == ADDR_EXPR
)
621 val
= get_value_from_alignment (val
.value
);
622 else if (TREE_CODE (val
.value
) != INTEGER_CST
)
624 val
.lattice_val
= VARYING
;
625 val
.value
= NULL_TREE
;
629 /* Fall back to a copy value. */
631 && val
.lattice_val
== VARYING
632 && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (expr
))
634 val
.lattice_val
= CONSTANT
;
639 else if (is_gimple_min_invariant (expr
)
640 && (!for_bits_p
|| TREE_CODE (expr
) == INTEGER_CST
))
642 val
.lattice_val
= CONSTANT
;
645 canonicalize_value (&val
);
647 else if (TREE_CODE (expr
) == ADDR_EXPR
)
648 val
= get_value_from_alignment (expr
);
651 val
.lattice_val
= VARYING
;
653 val
.value
= NULL_TREE
;
656 if (val
.lattice_val
== VARYING
657 && TYPE_UNSIGNED (TREE_TYPE (expr
)))
658 val
.mask
= wi::zext (val
.mask
, TYPE_PRECISION (TREE_TYPE (expr
)));
663 /* Return the likely CCP lattice value for STMT.
665 If STMT has no operands, then return CONSTANT.
667 Else if undefinedness of operands of STMT cause its value to be
668 undefined, then return UNDEFINED.
670 Else if any operands of STMT are constants, then return CONSTANT.
672 Else return VARYING. */
675 likely_value (gimple
*stmt
)
677 bool has_constant_operand
, has_undefined_operand
, all_undefined_operands
;
678 bool has_nsa_operand
;
683 enum gimple_code code
= gimple_code (stmt
);
685 /* This function appears to be called only for assignments, calls,
686 conditionals, and switches, due to the logic in visit_stmt. */
687 gcc_assert (code
== GIMPLE_ASSIGN
688 || code
== GIMPLE_CALL
689 || code
== GIMPLE_COND
690 || code
== GIMPLE_SWITCH
);
692 /* If the statement has volatile operands, it won't fold to a
694 if (gimple_has_volatile_ops (stmt
))
697 /* Arrive here for more complex cases. */
698 has_constant_operand
= false;
699 has_undefined_operand
= false;
700 all_undefined_operands
= true;
701 has_nsa_operand
= false;
702 FOR_EACH_SSA_TREE_OPERAND (use
, stmt
, iter
, SSA_OP_USE
)
704 ccp_prop_value_t
*val
= get_value (use
);
706 if (val
&& val
->lattice_val
== UNDEFINED
)
707 has_undefined_operand
= true;
709 all_undefined_operands
= false;
711 if (val
&& val
->lattice_val
== CONSTANT
)
712 has_constant_operand
= true;
714 if (SSA_NAME_IS_DEFAULT_DEF (use
)
715 || !prop_simulate_again_p (SSA_NAME_DEF_STMT (use
)))
716 has_nsa_operand
= true;
719 /* There may be constants in regular rhs operands. For calls we
720 have to ignore lhs, fndecl and static chain, otherwise only
722 for (i
= (is_gimple_call (stmt
) ? 2 : 0) + gimple_has_lhs (stmt
);
723 i
< gimple_num_ops (stmt
); ++i
)
725 tree op
= gimple_op (stmt
, i
);
726 if (!op
|| TREE_CODE (op
) == SSA_NAME
)
728 if (is_gimple_min_invariant (op
))
729 has_constant_operand
= true;
732 if (has_constant_operand
)
733 all_undefined_operands
= false;
735 if (has_undefined_operand
736 && code
== GIMPLE_CALL
737 && gimple_call_internal_p (stmt
))
738 switch (gimple_call_internal_fn (stmt
))
740 /* These 3 builtins use the first argument just as a magic
741 way how to find out a decl uid. */
742 case IFN_GOMP_SIMD_LANE
:
743 case IFN_GOMP_SIMD_VF
:
744 case IFN_GOMP_SIMD_LAST_LANE
:
745 has_undefined_operand
= false;
751 /* If the operation combines operands like COMPLEX_EXPR make sure to
752 not mark the result UNDEFINED if only one part of the result is
754 if (has_undefined_operand
&& all_undefined_operands
)
756 else if (code
== GIMPLE_ASSIGN
&& has_undefined_operand
)
758 switch (gimple_assign_rhs_code (stmt
))
760 /* Unary operators are handled with all_undefined_operands. */
763 case POINTER_PLUS_EXPR
:
765 /* Not MIN_EXPR, MAX_EXPR. One VARYING operand may be selected.
766 Not bitwise operators, one VARYING operand may specify the
768 Not logical operators for the same reason, apart from XOR.
769 Not COMPLEX_EXPR as one VARYING operand makes the result partly
770 not UNDEFINED. Not *DIV_EXPR, comparisons and shifts because
771 the undefined operand may be promoted. */
775 /* If any part of an address is UNDEFINED, like the index
776 of an ARRAY_EXPR, then treat the result as UNDEFINED. */
783 /* If there was an UNDEFINED operand but the result may be not UNDEFINED
784 fall back to CONSTANT. During iteration UNDEFINED may still drop
786 if (has_undefined_operand
)
789 /* We do not consider virtual operands here -- load from read-only
790 memory may have only VARYING virtual operands, but still be
791 constant. Also we can combine the stmt with definitions from
792 operands whose definitions are not simulated again. */
793 if (has_constant_operand
795 || gimple_references_memory_p (stmt
))
801 /* Returns true if STMT cannot be constant. */
804 surely_varying_stmt_p (gimple
*stmt
)
806 /* If the statement has operands that we cannot handle, it cannot be
808 if (gimple_has_volatile_ops (stmt
))
811 /* If it is a call and does not return a value or is not a
812 builtin and not an indirect call or a call to function with
813 assume_aligned/alloc_align attribute, it is varying. */
814 if (is_gimple_call (stmt
))
816 tree fndecl
, fntype
= gimple_call_fntype (stmt
);
817 if (!gimple_call_lhs (stmt
)
818 || ((fndecl
= gimple_call_fndecl (stmt
)) != NULL_TREE
819 && !fndecl_built_in_p (fndecl
)
820 && !lookup_attribute ("assume_aligned",
821 TYPE_ATTRIBUTES (fntype
))
822 && !lookup_attribute ("alloc_align",
823 TYPE_ATTRIBUTES (fntype
))))
827 /* Any other store operation is not interesting. */
828 else if (gimple_vdef (stmt
))
831 /* Anything other than assignments and conditional jumps are not
832 interesting for CCP. */
833 if (gimple_code (stmt
) != GIMPLE_ASSIGN
834 && gimple_code (stmt
) != GIMPLE_COND
835 && gimple_code (stmt
) != GIMPLE_SWITCH
836 && gimple_code (stmt
) != GIMPLE_CALL
)
842 /* Initialize local data structures for CCP. */
845 ccp_initialize (void)
849 n_const_val
= num_ssa_names
;
850 const_val
= XCNEWVEC (ccp_prop_value_t
, n_const_val
);
852 /* Initialize simulation flags for PHI nodes and statements. */
853 FOR_EACH_BB_FN (bb
, cfun
)
855 gimple_stmt_iterator i
;
857 for (i
= gsi_start_bb (bb
); !gsi_end_p (i
); gsi_next (&i
))
859 gimple
*stmt
= gsi_stmt (i
);
862 /* If the statement is a control insn, then we do not
863 want to avoid simulating the statement once. Failure
864 to do so means that those edges will never get added. */
865 if (stmt_ends_bb_p (stmt
))
868 is_varying
= surely_varying_stmt_p (stmt
);
875 /* If the statement will not produce a constant, mark
876 all its outputs VARYING. */
877 FOR_EACH_SSA_TREE_OPERAND (def
, stmt
, iter
, SSA_OP_ALL_DEFS
)
878 set_value_varying (def
);
880 prop_set_simulate_again (stmt
, !is_varying
);
884 /* Now process PHI nodes. We never clear the simulate_again flag on
885 phi nodes, since we do not know which edges are executable yet,
886 except for phi nodes for virtual operands when we do not do store ccp. */
887 FOR_EACH_BB_FN (bb
, cfun
)
891 for (i
= gsi_start_phis (bb
); !gsi_end_p (i
); gsi_next (&i
))
893 gphi
*phi
= i
.phi ();
895 if (virtual_operand_p (gimple_phi_result (phi
)))
896 prop_set_simulate_again (phi
, false);
898 prop_set_simulate_again (phi
, true);
903 /* Debug count support. Reset the values of ssa names
904 VARYING when the total number ssa names analyzed is
905 beyond the debug count specified. */
911 for (i
= 0; i
< num_ssa_names
; i
++)
915 const_val
[i
].lattice_val
= VARYING
;
916 const_val
[i
].mask
= -1;
917 const_val
[i
].value
= NULL_TREE
;
923 /* We want to provide our own GET_VALUE and FOLD_STMT virtual methods. */
924 class ccp_folder
: public substitute_and_fold_engine
927 tree
get_value (tree
) FINAL OVERRIDE
;
928 bool fold_stmt (gimple_stmt_iterator
*) FINAL OVERRIDE
;
931 /* This method just wraps GET_CONSTANT_VALUE for now. Over time
932 naked calls to GET_CONSTANT_VALUE should be eliminated in favor
933 of calling member functions. */
936 ccp_folder::get_value (tree op
)
938 return get_constant_value (op
);
941 /* Do final substitution of propagated values, cleanup the flowgraph and
942 free allocated storage. If NONZERO_P, record nonzero bits.
944 Return TRUE when something was optimized. */
947 ccp_finalize (bool nonzero_p
)
949 bool something_changed
;
955 /* Derive alignment and misalignment information from partially
956 constant pointers in the lattice or nonzero bits from partially
957 constant integers. */
958 FOR_EACH_SSA_NAME (i
, name
, cfun
)
960 ccp_prop_value_t
*val
;
961 unsigned int tem
, align
;
963 if (!POINTER_TYPE_P (TREE_TYPE (name
))
964 && (!INTEGRAL_TYPE_P (TREE_TYPE (name
))
965 /* Don't record nonzero bits before IPA to avoid
966 using too much memory. */
970 val
= get_value (name
);
971 if (val
->lattice_val
!= CONSTANT
972 || TREE_CODE (val
->value
) != INTEGER_CST
976 if (POINTER_TYPE_P (TREE_TYPE (name
)))
978 /* Trailing mask bits specify the alignment, trailing value
979 bits the misalignment. */
980 tem
= val
->mask
.to_uhwi ();
981 align
= least_bit_hwi (tem
);
983 set_ptr_info_alignment (get_ptr_info (name
), align
,
984 (TREE_INT_CST_LOW (val
->value
)
989 unsigned int precision
= TYPE_PRECISION (TREE_TYPE (val
->value
));
990 wide_int nonzero_bits
991 = (wide_int::from (val
->mask
, precision
, UNSIGNED
)
992 | wi::to_wide (val
->value
));
993 nonzero_bits
&= get_nonzero_bits (name
);
994 set_nonzero_bits (name
, nonzero_bits
);
998 /* Perform substitutions based on the known constant values. */
999 class ccp_folder ccp_folder
;
1000 something_changed
= ccp_folder
.substitute_and_fold ();
1004 return something_changed
;
1008 /* Compute the meet operator between *VAL1 and *VAL2. Store the result
1011 any M UNDEFINED = any
1012 any M VARYING = VARYING
1013 Ci M Cj = Ci if (i == j)
1014 Ci M Cj = VARYING if (i != j)
1018 ccp_lattice_meet (ccp_prop_value_t
*val1
, ccp_prop_value_t
*val2
)
1020 if (val1
->lattice_val
== UNDEFINED
1021 /* For UNDEFINED M SSA we can't always SSA because its definition
1022 may not dominate the PHI node. Doing optimistic copy propagation
1023 also causes a lot of gcc.dg/uninit-pred*.c FAILs. */
1024 && (val2
->lattice_val
!= CONSTANT
1025 || TREE_CODE (val2
->value
) != SSA_NAME
))
1027 /* UNDEFINED M any = any */
1030 else if (val2
->lattice_val
== UNDEFINED
1032 && (val1
->lattice_val
!= CONSTANT
1033 || TREE_CODE (val1
->value
) != SSA_NAME
))
1035 /* any M UNDEFINED = any
1036 Nothing to do. VAL1 already contains the value we want. */
1039 else if (val1
->lattice_val
== VARYING
1040 || val2
->lattice_val
== VARYING
)
1042 /* any M VARYING = VARYING. */
1043 val1
->lattice_val
= VARYING
;
1045 val1
->value
= NULL_TREE
;
1047 else if (val1
->lattice_val
== CONSTANT
1048 && val2
->lattice_val
== CONSTANT
1049 && TREE_CODE (val1
->value
) == INTEGER_CST
1050 && TREE_CODE (val2
->value
) == INTEGER_CST
)
1052 /* Ci M Cj = Ci if (i == j)
1053 Ci M Cj = VARYING if (i != j)
1055 For INTEGER_CSTs mask unequal bits. If no equal bits remain,
1057 val1
->mask
= (val1
->mask
| val2
->mask
1058 | (wi::to_widest (val1
->value
)
1059 ^ wi::to_widest (val2
->value
)));
1060 if (wi::sext (val1
->mask
, TYPE_PRECISION (TREE_TYPE (val1
->value
))) == -1)
1062 val1
->lattice_val
= VARYING
;
1063 val1
->value
= NULL_TREE
;
1066 else if (val1
->lattice_val
== CONSTANT
1067 && val2
->lattice_val
== CONSTANT
1068 && operand_equal_p (val1
->value
, val2
->value
, 0))
1070 /* Ci M Cj = Ci if (i == j)
1071 Ci M Cj = VARYING if (i != j)
1073 VAL1 already contains the value we want for equivalent values. */
1075 else if (val1
->lattice_val
== CONSTANT
1076 && val2
->lattice_val
== CONSTANT
1077 && (TREE_CODE (val1
->value
) == ADDR_EXPR
1078 || TREE_CODE (val2
->value
) == ADDR_EXPR
))
1080 /* When not equal addresses are involved try meeting for
1082 ccp_prop_value_t tem
= *val2
;
1083 if (TREE_CODE (val1
->value
) == ADDR_EXPR
)
1084 *val1
= get_value_for_expr (val1
->value
, true);
1085 if (TREE_CODE (val2
->value
) == ADDR_EXPR
)
1086 tem
= get_value_for_expr (val2
->value
, true);
1087 ccp_lattice_meet (val1
, &tem
);
1091 /* Any other combination is VARYING. */
1092 val1
->lattice_val
= VARYING
;
1094 val1
->value
= NULL_TREE
;
1099 /* Loop through the PHI_NODE's parameters for BLOCK and compare their
1100 lattice values to determine PHI_NODE's lattice value. The value of a
1101 PHI node is determined calling ccp_lattice_meet with all the arguments
1102 of the PHI node that are incoming via executable edges. */
1104 enum ssa_prop_result
1105 ccp_propagate::visit_phi (gphi
*phi
)
1108 ccp_prop_value_t new_val
;
1110 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1112 fprintf (dump_file
, "\nVisiting PHI node: ");
1113 print_gimple_stmt (dump_file
, phi
, 0, dump_flags
);
1116 new_val
.lattice_val
= UNDEFINED
;
1117 new_val
.value
= NULL_TREE
;
1121 bool non_exec_edge
= false;
1122 for (i
= 0; i
< gimple_phi_num_args (phi
); i
++)
1124 /* Compute the meet operator over all the PHI arguments flowing
1125 through executable edges. */
1126 edge e
= gimple_phi_arg_edge (phi
, i
);
1128 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1131 "\tArgument #%d (%d -> %d %sexecutable)\n",
1132 i
, e
->src
->index
, e
->dest
->index
,
1133 (e
->flags
& EDGE_EXECUTABLE
) ? "" : "not ");
1136 /* If the incoming edge is executable, Compute the meet operator for
1137 the existing value of the PHI node and the current PHI argument. */
1138 if (e
->flags
& EDGE_EXECUTABLE
)
1140 tree arg
= gimple_phi_arg (phi
, i
)->def
;
1141 ccp_prop_value_t arg_val
= get_value_for_expr (arg
, false);
1149 ccp_lattice_meet (&new_val
, &arg_val
);
1151 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1153 fprintf (dump_file
, "\t");
1154 print_generic_expr (dump_file
, arg
, dump_flags
);
1155 dump_lattice_value (dump_file
, "\tValue: ", arg_val
);
1156 fprintf (dump_file
, "\n");
1159 if (new_val
.lattice_val
== VARYING
)
1163 non_exec_edge
= true;
1166 /* In case there were non-executable edges and the value is a copy
1167 make sure its definition dominates the PHI node. */
1169 && new_val
.lattice_val
== CONSTANT
1170 && TREE_CODE (new_val
.value
) == SSA_NAME
1171 && ! SSA_NAME_IS_DEFAULT_DEF (new_val
.value
)
1172 && ! dominated_by_p (CDI_DOMINATORS
, gimple_bb (phi
),
1173 gimple_bb (SSA_NAME_DEF_STMT (new_val
.value
))))
1175 new_val
.lattice_val
= VARYING
;
1176 new_val
.value
= NULL_TREE
;
1180 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1182 dump_lattice_value (dump_file
, "\n PHI node value: ", new_val
);
1183 fprintf (dump_file
, "\n\n");
1186 /* Make the transition to the new value. */
1187 if (set_lattice_value (gimple_phi_result (phi
), &new_val
))
1189 if (new_val
.lattice_val
== VARYING
)
1190 return SSA_PROP_VARYING
;
1192 return SSA_PROP_INTERESTING
;
1195 return SSA_PROP_NOT_INTERESTING
;
1198 /* Return the constant value for OP or OP otherwise. */
1201 valueize_op (tree op
)
1203 if (TREE_CODE (op
) == SSA_NAME
)
1205 tree tem
= get_constant_value (op
);
1212 /* Return the constant value for OP, but signal to not follow SSA
1213 edges if the definition may be simulated again. */
1216 valueize_op_1 (tree op
)
1218 if (TREE_CODE (op
) == SSA_NAME
)
1220 /* If the definition may be simulated again we cannot follow
1221 this SSA edge as the SSA propagator does not necessarily
1222 re-visit the use. */
1223 gimple
*def_stmt
= SSA_NAME_DEF_STMT (op
);
1224 if (!gimple_nop_p (def_stmt
)
1225 && prop_simulate_again_p (def_stmt
))
1227 tree tem
= get_constant_value (op
);
1234 /* CCP specific front-end to the non-destructive constant folding
1237 Attempt to simplify the RHS of STMT knowing that one or more
1238 operands are constants.
1240 If simplification is possible, return the simplified RHS,
1241 otherwise return the original RHS or NULL_TREE. */
1244 ccp_fold (gimple
*stmt
)
1246 location_t loc
= gimple_location (stmt
);
1247 switch (gimple_code (stmt
))
1251 /* Handle comparison operators that can appear in GIMPLE form. */
1252 tree op0
= valueize_op (gimple_cond_lhs (stmt
));
1253 tree op1
= valueize_op (gimple_cond_rhs (stmt
));
1254 enum tree_code code
= gimple_cond_code (stmt
);
1255 return fold_binary_loc (loc
, code
, boolean_type_node
, op0
, op1
);
1260 /* Return the constant switch index. */
1261 return valueize_op (gimple_switch_index (as_a
<gswitch
*> (stmt
)));
1266 return gimple_fold_stmt_to_constant_1 (stmt
,
1267 valueize_op
, valueize_op_1
);
1274 /* Apply the operation CODE in type TYPE to the value, mask pair
1275 RVAL and RMASK representing a value of type RTYPE and set
1276 the value, mask pair *VAL and *MASK to the result. */
1279 bit_value_unop (enum tree_code code
, signop type_sgn
, int type_precision
,
1280 widest_int
*val
, widest_int
*mask
,
1281 signop rtype_sgn
, int rtype_precision
,
1282 const widest_int
&rval
, const widest_int
&rmask
)
1293 widest_int temv
, temm
;
1294 /* Return ~rval + 1. */
1295 bit_value_unop (BIT_NOT_EXPR
, type_sgn
, type_precision
, &temv
, &temm
,
1296 type_sgn
, type_precision
, rval
, rmask
);
1297 bit_value_binop (PLUS_EXPR
, type_sgn
, type_precision
, val
, mask
,
1298 type_sgn
, type_precision
, temv
, temm
,
1299 type_sgn
, type_precision
, 1, 0);
1305 /* First extend mask and value according to the original type. */
1306 *mask
= wi::ext (rmask
, rtype_precision
, rtype_sgn
);
1307 *val
= wi::ext (rval
, rtype_precision
, rtype_sgn
);
1309 /* Then extend mask and value according to the target type. */
1310 *mask
= wi::ext (*mask
, type_precision
, type_sgn
);
1311 *val
= wi::ext (*val
, type_precision
, type_sgn
);
1321 /* Apply the operation CODE in type TYPE to the value, mask pairs
1322 R1VAL, R1MASK and R2VAL, R2MASK representing a values of type R1TYPE
1323 and R2TYPE and set the value, mask pair *VAL and *MASK to the result. */
1326 bit_value_binop (enum tree_code code
, signop sgn
, int width
,
1327 widest_int
*val
, widest_int
*mask
,
1328 signop r1type_sgn
, int r1type_precision
,
1329 const widest_int
&r1val
, const widest_int
&r1mask
,
1330 signop r2type_sgn
, int r2type_precision
,
1331 const widest_int
&r2val
, const widest_int
&r2mask
)
1333 bool swap_p
= false;
1335 /* Assume we'll get a constant result. Use an initial non varying
1336 value, we fall back to varying in the end if necessary. */
1342 /* The mask is constant where there is a known not
1343 set bit, (m1 | m2) & ((v1 | m1) & (v2 | m2)) */
1344 *mask
= (r1mask
| r2mask
) & (r1val
| r1mask
) & (r2val
| r2mask
);
1345 *val
= r1val
& r2val
;
1349 /* The mask is constant where there is a known
1350 set bit, (m1 | m2) & ~((v1 & ~m1) | (v2 & ~m2)). */
1351 *mask
= wi::bit_and_not (r1mask
| r2mask
,
1352 wi::bit_and_not (r1val
, r1mask
)
1353 | wi::bit_and_not (r2val
, r2mask
));
1354 *val
= r1val
| r2val
;
1359 *mask
= r1mask
| r2mask
;
1360 *val
= r1val
^ r2val
;
1367 widest_int shift
= r2val
;
1375 if (wi::neg_p (shift
))
1378 if (code
== RROTATE_EXPR
)
1379 code
= LROTATE_EXPR
;
1381 code
= RROTATE_EXPR
;
1383 if (code
== RROTATE_EXPR
)
1385 *mask
= wi::rrotate (r1mask
, shift
, width
);
1386 *val
= wi::rrotate (r1val
, shift
, width
);
1390 *mask
= wi::lrotate (r1mask
, shift
, width
);
1391 *val
= wi::lrotate (r1val
, shift
, width
);
1399 /* ??? We can handle partially known shift counts if we know
1400 its sign. That way we can tell that (x << (y | 8)) & 255
1404 widest_int shift
= r2val
;
1412 if (wi::neg_p (shift
))
1415 if (code
== RSHIFT_EXPR
)
1420 if (code
== RSHIFT_EXPR
)
1422 *mask
= wi::rshift (wi::ext (r1mask
, width
, sgn
), shift
, sgn
);
1423 *val
= wi::rshift (wi::ext (r1val
, width
, sgn
), shift
, sgn
);
1427 *mask
= wi::ext (r1mask
<< shift
, width
, sgn
);
1428 *val
= wi::ext (r1val
<< shift
, width
, sgn
);
1435 case POINTER_PLUS_EXPR
:
1437 /* Do the addition with unknown bits set to zero, to give carry-ins of
1438 zero wherever possible. */
1439 widest_int lo
= (wi::bit_and_not (r1val
, r1mask
)
1440 + wi::bit_and_not (r2val
, r2mask
));
1441 lo
= wi::ext (lo
, width
, sgn
);
1442 /* Do the addition with unknown bits set to one, to give carry-ins of
1443 one wherever possible. */
1444 widest_int hi
= (r1val
| r1mask
) + (r2val
| r2mask
);
1445 hi
= wi::ext (hi
, width
, sgn
);
1446 /* Each bit in the result is known if (a) the corresponding bits in
1447 both inputs are known, and (b) the carry-in to that bit position
1448 is known. We can check condition (b) by seeing if we got the same
1449 result with minimised carries as with maximised carries. */
1450 *mask
= r1mask
| r2mask
| (lo
^ hi
);
1451 *mask
= wi::ext (*mask
, width
, sgn
);
1452 /* It shouldn't matter whether we choose lo or hi here. */
1459 widest_int temv
, temm
;
1460 bit_value_unop (NEGATE_EXPR
, r2type_sgn
, r2type_precision
, &temv
, &temm
,
1461 r2type_sgn
, r2type_precision
, r2val
, r2mask
);
1462 bit_value_binop (PLUS_EXPR
, sgn
, width
, val
, mask
,
1463 r1type_sgn
, r1type_precision
, r1val
, r1mask
,
1464 r2type_sgn
, r2type_precision
, temv
, temm
);
1470 /* Just track trailing zeros in both operands and transfer
1471 them to the other. */
1472 int r1tz
= wi::ctz (r1val
| r1mask
);
1473 int r2tz
= wi::ctz (r2val
| r2mask
);
1474 if (r1tz
+ r2tz
>= width
)
1479 else if (r1tz
+ r2tz
> 0)
1481 *mask
= wi::ext (wi::mask
<widest_int
> (r1tz
+ r2tz
, true),
1491 widest_int m
= r1mask
| r2mask
;
1492 if (wi::bit_and_not (r1val
, m
) != wi::bit_and_not (r2val
, m
))
1495 *val
= ((code
== EQ_EXPR
) ? 0 : 1);
1499 /* We know the result of a comparison is always one or zero. */
1509 code
= swap_tree_comparison (code
);
1516 const widest_int
&o1val
= swap_p
? r2val
: r1val
;
1517 const widest_int
&o1mask
= swap_p
? r2mask
: r1mask
;
1518 const widest_int
&o2val
= swap_p
? r1val
: r2val
;
1519 const widest_int
&o2mask
= swap_p
? r1mask
: r2mask
;
1521 /* If the most significant bits are not known we know nothing. */
1522 if (wi::neg_p (o1mask
) || wi::neg_p (o2mask
))
1525 /* For comparisons the signedness is in the comparison operands. */
1528 /* If we know the most significant bits we know the values
1529 value ranges by means of treating varying bits as zero
1530 or one. Do a cross comparison of the max/min pairs. */
1531 maxmin
= wi::cmp (o1val
| o1mask
,
1532 wi::bit_and_not (o2val
, o2mask
), sgn
);
1533 minmax
= wi::cmp (wi::bit_and_not (o1val
, o1mask
),
1534 o2val
| o2mask
, sgn
);
1535 if (maxmin
< 0) /* o1 is less than o2. */
1540 else if (minmax
> 0) /* o1 is not less or equal to o2. */
1545 else if (maxmin
== minmax
) /* o1 and o2 are equal. */
1547 /* This probably should never happen as we'd have
1548 folded the thing during fully constant value folding. */
1550 *val
= (code
== LE_EXPR
? 1 : 0);
1554 /* We know the result of a comparison is always one or zero. */
1565 /* Return the propagation value when applying the operation CODE to
1566 the value RHS yielding type TYPE. */
1568 static ccp_prop_value_t
1569 bit_value_unop (enum tree_code code
, tree type
, tree rhs
)
1571 ccp_prop_value_t rval
= get_value_for_expr (rhs
, true);
1572 widest_int value
, mask
;
1573 ccp_prop_value_t val
;
1575 if (rval
.lattice_val
== UNDEFINED
)
1578 gcc_assert ((rval
.lattice_val
== CONSTANT
1579 && TREE_CODE (rval
.value
) == INTEGER_CST
)
1580 || wi::sext (rval
.mask
, TYPE_PRECISION (TREE_TYPE (rhs
))) == -1);
1581 bit_value_unop (code
, TYPE_SIGN (type
), TYPE_PRECISION (type
), &value
, &mask
,
1582 TYPE_SIGN (TREE_TYPE (rhs
)), TYPE_PRECISION (TREE_TYPE (rhs
)),
1583 value_to_wide_int (rval
), rval
.mask
);
1584 if (wi::sext (mask
, TYPE_PRECISION (type
)) != -1)
1586 val
.lattice_val
= CONSTANT
;
1588 /* ??? Delay building trees here. */
1589 val
.value
= wide_int_to_tree (type
, value
);
1593 val
.lattice_val
= VARYING
;
1594 val
.value
= NULL_TREE
;
1600 /* Return the propagation value when applying the operation CODE to
1601 the values RHS1 and RHS2 yielding type TYPE. */
1603 static ccp_prop_value_t
1604 bit_value_binop (enum tree_code code
, tree type
, tree rhs1
, tree rhs2
)
1606 ccp_prop_value_t r1val
= get_value_for_expr (rhs1
, true);
1607 ccp_prop_value_t r2val
= get_value_for_expr (rhs2
, true);
1608 widest_int value
, mask
;
1609 ccp_prop_value_t val
;
1611 if (r1val
.lattice_val
== UNDEFINED
1612 || r2val
.lattice_val
== UNDEFINED
)
1614 val
.lattice_val
= VARYING
;
1615 val
.value
= NULL_TREE
;
1620 gcc_assert ((r1val
.lattice_val
== CONSTANT
1621 && TREE_CODE (r1val
.value
) == INTEGER_CST
)
1622 || wi::sext (r1val
.mask
,
1623 TYPE_PRECISION (TREE_TYPE (rhs1
))) == -1);
1624 gcc_assert ((r2val
.lattice_val
== CONSTANT
1625 && TREE_CODE (r2val
.value
) == INTEGER_CST
)
1626 || wi::sext (r2val
.mask
,
1627 TYPE_PRECISION (TREE_TYPE (rhs2
))) == -1);
1628 bit_value_binop (code
, TYPE_SIGN (type
), TYPE_PRECISION (type
), &value
, &mask
,
1629 TYPE_SIGN (TREE_TYPE (rhs1
)), TYPE_PRECISION (TREE_TYPE (rhs1
)),
1630 value_to_wide_int (r1val
), r1val
.mask
,
1631 TYPE_SIGN (TREE_TYPE (rhs2
)), TYPE_PRECISION (TREE_TYPE (rhs2
)),
1632 value_to_wide_int (r2val
), r2val
.mask
);
1634 if (wi::sext (mask
, TYPE_PRECISION (type
)) != -1)
1636 val
.lattice_val
= CONSTANT
;
1638 /* ??? Delay building trees here. */
1639 val
.value
= wide_int_to_tree (type
, value
);
1643 val
.lattice_val
= VARYING
;
1644 val
.value
= NULL_TREE
;
1650 /* Return the propagation value for __builtin_assume_aligned
1651 and functions with assume_aligned or alloc_aligned attribute.
1652 For __builtin_assume_aligned, ATTR is NULL_TREE,
1653 for assume_aligned attribute ATTR is non-NULL and ALLOC_ALIGNED
1654 is false, for alloc_aligned attribute ATTR is non-NULL and
1655 ALLOC_ALIGNED is true. */
1657 static ccp_prop_value_t
1658 bit_value_assume_aligned (gimple
*stmt
, tree attr
, ccp_prop_value_t ptrval
,
1661 tree align
, misalign
= NULL_TREE
, type
;
1662 unsigned HOST_WIDE_INT aligni
, misaligni
= 0;
1663 ccp_prop_value_t alignval
;
1664 widest_int value
, mask
;
1665 ccp_prop_value_t val
;
1667 if (attr
== NULL_TREE
)
1669 tree ptr
= gimple_call_arg (stmt
, 0);
1670 type
= TREE_TYPE (ptr
);
1671 ptrval
= get_value_for_expr (ptr
, true);
1675 tree lhs
= gimple_call_lhs (stmt
);
1676 type
= TREE_TYPE (lhs
);
1679 if (ptrval
.lattice_val
== UNDEFINED
)
1681 gcc_assert ((ptrval
.lattice_val
== CONSTANT
1682 && TREE_CODE (ptrval
.value
) == INTEGER_CST
)
1683 || wi::sext (ptrval
.mask
, TYPE_PRECISION (type
)) == -1);
1684 if (attr
== NULL_TREE
)
1686 /* Get aligni and misaligni from __builtin_assume_aligned. */
1687 align
= gimple_call_arg (stmt
, 1);
1688 if (!tree_fits_uhwi_p (align
))
1690 aligni
= tree_to_uhwi (align
);
1691 if (gimple_call_num_args (stmt
) > 2)
1693 misalign
= gimple_call_arg (stmt
, 2);
1694 if (!tree_fits_uhwi_p (misalign
))
1696 misaligni
= tree_to_uhwi (misalign
);
1701 /* Get aligni and misaligni from assume_aligned or
1702 alloc_align attributes. */
1703 if (TREE_VALUE (attr
) == NULL_TREE
)
1705 attr
= TREE_VALUE (attr
);
1706 align
= TREE_VALUE (attr
);
1707 if (!tree_fits_uhwi_p (align
))
1709 aligni
= tree_to_uhwi (align
);
1712 if (aligni
== 0 || aligni
> gimple_call_num_args (stmt
))
1714 align
= gimple_call_arg (stmt
, aligni
- 1);
1715 if (!tree_fits_uhwi_p (align
))
1717 aligni
= tree_to_uhwi (align
);
1719 else if (TREE_CHAIN (attr
) && TREE_VALUE (TREE_CHAIN (attr
)))
1721 misalign
= TREE_VALUE (TREE_CHAIN (attr
));
1722 if (!tree_fits_uhwi_p (misalign
))
1724 misaligni
= tree_to_uhwi (misalign
);
1727 if (aligni
<= 1 || (aligni
& (aligni
- 1)) != 0 || misaligni
>= aligni
)
1730 align
= build_int_cst_type (type
, -aligni
);
1731 alignval
= get_value_for_expr (align
, true);
1732 bit_value_binop (BIT_AND_EXPR
, TYPE_SIGN (type
), TYPE_PRECISION (type
), &value
, &mask
,
1733 TYPE_SIGN (type
), TYPE_PRECISION (type
), value_to_wide_int (ptrval
), ptrval
.mask
,
1734 TYPE_SIGN (type
), TYPE_PRECISION (type
), value_to_wide_int (alignval
), alignval
.mask
);
1736 if (wi::sext (mask
, TYPE_PRECISION (type
)) != -1)
1738 val
.lattice_val
= CONSTANT
;
1740 gcc_assert ((mask
.to_uhwi () & (aligni
- 1)) == 0);
1741 gcc_assert ((value
.to_uhwi () & (aligni
- 1)) == 0);
1743 /* ??? Delay building trees here. */
1744 val
.value
= wide_int_to_tree (type
, value
);
1748 val
.lattice_val
= VARYING
;
1749 val
.value
= NULL_TREE
;
1755 /* Evaluate statement STMT.
1756 Valid only for assignments, calls, conditionals, and switches. */
1758 static ccp_prop_value_t
1759 evaluate_stmt (gimple
*stmt
)
1761 ccp_prop_value_t val
;
1762 tree simplified
= NULL_TREE
;
1763 ccp_lattice_t likelyvalue
= likely_value (stmt
);
1764 bool is_constant
= false;
1767 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1769 fprintf (dump_file
, "which is likely ");
1770 switch (likelyvalue
)
1773 fprintf (dump_file
, "CONSTANT");
1776 fprintf (dump_file
, "UNDEFINED");
1779 fprintf (dump_file
, "VARYING");
1783 fprintf (dump_file
, "\n");
1786 /* If the statement is likely to have a CONSTANT result, then try
1787 to fold the statement to determine the constant value. */
1788 /* FIXME. This is the only place that we call ccp_fold.
1789 Since likely_value never returns CONSTANT for calls, we will
1790 not attempt to fold them, including builtins that may profit. */
1791 if (likelyvalue
== CONSTANT
)
1793 fold_defer_overflow_warnings ();
1794 simplified
= ccp_fold (stmt
);
1796 && TREE_CODE (simplified
) == SSA_NAME
)
1798 /* We may not use values of something that may be simulated again,
1799 see valueize_op_1. */
1800 if (SSA_NAME_IS_DEFAULT_DEF (simplified
)
1801 || ! prop_simulate_again_p (SSA_NAME_DEF_STMT (simplified
)))
1803 ccp_prop_value_t
*val
= get_value (simplified
);
1804 if (val
&& val
->lattice_val
!= VARYING
)
1806 fold_undefer_overflow_warnings (true, stmt
, 0);
1811 /* We may also not place a non-valueized copy in the lattice
1812 as that might become stale if we never re-visit this stmt. */
1813 simplified
= NULL_TREE
;
1815 is_constant
= simplified
&& is_gimple_min_invariant (simplified
);
1816 fold_undefer_overflow_warnings (is_constant
, stmt
, 0);
1819 /* The statement produced a constant value. */
1820 val
.lattice_val
= CONSTANT
;
1821 val
.value
= simplified
;
1826 /* If the statement is likely to have a VARYING result, then do not
1827 bother folding the statement. */
1828 else if (likelyvalue
== VARYING
)
1830 enum gimple_code code
= gimple_code (stmt
);
1831 if (code
== GIMPLE_ASSIGN
)
1833 enum tree_code subcode
= gimple_assign_rhs_code (stmt
);
1835 /* Other cases cannot satisfy is_gimple_min_invariant
1837 if (get_gimple_rhs_class (subcode
) == GIMPLE_SINGLE_RHS
)
1838 simplified
= gimple_assign_rhs1 (stmt
);
1840 else if (code
== GIMPLE_SWITCH
)
1841 simplified
= gimple_switch_index (as_a
<gswitch
*> (stmt
));
1843 /* These cannot satisfy is_gimple_min_invariant without folding. */
1844 gcc_assert (code
== GIMPLE_CALL
|| code
== GIMPLE_COND
);
1845 is_constant
= simplified
&& is_gimple_min_invariant (simplified
);
1848 /* The statement produced a constant value. */
1849 val
.lattice_val
= CONSTANT
;
1850 val
.value
= simplified
;
1854 /* If the statement result is likely UNDEFINED, make it so. */
1855 else if (likelyvalue
== UNDEFINED
)
1857 val
.lattice_val
= UNDEFINED
;
1858 val
.value
= NULL_TREE
;
1863 /* Resort to simplification for bitwise tracking. */
1864 if (flag_tree_bit_ccp
1865 && (likelyvalue
== CONSTANT
|| is_gimple_call (stmt
)
1866 || (gimple_assign_single_p (stmt
)
1867 && gimple_assign_rhs_code (stmt
) == ADDR_EXPR
))
1870 enum gimple_code code
= gimple_code (stmt
);
1871 val
.lattice_val
= VARYING
;
1872 val
.value
= NULL_TREE
;
1874 if (code
== GIMPLE_ASSIGN
)
1876 enum tree_code subcode
= gimple_assign_rhs_code (stmt
);
1877 tree rhs1
= gimple_assign_rhs1 (stmt
);
1878 tree lhs
= gimple_assign_lhs (stmt
);
1879 if ((INTEGRAL_TYPE_P (TREE_TYPE (lhs
))
1880 || POINTER_TYPE_P (TREE_TYPE (lhs
)))
1881 && (INTEGRAL_TYPE_P (TREE_TYPE (rhs1
))
1882 || POINTER_TYPE_P (TREE_TYPE (rhs1
))))
1883 switch (get_gimple_rhs_class (subcode
))
1885 case GIMPLE_SINGLE_RHS
:
1886 val
= get_value_for_expr (rhs1
, true);
1889 case GIMPLE_UNARY_RHS
:
1890 val
= bit_value_unop (subcode
, TREE_TYPE (lhs
), rhs1
);
1893 case GIMPLE_BINARY_RHS
:
1894 val
= bit_value_binop (subcode
, TREE_TYPE (lhs
), rhs1
,
1895 gimple_assign_rhs2 (stmt
));
1901 else if (code
== GIMPLE_COND
)
1903 enum tree_code code
= gimple_cond_code (stmt
);
1904 tree rhs1
= gimple_cond_lhs (stmt
);
1905 tree rhs2
= gimple_cond_rhs (stmt
);
1906 if (INTEGRAL_TYPE_P (TREE_TYPE (rhs1
))
1907 || POINTER_TYPE_P (TREE_TYPE (rhs1
)))
1908 val
= bit_value_binop (code
, TREE_TYPE (rhs1
), rhs1
, rhs2
);
1910 else if (gimple_call_builtin_p (stmt
, BUILT_IN_NORMAL
))
1912 tree fndecl
= gimple_call_fndecl (stmt
);
1913 switch (DECL_FUNCTION_CODE (fndecl
))
1915 case BUILT_IN_MALLOC
:
1916 case BUILT_IN_REALLOC
:
1917 case BUILT_IN_CALLOC
:
1918 case BUILT_IN_STRDUP
:
1919 case BUILT_IN_STRNDUP
:
1920 val
.lattice_val
= CONSTANT
;
1921 val
.value
= build_int_cst (TREE_TYPE (gimple_get_lhs (stmt
)), 0);
1922 val
.mask
= ~((HOST_WIDE_INT
) MALLOC_ABI_ALIGNMENT
1923 / BITS_PER_UNIT
- 1);
1926 CASE_BUILT_IN_ALLOCA
:
1927 align
= (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_ALLOCA
1929 : TREE_INT_CST_LOW (gimple_call_arg (stmt
, 1)));
1930 val
.lattice_val
= CONSTANT
;
1931 val
.value
= build_int_cst (TREE_TYPE (gimple_get_lhs (stmt
)), 0);
1932 val
.mask
= ~((HOST_WIDE_INT
) align
/ BITS_PER_UNIT
- 1);
1935 /* These builtins return their first argument, unmodified. */
1936 case BUILT_IN_MEMCPY
:
1937 case BUILT_IN_MEMMOVE
:
1938 case BUILT_IN_MEMSET
:
1939 case BUILT_IN_STRCPY
:
1940 case BUILT_IN_STRNCPY
:
1941 case BUILT_IN_MEMCPY_CHK
:
1942 case BUILT_IN_MEMMOVE_CHK
:
1943 case BUILT_IN_MEMSET_CHK
:
1944 case BUILT_IN_STRCPY_CHK
:
1945 case BUILT_IN_STRNCPY_CHK
:
1946 val
= get_value_for_expr (gimple_call_arg (stmt
, 0), true);
1949 case BUILT_IN_ASSUME_ALIGNED
:
1950 val
= bit_value_assume_aligned (stmt
, NULL_TREE
, val
, false);
1953 case BUILT_IN_ALIGNED_ALLOC
:
1955 tree align
= get_constant_value (gimple_call_arg (stmt
, 0));
1957 && tree_fits_uhwi_p (align
))
1959 unsigned HOST_WIDE_INT aligni
= tree_to_uhwi (align
);
1961 /* align must be power-of-two */
1962 && (aligni
& (aligni
- 1)) == 0)
1964 val
.lattice_val
= CONSTANT
;
1965 val
.value
= build_int_cst (ptr_type_node
, 0);
1972 case BUILT_IN_BSWAP16
:
1973 case BUILT_IN_BSWAP32
:
1974 case BUILT_IN_BSWAP64
:
1975 val
= get_value_for_expr (gimple_call_arg (stmt
, 0), true);
1976 if (val
.lattice_val
== UNDEFINED
)
1978 else if (val
.lattice_val
== CONSTANT
1980 && TREE_CODE (val
.value
) == INTEGER_CST
)
1982 tree type
= TREE_TYPE (gimple_call_lhs (stmt
));
1983 int prec
= TYPE_PRECISION (type
);
1984 wide_int wval
= wi::to_wide (val
.value
);
1986 = wide_int_to_tree (type
,
1987 wide_int::from (wval
, prec
,
1988 UNSIGNED
).bswap ());
1990 = widest_int::from (wide_int::from (val
.mask
, prec
,
1993 if (wi::sext (val
.mask
, prec
) != -1)
1996 val
.lattice_val
= VARYING
;
1997 val
.value
= NULL_TREE
;
2004 if (is_gimple_call (stmt
) && gimple_call_lhs (stmt
))
2006 tree fntype
= gimple_call_fntype (stmt
);
2009 tree attrs
= lookup_attribute ("assume_aligned",
2010 TYPE_ATTRIBUTES (fntype
));
2012 val
= bit_value_assume_aligned (stmt
, attrs
, val
, false);
2013 attrs
= lookup_attribute ("alloc_align",
2014 TYPE_ATTRIBUTES (fntype
));
2016 val
= bit_value_assume_aligned (stmt
, attrs
, val
, true);
2019 is_constant
= (val
.lattice_val
== CONSTANT
);
2022 if (flag_tree_bit_ccp
2023 && ((is_constant
&& TREE_CODE (val
.value
) == INTEGER_CST
)
2025 && gimple_get_lhs (stmt
)
2026 && TREE_CODE (gimple_get_lhs (stmt
)) == SSA_NAME
)
2028 tree lhs
= gimple_get_lhs (stmt
);
2029 wide_int nonzero_bits
= get_nonzero_bits (lhs
);
2030 if (nonzero_bits
!= -1)
2034 val
.lattice_val
= CONSTANT
;
2035 val
.value
= build_zero_cst (TREE_TYPE (lhs
));
2036 val
.mask
= extend_mask (nonzero_bits
, TYPE_SIGN (TREE_TYPE (lhs
)));
2041 if (wi::bit_and_not (wi::to_wide (val
.value
), nonzero_bits
) != 0)
2042 val
.value
= wide_int_to_tree (TREE_TYPE (lhs
),
2044 & wi::to_wide (val
.value
));
2045 if (nonzero_bits
== 0)
2048 val
.mask
= val
.mask
& extend_mask (nonzero_bits
,
2049 TYPE_SIGN (TREE_TYPE (lhs
)));
2054 /* The statement produced a nonconstant value. */
2057 /* The statement produced a copy. */
2058 if (simplified
&& TREE_CODE (simplified
) == SSA_NAME
2059 && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (simplified
))
2061 val
.lattice_val
= CONSTANT
;
2062 val
.value
= simplified
;
2065 /* The statement is VARYING. */
2068 val
.lattice_val
= VARYING
;
2069 val
.value
= NULL_TREE
;
2077 typedef hash_table
<nofree_ptr_hash
<gimple
> > gimple_htab
;
2079 /* Given a BUILT_IN_STACK_SAVE value SAVED_VAL, insert a clobber of VAR before
2080 each matching BUILT_IN_STACK_RESTORE. Mark visited phis in VISITED. */
2083 insert_clobber_before_stack_restore (tree saved_val
, tree var
,
2084 gimple_htab
**visited
)
2087 gassign
*clobber_stmt
;
2089 imm_use_iterator iter
;
2090 gimple_stmt_iterator i
;
2093 FOR_EACH_IMM_USE_STMT (stmt
, iter
, saved_val
)
2094 if (gimple_call_builtin_p (stmt
, BUILT_IN_STACK_RESTORE
))
2096 clobber
= build_clobber (TREE_TYPE (var
));
2097 clobber_stmt
= gimple_build_assign (var
, clobber
);
2099 i
= gsi_for_stmt (stmt
);
2100 gsi_insert_before (&i
, clobber_stmt
, GSI_SAME_STMT
);
2102 else if (gimple_code (stmt
) == GIMPLE_PHI
)
2105 *visited
= new gimple_htab (10);
2107 slot
= (*visited
)->find_slot (stmt
, INSERT
);
2112 insert_clobber_before_stack_restore (gimple_phi_result (stmt
), var
,
2115 else if (gimple_assign_ssa_name_copy_p (stmt
))
2116 insert_clobber_before_stack_restore (gimple_assign_lhs (stmt
), var
,
2119 gcc_assert (is_gimple_debug (stmt
));
2122 /* Advance the iterator to the previous non-debug gimple statement in the same
2123 or dominating basic block. */
2126 gsi_prev_dom_bb_nondebug (gimple_stmt_iterator
*i
)
2130 gsi_prev_nondebug (i
);
2131 while (gsi_end_p (*i
))
2133 dom
= get_immediate_dominator (CDI_DOMINATORS
, i
->bb
);
2134 if (dom
== NULL
|| dom
== ENTRY_BLOCK_PTR_FOR_FN (cfun
))
2137 *i
= gsi_last_bb (dom
);
2141 /* Find a BUILT_IN_STACK_SAVE dominating gsi_stmt (I), and insert
2142 a clobber of VAR before each matching BUILT_IN_STACK_RESTORE.
2144 It is possible that BUILT_IN_STACK_SAVE cannot be find in a dominator when a
2145 previous pass (such as DOM) duplicated it along multiple paths to a BB. In
2146 that case the function gives up without inserting the clobbers. */
2149 insert_clobbers_for_var (gimple_stmt_iterator i
, tree var
)
2153 gimple_htab
*visited
= NULL
;
2155 for (; !gsi_end_p (i
); gsi_prev_dom_bb_nondebug (&i
))
2157 stmt
= gsi_stmt (i
);
2159 if (!gimple_call_builtin_p (stmt
, BUILT_IN_STACK_SAVE
))
2162 saved_val
= gimple_call_lhs (stmt
);
2163 if (saved_val
== NULL_TREE
)
2166 insert_clobber_before_stack_restore (saved_val
, var
, &visited
);
2173 /* Detects a __builtin_alloca_with_align with constant size argument. Declares
2174 fixed-size array and returns the address, if found, otherwise returns
2178 fold_builtin_alloca_with_align (gimple
*stmt
)
2180 unsigned HOST_WIDE_INT size
, threshold
, n_elem
;
2181 tree lhs
, arg
, block
, var
, elem_type
, array_type
;
2184 lhs
= gimple_call_lhs (stmt
);
2185 if (lhs
== NULL_TREE
)
2188 /* Detect constant argument. */
2189 arg
= get_constant_value (gimple_call_arg (stmt
, 0));
2190 if (arg
== NULL_TREE
2191 || TREE_CODE (arg
) != INTEGER_CST
2192 || !tree_fits_uhwi_p (arg
))
2195 size
= tree_to_uhwi (arg
);
2197 /* Heuristic: don't fold large allocas. */
2198 threshold
= (unsigned HOST_WIDE_INT
)PARAM_VALUE (PARAM_LARGE_STACK_FRAME
);
2199 /* In case the alloca is located at function entry, it has the same lifetime
2200 as a declared array, so we allow a larger size. */
2201 block
= gimple_block (stmt
);
2202 if (!(cfun
->after_inlining
2204 && TREE_CODE (BLOCK_SUPERCONTEXT (block
)) == FUNCTION_DECL
))
2206 if (size
> threshold
)
2209 /* We have to be able to move points-to info. We used to assert
2210 that we can but IPA PTA might end up with two UIDs here
2211 as it might need to handle more than one instance being
2212 live at the same time. Instead of trying to detect this case
2213 (using the first UID would be OK) just give up for now. */
2214 struct ptr_info_def
*pi
= SSA_NAME_PTR_INFO (lhs
);
2218 && !pt_solution_singleton_or_null_p (&pi
->pt
, &uid
))
2221 /* Declare array. */
2222 elem_type
= build_nonstandard_integer_type (BITS_PER_UNIT
, 1);
2223 n_elem
= size
* 8 / BITS_PER_UNIT
;
2224 array_type
= build_array_type_nelts (elem_type
, n_elem
);
2226 if (tree ssa_name
= SSA_NAME_IDENTIFIER (lhs
))
2228 /* Give the temporary a name derived from the name of the VLA
2229 declaration so it can be referenced in diagnostics. */
2230 const char *name
= IDENTIFIER_POINTER (ssa_name
);
2231 var
= create_tmp_var (array_type
, name
);
2234 var
= create_tmp_var (array_type
);
2236 if (gimple
*lhsdef
= SSA_NAME_DEF_STMT (lhs
))
2238 /* Set the temporary's location to that of the VLA declaration
2239 so it can be pointed to in diagnostics. */
2240 location_t loc
= gimple_location (lhsdef
);
2241 DECL_SOURCE_LOCATION (var
) = loc
;
2244 SET_DECL_ALIGN (var
, TREE_INT_CST_LOW (gimple_call_arg (stmt
, 1)));
2246 SET_DECL_PT_UID (var
, uid
);
2248 /* Fold alloca to the address of the array. */
2249 return fold_convert (TREE_TYPE (lhs
), build_fold_addr_expr (var
));
2252 /* Fold the stmt at *GSI with CCP specific information that propagating
2253 and regular folding does not catch. */
2256 ccp_folder::fold_stmt (gimple_stmt_iterator
*gsi
)
2258 gimple
*stmt
= gsi_stmt (*gsi
);
2260 switch (gimple_code (stmt
))
2264 gcond
*cond_stmt
= as_a
<gcond
*> (stmt
);
2265 ccp_prop_value_t val
;
2266 /* Statement evaluation will handle type mismatches in constants
2267 more gracefully than the final propagation. This allows us to
2268 fold more conditionals here. */
2269 val
= evaluate_stmt (stmt
);
2270 if (val
.lattice_val
!= CONSTANT
2276 fprintf (dump_file
, "Folding predicate ");
2277 print_gimple_expr (dump_file
, stmt
, 0);
2278 fprintf (dump_file
, " to ");
2279 print_generic_expr (dump_file
, val
.value
);
2280 fprintf (dump_file
, "\n");
2283 if (integer_zerop (val
.value
))
2284 gimple_cond_make_false (cond_stmt
);
2286 gimple_cond_make_true (cond_stmt
);
2293 tree lhs
= gimple_call_lhs (stmt
);
2294 int flags
= gimple_call_flags (stmt
);
2297 bool changed
= false;
2300 /* If the call was folded into a constant make sure it goes
2301 away even if we cannot propagate into all uses because of
2304 && TREE_CODE (lhs
) == SSA_NAME
2305 && (val
= get_constant_value (lhs
))
2306 /* Don't optimize away calls that have side-effects. */
2307 && (flags
& (ECF_CONST
|ECF_PURE
)) != 0
2308 && (flags
& ECF_LOOPING_CONST_OR_PURE
) == 0)
2310 tree new_rhs
= unshare_expr (val
);
2312 if (!useless_type_conversion_p (TREE_TYPE (lhs
),
2313 TREE_TYPE (new_rhs
)))
2314 new_rhs
= fold_convert (TREE_TYPE (lhs
), new_rhs
);
2315 res
= update_call_from_tree (gsi
, new_rhs
);
2320 /* Internal calls provide no argument types, so the extra laxity
2321 for normal calls does not apply. */
2322 if (gimple_call_internal_p (stmt
))
2325 /* The heuristic of fold_builtin_alloca_with_align differs before and
2326 after inlining, so we don't require the arg to be changed into a
2327 constant for folding, but just to be constant. */
2328 if (gimple_call_builtin_p (stmt
, BUILT_IN_ALLOCA_WITH_ALIGN
)
2329 || gimple_call_builtin_p (stmt
, BUILT_IN_ALLOCA_WITH_ALIGN_AND_MAX
))
2331 tree new_rhs
= fold_builtin_alloca_with_align (stmt
);
2334 bool res
= update_call_from_tree (gsi
, new_rhs
);
2335 tree var
= TREE_OPERAND (TREE_OPERAND (new_rhs
, 0),0);
2337 insert_clobbers_for_var (*gsi
, var
);
2342 /* If there's no extra info from an assume_aligned call,
2343 drop it so it doesn't act as otherwise useless dataflow
2345 if (gimple_call_builtin_p (stmt
, BUILT_IN_ASSUME_ALIGNED
))
2347 tree ptr
= gimple_call_arg (stmt
, 0);
2348 ccp_prop_value_t ptrval
= get_value_for_expr (ptr
, true);
2349 if (ptrval
.lattice_val
== CONSTANT
2350 && TREE_CODE (ptrval
.value
) == INTEGER_CST
2351 && ptrval
.mask
!= 0)
2353 ccp_prop_value_t val
2354 = bit_value_assume_aligned (stmt
, NULL_TREE
, ptrval
, false);
2355 unsigned int ptralign
= least_bit_hwi (ptrval
.mask
.to_uhwi ());
2356 unsigned int align
= least_bit_hwi (val
.mask
.to_uhwi ());
2357 if (ptralign
== align
2358 && ((TREE_INT_CST_LOW (ptrval
.value
) & (align
- 1))
2359 == (TREE_INT_CST_LOW (val
.value
) & (align
- 1))))
2361 bool res
= update_call_from_tree (gsi
, ptr
);
2368 /* Propagate into the call arguments. Compared to replace_uses_in
2369 this can use the argument slot types for type verification
2370 instead of the current argument type. We also can safely
2371 drop qualifiers here as we are dealing with constants anyway. */
2372 argt
= TYPE_ARG_TYPES (gimple_call_fntype (stmt
));
2373 for (i
= 0; i
< gimple_call_num_args (stmt
) && argt
;
2374 ++i
, argt
= TREE_CHAIN (argt
))
2376 tree arg
= gimple_call_arg (stmt
, i
);
2377 if (TREE_CODE (arg
) == SSA_NAME
2378 && (val
= get_constant_value (arg
))
2379 && useless_type_conversion_p
2380 (TYPE_MAIN_VARIANT (TREE_VALUE (argt
)),
2381 TYPE_MAIN_VARIANT (TREE_TYPE (val
))))
2383 gimple_call_set_arg (stmt
, i
, unshare_expr (val
));
2393 tree lhs
= gimple_assign_lhs (stmt
);
2396 /* If we have a load that turned out to be constant replace it
2397 as we cannot propagate into all uses in all cases. */
2398 if (gimple_assign_single_p (stmt
)
2399 && TREE_CODE (lhs
) == SSA_NAME
2400 && (val
= get_constant_value (lhs
)))
2402 tree rhs
= unshare_expr (val
);
2403 if (!useless_type_conversion_p (TREE_TYPE (lhs
), TREE_TYPE (rhs
)))
2404 rhs
= fold_build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (lhs
), rhs
);
2405 gimple_assign_set_rhs_from_tree (gsi
, rhs
);
2417 /* Visit the assignment statement STMT. Set the value of its LHS to the
2418 value computed by the RHS and store LHS in *OUTPUT_P. If STMT
2419 creates virtual definitions, set the value of each new name to that
2420 of the RHS (if we can derive a constant out of the RHS).
2421 Value-returning call statements also perform an assignment, and
2422 are handled here. */
2424 static enum ssa_prop_result
2425 visit_assignment (gimple
*stmt
, tree
*output_p
)
2427 ccp_prop_value_t val
;
2428 enum ssa_prop_result retval
= SSA_PROP_NOT_INTERESTING
;
2430 tree lhs
= gimple_get_lhs (stmt
);
2431 if (TREE_CODE (lhs
) == SSA_NAME
)
2433 /* Evaluate the statement, which could be
2434 either a GIMPLE_ASSIGN or a GIMPLE_CALL. */
2435 val
= evaluate_stmt (stmt
);
2437 /* If STMT is an assignment to an SSA_NAME, we only have one
2439 if (set_lattice_value (lhs
, &val
))
2442 if (val
.lattice_val
== VARYING
)
2443 retval
= SSA_PROP_VARYING
;
2445 retval
= SSA_PROP_INTERESTING
;
2453 /* Visit the conditional statement STMT. Return SSA_PROP_INTERESTING
2454 if it can determine which edge will be taken. Otherwise, return
2455 SSA_PROP_VARYING. */
2457 static enum ssa_prop_result
2458 visit_cond_stmt (gimple
*stmt
, edge
*taken_edge_p
)
2460 ccp_prop_value_t val
;
2463 block
= gimple_bb (stmt
);
2464 val
= evaluate_stmt (stmt
);
2465 if (val
.lattice_val
!= CONSTANT
2467 return SSA_PROP_VARYING
;
2469 /* Find which edge out of the conditional block will be taken and add it
2470 to the worklist. If no single edge can be determined statically,
2471 return SSA_PROP_VARYING to feed all the outgoing edges to the
2472 propagation engine. */
2473 *taken_edge_p
= find_taken_edge (block
, val
.value
);
2475 return SSA_PROP_INTERESTING
;
2477 return SSA_PROP_VARYING
;
2481 /* Evaluate statement STMT. If the statement produces an output value and
2482 its evaluation changes the lattice value of its output, return
2483 SSA_PROP_INTERESTING and set *OUTPUT_P to the SSA_NAME holding the
2486 If STMT is a conditional branch and we can determine its truth
2487 value, set *TAKEN_EDGE_P accordingly. If STMT produces a varying
2488 value, return SSA_PROP_VARYING. */
2490 enum ssa_prop_result
2491 ccp_propagate::visit_stmt (gimple
*stmt
, edge
*taken_edge_p
, tree
*output_p
)
2496 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2498 fprintf (dump_file
, "\nVisiting statement:\n");
2499 print_gimple_stmt (dump_file
, stmt
, 0, dump_flags
);
2502 switch (gimple_code (stmt
))
2505 /* If the statement is an assignment that produces a single
2506 output value, evaluate its RHS to see if the lattice value of
2507 its output has changed. */
2508 return visit_assignment (stmt
, output_p
);
2511 /* A value-returning call also performs an assignment. */
2512 if (gimple_call_lhs (stmt
) != NULL_TREE
)
2513 return visit_assignment (stmt
, output_p
);
2518 /* If STMT is a conditional branch, see if we can determine
2519 which branch will be taken. */
2520 /* FIXME. It appears that we should be able to optimize
2521 computed GOTOs here as well. */
2522 return visit_cond_stmt (stmt
, taken_edge_p
);
2528 /* Any other kind of statement is not interesting for constant
2529 propagation and, therefore, not worth simulating. */
2530 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2531 fprintf (dump_file
, "No interesting values produced. Marked VARYING.\n");
2533 /* Definitions made by statements other than assignments to
2534 SSA_NAMEs represent unknown modifications to their outputs.
2535 Mark them VARYING. */
2536 FOR_EACH_SSA_TREE_OPERAND (def
, stmt
, iter
, SSA_OP_ALL_DEFS
)
2537 set_value_varying (def
);
2539 return SSA_PROP_VARYING
;
2543 /* Main entry point for SSA Conditional Constant Propagation. If NONZERO_P,
2544 record nonzero bits. */
2547 do_ssa_ccp (bool nonzero_p
)
2549 unsigned int todo
= 0;
2550 calculate_dominance_info (CDI_DOMINATORS
);
2553 class ccp_propagate ccp_propagate
;
2554 ccp_propagate
.ssa_propagate ();
2555 if (ccp_finalize (nonzero_p
|| flag_ipa_bit_cp
))
2557 todo
= (TODO_cleanup_cfg
| TODO_update_ssa
);
2559 /* ccp_finalize does not preserve loop-closed ssa. */
2560 loops_state_clear (LOOP_CLOSED_SSA
);
2563 free_dominance_info (CDI_DOMINATORS
);
2570 const pass_data pass_data_ccp
=
2572 GIMPLE_PASS
, /* type */
2574 OPTGROUP_NONE
, /* optinfo_flags */
2575 TV_TREE_CCP
, /* tv_id */
2576 ( PROP_cfg
| PROP_ssa
), /* properties_required */
2577 0, /* properties_provided */
2578 0, /* properties_destroyed */
2579 0, /* todo_flags_start */
2580 TODO_update_address_taken
, /* todo_flags_finish */
2583 class pass_ccp
: public gimple_opt_pass
2586 pass_ccp (gcc::context
*ctxt
)
2587 : gimple_opt_pass (pass_data_ccp
, ctxt
), nonzero_p (false)
2590 /* opt_pass methods: */
2591 opt_pass
* clone () { return new pass_ccp (m_ctxt
); }
2592 void set_pass_param (unsigned int n
, bool param
)
2594 gcc_assert (n
== 0);
2597 virtual bool gate (function
*) { return flag_tree_ccp
!= 0; }
2598 virtual unsigned int execute (function
*) { return do_ssa_ccp (nonzero_p
); }
2601 /* Determines whether the pass instance records nonzero bits. */
2603 }; // class pass_ccp
2608 make_pass_ccp (gcc::context
*ctxt
)
2610 return new pass_ccp (ctxt
);
2615 /* Try to optimize out __builtin_stack_restore. Optimize it out
2616 if there is another __builtin_stack_restore in the same basic
2617 block and no calls or ASM_EXPRs are in between, or if this block's
2618 only outgoing edge is to EXIT_BLOCK and there are no calls or
2619 ASM_EXPRs after this __builtin_stack_restore. */
2622 optimize_stack_restore (gimple_stmt_iterator i
)
2627 basic_block bb
= gsi_bb (i
);
2628 gimple
*call
= gsi_stmt (i
);
2630 if (gimple_code (call
) != GIMPLE_CALL
2631 || gimple_call_num_args (call
) != 1
2632 || TREE_CODE (gimple_call_arg (call
, 0)) != SSA_NAME
2633 || !POINTER_TYPE_P (TREE_TYPE (gimple_call_arg (call
, 0))))
2636 for (gsi_next (&i
); !gsi_end_p (i
); gsi_next (&i
))
2638 stmt
= gsi_stmt (i
);
2639 if (gimple_code (stmt
) == GIMPLE_ASM
)
2641 if (gimple_code (stmt
) != GIMPLE_CALL
)
2644 callee
= gimple_call_fndecl (stmt
);
2646 || !fndecl_built_in_p (callee
, BUILT_IN_NORMAL
)
2647 /* All regular builtins are ok, just obviously not alloca. */
2648 || ALLOCA_FUNCTION_CODE_P (DECL_FUNCTION_CODE (callee
)))
2651 if (fndecl_built_in_p (callee
, BUILT_IN_STACK_RESTORE
))
2652 goto second_stack_restore
;
2658 /* Allow one successor of the exit block, or zero successors. */
2659 switch (EDGE_COUNT (bb
->succs
))
2664 if (single_succ_edge (bb
)->dest
!= EXIT_BLOCK_PTR_FOR_FN (cfun
))
2670 second_stack_restore
:
2672 /* If there's exactly one use, then zap the call to __builtin_stack_save.
2673 If there are multiple uses, then the last one should remove the call.
2674 In any case, whether the call to __builtin_stack_save can be removed
2675 or not is irrelevant to removing the call to __builtin_stack_restore. */
2676 if (has_single_use (gimple_call_arg (call
, 0)))
2678 gimple
*stack_save
= SSA_NAME_DEF_STMT (gimple_call_arg (call
, 0));
2679 if (is_gimple_call (stack_save
))
2681 callee
= gimple_call_fndecl (stack_save
);
2682 if (callee
&& fndecl_built_in_p (callee
, BUILT_IN_STACK_SAVE
))
2684 gimple_stmt_iterator stack_save_gsi
;
2687 stack_save_gsi
= gsi_for_stmt (stack_save
);
2688 rhs
= build_int_cst (TREE_TYPE (gimple_call_arg (call
, 0)), 0);
2689 update_call_from_tree (&stack_save_gsi
, rhs
);
2694 /* No effect, so the statement will be deleted. */
2695 return integer_zero_node
;
2698 /* If va_list type is a simple pointer and nothing special is needed,
2699 optimize __builtin_va_start (&ap, 0) into ap = __builtin_next_arg (0),
2700 __builtin_va_end (&ap) out as NOP and __builtin_va_copy into a simple
2701 pointer assignment. */
2704 optimize_stdarg_builtin (gimple
*call
)
2706 tree callee
, lhs
, rhs
, cfun_va_list
;
2707 bool va_list_simple_ptr
;
2708 location_t loc
= gimple_location (call
);
2710 callee
= gimple_call_fndecl (call
);
2712 cfun_va_list
= targetm
.fn_abi_va_list (callee
);
2713 va_list_simple_ptr
= POINTER_TYPE_P (cfun_va_list
)
2714 && (TREE_TYPE (cfun_va_list
) == void_type_node
2715 || TREE_TYPE (cfun_va_list
) == char_type_node
);
2717 switch (DECL_FUNCTION_CODE (callee
))
2719 case BUILT_IN_VA_START
:
2720 if (!va_list_simple_ptr
2721 || targetm
.expand_builtin_va_start
!= NULL
2722 || !builtin_decl_explicit_p (BUILT_IN_NEXT_ARG
))
2725 if (gimple_call_num_args (call
) != 2)
2728 lhs
= gimple_call_arg (call
, 0);
2729 if (!POINTER_TYPE_P (TREE_TYPE (lhs
))
2730 || TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (lhs
)))
2731 != TYPE_MAIN_VARIANT (cfun_va_list
))
2734 lhs
= build_fold_indirect_ref_loc (loc
, lhs
);
2735 rhs
= build_call_expr_loc (loc
, builtin_decl_explicit (BUILT_IN_NEXT_ARG
),
2736 1, integer_zero_node
);
2737 rhs
= fold_convert_loc (loc
, TREE_TYPE (lhs
), rhs
);
2738 return build2 (MODIFY_EXPR
, TREE_TYPE (lhs
), lhs
, rhs
);
2740 case BUILT_IN_VA_COPY
:
2741 if (!va_list_simple_ptr
)
2744 if (gimple_call_num_args (call
) != 2)
2747 lhs
= gimple_call_arg (call
, 0);
2748 if (!POINTER_TYPE_P (TREE_TYPE (lhs
))
2749 || TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (lhs
)))
2750 != TYPE_MAIN_VARIANT (cfun_va_list
))
2753 lhs
= build_fold_indirect_ref_loc (loc
, lhs
);
2754 rhs
= gimple_call_arg (call
, 1);
2755 if (TYPE_MAIN_VARIANT (TREE_TYPE (rhs
))
2756 != TYPE_MAIN_VARIANT (cfun_va_list
))
2759 rhs
= fold_convert_loc (loc
, TREE_TYPE (lhs
), rhs
);
2760 return build2 (MODIFY_EXPR
, TREE_TYPE (lhs
), lhs
, rhs
);
2762 case BUILT_IN_VA_END
:
2763 /* No effect, so the statement will be deleted. */
2764 return integer_zero_node
;
2771 /* Attemp to make the block of __builtin_unreachable I unreachable by changing
2772 the incoming jumps. Return true if at least one jump was changed. */
2775 optimize_unreachable (gimple_stmt_iterator i
)
2777 basic_block bb
= gsi_bb (i
);
2778 gimple_stmt_iterator gsi
;
2784 if (flag_sanitize
& SANITIZE_UNREACHABLE
)
2787 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
2789 stmt
= gsi_stmt (gsi
);
2791 if (is_gimple_debug (stmt
))
2794 if (glabel
*label_stmt
= dyn_cast
<glabel
*> (stmt
))
2796 /* Verify we do not need to preserve the label. */
2797 if (FORCED_LABEL (gimple_label_label (label_stmt
)))
2803 /* Only handle the case that __builtin_unreachable is the first statement
2804 in the block. We rely on DCE to remove stmts without side-effects
2805 before __builtin_unreachable. */
2806 if (gsi_stmt (gsi
) != gsi_stmt (i
))
2811 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
2813 gsi
= gsi_last_bb (e
->src
);
2814 if (gsi_end_p (gsi
))
2817 stmt
= gsi_stmt (gsi
);
2818 if (gcond
*cond_stmt
= dyn_cast
<gcond
*> (stmt
))
2820 if (e
->flags
& EDGE_TRUE_VALUE
)
2821 gimple_cond_make_false (cond_stmt
);
2822 else if (e
->flags
& EDGE_FALSE_VALUE
)
2823 gimple_cond_make_true (cond_stmt
);
2826 update_stmt (cond_stmt
);
2830 /* Todo: handle other cases. Note that unreachable switch case
2831 statements have already been removed. */
2842 mask_2 = 1 << cnt_1;
2843 _4 = __atomic_fetch_or_* (ptr_6, mask_2, _3);
2846 _4 = ATOMIC_BIT_TEST_AND_SET (ptr_6, cnt_1, 0, _3);
2848 If _5 is only used in _5 != 0 or _5 == 0 comparisons, 1
2849 is passed instead of 0, and the builtin just returns a zero
2850 or 1 value instead of the actual bit.
2851 Similarly for __sync_fetch_and_or_* (without the ", _3" part
2852 in there), and/or if mask_2 is a power of 2 constant.
2853 Similarly for xor instead of or, use ATOMIC_BIT_TEST_AND_COMPLEMENT
2854 in that case. And similarly for and instead of or, except that
2855 the second argument to the builtin needs to be one's complement
2856 of the mask instead of mask. */
2859 optimize_atomic_bit_test_and (gimple_stmt_iterator
*gsip
,
2860 enum internal_fn fn
, bool has_model_arg
,
2863 gimple
*call
= gsi_stmt (*gsip
);
2864 tree lhs
= gimple_call_lhs (call
);
2865 use_operand_p use_p
;
2870 if (!flag_inline_atomics
2872 || !gimple_call_builtin_p (call
, BUILT_IN_NORMAL
)
2874 || SSA_NAME_OCCURS_IN_ABNORMAL_PHI (lhs
)
2875 || !single_imm_use (lhs
, &use_p
, &use_stmt
)
2876 || !is_gimple_assign (use_stmt
)
2877 || gimple_assign_rhs_code (use_stmt
) != BIT_AND_EXPR
2878 || !gimple_vdef (call
))
2883 case IFN_ATOMIC_BIT_TEST_AND_SET
:
2884 optab
= atomic_bit_test_and_set_optab
;
2886 case IFN_ATOMIC_BIT_TEST_AND_COMPLEMENT
:
2887 optab
= atomic_bit_test_and_complement_optab
;
2889 case IFN_ATOMIC_BIT_TEST_AND_RESET
:
2890 optab
= atomic_bit_test_and_reset_optab
;
2896 if (optab_handler (optab
, TYPE_MODE (TREE_TYPE (lhs
))) == CODE_FOR_nothing
)
2899 mask
= gimple_call_arg (call
, 1);
2900 tree use_lhs
= gimple_assign_lhs (use_stmt
);
2904 if (TREE_CODE (mask
) == INTEGER_CST
)
2906 if (fn
== IFN_ATOMIC_BIT_TEST_AND_RESET
)
2907 mask
= const_unop (BIT_NOT_EXPR
, TREE_TYPE (mask
), mask
);
2908 mask
= fold_convert (TREE_TYPE (lhs
), mask
);
2909 int ibit
= tree_log2 (mask
);
2912 bit
= build_int_cst (TREE_TYPE (lhs
), ibit
);
2914 else if (TREE_CODE (mask
) == SSA_NAME
)
2916 gimple
*g
= SSA_NAME_DEF_STMT (mask
);
2917 if (fn
== IFN_ATOMIC_BIT_TEST_AND_RESET
)
2919 if (!is_gimple_assign (g
)
2920 || gimple_assign_rhs_code (g
) != BIT_NOT_EXPR
)
2922 mask
= gimple_assign_rhs1 (g
);
2923 if (TREE_CODE (mask
) != SSA_NAME
)
2925 g
= SSA_NAME_DEF_STMT (mask
);
2927 if (!is_gimple_assign (g
)
2928 || gimple_assign_rhs_code (g
) != LSHIFT_EXPR
2929 || !integer_onep (gimple_assign_rhs1 (g
)))
2931 bit
= gimple_assign_rhs2 (g
);
2936 if (gimple_assign_rhs1 (use_stmt
) == lhs
)
2938 if (!operand_equal_p (gimple_assign_rhs2 (use_stmt
), mask
, 0))
2941 else if (gimple_assign_rhs2 (use_stmt
) != lhs
2942 || !operand_equal_p (gimple_assign_rhs1 (use_stmt
), mask
, 0))
2945 bool use_bool
= true;
2946 bool has_debug_uses
= false;
2947 imm_use_iterator iter
;
2950 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (use_lhs
))
2952 FOR_EACH_IMM_USE_STMT (g
, iter
, use_lhs
)
2954 enum tree_code code
= ERROR_MARK
;
2955 tree op0
= NULL_TREE
, op1
= NULL_TREE
;
2956 if (is_gimple_debug (g
))
2958 has_debug_uses
= true;
2961 else if (is_gimple_assign (g
))
2962 switch (gimple_assign_rhs_code (g
))
2965 op1
= gimple_assign_rhs1 (g
);
2966 code
= TREE_CODE (op1
);
2967 op0
= TREE_OPERAND (op1
, 0);
2968 op1
= TREE_OPERAND (op1
, 1);
2972 code
= gimple_assign_rhs_code (g
);
2973 op0
= gimple_assign_rhs1 (g
);
2974 op1
= gimple_assign_rhs2 (g
);
2979 else if (gimple_code (g
) == GIMPLE_COND
)
2981 code
= gimple_cond_code (g
);
2982 op0
= gimple_cond_lhs (g
);
2983 op1
= gimple_cond_rhs (g
);
2986 if ((code
== EQ_EXPR
|| code
== NE_EXPR
)
2988 && integer_zerop (op1
))
2990 use_operand_p use_p
;
2992 FOR_EACH_IMM_USE_ON_STMT (use_p
, iter
)
2999 BREAK_FROM_IMM_USE_STMT (iter
);
3002 tree new_lhs
= make_ssa_name (TREE_TYPE (lhs
));
3003 tree flag
= build_int_cst (TREE_TYPE (lhs
), use_bool
);
3005 g
= gimple_build_call_internal (fn
, 4, gimple_call_arg (call
, 0),
3006 bit
, flag
, gimple_call_arg (call
, 2));
3008 g
= gimple_build_call_internal (fn
, 3, gimple_call_arg (call
, 0),
3010 gimple_call_set_lhs (g
, new_lhs
);
3011 gimple_set_location (g
, gimple_location (call
));
3012 gimple_move_vops (g
, call
);
3013 bool throws
= stmt_can_throw_internal (cfun
, call
);
3014 gimple_call_set_nothrow (as_a
<gcall
*> (g
),
3015 gimple_call_nothrow_p (as_a
<gcall
*> (call
)));
3016 gimple_stmt_iterator gsi
= *gsip
;
3017 gsi_insert_after (&gsi
, g
, GSI_NEW_STMT
);
3021 maybe_clean_or_replace_eh_stmt (call
, g
);
3022 if (after
|| (use_bool
&& has_debug_uses
))
3023 e
= find_fallthru_edge (gsi_bb (gsi
)->succs
);
3027 /* The internal function returns the value of the specified bit
3028 before the atomic operation. If we are interested in the value
3029 of the specified bit after the atomic operation (makes only sense
3030 for xor, otherwise the bit content is compile time known),
3031 we need to invert the bit. */
3032 g
= gimple_build_assign (make_ssa_name (TREE_TYPE (lhs
)),
3033 BIT_XOR_EXPR
, new_lhs
,
3034 use_bool
? build_int_cst (TREE_TYPE (lhs
), 1)
3036 new_lhs
= gimple_assign_lhs (g
);
3039 gsi_insert_on_edge_immediate (e
, g
);
3040 gsi
= gsi_for_stmt (g
);
3043 gsi_insert_after (&gsi
, g
, GSI_NEW_STMT
);
3045 if (use_bool
&& has_debug_uses
)
3047 tree temp
= NULL_TREE
;
3048 if (!throws
|| after
|| single_pred_p (e
->dest
))
3050 temp
= make_node (DEBUG_EXPR_DECL
);
3051 DECL_ARTIFICIAL (temp
) = 1;
3052 TREE_TYPE (temp
) = TREE_TYPE (lhs
);
3053 SET_DECL_MODE (temp
, TYPE_MODE (TREE_TYPE (lhs
)));
3054 tree t
= build2 (LSHIFT_EXPR
, TREE_TYPE (lhs
), new_lhs
, bit
);
3055 g
= gimple_build_debug_bind (temp
, t
, g
);
3056 if (throws
&& !after
)
3058 gsi
= gsi_after_labels (e
->dest
);
3059 gsi_insert_before (&gsi
, g
, GSI_SAME_STMT
);
3062 gsi_insert_after (&gsi
, g
, GSI_NEW_STMT
);
3064 FOR_EACH_IMM_USE_STMT (g
, iter
, use_lhs
)
3065 if (is_gimple_debug (g
))
3067 use_operand_p use_p
;
3068 if (temp
== NULL_TREE
)
3069 gimple_debug_bind_reset_value (g
);
3071 FOR_EACH_IMM_USE_ON_STMT (use_p
, iter
)
3072 SET_USE (use_p
, temp
);
3076 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (new_lhs
)
3077 = SSA_NAME_OCCURS_IN_ABNORMAL_PHI (use_lhs
);
3078 replace_uses_by (use_lhs
, new_lhs
);
3079 gsi
= gsi_for_stmt (use_stmt
);
3080 gsi_remove (&gsi
, true);
3081 release_defs (use_stmt
);
3082 gsi_remove (gsip
, true);
3083 release_ssa_name (lhs
);
3092 Similarly for memset (&a, ..., sizeof (a)); instead of a = {};
3093 and/or memcpy (&b, &a, sizeof (a)); instead of b = a; */
3096 optimize_memcpy (gimple_stmt_iterator
*gsip
, tree dest
, tree src
, tree len
)
3098 gimple
*stmt
= gsi_stmt (*gsip
);
3099 if (gimple_has_volatile_ops (stmt
))
3102 tree vuse
= gimple_vuse (stmt
);
3106 gimple
*defstmt
= SSA_NAME_DEF_STMT (vuse
);
3107 tree src2
= NULL_TREE
, len2
= NULL_TREE
;
3108 poly_int64 offset
, offset2
;
3109 tree val
= integer_zero_node
;
3110 if (gimple_store_p (defstmt
)
3111 && gimple_assign_single_p (defstmt
)
3112 && TREE_CODE (gimple_assign_rhs1 (defstmt
)) == CONSTRUCTOR
3113 && !gimple_clobber_p (defstmt
))
3114 src2
= gimple_assign_lhs (defstmt
);
3115 else if (gimple_call_builtin_p (defstmt
, BUILT_IN_MEMSET
)
3116 && TREE_CODE (gimple_call_arg (defstmt
, 0)) == ADDR_EXPR
3117 && TREE_CODE (gimple_call_arg (defstmt
, 1)) == INTEGER_CST
)
3119 src2
= TREE_OPERAND (gimple_call_arg (defstmt
, 0), 0);
3120 len2
= gimple_call_arg (defstmt
, 2);
3121 val
= gimple_call_arg (defstmt
, 1);
3122 /* For non-0 val, we'd have to transform stmt from assignment
3123 into memset (only if dest is addressable). */
3124 if (!integer_zerop (val
) && is_gimple_assign (stmt
))
3128 if (src2
== NULL_TREE
)
3131 if (len
== NULL_TREE
)
3132 len
= (TREE_CODE (src
) == COMPONENT_REF
3133 ? DECL_SIZE_UNIT (TREE_OPERAND (src
, 1))
3134 : TYPE_SIZE_UNIT (TREE_TYPE (src
)));
3135 if (len2
== NULL_TREE
)
3136 len2
= (TREE_CODE (src2
) == COMPONENT_REF
3137 ? DECL_SIZE_UNIT (TREE_OPERAND (src2
, 1))
3138 : TYPE_SIZE_UNIT (TREE_TYPE (src2
)));
3139 if (len
== NULL_TREE
3140 || !poly_int_tree_p (len
)
3141 || len2
== NULL_TREE
3142 || !poly_int_tree_p (len2
))
3145 src
= get_addr_base_and_unit_offset (src
, &offset
);
3146 src2
= get_addr_base_and_unit_offset (src2
, &offset2
);
3147 if (src
== NULL_TREE
3148 || src2
== NULL_TREE
3149 || maybe_lt (offset
, offset2
))
3152 if (!operand_equal_p (src
, src2
, 0))
3155 /* [ src + offset2, src + offset2 + len2 - 1 ] is set to val.
3157 [ src + offset, src + offset + len - 1 ] is a subset of that. */
3158 if (maybe_gt (wi::to_poly_offset (len
) + (offset
- offset2
),
3159 wi::to_poly_offset (len2
)))
3162 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
3164 fprintf (dump_file
, "Simplified\n ");
3165 print_gimple_stmt (dump_file
, stmt
, 0, dump_flags
);
3166 fprintf (dump_file
, "after previous\n ");
3167 print_gimple_stmt (dump_file
, defstmt
, 0, dump_flags
);
3170 /* For simplicity, don't change the kind of the stmt,
3171 turn dest = src; into dest = {}; and memcpy (&dest, &src, len);
3172 into memset (&dest, val, len);
3173 In theory we could change dest = src into memset if dest
3174 is addressable (maybe beneficial if val is not 0), or
3175 memcpy (&dest, &src, len) into dest = {} if len is the size
3176 of dest, dest isn't volatile. */
3177 if (is_gimple_assign (stmt
))
3179 tree ctor
= build_constructor (TREE_TYPE (dest
), NULL
);
3180 gimple_assign_set_rhs_from_tree (gsip
, ctor
);
3183 else /* If stmt is memcpy, transform it into memset. */
3185 gcall
*call
= as_a
<gcall
*> (stmt
);
3186 tree fndecl
= builtin_decl_implicit (BUILT_IN_MEMSET
);
3187 gimple_call_set_fndecl (call
, fndecl
);
3188 gimple_call_set_fntype (call
, TREE_TYPE (fndecl
));
3189 gimple_call_set_arg (call
, 1, val
);
3193 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
3195 fprintf (dump_file
, "into\n ");
3196 print_gimple_stmt (dump_file
, stmt
, 0, dump_flags
);
3200 /* A simple pass that attempts to fold all builtin functions. This pass
3201 is run after we've propagated as many constants as we can. */
3205 const pass_data pass_data_fold_builtins
=
3207 GIMPLE_PASS
, /* type */
3209 OPTGROUP_NONE
, /* optinfo_flags */
3210 TV_NONE
, /* tv_id */
3211 ( PROP_cfg
| PROP_ssa
), /* properties_required */
3212 0, /* properties_provided */
3213 0, /* properties_destroyed */
3214 0, /* todo_flags_start */
3215 TODO_update_ssa
, /* todo_flags_finish */
3218 class pass_fold_builtins
: public gimple_opt_pass
3221 pass_fold_builtins (gcc::context
*ctxt
)
3222 : gimple_opt_pass (pass_data_fold_builtins
, ctxt
)
3225 /* opt_pass methods: */
3226 opt_pass
* clone () { return new pass_fold_builtins (m_ctxt
); }
3227 virtual unsigned int execute (function
*);
3229 }; // class pass_fold_builtins
3232 pass_fold_builtins::execute (function
*fun
)
3234 bool cfg_changed
= false;
3236 unsigned int todoflags
= 0;
3238 FOR_EACH_BB_FN (bb
, fun
)
3240 gimple_stmt_iterator i
;
3241 for (i
= gsi_start_bb (bb
); !gsi_end_p (i
); )
3243 gimple
*stmt
, *old_stmt
;
3245 enum built_in_function fcode
;
3247 stmt
= gsi_stmt (i
);
3249 if (gimple_code (stmt
) != GIMPLE_CALL
)
3251 /* Remove all *ssaname_N ={v} {CLOBBER}; stmts,
3252 after the last GIMPLE DSE they aren't needed and might
3253 unnecessarily keep the SSA_NAMEs live. */
3254 if (gimple_clobber_p (stmt
))
3256 tree lhs
= gimple_assign_lhs (stmt
);
3257 if (TREE_CODE (lhs
) == MEM_REF
3258 && TREE_CODE (TREE_OPERAND (lhs
, 0)) == SSA_NAME
)
3260 unlink_stmt_vdef (stmt
);
3261 gsi_remove (&i
, true);
3262 release_defs (stmt
);
3266 else if (gimple_assign_load_p (stmt
) && gimple_store_p (stmt
))
3267 optimize_memcpy (&i
, gimple_assign_lhs (stmt
),
3268 gimple_assign_rhs1 (stmt
), NULL_TREE
);
3273 callee
= gimple_call_fndecl (stmt
);
3274 if (!callee
|| !fndecl_built_in_p (callee
, BUILT_IN_NORMAL
))
3280 fcode
= DECL_FUNCTION_CODE (callee
);
3285 tree result
= NULL_TREE
;
3286 switch (DECL_FUNCTION_CODE (callee
))
3288 case BUILT_IN_CONSTANT_P
:
3289 /* Resolve __builtin_constant_p. If it hasn't been
3290 folded to integer_one_node by now, it's fairly
3291 certain that the value simply isn't constant. */
3292 result
= integer_zero_node
;
3295 case BUILT_IN_ASSUME_ALIGNED
:
3296 /* Remove __builtin_assume_aligned. */
3297 result
= gimple_call_arg (stmt
, 0);
3300 case BUILT_IN_STACK_RESTORE
:
3301 result
= optimize_stack_restore (i
);
3307 case BUILT_IN_UNREACHABLE
:
3308 if (optimize_unreachable (i
))
3312 case BUILT_IN_ATOMIC_FETCH_OR_1
:
3313 case BUILT_IN_ATOMIC_FETCH_OR_2
:
3314 case BUILT_IN_ATOMIC_FETCH_OR_4
:
3315 case BUILT_IN_ATOMIC_FETCH_OR_8
:
3316 case BUILT_IN_ATOMIC_FETCH_OR_16
:
3317 optimize_atomic_bit_test_and (&i
,
3318 IFN_ATOMIC_BIT_TEST_AND_SET
,
3321 case BUILT_IN_SYNC_FETCH_AND_OR_1
:
3322 case BUILT_IN_SYNC_FETCH_AND_OR_2
:
3323 case BUILT_IN_SYNC_FETCH_AND_OR_4
:
3324 case BUILT_IN_SYNC_FETCH_AND_OR_8
:
3325 case BUILT_IN_SYNC_FETCH_AND_OR_16
:
3326 optimize_atomic_bit_test_and (&i
,
3327 IFN_ATOMIC_BIT_TEST_AND_SET
,
3331 case BUILT_IN_ATOMIC_FETCH_XOR_1
:
3332 case BUILT_IN_ATOMIC_FETCH_XOR_2
:
3333 case BUILT_IN_ATOMIC_FETCH_XOR_4
:
3334 case BUILT_IN_ATOMIC_FETCH_XOR_8
:
3335 case BUILT_IN_ATOMIC_FETCH_XOR_16
:
3336 optimize_atomic_bit_test_and
3337 (&i
, IFN_ATOMIC_BIT_TEST_AND_COMPLEMENT
, true, false);
3339 case BUILT_IN_SYNC_FETCH_AND_XOR_1
:
3340 case BUILT_IN_SYNC_FETCH_AND_XOR_2
:
3341 case BUILT_IN_SYNC_FETCH_AND_XOR_4
:
3342 case BUILT_IN_SYNC_FETCH_AND_XOR_8
:
3343 case BUILT_IN_SYNC_FETCH_AND_XOR_16
:
3344 optimize_atomic_bit_test_and
3345 (&i
, IFN_ATOMIC_BIT_TEST_AND_COMPLEMENT
, false, false);
3348 case BUILT_IN_ATOMIC_XOR_FETCH_1
:
3349 case BUILT_IN_ATOMIC_XOR_FETCH_2
:
3350 case BUILT_IN_ATOMIC_XOR_FETCH_4
:
3351 case BUILT_IN_ATOMIC_XOR_FETCH_8
:
3352 case BUILT_IN_ATOMIC_XOR_FETCH_16
:
3353 optimize_atomic_bit_test_and
3354 (&i
, IFN_ATOMIC_BIT_TEST_AND_COMPLEMENT
, true, true);
3356 case BUILT_IN_SYNC_XOR_AND_FETCH_1
:
3357 case BUILT_IN_SYNC_XOR_AND_FETCH_2
:
3358 case BUILT_IN_SYNC_XOR_AND_FETCH_4
:
3359 case BUILT_IN_SYNC_XOR_AND_FETCH_8
:
3360 case BUILT_IN_SYNC_XOR_AND_FETCH_16
:
3361 optimize_atomic_bit_test_and
3362 (&i
, IFN_ATOMIC_BIT_TEST_AND_COMPLEMENT
, false, true);
3365 case BUILT_IN_ATOMIC_FETCH_AND_1
:
3366 case BUILT_IN_ATOMIC_FETCH_AND_2
:
3367 case BUILT_IN_ATOMIC_FETCH_AND_4
:
3368 case BUILT_IN_ATOMIC_FETCH_AND_8
:
3369 case BUILT_IN_ATOMIC_FETCH_AND_16
:
3370 optimize_atomic_bit_test_and (&i
,
3371 IFN_ATOMIC_BIT_TEST_AND_RESET
,
3374 case BUILT_IN_SYNC_FETCH_AND_AND_1
:
3375 case BUILT_IN_SYNC_FETCH_AND_AND_2
:
3376 case BUILT_IN_SYNC_FETCH_AND_AND_4
:
3377 case BUILT_IN_SYNC_FETCH_AND_AND_8
:
3378 case BUILT_IN_SYNC_FETCH_AND_AND_16
:
3379 optimize_atomic_bit_test_and (&i
,
3380 IFN_ATOMIC_BIT_TEST_AND_RESET
,
3384 case BUILT_IN_MEMCPY
:
3385 if (gimple_call_builtin_p (stmt
, BUILT_IN_NORMAL
)
3386 && TREE_CODE (gimple_call_arg (stmt
, 0)) == ADDR_EXPR
3387 && TREE_CODE (gimple_call_arg (stmt
, 1)) == ADDR_EXPR
3388 && TREE_CODE (gimple_call_arg (stmt
, 2)) == INTEGER_CST
)
3390 tree dest
= TREE_OPERAND (gimple_call_arg (stmt
, 0), 0);
3391 tree src
= TREE_OPERAND (gimple_call_arg (stmt
, 1), 0);
3392 tree len
= gimple_call_arg (stmt
, 2);
3393 optimize_memcpy (&i
, dest
, src
, len
);
3397 case BUILT_IN_VA_START
:
3398 case BUILT_IN_VA_END
:
3399 case BUILT_IN_VA_COPY
:
3400 /* These shouldn't be folded before pass_stdarg. */
3401 result
= optimize_stdarg_builtin (stmt
);
3413 if (!update_call_from_tree (&i
, result
))
3414 gimplify_and_update_call_from_tree (&i
, result
);
3417 todoflags
|= TODO_update_address_taken
;
3419 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
3421 fprintf (dump_file
, "Simplified\n ");
3422 print_gimple_stmt (dump_file
, stmt
, 0, dump_flags
);
3426 stmt
= gsi_stmt (i
);
3429 if (maybe_clean_or_replace_eh_stmt (old_stmt
, stmt
)
3430 && gimple_purge_dead_eh_edges (bb
))
3433 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
3435 fprintf (dump_file
, "to\n ");
3436 print_gimple_stmt (dump_file
, stmt
, 0, dump_flags
);
3437 fprintf (dump_file
, "\n");
3440 /* Retry the same statement if it changed into another
3441 builtin, there might be new opportunities now. */
3442 if (gimple_code (stmt
) != GIMPLE_CALL
)
3447 callee
= gimple_call_fndecl (stmt
);
3449 || !fndecl_built_in_p (callee
, fcode
))
3454 /* Delete unreachable blocks. */
3456 todoflags
|= TODO_cleanup_cfg
;
3464 make_pass_fold_builtins (gcc::context
*ctxt
)
3466 return new pass_fold_builtins (ctxt
);
3469 /* A simple pass that emits some warnings post IPA. */
3473 const pass_data pass_data_post_ipa_warn
=
3475 GIMPLE_PASS
, /* type */
3476 "post_ipa_warn", /* name */
3477 OPTGROUP_NONE
, /* optinfo_flags */
3478 TV_NONE
, /* tv_id */
3479 ( PROP_cfg
| PROP_ssa
), /* properties_required */
3480 0, /* properties_provided */
3481 0, /* properties_destroyed */
3482 0, /* todo_flags_start */
3483 0, /* todo_flags_finish */
3486 class pass_post_ipa_warn
: public gimple_opt_pass
3489 pass_post_ipa_warn (gcc::context
*ctxt
)
3490 : gimple_opt_pass (pass_data_post_ipa_warn
, ctxt
)
3493 /* opt_pass methods: */
3494 opt_pass
* clone () { return new pass_post_ipa_warn (m_ctxt
); }
3495 virtual bool gate (function
*) { return warn_nonnull
!= 0; }
3496 virtual unsigned int execute (function
*);
3498 }; // class pass_fold_builtins
3501 pass_post_ipa_warn::execute (function
*fun
)
3505 FOR_EACH_BB_FN (bb
, fun
)
3507 gimple_stmt_iterator gsi
;
3508 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
3510 gimple
*stmt
= gsi_stmt (gsi
);
3511 if (!is_gimple_call (stmt
) || gimple_no_warning_p (stmt
))
3517 = get_nonnull_args (gimple_call_fntype (stmt
));
3520 for (unsigned i
= 0; i
< gimple_call_num_args (stmt
); i
++)
3522 tree arg
= gimple_call_arg (stmt
, i
);
3523 if (TREE_CODE (TREE_TYPE (arg
)) != POINTER_TYPE
)
3525 if (!integer_zerop (arg
))
3527 if (!bitmap_empty_p (nonnullargs
)
3528 && !bitmap_bit_p (nonnullargs
, i
))
3531 location_t loc
= gimple_location (stmt
);
3532 auto_diagnostic_group d
;
3533 if (warning_at (loc
, OPT_Wnonnull
,
3534 "%Gargument %u null where non-null "
3535 "expected", stmt
, i
+ 1))
3537 tree fndecl
= gimple_call_fndecl (stmt
);
3538 if (fndecl
&& DECL_IS_BUILTIN (fndecl
))
3539 inform (loc
, "in a call to built-in function %qD",
3542 inform (DECL_SOURCE_LOCATION (fndecl
),
3543 "in a call to function %qD declared here",
3548 BITMAP_FREE (nonnullargs
);
3559 make_pass_post_ipa_warn (gcc::context
*ctxt
)
3561 return new pass_post_ipa_warn (ctxt
);