* tree-vect-loop-manip.c (vect_do_peeling): Do not use
[official-gcc.git] / gcc / tree-ssa-ccp.c
blob283567c18c35cecba9b8070d875479fc635e182d
1 /* Conditional constant propagation pass for the GNU compiler.
2 Copyright (C) 2000-2017 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
11 later version.
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
16 for more details.
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
28 following values:
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
41 or not.
43 CONSTANT -> V_i has been found to hold a constant
44 value C.
46 VARYING -> V_i cannot take a constant value, or if it
47 does, it is not possible to determine it
48 at compile time.
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
59 can be visited.
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:
76 if (PRED)
77 a_9 = 3;
78 else
79 a_10 = 100;
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
108 never be extended.
110 References:
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 */
121 #include "config.h"
122 #include "system.h"
123 #include "coretypes.h"
124 #include "backend.h"
125 #include "target.h"
126 #include "tree.h"
127 #include "gimple.h"
128 #include "tree-pass.h"
129 #include "ssa.h"
130 #include "gimple-pretty-print.h"
131 #include "fold-const.h"
132 #include "gimple-fold.h"
133 #include "tree-eh.h"
134 #include "gimplify.h"
135 #include "gimple-iterator.h"
136 #include "tree-cfg.h"
137 #include "tree-ssa-propagate.h"
138 #include "dbgcnt.h"
139 #include "params.h"
140 #include "builtins.h"
141 #include "tree-chkp.h"
142 #include "cfgloop.h"
143 #include "stor-layout.h"
144 #include "optabs-query.h"
145 #include "tree-ssa-ccp.h"
146 #include "tree-dfa.h"
147 #include "diagnostic-core.h"
148 #include "stringpool.h"
149 #include "attribs.h"
151 /* Possible lattice values. */
152 typedef enum
154 UNINITIALIZED,
155 UNDEFINED,
156 CONSTANT,
157 VARYING
158 } ccp_lattice_t;
160 struct ccp_prop_value_t {
161 /* Lattice value. */
162 ccp_lattice_t lattice_val;
164 /* Propagated value. */
165 tree value;
167 /* Mask that applies to the propagated value during CCP. For X
168 with a CONSTANT lattice value X & ~mask == value & ~mask. The
169 zero bits in the mask cover constant values. The ones mean no
170 information. */
171 widest_int mask;
174 class ccp_propagate : public ssa_propagation_engine
176 public:
177 enum ssa_prop_result visit_stmt (gimple *, edge *, tree *) FINAL OVERRIDE;
178 enum ssa_prop_result visit_phi (gphi *) FINAL OVERRIDE;
181 /* Array of propagated constant values. After propagation,
182 CONST_VAL[I].VALUE holds the constant value for SSA_NAME(I). If
183 the constant is held in an SSA name representing a memory store
184 (i.e., a VDEF), CONST_VAL[I].MEM_REF will contain the actual
185 memory reference used to store (i.e., the LHS of the assignment
186 doing the store). */
187 static ccp_prop_value_t *const_val;
188 static unsigned n_const_val;
190 static void canonicalize_value (ccp_prop_value_t *);
191 static void ccp_lattice_meet (ccp_prop_value_t *, ccp_prop_value_t *);
193 /* Dump constant propagation value VAL to file OUTF prefixed by PREFIX. */
195 static void
196 dump_lattice_value (FILE *outf, const char *prefix, ccp_prop_value_t val)
198 switch (val.lattice_val)
200 case UNINITIALIZED:
201 fprintf (outf, "%sUNINITIALIZED", prefix);
202 break;
203 case UNDEFINED:
204 fprintf (outf, "%sUNDEFINED", prefix);
205 break;
206 case VARYING:
207 fprintf (outf, "%sVARYING", prefix);
208 break;
209 case CONSTANT:
210 if (TREE_CODE (val.value) != INTEGER_CST
211 || val.mask == 0)
213 fprintf (outf, "%sCONSTANT ", prefix);
214 print_generic_expr (outf, val.value, dump_flags);
216 else
218 widest_int cval = wi::bit_and_not (wi::to_widest (val.value),
219 val.mask);
220 fprintf (outf, "%sCONSTANT ", prefix);
221 print_hex (cval, outf);
222 fprintf (outf, " (");
223 print_hex (val.mask, outf);
224 fprintf (outf, ")");
226 break;
227 default:
228 gcc_unreachable ();
233 /* Print lattice value VAL to stderr. */
235 void debug_lattice_value (ccp_prop_value_t val);
237 DEBUG_FUNCTION void
238 debug_lattice_value (ccp_prop_value_t val)
240 dump_lattice_value (stderr, "", val);
241 fprintf (stderr, "\n");
244 /* Extend NONZERO_BITS to a full mask, based on sgn. */
246 static widest_int
247 extend_mask (const wide_int &nonzero_bits, signop sgn)
249 return widest_int::from (nonzero_bits, sgn);
252 /* Compute a default value for variable VAR and store it in the
253 CONST_VAL array. The following rules are used to get default
254 values:
256 1- Global and static variables that are declared constant are
257 considered CONSTANT.
259 2- Any other value is considered UNDEFINED. This is useful when
260 considering PHI nodes. PHI arguments that are undefined do not
261 change the constant value of the PHI node, which allows for more
262 constants to be propagated.
264 3- Variables defined by statements other than assignments and PHI
265 nodes are considered VARYING.
267 4- Initial values of variables that are not GIMPLE registers are
268 considered VARYING. */
270 static ccp_prop_value_t
271 get_default_value (tree var)
273 ccp_prop_value_t val = { UNINITIALIZED, NULL_TREE, 0 };
274 gimple *stmt;
276 stmt = SSA_NAME_DEF_STMT (var);
278 if (gimple_nop_p (stmt))
280 /* Variables defined by an empty statement are those used
281 before being initialized. If VAR is a local variable, we
282 can assume initially that it is UNDEFINED, otherwise we must
283 consider it VARYING. */
284 if (!virtual_operand_p (var)
285 && SSA_NAME_VAR (var)
286 && TREE_CODE (SSA_NAME_VAR (var)) == VAR_DECL)
287 val.lattice_val = UNDEFINED;
288 else
290 val.lattice_val = VARYING;
291 val.mask = -1;
292 if (flag_tree_bit_ccp)
294 wide_int nonzero_bits = get_nonzero_bits (var);
295 if (nonzero_bits != -1)
297 val.lattice_val = CONSTANT;
298 val.value = build_zero_cst (TREE_TYPE (var));
299 val.mask = extend_mask (nonzero_bits, TYPE_SIGN (TREE_TYPE (var)));
304 else if (is_gimple_assign (stmt))
306 tree cst;
307 if (gimple_assign_single_p (stmt)
308 && DECL_P (gimple_assign_rhs1 (stmt))
309 && (cst = get_symbol_constant_value (gimple_assign_rhs1 (stmt))))
311 val.lattice_val = CONSTANT;
312 val.value = cst;
314 else
316 /* Any other variable defined by an assignment is considered
317 UNDEFINED. */
318 val.lattice_val = UNDEFINED;
321 else if ((is_gimple_call (stmt)
322 && gimple_call_lhs (stmt) != NULL_TREE)
323 || gimple_code (stmt) == GIMPLE_PHI)
325 /* A variable defined by a call or a PHI node is considered
326 UNDEFINED. */
327 val.lattice_val = UNDEFINED;
329 else
331 /* Otherwise, VAR will never take on a constant value. */
332 val.lattice_val = VARYING;
333 val.mask = -1;
336 return val;
340 /* Get the constant value associated with variable VAR. */
342 static inline ccp_prop_value_t *
343 get_value (tree var)
345 ccp_prop_value_t *val;
347 if (const_val == NULL
348 || SSA_NAME_VERSION (var) >= n_const_val)
349 return NULL;
351 val = &const_val[SSA_NAME_VERSION (var)];
352 if (val->lattice_val == UNINITIALIZED)
353 *val = get_default_value (var);
355 canonicalize_value (val);
357 return val;
360 /* Return the constant tree value associated with VAR. */
362 static inline tree
363 get_constant_value (tree var)
365 ccp_prop_value_t *val;
366 if (TREE_CODE (var) != SSA_NAME)
368 if (is_gimple_min_invariant (var))
369 return var;
370 return NULL_TREE;
372 val = get_value (var);
373 if (val
374 && val->lattice_val == CONSTANT
375 && (TREE_CODE (val->value) != INTEGER_CST
376 || val->mask == 0))
377 return val->value;
378 return NULL_TREE;
381 /* Sets the value associated with VAR to VARYING. */
383 static inline void
384 set_value_varying (tree var)
386 ccp_prop_value_t *val = &const_val[SSA_NAME_VERSION (var)];
388 val->lattice_val = VARYING;
389 val->value = NULL_TREE;
390 val->mask = -1;
393 /* For integer constants, make sure to drop TREE_OVERFLOW. */
395 static void
396 canonicalize_value (ccp_prop_value_t *val)
398 if (val->lattice_val != CONSTANT)
399 return;
401 if (TREE_OVERFLOW_P (val->value))
402 val->value = drop_tree_overflow (val->value);
405 /* Return whether the lattice transition is valid. */
407 static bool
408 valid_lattice_transition (ccp_prop_value_t old_val, ccp_prop_value_t new_val)
410 /* Lattice transitions must always be monotonically increasing in
411 value. */
412 if (old_val.lattice_val < new_val.lattice_val)
413 return true;
415 if (old_val.lattice_val != new_val.lattice_val)
416 return false;
418 if (!old_val.value && !new_val.value)
419 return true;
421 /* Now both lattice values are CONSTANT. */
423 /* Allow arbitrary copy changes as we might look through PHI <a_1, ...>
424 when only a single copy edge is executable. */
425 if (TREE_CODE (old_val.value) == SSA_NAME
426 && TREE_CODE (new_val.value) == SSA_NAME)
427 return true;
429 /* Allow transitioning from a constant to a copy. */
430 if (is_gimple_min_invariant (old_val.value)
431 && TREE_CODE (new_val.value) == SSA_NAME)
432 return true;
434 /* Allow transitioning from PHI <&x, not executable> == &x
435 to PHI <&x, &y> == common alignment. */
436 if (TREE_CODE (old_val.value) != INTEGER_CST
437 && TREE_CODE (new_val.value) == INTEGER_CST)
438 return true;
440 /* Bit-lattices have to agree in the still valid bits. */
441 if (TREE_CODE (old_val.value) == INTEGER_CST
442 && TREE_CODE (new_val.value) == INTEGER_CST)
443 return (wi::bit_and_not (wi::to_widest (old_val.value), new_val.mask)
444 == wi::bit_and_not (wi::to_widest (new_val.value), new_val.mask));
446 /* Otherwise constant values have to agree. */
447 if (operand_equal_p (old_val.value, new_val.value, 0))
448 return true;
450 /* At least the kinds and types should agree now. */
451 if (TREE_CODE (old_val.value) != TREE_CODE (new_val.value)
452 || !types_compatible_p (TREE_TYPE (old_val.value),
453 TREE_TYPE (new_val.value)))
454 return false;
456 /* For floats and !HONOR_NANS allow transitions from (partial) NaN
457 to non-NaN. */
458 tree type = TREE_TYPE (new_val.value);
459 if (SCALAR_FLOAT_TYPE_P (type)
460 && !HONOR_NANS (type))
462 if (REAL_VALUE_ISNAN (TREE_REAL_CST (old_val.value)))
463 return true;
465 else if (VECTOR_FLOAT_TYPE_P (type)
466 && !HONOR_NANS (type))
468 for (unsigned i = 0; i < VECTOR_CST_NELTS (old_val.value); ++i)
469 if (!REAL_VALUE_ISNAN
470 (TREE_REAL_CST (VECTOR_CST_ELT (old_val.value, i)))
471 && !operand_equal_p (VECTOR_CST_ELT (old_val.value, i),
472 VECTOR_CST_ELT (new_val.value, i), 0))
473 return false;
474 return true;
476 else if (COMPLEX_FLOAT_TYPE_P (type)
477 && !HONOR_NANS (type))
479 if (!REAL_VALUE_ISNAN (TREE_REAL_CST (TREE_REALPART (old_val.value)))
480 && !operand_equal_p (TREE_REALPART (old_val.value),
481 TREE_REALPART (new_val.value), 0))
482 return false;
483 if (!REAL_VALUE_ISNAN (TREE_REAL_CST (TREE_IMAGPART (old_val.value)))
484 && !operand_equal_p (TREE_IMAGPART (old_val.value),
485 TREE_IMAGPART (new_val.value), 0))
486 return false;
487 return true;
489 return false;
492 /* Set the value for variable VAR to NEW_VAL. Return true if the new
493 value is different from VAR's previous value. */
495 static bool
496 set_lattice_value (tree var, ccp_prop_value_t *new_val)
498 /* We can deal with old UNINITIALIZED values just fine here. */
499 ccp_prop_value_t *old_val = &const_val[SSA_NAME_VERSION (var)];
501 canonicalize_value (new_val);
503 /* We have to be careful to not go up the bitwise lattice
504 represented by the mask. Instead of dropping to VARYING
505 use the meet operator to retain a conservative value.
506 Missed optimizations like PR65851 makes this necessary.
507 It also ensures we converge to a stable lattice solution. */
508 if (old_val->lattice_val != UNINITIALIZED)
509 ccp_lattice_meet (new_val, old_val);
511 gcc_checking_assert (valid_lattice_transition (*old_val, *new_val));
513 /* If *OLD_VAL and NEW_VAL are the same, return false to inform the
514 caller that this was a non-transition. */
515 if (old_val->lattice_val != new_val->lattice_val
516 || (new_val->lattice_val == CONSTANT
517 && (TREE_CODE (new_val->value) != TREE_CODE (old_val->value)
518 || (TREE_CODE (new_val->value) == INTEGER_CST
519 && (new_val->mask != old_val->mask
520 || (wi::bit_and_not (wi::to_widest (old_val->value),
521 new_val->mask)
522 != wi::bit_and_not (wi::to_widest (new_val->value),
523 new_val->mask))))
524 || (TREE_CODE (new_val->value) != INTEGER_CST
525 && !operand_equal_p (new_val->value, old_val->value, 0)))))
527 /* ??? We would like to delay creation of INTEGER_CSTs from
528 partially constants here. */
530 if (dump_file && (dump_flags & TDF_DETAILS))
532 dump_lattice_value (dump_file, "Lattice value changed to ", *new_val);
533 fprintf (dump_file, ". Adding SSA edges to worklist.\n");
536 *old_val = *new_val;
538 gcc_assert (new_val->lattice_val != UNINITIALIZED);
539 return true;
542 return false;
545 static ccp_prop_value_t get_value_for_expr (tree, bool);
546 static ccp_prop_value_t bit_value_binop (enum tree_code, tree, tree, tree);
547 void bit_value_binop (enum tree_code, signop, int, widest_int *, widest_int *,
548 signop, int, const widest_int &, const widest_int &,
549 signop, int, const widest_int &, const widest_int &);
551 /* Return a widest_int that can be used for bitwise simplifications
552 from VAL. */
554 static widest_int
555 value_to_wide_int (ccp_prop_value_t val)
557 if (val.value
558 && TREE_CODE (val.value) == INTEGER_CST)
559 return wi::to_widest (val.value);
561 return 0;
564 /* Return the value for the address expression EXPR based on alignment
565 information. */
567 static ccp_prop_value_t
568 get_value_from_alignment (tree expr)
570 tree type = TREE_TYPE (expr);
571 ccp_prop_value_t val;
572 unsigned HOST_WIDE_INT bitpos;
573 unsigned int align;
575 gcc_assert (TREE_CODE (expr) == ADDR_EXPR);
577 get_pointer_alignment_1 (expr, &align, &bitpos);
578 val.mask = wi::bit_and_not
579 (POINTER_TYPE_P (type) || TYPE_UNSIGNED (type)
580 ? wi::mask <widest_int> (TYPE_PRECISION (type), false)
581 : -1,
582 align / BITS_PER_UNIT - 1);
583 val.lattice_val
584 = wi::sext (val.mask, TYPE_PRECISION (type)) == -1 ? VARYING : CONSTANT;
585 if (val.lattice_val == CONSTANT)
586 val.value = build_int_cstu (type, bitpos / BITS_PER_UNIT);
587 else
588 val.value = NULL_TREE;
590 return val;
593 /* Return the value for the tree operand EXPR. If FOR_BITS_P is true
594 return constant bits extracted from alignment information for
595 invariant addresses. */
597 static ccp_prop_value_t
598 get_value_for_expr (tree expr, bool for_bits_p)
600 ccp_prop_value_t val;
602 if (TREE_CODE (expr) == SSA_NAME)
604 ccp_prop_value_t *val_ = get_value (expr);
605 if (val_)
606 val = *val_;
607 else
609 val.lattice_val = VARYING;
610 val.value = NULL_TREE;
611 val.mask = -1;
613 if (for_bits_p
614 && val.lattice_val == CONSTANT
615 && TREE_CODE (val.value) == ADDR_EXPR)
616 val = get_value_from_alignment (val.value);
617 /* Fall back to a copy value. */
618 if (!for_bits_p
619 && val.lattice_val == VARYING
620 && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (expr))
622 val.lattice_val = CONSTANT;
623 val.value = expr;
624 val.mask = -1;
627 else if (is_gimple_min_invariant (expr)
628 && (!for_bits_p || TREE_CODE (expr) == INTEGER_CST))
630 val.lattice_val = CONSTANT;
631 val.value = expr;
632 val.mask = 0;
633 canonicalize_value (&val);
635 else if (TREE_CODE (expr) == ADDR_EXPR)
636 val = get_value_from_alignment (expr);
637 else
639 val.lattice_val = VARYING;
640 val.mask = -1;
641 val.value = NULL_TREE;
644 if (val.lattice_val == VARYING
645 && TYPE_UNSIGNED (TREE_TYPE (expr)))
646 val.mask = wi::zext (val.mask, TYPE_PRECISION (TREE_TYPE (expr)));
648 return val;
651 /* Return the likely CCP lattice value for STMT.
653 If STMT has no operands, then return CONSTANT.
655 Else if undefinedness of operands of STMT cause its value to be
656 undefined, then return UNDEFINED.
658 Else if any operands of STMT are constants, then return CONSTANT.
660 Else return VARYING. */
662 static ccp_lattice_t
663 likely_value (gimple *stmt)
665 bool has_constant_operand, has_undefined_operand, all_undefined_operands;
666 bool has_nsa_operand;
667 tree use;
668 ssa_op_iter iter;
669 unsigned i;
671 enum gimple_code code = gimple_code (stmt);
673 /* This function appears to be called only for assignments, calls,
674 conditionals, and switches, due to the logic in visit_stmt. */
675 gcc_assert (code == GIMPLE_ASSIGN
676 || code == GIMPLE_CALL
677 || code == GIMPLE_COND
678 || code == GIMPLE_SWITCH);
680 /* If the statement has volatile operands, it won't fold to a
681 constant value. */
682 if (gimple_has_volatile_ops (stmt))
683 return VARYING;
685 /* Arrive here for more complex cases. */
686 has_constant_operand = false;
687 has_undefined_operand = false;
688 all_undefined_operands = true;
689 has_nsa_operand = false;
690 FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter, SSA_OP_USE)
692 ccp_prop_value_t *val = get_value (use);
694 if (val && val->lattice_val == UNDEFINED)
695 has_undefined_operand = true;
696 else
697 all_undefined_operands = false;
699 if (val && val->lattice_val == CONSTANT)
700 has_constant_operand = true;
702 if (SSA_NAME_IS_DEFAULT_DEF (use)
703 || !prop_simulate_again_p (SSA_NAME_DEF_STMT (use)))
704 has_nsa_operand = true;
707 /* There may be constants in regular rhs operands. For calls we
708 have to ignore lhs, fndecl and static chain, otherwise only
709 the lhs. */
710 for (i = (is_gimple_call (stmt) ? 2 : 0) + gimple_has_lhs (stmt);
711 i < gimple_num_ops (stmt); ++i)
713 tree op = gimple_op (stmt, i);
714 if (!op || TREE_CODE (op) == SSA_NAME)
715 continue;
716 if (is_gimple_min_invariant (op))
717 has_constant_operand = true;
720 if (has_constant_operand)
721 all_undefined_operands = false;
723 if (has_undefined_operand
724 && code == GIMPLE_CALL
725 && gimple_call_internal_p (stmt))
726 switch (gimple_call_internal_fn (stmt))
728 /* These 3 builtins use the first argument just as a magic
729 way how to find out a decl uid. */
730 case IFN_GOMP_SIMD_LANE:
731 case IFN_GOMP_SIMD_VF:
732 case IFN_GOMP_SIMD_LAST_LANE:
733 has_undefined_operand = false;
734 break;
735 default:
736 break;
739 /* If the operation combines operands like COMPLEX_EXPR make sure to
740 not mark the result UNDEFINED if only one part of the result is
741 undefined. */
742 if (has_undefined_operand && all_undefined_operands)
743 return UNDEFINED;
744 else if (code == GIMPLE_ASSIGN && has_undefined_operand)
746 switch (gimple_assign_rhs_code (stmt))
748 /* Unary operators are handled with all_undefined_operands. */
749 case PLUS_EXPR:
750 case MINUS_EXPR:
751 case POINTER_PLUS_EXPR:
752 case BIT_XOR_EXPR:
753 /* Not MIN_EXPR, MAX_EXPR. One VARYING operand may be selected.
754 Not bitwise operators, one VARYING operand may specify the
755 result completely.
756 Not logical operators for the same reason, apart from XOR.
757 Not COMPLEX_EXPR as one VARYING operand makes the result partly
758 not UNDEFINED. Not *DIV_EXPR, comparisons and shifts because
759 the undefined operand may be promoted. */
760 return UNDEFINED;
762 case ADDR_EXPR:
763 /* If any part of an address is UNDEFINED, like the index
764 of an ARRAY_EXPR, then treat the result as UNDEFINED. */
765 return UNDEFINED;
767 default:
771 /* If there was an UNDEFINED operand but the result may be not UNDEFINED
772 fall back to CONSTANT. During iteration UNDEFINED may still drop
773 to CONSTANT. */
774 if (has_undefined_operand)
775 return CONSTANT;
777 /* We do not consider virtual operands here -- load from read-only
778 memory may have only VARYING virtual operands, but still be
779 constant. Also we can combine the stmt with definitions from
780 operands whose definitions are not simulated again. */
781 if (has_constant_operand
782 || has_nsa_operand
783 || gimple_references_memory_p (stmt))
784 return CONSTANT;
786 return VARYING;
789 /* Returns true if STMT cannot be constant. */
791 static bool
792 surely_varying_stmt_p (gimple *stmt)
794 /* If the statement has operands that we cannot handle, it cannot be
795 constant. */
796 if (gimple_has_volatile_ops (stmt))
797 return true;
799 /* If it is a call and does not return a value or is not a
800 builtin and not an indirect call or a call to function with
801 assume_aligned/alloc_align attribute, it is varying. */
802 if (is_gimple_call (stmt))
804 tree fndecl, fntype = gimple_call_fntype (stmt);
805 if (!gimple_call_lhs (stmt)
806 || ((fndecl = gimple_call_fndecl (stmt)) != NULL_TREE
807 && !DECL_BUILT_IN (fndecl)
808 && !lookup_attribute ("assume_aligned",
809 TYPE_ATTRIBUTES (fntype))
810 && !lookup_attribute ("alloc_align",
811 TYPE_ATTRIBUTES (fntype))))
812 return true;
815 /* Any other store operation is not interesting. */
816 else if (gimple_vdef (stmt))
817 return true;
819 /* Anything other than assignments and conditional jumps are not
820 interesting for CCP. */
821 if (gimple_code (stmt) != GIMPLE_ASSIGN
822 && gimple_code (stmt) != GIMPLE_COND
823 && gimple_code (stmt) != GIMPLE_SWITCH
824 && gimple_code (stmt) != GIMPLE_CALL)
825 return true;
827 return false;
830 /* Initialize local data structures for CCP. */
832 static void
833 ccp_initialize (void)
835 basic_block bb;
837 n_const_val = num_ssa_names;
838 const_val = XCNEWVEC (ccp_prop_value_t, n_const_val);
840 /* Initialize simulation flags for PHI nodes and statements. */
841 FOR_EACH_BB_FN (bb, cfun)
843 gimple_stmt_iterator i;
845 for (i = gsi_start_bb (bb); !gsi_end_p (i); gsi_next (&i))
847 gimple *stmt = gsi_stmt (i);
848 bool is_varying;
850 /* If the statement is a control insn, then we do not
851 want to avoid simulating the statement once. Failure
852 to do so means that those edges will never get added. */
853 if (stmt_ends_bb_p (stmt))
854 is_varying = false;
855 else
856 is_varying = surely_varying_stmt_p (stmt);
858 if (is_varying)
860 tree def;
861 ssa_op_iter iter;
863 /* If the statement will not produce a constant, mark
864 all its outputs VARYING. */
865 FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_ALL_DEFS)
866 set_value_varying (def);
868 prop_set_simulate_again (stmt, !is_varying);
872 /* Now process PHI nodes. We never clear the simulate_again flag on
873 phi nodes, since we do not know which edges are executable yet,
874 except for phi nodes for virtual operands when we do not do store ccp. */
875 FOR_EACH_BB_FN (bb, cfun)
877 gphi_iterator i;
879 for (i = gsi_start_phis (bb); !gsi_end_p (i); gsi_next (&i))
881 gphi *phi = i.phi ();
883 if (virtual_operand_p (gimple_phi_result (phi)))
884 prop_set_simulate_again (phi, false);
885 else
886 prop_set_simulate_again (phi, true);
891 /* Debug count support. Reset the values of ssa names
892 VARYING when the total number ssa names analyzed is
893 beyond the debug count specified. */
895 static void
896 do_dbg_cnt (void)
898 unsigned i;
899 for (i = 0; i < num_ssa_names; i++)
901 if (!dbg_cnt (ccp))
903 const_val[i].lattice_val = VARYING;
904 const_val[i].mask = -1;
905 const_val[i].value = NULL_TREE;
911 /* We want to provide our own GET_VALUE and FOLD_STMT virtual methods. */
912 class ccp_folder : public substitute_and_fold_engine
914 public:
915 tree get_value (tree) FINAL OVERRIDE;
916 bool fold_stmt (gimple_stmt_iterator *) FINAL OVERRIDE;
919 /* This method just wraps GET_CONSTANT_VALUE for now. Over time
920 naked calls to GET_CONSTANT_VALUE should be eliminated in favor
921 of calling member functions. */
923 tree
924 ccp_folder::get_value (tree op)
926 return get_constant_value (op);
929 /* Do final substitution of propagated values, cleanup the flowgraph and
930 free allocated storage. If NONZERO_P, record nonzero bits.
932 Return TRUE when something was optimized. */
934 static bool
935 ccp_finalize (bool nonzero_p)
937 bool something_changed;
938 unsigned i;
939 tree name;
941 do_dbg_cnt ();
943 /* Derive alignment and misalignment information from partially
944 constant pointers in the lattice or nonzero bits from partially
945 constant integers. */
946 FOR_EACH_SSA_NAME (i, name, cfun)
948 ccp_prop_value_t *val;
949 unsigned int tem, align;
951 if (!POINTER_TYPE_P (TREE_TYPE (name))
952 && (!INTEGRAL_TYPE_P (TREE_TYPE (name))
953 /* Don't record nonzero bits before IPA to avoid
954 using too much memory. */
955 || !nonzero_p))
956 continue;
958 val = get_value (name);
959 if (val->lattice_val != CONSTANT
960 || TREE_CODE (val->value) != INTEGER_CST
961 || val->mask == 0)
962 continue;
964 if (POINTER_TYPE_P (TREE_TYPE (name)))
966 /* Trailing mask bits specify the alignment, trailing value
967 bits the misalignment. */
968 tem = val->mask.to_uhwi ();
969 align = least_bit_hwi (tem);
970 if (align > 1)
971 set_ptr_info_alignment (get_ptr_info (name), align,
972 (TREE_INT_CST_LOW (val->value)
973 & (align - 1)));
975 else
977 unsigned int precision = TYPE_PRECISION (TREE_TYPE (val->value));
978 wide_int nonzero_bits
979 = (wide_int::from (val->mask, precision, UNSIGNED)
980 | wi::to_wide (val->value));
981 nonzero_bits &= get_nonzero_bits (name);
982 set_nonzero_bits (name, nonzero_bits);
986 /* Perform substitutions based on the known constant values. */
987 class ccp_folder ccp_folder;
988 something_changed = ccp_folder.substitute_and_fold ();
990 free (const_val);
991 const_val = NULL;
992 return something_changed;;
996 /* Compute the meet operator between *VAL1 and *VAL2. Store the result
997 in VAL1.
999 any M UNDEFINED = any
1000 any M VARYING = VARYING
1001 Ci M Cj = Ci if (i == j)
1002 Ci M Cj = VARYING if (i != j)
1005 static void
1006 ccp_lattice_meet (ccp_prop_value_t *val1, ccp_prop_value_t *val2)
1008 if (val1->lattice_val == UNDEFINED
1009 /* For UNDEFINED M SSA we can't always SSA because its definition
1010 may not dominate the PHI node. Doing optimistic copy propagation
1011 also causes a lot of gcc.dg/uninit-pred*.c FAILs. */
1012 && (val2->lattice_val != CONSTANT
1013 || TREE_CODE (val2->value) != SSA_NAME))
1015 /* UNDEFINED M any = any */
1016 *val1 = *val2;
1018 else if (val2->lattice_val == UNDEFINED
1019 /* See above. */
1020 && (val1->lattice_val != CONSTANT
1021 || TREE_CODE (val1->value) != SSA_NAME))
1023 /* any M UNDEFINED = any
1024 Nothing to do. VAL1 already contains the value we want. */
1027 else if (val1->lattice_val == VARYING
1028 || val2->lattice_val == VARYING)
1030 /* any M VARYING = VARYING. */
1031 val1->lattice_val = VARYING;
1032 val1->mask = -1;
1033 val1->value = NULL_TREE;
1035 else if (val1->lattice_val == CONSTANT
1036 && val2->lattice_val == CONSTANT
1037 && TREE_CODE (val1->value) == INTEGER_CST
1038 && TREE_CODE (val2->value) == INTEGER_CST)
1040 /* Ci M Cj = Ci if (i == j)
1041 Ci M Cj = VARYING if (i != j)
1043 For INTEGER_CSTs mask unequal bits. If no equal bits remain,
1044 drop to varying. */
1045 val1->mask = (val1->mask | val2->mask
1046 | (wi::to_widest (val1->value)
1047 ^ wi::to_widest (val2->value)));
1048 if (wi::sext (val1->mask, TYPE_PRECISION (TREE_TYPE (val1->value))) == -1)
1050 val1->lattice_val = VARYING;
1051 val1->value = NULL_TREE;
1054 else if (val1->lattice_val == CONSTANT
1055 && val2->lattice_val == CONSTANT
1056 && operand_equal_p (val1->value, val2->value, 0))
1058 /* Ci M Cj = Ci if (i == j)
1059 Ci M Cj = VARYING if (i != j)
1061 VAL1 already contains the value we want for equivalent values. */
1063 else if (val1->lattice_val == CONSTANT
1064 && val2->lattice_val == CONSTANT
1065 && (TREE_CODE (val1->value) == ADDR_EXPR
1066 || TREE_CODE (val2->value) == ADDR_EXPR))
1068 /* When not equal addresses are involved try meeting for
1069 alignment. */
1070 ccp_prop_value_t tem = *val2;
1071 if (TREE_CODE (val1->value) == ADDR_EXPR)
1072 *val1 = get_value_for_expr (val1->value, true);
1073 if (TREE_CODE (val2->value) == ADDR_EXPR)
1074 tem = get_value_for_expr (val2->value, true);
1075 ccp_lattice_meet (val1, &tem);
1077 else
1079 /* Any other combination is VARYING. */
1080 val1->lattice_val = VARYING;
1081 val1->mask = -1;
1082 val1->value = NULL_TREE;
1087 /* Loop through the PHI_NODE's parameters for BLOCK and compare their
1088 lattice values to determine PHI_NODE's lattice value. The value of a
1089 PHI node is determined calling ccp_lattice_meet with all the arguments
1090 of the PHI node that are incoming via executable edges. */
1092 enum ssa_prop_result
1093 ccp_propagate::visit_phi (gphi *phi)
1095 unsigned i;
1096 ccp_prop_value_t new_val;
1098 if (dump_file && (dump_flags & TDF_DETAILS))
1100 fprintf (dump_file, "\nVisiting PHI node: ");
1101 print_gimple_stmt (dump_file, phi, 0, dump_flags);
1104 new_val.lattice_val = UNDEFINED;
1105 new_val.value = NULL_TREE;
1106 new_val.mask = 0;
1108 bool first = true;
1109 bool non_exec_edge = false;
1110 for (i = 0; i < gimple_phi_num_args (phi); i++)
1112 /* Compute the meet operator over all the PHI arguments flowing
1113 through executable edges. */
1114 edge e = gimple_phi_arg_edge (phi, i);
1116 if (dump_file && (dump_flags & TDF_DETAILS))
1118 fprintf (dump_file,
1119 "\n Argument #%d (%d -> %d %sexecutable)\n",
1120 i, e->src->index, e->dest->index,
1121 (e->flags & EDGE_EXECUTABLE) ? "" : "not ");
1124 /* If the incoming edge is executable, Compute the meet operator for
1125 the existing value of the PHI node and the current PHI argument. */
1126 if (e->flags & EDGE_EXECUTABLE)
1128 tree arg = gimple_phi_arg (phi, i)->def;
1129 ccp_prop_value_t arg_val = get_value_for_expr (arg, false);
1131 if (first)
1133 new_val = arg_val;
1134 first = false;
1136 else
1137 ccp_lattice_meet (&new_val, &arg_val);
1139 if (dump_file && (dump_flags & TDF_DETAILS))
1141 fprintf (dump_file, "\t");
1142 print_generic_expr (dump_file, arg, dump_flags);
1143 dump_lattice_value (dump_file, "\tValue: ", arg_val);
1144 fprintf (dump_file, "\n");
1147 if (new_val.lattice_val == VARYING)
1148 break;
1150 else
1151 non_exec_edge = true;
1154 /* In case there were non-executable edges and the value is a copy
1155 make sure its definition dominates the PHI node. */
1156 if (non_exec_edge
1157 && new_val.lattice_val == CONSTANT
1158 && TREE_CODE (new_val.value) == SSA_NAME
1159 && ! SSA_NAME_IS_DEFAULT_DEF (new_val.value)
1160 && ! dominated_by_p (CDI_DOMINATORS, gimple_bb (phi),
1161 gimple_bb (SSA_NAME_DEF_STMT (new_val.value))))
1163 new_val.lattice_val = VARYING;
1164 new_val.value = NULL_TREE;
1165 new_val.mask = -1;
1168 if (dump_file && (dump_flags & TDF_DETAILS))
1170 dump_lattice_value (dump_file, "\n PHI node value: ", new_val);
1171 fprintf (dump_file, "\n\n");
1174 /* Make the transition to the new value. */
1175 if (set_lattice_value (gimple_phi_result (phi), &new_val))
1177 if (new_val.lattice_val == VARYING)
1178 return SSA_PROP_VARYING;
1179 else
1180 return SSA_PROP_INTERESTING;
1182 else
1183 return SSA_PROP_NOT_INTERESTING;
1186 /* Return the constant value for OP or OP otherwise. */
1188 static tree
1189 valueize_op (tree op)
1191 if (TREE_CODE (op) == SSA_NAME)
1193 tree tem = get_constant_value (op);
1194 if (tem)
1195 return tem;
1197 return op;
1200 /* Return the constant value for OP, but signal to not follow SSA
1201 edges if the definition may be simulated again. */
1203 static tree
1204 valueize_op_1 (tree op)
1206 if (TREE_CODE (op) == SSA_NAME)
1208 /* If the definition may be simulated again we cannot follow
1209 this SSA edge as the SSA propagator does not necessarily
1210 re-visit the use. */
1211 gimple *def_stmt = SSA_NAME_DEF_STMT (op);
1212 if (!gimple_nop_p (def_stmt)
1213 && prop_simulate_again_p (def_stmt))
1214 return NULL_TREE;
1215 tree tem = get_constant_value (op);
1216 if (tem)
1217 return tem;
1219 return op;
1222 /* CCP specific front-end to the non-destructive constant folding
1223 routines.
1225 Attempt to simplify the RHS of STMT knowing that one or more
1226 operands are constants.
1228 If simplification is possible, return the simplified RHS,
1229 otherwise return the original RHS or NULL_TREE. */
1231 static tree
1232 ccp_fold (gimple *stmt)
1234 location_t loc = gimple_location (stmt);
1235 switch (gimple_code (stmt))
1237 case GIMPLE_COND:
1239 /* Handle comparison operators that can appear in GIMPLE form. */
1240 tree op0 = valueize_op (gimple_cond_lhs (stmt));
1241 tree op1 = valueize_op (gimple_cond_rhs (stmt));
1242 enum tree_code code = gimple_cond_code (stmt);
1243 return fold_binary_loc (loc, code, boolean_type_node, op0, op1);
1246 case GIMPLE_SWITCH:
1248 /* Return the constant switch index. */
1249 return valueize_op (gimple_switch_index (as_a <gswitch *> (stmt)));
1252 case GIMPLE_ASSIGN:
1253 case GIMPLE_CALL:
1254 return gimple_fold_stmt_to_constant_1 (stmt,
1255 valueize_op, valueize_op_1);
1257 default:
1258 gcc_unreachable ();
1262 /* Apply the operation CODE in type TYPE to the value, mask pair
1263 RVAL and RMASK representing a value of type RTYPE and set
1264 the value, mask pair *VAL and *MASK to the result. */
1266 void
1267 bit_value_unop (enum tree_code code, signop type_sgn, int type_precision,
1268 widest_int *val, widest_int *mask,
1269 signop rtype_sgn, int rtype_precision,
1270 const widest_int &rval, const widest_int &rmask)
1272 switch (code)
1274 case BIT_NOT_EXPR:
1275 *mask = rmask;
1276 *val = ~rval;
1277 break;
1279 case NEGATE_EXPR:
1281 widest_int temv, temm;
1282 /* Return ~rval + 1. */
1283 bit_value_unop (BIT_NOT_EXPR, type_sgn, type_precision, &temv, &temm,
1284 type_sgn, type_precision, rval, rmask);
1285 bit_value_binop (PLUS_EXPR, type_sgn, type_precision, val, mask,
1286 type_sgn, type_precision, temv, temm,
1287 type_sgn, type_precision, 1, 0);
1288 break;
1291 CASE_CONVERT:
1293 /* First extend mask and value according to the original type. */
1294 *mask = wi::ext (rmask, rtype_precision, rtype_sgn);
1295 *val = wi::ext (rval, rtype_precision, rtype_sgn);
1297 /* Then extend mask and value according to the target type. */
1298 *mask = wi::ext (*mask, type_precision, type_sgn);
1299 *val = wi::ext (*val, type_precision, type_sgn);
1300 break;
1303 default:
1304 *mask = -1;
1305 break;
1309 /* Apply the operation CODE in type TYPE to the value, mask pairs
1310 R1VAL, R1MASK and R2VAL, R2MASK representing a values of type R1TYPE
1311 and R2TYPE and set the value, mask pair *VAL and *MASK to the result. */
1313 void
1314 bit_value_binop (enum tree_code code, signop sgn, int width,
1315 widest_int *val, widest_int *mask,
1316 signop r1type_sgn, int r1type_precision,
1317 const widest_int &r1val, const widest_int &r1mask,
1318 signop r2type_sgn, int r2type_precision,
1319 const widest_int &r2val, const widest_int &r2mask)
1321 bool swap_p = false;
1323 /* Assume we'll get a constant result. Use an initial non varying
1324 value, we fall back to varying in the end if necessary. */
1325 *mask = -1;
1327 switch (code)
1329 case BIT_AND_EXPR:
1330 /* The mask is constant where there is a known not
1331 set bit, (m1 | m2) & ((v1 | m1) & (v2 | m2)) */
1332 *mask = (r1mask | r2mask) & (r1val | r1mask) & (r2val | r2mask);
1333 *val = r1val & r2val;
1334 break;
1336 case BIT_IOR_EXPR:
1337 /* The mask is constant where there is a known
1338 set bit, (m1 | m2) & ~((v1 & ~m1) | (v2 & ~m2)). */
1339 *mask = wi::bit_and_not (r1mask | r2mask,
1340 wi::bit_and_not (r1val, r1mask)
1341 | wi::bit_and_not (r2val, r2mask));
1342 *val = r1val | r2val;
1343 break;
1345 case BIT_XOR_EXPR:
1346 /* m1 | m2 */
1347 *mask = r1mask | r2mask;
1348 *val = r1val ^ r2val;
1349 break;
1351 case LROTATE_EXPR:
1352 case RROTATE_EXPR:
1353 if (r2mask == 0)
1355 widest_int shift = r2val;
1356 if (shift == 0)
1358 *mask = r1mask;
1359 *val = r1val;
1361 else
1363 if (wi::neg_p (shift))
1365 shift = -shift;
1366 if (code == RROTATE_EXPR)
1367 code = LROTATE_EXPR;
1368 else
1369 code = RROTATE_EXPR;
1371 if (code == RROTATE_EXPR)
1373 *mask = wi::rrotate (r1mask, shift, width);
1374 *val = wi::rrotate (r1val, shift, width);
1376 else
1378 *mask = wi::lrotate (r1mask, shift, width);
1379 *val = wi::lrotate (r1val, shift, width);
1383 break;
1385 case LSHIFT_EXPR:
1386 case RSHIFT_EXPR:
1387 /* ??? We can handle partially known shift counts if we know
1388 its sign. That way we can tell that (x << (y | 8)) & 255
1389 is zero. */
1390 if (r2mask == 0)
1392 widest_int shift = r2val;
1393 if (shift == 0)
1395 *mask = r1mask;
1396 *val = r1val;
1398 else
1400 if (wi::neg_p (shift))
1402 shift = -shift;
1403 if (code == RSHIFT_EXPR)
1404 code = LSHIFT_EXPR;
1405 else
1406 code = RSHIFT_EXPR;
1408 if (code == RSHIFT_EXPR)
1410 *mask = wi::rshift (wi::ext (r1mask, width, sgn), shift, sgn);
1411 *val = wi::rshift (wi::ext (r1val, width, sgn), shift, sgn);
1413 else
1415 *mask = wi::ext (r1mask << shift, width, sgn);
1416 *val = wi::ext (r1val << shift, width, sgn);
1420 break;
1422 case PLUS_EXPR:
1423 case POINTER_PLUS_EXPR:
1425 /* Do the addition with unknown bits set to zero, to give carry-ins of
1426 zero wherever possible. */
1427 widest_int lo = (wi::bit_and_not (r1val, r1mask)
1428 + wi::bit_and_not (r2val, r2mask));
1429 lo = wi::ext (lo, width, sgn);
1430 /* Do the addition with unknown bits set to one, to give carry-ins of
1431 one wherever possible. */
1432 widest_int hi = (r1val | r1mask) + (r2val | r2mask);
1433 hi = wi::ext (hi, width, sgn);
1434 /* Each bit in the result is known if (a) the corresponding bits in
1435 both inputs are known, and (b) the carry-in to that bit position
1436 is known. We can check condition (b) by seeing if we got the same
1437 result with minimised carries as with maximised carries. */
1438 *mask = r1mask | r2mask | (lo ^ hi);
1439 *mask = wi::ext (*mask, width, sgn);
1440 /* It shouldn't matter whether we choose lo or hi here. */
1441 *val = lo;
1442 break;
1445 case MINUS_EXPR:
1447 widest_int temv, temm;
1448 bit_value_unop (NEGATE_EXPR, r2type_sgn, r2type_precision, &temv, &temm,
1449 r2type_sgn, r2type_precision, r2val, r2mask);
1450 bit_value_binop (PLUS_EXPR, sgn, width, val, mask,
1451 r1type_sgn, r1type_precision, r1val, r1mask,
1452 r2type_sgn, r2type_precision, temv, temm);
1453 break;
1456 case MULT_EXPR:
1458 /* Just track trailing zeros in both operands and transfer
1459 them to the other. */
1460 int r1tz = wi::ctz (r1val | r1mask);
1461 int r2tz = wi::ctz (r2val | r2mask);
1462 if (r1tz + r2tz >= width)
1464 *mask = 0;
1465 *val = 0;
1467 else if (r1tz + r2tz > 0)
1469 *mask = wi::ext (wi::mask <widest_int> (r1tz + r2tz, true),
1470 width, sgn);
1471 *val = 0;
1473 break;
1476 case EQ_EXPR:
1477 case NE_EXPR:
1479 widest_int m = r1mask | r2mask;
1480 if (wi::bit_and_not (r1val, m) != wi::bit_and_not (r2val, m))
1482 *mask = 0;
1483 *val = ((code == EQ_EXPR) ? 0 : 1);
1485 else
1487 /* We know the result of a comparison is always one or zero. */
1488 *mask = 1;
1489 *val = 0;
1491 break;
1494 case GE_EXPR:
1495 case GT_EXPR:
1496 swap_p = true;
1497 code = swap_tree_comparison (code);
1498 /* Fall through. */
1499 case LT_EXPR:
1500 case LE_EXPR:
1502 int minmax, maxmin;
1504 const widest_int &o1val = swap_p ? r2val : r1val;
1505 const widest_int &o1mask = swap_p ? r2mask : r1mask;
1506 const widest_int &o2val = swap_p ? r1val : r2val;
1507 const widest_int &o2mask = swap_p ? r1mask : r2mask;
1509 /* If the most significant bits are not known we know nothing. */
1510 if (wi::neg_p (o1mask) || wi::neg_p (o2mask))
1511 break;
1513 /* For comparisons the signedness is in the comparison operands. */
1514 sgn = r1type_sgn;
1516 /* If we know the most significant bits we know the values
1517 value ranges by means of treating varying bits as zero
1518 or one. Do a cross comparison of the max/min pairs. */
1519 maxmin = wi::cmp (o1val | o1mask,
1520 wi::bit_and_not (o2val, o2mask), sgn);
1521 minmax = wi::cmp (wi::bit_and_not (o1val, o1mask),
1522 o2val | o2mask, sgn);
1523 if (maxmin < 0) /* o1 is less than o2. */
1525 *mask = 0;
1526 *val = 1;
1528 else if (minmax > 0) /* o1 is not less or equal to o2. */
1530 *mask = 0;
1531 *val = 0;
1533 else if (maxmin == minmax) /* o1 and o2 are equal. */
1535 /* This probably should never happen as we'd have
1536 folded the thing during fully constant value folding. */
1537 *mask = 0;
1538 *val = (code == LE_EXPR ? 1 : 0);
1540 else
1542 /* We know the result of a comparison is always one or zero. */
1543 *mask = 1;
1544 *val = 0;
1546 break;
1549 default:;
1553 /* Return the propagation value when applying the operation CODE to
1554 the value RHS yielding type TYPE. */
1556 static ccp_prop_value_t
1557 bit_value_unop (enum tree_code code, tree type, tree rhs)
1559 ccp_prop_value_t rval = get_value_for_expr (rhs, true);
1560 widest_int value, mask;
1561 ccp_prop_value_t val;
1563 if (rval.lattice_val == UNDEFINED)
1564 return rval;
1566 gcc_assert ((rval.lattice_val == CONSTANT
1567 && TREE_CODE (rval.value) == INTEGER_CST)
1568 || wi::sext (rval.mask, TYPE_PRECISION (TREE_TYPE (rhs))) == -1);
1569 bit_value_unop (code, TYPE_SIGN (type), TYPE_PRECISION (type), &value, &mask,
1570 TYPE_SIGN (TREE_TYPE (rhs)), TYPE_PRECISION (TREE_TYPE (rhs)),
1571 value_to_wide_int (rval), rval.mask);
1572 if (wi::sext (mask, TYPE_PRECISION (type)) != -1)
1574 val.lattice_val = CONSTANT;
1575 val.mask = mask;
1576 /* ??? Delay building trees here. */
1577 val.value = wide_int_to_tree (type, value);
1579 else
1581 val.lattice_val = VARYING;
1582 val.value = NULL_TREE;
1583 val.mask = -1;
1585 return val;
1588 /* Return the propagation value when applying the operation CODE to
1589 the values RHS1 and RHS2 yielding type TYPE. */
1591 static ccp_prop_value_t
1592 bit_value_binop (enum tree_code code, tree type, tree rhs1, tree rhs2)
1594 ccp_prop_value_t r1val = get_value_for_expr (rhs1, true);
1595 ccp_prop_value_t r2val = get_value_for_expr (rhs2, true);
1596 widest_int value, mask;
1597 ccp_prop_value_t val;
1599 if (r1val.lattice_val == UNDEFINED
1600 || r2val.lattice_val == UNDEFINED)
1602 val.lattice_val = VARYING;
1603 val.value = NULL_TREE;
1604 val.mask = -1;
1605 return val;
1608 gcc_assert ((r1val.lattice_val == CONSTANT
1609 && TREE_CODE (r1val.value) == INTEGER_CST)
1610 || wi::sext (r1val.mask,
1611 TYPE_PRECISION (TREE_TYPE (rhs1))) == -1);
1612 gcc_assert ((r2val.lattice_val == CONSTANT
1613 && TREE_CODE (r2val.value) == INTEGER_CST)
1614 || wi::sext (r2val.mask,
1615 TYPE_PRECISION (TREE_TYPE (rhs2))) == -1);
1616 bit_value_binop (code, TYPE_SIGN (type), TYPE_PRECISION (type), &value, &mask,
1617 TYPE_SIGN (TREE_TYPE (rhs1)), TYPE_PRECISION (TREE_TYPE (rhs1)),
1618 value_to_wide_int (r1val), r1val.mask,
1619 TYPE_SIGN (TREE_TYPE (rhs2)), TYPE_PRECISION (TREE_TYPE (rhs2)),
1620 value_to_wide_int (r2val), r2val.mask);
1622 if (wi::sext (mask, TYPE_PRECISION (type)) != -1)
1624 val.lattice_val = CONSTANT;
1625 val.mask = mask;
1626 /* ??? Delay building trees here. */
1627 val.value = wide_int_to_tree (type, value);
1629 else
1631 val.lattice_val = VARYING;
1632 val.value = NULL_TREE;
1633 val.mask = -1;
1635 return val;
1638 /* Return the propagation value for __builtin_assume_aligned
1639 and functions with assume_aligned or alloc_aligned attribute.
1640 For __builtin_assume_aligned, ATTR is NULL_TREE,
1641 for assume_aligned attribute ATTR is non-NULL and ALLOC_ALIGNED
1642 is false, for alloc_aligned attribute ATTR is non-NULL and
1643 ALLOC_ALIGNED is true. */
1645 static ccp_prop_value_t
1646 bit_value_assume_aligned (gimple *stmt, tree attr, ccp_prop_value_t ptrval,
1647 bool alloc_aligned)
1649 tree align, misalign = NULL_TREE, type;
1650 unsigned HOST_WIDE_INT aligni, misaligni = 0;
1651 ccp_prop_value_t alignval;
1652 widest_int value, mask;
1653 ccp_prop_value_t val;
1655 if (attr == NULL_TREE)
1657 tree ptr = gimple_call_arg (stmt, 0);
1658 type = TREE_TYPE (ptr);
1659 ptrval = get_value_for_expr (ptr, true);
1661 else
1663 tree lhs = gimple_call_lhs (stmt);
1664 type = TREE_TYPE (lhs);
1667 if (ptrval.lattice_val == UNDEFINED)
1668 return ptrval;
1669 gcc_assert ((ptrval.lattice_val == CONSTANT
1670 && TREE_CODE (ptrval.value) == INTEGER_CST)
1671 || wi::sext (ptrval.mask, TYPE_PRECISION (type)) == -1);
1672 if (attr == NULL_TREE)
1674 /* Get aligni and misaligni from __builtin_assume_aligned. */
1675 align = gimple_call_arg (stmt, 1);
1676 if (!tree_fits_uhwi_p (align))
1677 return ptrval;
1678 aligni = tree_to_uhwi (align);
1679 if (gimple_call_num_args (stmt) > 2)
1681 misalign = gimple_call_arg (stmt, 2);
1682 if (!tree_fits_uhwi_p (misalign))
1683 return ptrval;
1684 misaligni = tree_to_uhwi (misalign);
1687 else
1689 /* Get aligni and misaligni from assume_aligned or
1690 alloc_align attributes. */
1691 if (TREE_VALUE (attr) == NULL_TREE)
1692 return ptrval;
1693 attr = TREE_VALUE (attr);
1694 align = TREE_VALUE (attr);
1695 if (!tree_fits_uhwi_p (align))
1696 return ptrval;
1697 aligni = tree_to_uhwi (align);
1698 if (alloc_aligned)
1700 if (aligni == 0 || aligni > gimple_call_num_args (stmt))
1701 return ptrval;
1702 align = gimple_call_arg (stmt, aligni - 1);
1703 if (!tree_fits_uhwi_p (align))
1704 return ptrval;
1705 aligni = tree_to_uhwi (align);
1707 else if (TREE_CHAIN (attr) && TREE_VALUE (TREE_CHAIN (attr)))
1709 misalign = TREE_VALUE (TREE_CHAIN (attr));
1710 if (!tree_fits_uhwi_p (misalign))
1711 return ptrval;
1712 misaligni = tree_to_uhwi (misalign);
1715 if (aligni <= 1 || (aligni & (aligni - 1)) != 0 || misaligni >= aligni)
1716 return ptrval;
1718 align = build_int_cst_type (type, -aligni);
1719 alignval = get_value_for_expr (align, true);
1720 bit_value_binop (BIT_AND_EXPR, TYPE_SIGN (type), TYPE_PRECISION (type), &value, &mask,
1721 TYPE_SIGN (type), TYPE_PRECISION (type), value_to_wide_int (ptrval), ptrval.mask,
1722 TYPE_SIGN (type), TYPE_PRECISION (type), value_to_wide_int (alignval), alignval.mask);
1724 if (wi::sext (mask, TYPE_PRECISION (type)) != -1)
1726 val.lattice_val = CONSTANT;
1727 val.mask = mask;
1728 gcc_assert ((mask.to_uhwi () & (aligni - 1)) == 0);
1729 gcc_assert ((value.to_uhwi () & (aligni - 1)) == 0);
1730 value |= misaligni;
1731 /* ??? Delay building trees here. */
1732 val.value = wide_int_to_tree (type, value);
1734 else
1736 val.lattice_val = VARYING;
1737 val.value = NULL_TREE;
1738 val.mask = -1;
1740 return val;
1743 /* Evaluate statement STMT.
1744 Valid only for assignments, calls, conditionals, and switches. */
1746 static ccp_prop_value_t
1747 evaluate_stmt (gimple *stmt)
1749 ccp_prop_value_t val;
1750 tree simplified = NULL_TREE;
1751 ccp_lattice_t likelyvalue = likely_value (stmt);
1752 bool is_constant = false;
1753 unsigned int align;
1755 if (dump_file && (dump_flags & TDF_DETAILS))
1757 fprintf (dump_file, "which is likely ");
1758 switch (likelyvalue)
1760 case CONSTANT:
1761 fprintf (dump_file, "CONSTANT");
1762 break;
1763 case UNDEFINED:
1764 fprintf (dump_file, "UNDEFINED");
1765 break;
1766 case VARYING:
1767 fprintf (dump_file, "VARYING");
1768 break;
1769 default:;
1771 fprintf (dump_file, "\n");
1774 /* If the statement is likely to have a CONSTANT result, then try
1775 to fold the statement to determine the constant value. */
1776 /* FIXME. This is the only place that we call ccp_fold.
1777 Since likely_value never returns CONSTANT for calls, we will
1778 not attempt to fold them, including builtins that may profit. */
1779 if (likelyvalue == CONSTANT)
1781 fold_defer_overflow_warnings ();
1782 simplified = ccp_fold (stmt);
1783 if (simplified
1784 && TREE_CODE (simplified) == SSA_NAME)
1786 /* We may not use values of something that may be simulated again,
1787 see valueize_op_1. */
1788 if (SSA_NAME_IS_DEFAULT_DEF (simplified)
1789 || ! prop_simulate_again_p (SSA_NAME_DEF_STMT (simplified)))
1791 ccp_prop_value_t *val = get_value (simplified);
1792 if (val && val->lattice_val != VARYING)
1794 fold_undefer_overflow_warnings (true, stmt, 0);
1795 return *val;
1798 else
1799 /* We may also not place a non-valueized copy in the lattice
1800 as that might become stale if we never re-visit this stmt. */
1801 simplified = NULL_TREE;
1803 is_constant = simplified && is_gimple_min_invariant (simplified);
1804 fold_undefer_overflow_warnings (is_constant, stmt, 0);
1805 if (is_constant)
1807 /* The statement produced a constant value. */
1808 val.lattice_val = CONSTANT;
1809 val.value = simplified;
1810 val.mask = 0;
1811 return val;
1814 /* If the statement is likely to have a VARYING result, then do not
1815 bother folding the statement. */
1816 else if (likelyvalue == VARYING)
1818 enum gimple_code code = gimple_code (stmt);
1819 if (code == GIMPLE_ASSIGN)
1821 enum tree_code subcode = gimple_assign_rhs_code (stmt);
1823 /* Other cases cannot satisfy is_gimple_min_invariant
1824 without folding. */
1825 if (get_gimple_rhs_class (subcode) == GIMPLE_SINGLE_RHS)
1826 simplified = gimple_assign_rhs1 (stmt);
1828 else if (code == GIMPLE_SWITCH)
1829 simplified = gimple_switch_index (as_a <gswitch *> (stmt));
1830 else
1831 /* These cannot satisfy is_gimple_min_invariant without folding. */
1832 gcc_assert (code == GIMPLE_CALL || code == GIMPLE_COND);
1833 is_constant = simplified && is_gimple_min_invariant (simplified);
1834 if (is_constant)
1836 /* The statement produced a constant value. */
1837 val.lattice_val = CONSTANT;
1838 val.value = simplified;
1839 val.mask = 0;
1842 /* If the statement result is likely UNDEFINED, make it so. */
1843 else if (likelyvalue == UNDEFINED)
1845 val.lattice_val = UNDEFINED;
1846 val.value = NULL_TREE;
1847 val.mask = 0;
1848 return val;
1851 /* Resort to simplification for bitwise tracking. */
1852 if (flag_tree_bit_ccp
1853 && (likelyvalue == CONSTANT || is_gimple_call (stmt)
1854 || (gimple_assign_single_p (stmt)
1855 && gimple_assign_rhs_code (stmt) == ADDR_EXPR))
1856 && !is_constant)
1858 enum gimple_code code = gimple_code (stmt);
1859 val.lattice_val = VARYING;
1860 val.value = NULL_TREE;
1861 val.mask = -1;
1862 if (code == GIMPLE_ASSIGN)
1864 enum tree_code subcode = gimple_assign_rhs_code (stmt);
1865 tree rhs1 = gimple_assign_rhs1 (stmt);
1866 tree lhs = gimple_assign_lhs (stmt);
1867 if ((INTEGRAL_TYPE_P (TREE_TYPE (lhs))
1868 || POINTER_TYPE_P (TREE_TYPE (lhs)))
1869 && (INTEGRAL_TYPE_P (TREE_TYPE (rhs1))
1870 || POINTER_TYPE_P (TREE_TYPE (rhs1))))
1871 switch (get_gimple_rhs_class (subcode))
1873 case GIMPLE_SINGLE_RHS:
1874 val = get_value_for_expr (rhs1, true);
1875 break;
1877 case GIMPLE_UNARY_RHS:
1878 val = bit_value_unop (subcode, TREE_TYPE (lhs), rhs1);
1879 break;
1881 case GIMPLE_BINARY_RHS:
1882 val = bit_value_binop (subcode, TREE_TYPE (lhs), rhs1,
1883 gimple_assign_rhs2 (stmt));
1884 break;
1886 default:;
1889 else if (code == GIMPLE_COND)
1891 enum tree_code code = gimple_cond_code (stmt);
1892 tree rhs1 = gimple_cond_lhs (stmt);
1893 tree rhs2 = gimple_cond_rhs (stmt);
1894 if (INTEGRAL_TYPE_P (TREE_TYPE (rhs1))
1895 || POINTER_TYPE_P (TREE_TYPE (rhs1)))
1896 val = bit_value_binop (code, TREE_TYPE (rhs1), rhs1, rhs2);
1898 else if (gimple_call_builtin_p (stmt, BUILT_IN_NORMAL))
1900 tree fndecl = gimple_call_fndecl (stmt);
1901 switch (DECL_FUNCTION_CODE (fndecl))
1903 case BUILT_IN_MALLOC:
1904 case BUILT_IN_REALLOC:
1905 case BUILT_IN_CALLOC:
1906 case BUILT_IN_STRDUP:
1907 case BUILT_IN_STRNDUP:
1908 val.lattice_val = CONSTANT;
1909 val.value = build_int_cst (TREE_TYPE (gimple_get_lhs (stmt)), 0);
1910 val.mask = ~((HOST_WIDE_INT) MALLOC_ABI_ALIGNMENT
1911 / BITS_PER_UNIT - 1);
1912 break;
1914 CASE_BUILT_IN_ALLOCA:
1915 align = (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_ALLOCA
1916 ? BIGGEST_ALIGNMENT
1917 : TREE_INT_CST_LOW (gimple_call_arg (stmt, 1)));
1918 val.lattice_val = CONSTANT;
1919 val.value = build_int_cst (TREE_TYPE (gimple_get_lhs (stmt)), 0);
1920 val.mask = ~((HOST_WIDE_INT) align / BITS_PER_UNIT - 1);
1921 break;
1923 /* These builtins return their first argument, unmodified. */
1924 case BUILT_IN_MEMCPY:
1925 case BUILT_IN_MEMMOVE:
1926 case BUILT_IN_MEMSET:
1927 case BUILT_IN_STRCPY:
1928 case BUILT_IN_STRNCPY:
1929 case BUILT_IN_MEMCPY_CHK:
1930 case BUILT_IN_MEMMOVE_CHK:
1931 case BUILT_IN_MEMSET_CHK:
1932 case BUILT_IN_STRCPY_CHK:
1933 case BUILT_IN_STRNCPY_CHK:
1934 val = get_value_for_expr (gimple_call_arg (stmt, 0), true);
1935 break;
1937 case BUILT_IN_ASSUME_ALIGNED:
1938 val = bit_value_assume_aligned (stmt, NULL_TREE, val, false);
1939 break;
1941 case BUILT_IN_ALIGNED_ALLOC:
1943 tree align = get_constant_value (gimple_call_arg (stmt, 0));
1944 if (align
1945 && tree_fits_uhwi_p (align))
1947 unsigned HOST_WIDE_INT aligni = tree_to_uhwi (align);
1948 if (aligni > 1
1949 /* align must be power-of-two */
1950 && (aligni & (aligni - 1)) == 0)
1952 val.lattice_val = CONSTANT;
1953 val.value = build_int_cst (ptr_type_node, 0);
1954 val.mask = -aligni;
1957 break;
1960 default:;
1963 if (is_gimple_call (stmt) && gimple_call_lhs (stmt))
1965 tree fntype = gimple_call_fntype (stmt);
1966 if (fntype)
1968 tree attrs = lookup_attribute ("assume_aligned",
1969 TYPE_ATTRIBUTES (fntype));
1970 if (attrs)
1971 val = bit_value_assume_aligned (stmt, attrs, val, false);
1972 attrs = lookup_attribute ("alloc_align",
1973 TYPE_ATTRIBUTES (fntype));
1974 if (attrs)
1975 val = bit_value_assume_aligned (stmt, attrs, val, true);
1978 is_constant = (val.lattice_val == CONSTANT);
1981 if (flag_tree_bit_ccp
1982 && ((is_constant && TREE_CODE (val.value) == INTEGER_CST)
1983 || !is_constant)
1984 && gimple_get_lhs (stmt)
1985 && TREE_CODE (gimple_get_lhs (stmt)) == SSA_NAME)
1987 tree lhs = gimple_get_lhs (stmt);
1988 wide_int nonzero_bits = get_nonzero_bits (lhs);
1989 if (nonzero_bits != -1)
1991 if (!is_constant)
1993 val.lattice_val = CONSTANT;
1994 val.value = build_zero_cst (TREE_TYPE (lhs));
1995 val.mask = extend_mask (nonzero_bits, TYPE_SIGN (TREE_TYPE (lhs)));
1996 is_constant = true;
1998 else
2000 if (wi::bit_and_not (wi::to_wide (val.value), nonzero_bits) != 0)
2001 val.value = wide_int_to_tree (TREE_TYPE (lhs),
2002 nonzero_bits
2003 & wi::to_wide (val.value));
2004 if (nonzero_bits == 0)
2005 val.mask = 0;
2006 else
2007 val.mask = val.mask & extend_mask (nonzero_bits,
2008 TYPE_SIGN (TREE_TYPE (lhs)));
2013 /* The statement produced a nonconstant value. */
2014 if (!is_constant)
2016 /* The statement produced a copy. */
2017 if (simplified && TREE_CODE (simplified) == SSA_NAME
2018 && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (simplified))
2020 val.lattice_val = CONSTANT;
2021 val.value = simplified;
2022 val.mask = -1;
2024 /* The statement is VARYING. */
2025 else
2027 val.lattice_val = VARYING;
2028 val.value = NULL_TREE;
2029 val.mask = -1;
2033 return val;
2036 typedef hash_table<nofree_ptr_hash<gimple> > gimple_htab;
2038 /* Given a BUILT_IN_STACK_SAVE value SAVED_VAL, insert a clobber of VAR before
2039 each matching BUILT_IN_STACK_RESTORE. Mark visited phis in VISITED. */
2041 static void
2042 insert_clobber_before_stack_restore (tree saved_val, tree var,
2043 gimple_htab **visited)
2045 gimple *stmt;
2046 gassign *clobber_stmt;
2047 tree clobber;
2048 imm_use_iterator iter;
2049 gimple_stmt_iterator i;
2050 gimple **slot;
2052 FOR_EACH_IMM_USE_STMT (stmt, iter, saved_val)
2053 if (gimple_call_builtin_p (stmt, BUILT_IN_STACK_RESTORE))
2055 clobber = build_constructor (TREE_TYPE (var),
2056 NULL);
2057 TREE_THIS_VOLATILE (clobber) = 1;
2058 clobber_stmt = gimple_build_assign (var, clobber);
2060 i = gsi_for_stmt (stmt);
2061 gsi_insert_before (&i, clobber_stmt, GSI_SAME_STMT);
2063 else if (gimple_code (stmt) == GIMPLE_PHI)
2065 if (!*visited)
2066 *visited = new gimple_htab (10);
2068 slot = (*visited)->find_slot (stmt, INSERT);
2069 if (*slot != NULL)
2070 continue;
2072 *slot = stmt;
2073 insert_clobber_before_stack_restore (gimple_phi_result (stmt), var,
2074 visited);
2076 else if (gimple_assign_ssa_name_copy_p (stmt))
2077 insert_clobber_before_stack_restore (gimple_assign_lhs (stmt), var,
2078 visited);
2079 else if (chkp_gimple_call_builtin_p (stmt, BUILT_IN_CHKP_BNDRET))
2080 continue;
2081 else
2082 gcc_assert (is_gimple_debug (stmt));
2085 /* Advance the iterator to the previous non-debug gimple statement in the same
2086 or dominating basic block. */
2088 static inline void
2089 gsi_prev_dom_bb_nondebug (gimple_stmt_iterator *i)
2091 basic_block dom;
2093 gsi_prev_nondebug (i);
2094 while (gsi_end_p (*i))
2096 dom = get_immediate_dominator (CDI_DOMINATORS, i->bb);
2097 if (dom == NULL || dom == ENTRY_BLOCK_PTR_FOR_FN (cfun))
2098 return;
2100 *i = gsi_last_bb (dom);
2104 /* Find a BUILT_IN_STACK_SAVE dominating gsi_stmt (I), and insert
2105 a clobber of VAR before each matching BUILT_IN_STACK_RESTORE.
2107 It is possible that BUILT_IN_STACK_SAVE cannot be find in a dominator when a
2108 previous pass (such as DOM) duplicated it along multiple paths to a BB. In
2109 that case the function gives up without inserting the clobbers. */
2111 static void
2112 insert_clobbers_for_var (gimple_stmt_iterator i, tree var)
2114 gimple *stmt;
2115 tree saved_val;
2116 gimple_htab *visited = NULL;
2118 for (; !gsi_end_p (i); gsi_prev_dom_bb_nondebug (&i))
2120 stmt = gsi_stmt (i);
2122 if (!gimple_call_builtin_p (stmt, BUILT_IN_STACK_SAVE))
2123 continue;
2125 saved_val = gimple_call_lhs (stmt);
2126 if (saved_val == NULL_TREE)
2127 continue;
2129 insert_clobber_before_stack_restore (saved_val, var, &visited);
2130 break;
2133 delete visited;
2136 /* Detects a __builtin_alloca_with_align with constant size argument. Declares
2137 fixed-size array and returns the address, if found, otherwise returns
2138 NULL_TREE. */
2140 static tree
2141 fold_builtin_alloca_with_align (gimple *stmt)
2143 unsigned HOST_WIDE_INT size, threshold, n_elem;
2144 tree lhs, arg, block, var, elem_type, array_type;
2146 /* Get lhs. */
2147 lhs = gimple_call_lhs (stmt);
2148 if (lhs == NULL_TREE)
2149 return NULL_TREE;
2151 /* Detect constant argument. */
2152 arg = get_constant_value (gimple_call_arg (stmt, 0));
2153 if (arg == NULL_TREE
2154 || TREE_CODE (arg) != INTEGER_CST
2155 || !tree_fits_uhwi_p (arg))
2156 return NULL_TREE;
2158 size = tree_to_uhwi (arg);
2160 /* Heuristic: don't fold large allocas. */
2161 threshold = (unsigned HOST_WIDE_INT)PARAM_VALUE (PARAM_LARGE_STACK_FRAME);
2162 /* In case the alloca is located at function entry, it has the same lifetime
2163 as a declared array, so we allow a larger size. */
2164 block = gimple_block (stmt);
2165 if (!(cfun->after_inlining
2166 && block
2167 && TREE_CODE (BLOCK_SUPERCONTEXT (block)) == FUNCTION_DECL))
2168 threshold /= 10;
2169 if (size > threshold)
2170 return NULL_TREE;
2172 /* Declare array. */
2173 elem_type = build_nonstandard_integer_type (BITS_PER_UNIT, 1);
2174 n_elem = size * 8 / BITS_PER_UNIT;
2175 array_type = build_array_type_nelts (elem_type, n_elem);
2176 var = create_tmp_var (array_type);
2177 SET_DECL_ALIGN (var, TREE_INT_CST_LOW (gimple_call_arg (stmt, 1)));
2179 struct ptr_info_def *pi = SSA_NAME_PTR_INFO (lhs);
2180 if (pi != NULL && !pi->pt.anything)
2182 bool singleton_p;
2183 unsigned uid;
2184 singleton_p = pt_solution_singleton_or_null_p (&pi->pt, &uid);
2185 gcc_assert (singleton_p);
2186 SET_DECL_PT_UID (var, uid);
2190 /* Fold alloca to the address of the array. */
2191 return fold_convert (TREE_TYPE (lhs), build_fold_addr_expr (var));
2194 /* Fold the stmt at *GSI with CCP specific information that propagating
2195 and regular folding does not catch. */
2197 bool
2198 ccp_folder::fold_stmt (gimple_stmt_iterator *gsi)
2200 gimple *stmt = gsi_stmt (*gsi);
2202 switch (gimple_code (stmt))
2204 case GIMPLE_COND:
2206 gcond *cond_stmt = as_a <gcond *> (stmt);
2207 ccp_prop_value_t val;
2208 /* Statement evaluation will handle type mismatches in constants
2209 more gracefully than the final propagation. This allows us to
2210 fold more conditionals here. */
2211 val = evaluate_stmt (stmt);
2212 if (val.lattice_val != CONSTANT
2213 || val.mask != 0)
2214 return false;
2216 if (dump_file)
2218 fprintf (dump_file, "Folding predicate ");
2219 print_gimple_expr (dump_file, stmt, 0);
2220 fprintf (dump_file, " to ");
2221 print_generic_expr (dump_file, val.value);
2222 fprintf (dump_file, "\n");
2225 if (integer_zerop (val.value))
2226 gimple_cond_make_false (cond_stmt);
2227 else
2228 gimple_cond_make_true (cond_stmt);
2230 return true;
2233 case GIMPLE_CALL:
2235 tree lhs = gimple_call_lhs (stmt);
2236 int flags = gimple_call_flags (stmt);
2237 tree val;
2238 tree argt;
2239 bool changed = false;
2240 unsigned i;
2242 /* If the call was folded into a constant make sure it goes
2243 away even if we cannot propagate into all uses because of
2244 type issues. */
2245 if (lhs
2246 && TREE_CODE (lhs) == SSA_NAME
2247 && (val = get_constant_value (lhs))
2248 /* Don't optimize away calls that have side-effects. */
2249 && (flags & (ECF_CONST|ECF_PURE)) != 0
2250 && (flags & ECF_LOOPING_CONST_OR_PURE) == 0)
2252 tree new_rhs = unshare_expr (val);
2253 bool res;
2254 if (!useless_type_conversion_p (TREE_TYPE (lhs),
2255 TREE_TYPE (new_rhs)))
2256 new_rhs = fold_convert (TREE_TYPE (lhs), new_rhs);
2257 res = update_call_from_tree (gsi, new_rhs);
2258 gcc_assert (res);
2259 return true;
2262 /* Internal calls provide no argument types, so the extra laxity
2263 for normal calls does not apply. */
2264 if (gimple_call_internal_p (stmt))
2265 return false;
2267 /* The heuristic of fold_builtin_alloca_with_align differs before and
2268 after inlining, so we don't require the arg to be changed into a
2269 constant for folding, but just to be constant. */
2270 if (gimple_call_builtin_p (stmt, BUILT_IN_ALLOCA_WITH_ALIGN)
2271 || gimple_call_builtin_p (stmt, BUILT_IN_ALLOCA_WITH_ALIGN_AND_MAX))
2273 tree new_rhs = fold_builtin_alloca_with_align (stmt);
2274 if (new_rhs)
2276 bool res = update_call_from_tree (gsi, new_rhs);
2277 tree var = TREE_OPERAND (TREE_OPERAND (new_rhs, 0),0);
2278 gcc_assert (res);
2279 insert_clobbers_for_var (*gsi, var);
2280 return true;
2284 /* Propagate into the call arguments. Compared to replace_uses_in
2285 this can use the argument slot types for type verification
2286 instead of the current argument type. We also can safely
2287 drop qualifiers here as we are dealing with constants anyway. */
2288 argt = TYPE_ARG_TYPES (gimple_call_fntype (stmt));
2289 for (i = 0; i < gimple_call_num_args (stmt) && argt;
2290 ++i, argt = TREE_CHAIN (argt))
2292 tree arg = gimple_call_arg (stmt, i);
2293 if (TREE_CODE (arg) == SSA_NAME
2294 && (val = get_constant_value (arg))
2295 && useless_type_conversion_p
2296 (TYPE_MAIN_VARIANT (TREE_VALUE (argt)),
2297 TYPE_MAIN_VARIANT (TREE_TYPE (val))))
2299 gimple_call_set_arg (stmt, i, unshare_expr (val));
2300 changed = true;
2304 return changed;
2307 case GIMPLE_ASSIGN:
2309 tree lhs = gimple_assign_lhs (stmt);
2310 tree val;
2312 /* If we have a load that turned out to be constant replace it
2313 as we cannot propagate into all uses in all cases. */
2314 if (gimple_assign_single_p (stmt)
2315 && TREE_CODE (lhs) == SSA_NAME
2316 && (val = get_constant_value (lhs)))
2318 tree rhs = unshare_expr (val);
2319 if (!useless_type_conversion_p (TREE_TYPE (lhs), TREE_TYPE (rhs)))
2320 rhs = fold_build1 (VIEW_CONVERT_EXPR, TREE_TYPE (lhs), rhs);
2321 gimple_assign_set_rhs_from_tree (gsi, rhs);
2322 return true;
2325 return false;
2328 default:
2329 return false;
2333 /* Visit the assignment statement STMT. Set the value of its LHS to the
2334 value computed by the RHS and store LHS in *OUTPUT_P. If STMT
2335 creates virtual definitions, set the value of each new name to that
2336 of the RHS (if we can derive a constant out of the RHS).
2337 Value-returning call statements also perform an assignment, and
2338 are handled here. */
2340 static enum ssa_prop_result
2341 visit_assignment (gimple *stmt, tree *output_p)
2343 ccp_prop_value_t val;
2344 enum ssa_prop_result retval = SSA_PROP_NOT_INTERESTING;
2346 tree lhs = gimple_get_lhs (stmt);
2347 if (TREE_CODE (lhs) == SSA_NAME)
2349 /* Evaluate the statement, which could be
2350 either a GIMPLE_ASSIGN or a GIMPLE_CALL. */
2351 val = evaluate_stmt (stmt);
2353 /* If STMT is an assignment to an SSA_NAME, we only have one
2354 value to set. */
2355 if (set_lattice_value (lhs, &val))
2357 *output_p = lhs;
2358 if (val.lattice_val == VARYING)
2359 retval = SSA_PROP_VARYING;
2360 else
2361 retval = SSA_PROP_INTERESTING;
2365 return retval;
2369 /* Visit the conditional statement STMT. Return SSA_PROP_INTERESTING
2370 if it can determine which edge will be taken. Otherwise, return
2371 SSA_PROP_VARYING. */
2373 static enum ssa_prop_result
2374 visit_cond_stmt (gimple *stmt, edge *taken_edge_p)
2376 ccp_prop_value_t val;
2377 basic_block block;
2379 block = gimple_bb (stmt);
2380 val = evaluate_stmt (stmt);
2381 if (val.lattice_val != CONSTANT
2382 || val.mask != 0)
2383 return SSA_PROP_VARYING;
2385 /* Find which edge out of the conditional block will be taken and add it
2386 to the worklist. If no single edge can be determined statically,
2387 return SSA_PROP_VARYING to feed all the outgoing edges to the
2388 propagation engine. */
2389 *taken_edge_p = find_taken_edge (block, val.value);
2390 if (*taken_edge_p)
2391 return SSA_PROP_INTERESTING;
2392 else
2393 return SSA_PROP_VARYING;
2397 /* Evaluate statement STMT. If the statement produces an output value and
2398 its evaluation changes the lattice value of its output, return
2399 SSA_PROP_INTERESTING and set *OUTPUT_P to the SSA_NAME holding the
2400 output value.
2402 If STMT is a conditional branch and we can determine its truth
2403 value, set *TAKEN_EDGE_P accordingly. If STMT produces a varying
2404 value, return SSA_PROP_VARYING. */
2406 enum ssa_prop_result
2407 ccp_propagate::visit_stmt (gimple *stmt, edge *taken_edge_p, tree *output_p)
2409 tree def;
2410 ssa_op_iter iter;
2412 if (dump_file && (dump_flags & TDF_DETAILS))
2414 fprintf (dump_file, "\nVisiting statement:\n");
2415 print_gimple_stmt (dump_file, stmt, 0, dump_flags);
2418 switch (gimple_code (stmt))
2420 case GIMPLE_ASSIGN:
2421 /* If the statement is an assignment that produces a single
2422 output value, evaluate its RHS to see if the lattice value of
2423 its output has changed. */
2424 return visit_assignment (stmt, output_p);
2426 case GIMPLE_CALL:
2427 /* A value-returning call also performs an assignment. */
2428 if (gimple_call_lhs (stmt) != NULL_TREE)
2429 return visit_assignment (stmt, output_p);
2430 break;
2432 case GIMPLE_COND:
2433 case GIMPLE_SWITCH:
2434 /* If STMT is a conditional branch, see if we can determine
2435 which branch will be taken. */
2436 /* FIXME. It appears that we should be able to optimize
2437 computed GOTOs here as well. */
2438 return visit_cond_stmt (stmt, taken_edge_p);
2440 default:
2441 break;
2444 /* Any other kind of statement is not interesting for constant
2445 propagation and, therefore, not worth simulating. */
2446 if (dump_file && (dump_flags & TDF_DETAILS))
2447 fprintf (dump_file, "No interesting values produced. Marked VARYING.\n");
2449 /* Definitions made by statements other than assignments to
2450 SSA_NAMEs represent unknown modifications to their outputs.
2451 Mark them VARYING. */
2452 FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_ALL_DEFS)
2453 set_value_varying (def);
2455 return SSA_PROP_VARYING;
2459 /* Main entry point for SSA Conditional Constant Propagation. If NONZERO_P,
2460 record nonzero bits. */
2462 static unsigned int
2463 do_ssa_ccp (bool nonzero_p)
2465 unsigned int todo = 0;
2466 calculate_dominance_info (CDI_DOMINATORS);
2468 ccp_initialize ();
2469 class ccp_propagate ccp_propagate;
2470 ccp_propagate.ssa_propagate ();
2471 if (ccp_finalize (nonzero_p || flag_ipa_bit_cp))
2473 todo = (TODO_cleanup_cfg | TODO_update_ssa);
2475 /* ccp_finalize does not preserve loop-closed ssa. */
2476 loops_state_clear (LOOP_CLOSED_SSA);
2479 free_dominance_info (CDI_DOMINATORS);
2480 return todo;
2484 namespace {
2486 const pass_data pass_data_ccp =
2488 GIMPLE_PASS, /* type */
2489 "ccp", /* name */
2490 OPTGROUP_NONE, /* optinfo_flags */
2491 TV_TREE_CCP, /* tv_id */
2492 ( PROP_cfg | PROP_ssa ), /* properties_required */
2493 0, /* properties_provided */
2494 0, /* properties_destroyed */
2495 0, /* todo_flags_start */
2496 TODO_update_address_taken, /* todo_flags_finish */
2499 class pass_ccp : public gimple_opt_pass
2501 public:
2502 pass_ccp (gcc::context *ctxt)
2503 : gimple_opt_pass (pass_data_ccp, ctxt), nonzero_p (false)
2506 /* opt_pass methods: */
2507 opt_pass * clone () { return new pass_ccp (m_ctxt); }
2508 void set_pass_param (unsigned int n, bool param)
2510 gcc_assert (n == 0);
2511 nonzero_p = param;
2513 virtual bool gate (function *) { return flag_tree_ccp != 0; }
2514 virtual unsigned int execute (function *) { return do_ssa_ccp (nonzero_p); }
2516 private:
2517 /* Determines whether the pass instance records nonzero bits. */
2518 bool nonzero_p;
2519 }; // class pass_ccp
2521 } // anon namespace
2523 gimple_opt_pass *
2524 make_pass_ccp (gcc::context *ctxt)
2526 return new pass_ccp (ctxt);
2531 /* Try to optimize out __builtin_stack_restore. Optimize it out
2532 if there is another __builtin_stack_restore in the same basic
2533 block and no calls or ASM_EXPRs are in between, or if this block's
2534 only outgoing edge is to EXIT_BLOCK and there are no calls or
2535 ASM_EXPRs after this __builtin_stack_restore. */
2537 static tree
2538 optimize_stack_restore (gimple_stmt_iterator i)
2540 tree callee;
2541 gimple *stmt;
2543 basic_block bb = gsi_bb (i);
2544 gimple *call = gsi_stmt (i);
2546 if (gimple_code (call) != GIMPLE_CALL
2547 || gimple_call_num_args (call) != 1
2548 || TREE_CODE (gimple_call_arg (call, 0)) != SSA_NAME
2549 || !POINTER_TYPE_P (TREE_TYPE (gimple_call_arg (call, 0))))
2550 return NULL_TREE;
2552 for (gsi_next (&i); !gsi_end_p (i); gsi_next (&i))
2554 stmt = gsi_stmt (i);
2555 if (gimple_code (stmt) == GIMPLE_ASM)
2556 return NULL_TREE;
2557 if (gimple_code (stmt) != GIMPLE_CALL)
2558 continue;
2560 callee = gimple_call_fndecl (stmt);
2561 if (!callee
2562 || DECL_BUILT_IN_CLASS (callee) != BUILT_IN_NORMAL
2563 /* All regular builtins are ok, just obviously not alloca. */
2564 || ALLOCA_FUNCTION_CODE_P (DECL_FUNCTION_CODE (callee)))
2565 return NULL_TREE;
2567 if (DECL_FUNCTION_CODE (callee) == BUILT_IN_STACK_RESTORE)
2568 goto second_stack_restore;
2571 if (!gsi_end_p (i))
2572 return NULL_TREE;
2574 /* Allow one successor of the exit block, or zero successors. */
2575 switch (EDGE_COUNT (bb->succs))
2577 case 0:
2578 break;
2579 case 1:
2580 if (single_succ_edge (bb)->dest != EXIT_BLOCK_PTR_FOR_FN (cfun))
2581 return NULL_TREE;
2582 break;
2583 default:
2584 return NULL_TREE;
2586 second_stack_restore:
2588 /* If there's exactly one use, then zap the call to __builtin_stack_save.
2589 If there are multiple uses, then the last one should remove the call.
2590 In any case, whether the call to __builtin_stack_save can be removed
2591 or not is irrelevant to removing the call to __builtin_stack_restore. */
2592 if (has_single_use (gimple_call_arg (call, 0)))
2594 gimple *stack_save = SSA_NAME_DEF_STMT (gimple_call_arg (call, 0));
2595 if (is_gimple_call (stack_save))
2597 callee = gimple_call_fndecl (stack_save);
2598 if (callee
2599 && DECL_BUILT_IN_CLASS (callee) == BUILT_IN_NORMAL
2600 && DECL_FUNCTION_CODE (callee) == BUILT_IN_STACK_SAVE)
2602 gimple_stmt_iterator stack_save_gsi;
2603 tree rhs;
2605 stack_save_gsi = gsi_for_stmt (stack_save);
2606 rhs = build_int_cst (TREE_TYPE (gimple_call_arg (call, 0)), 0);
2607 update_call_from_tree (&stack_save_gsi, rhs);
2612 /* No effect, so the statement will be deleted. */
2613 return integer_zero_node;
2616 /* If va_list type is a simple pointer and nothing special is needed,
2617 optimize __builtin_va_start (&ap, 0) into ap = __builtin_next_arg (0),
2618 __builtin_va_end (&ap) out as NOP and __builtin_va_copy into a simple
2619 pointer assignment. */
2621 static tree
2622 optimize_stdarg_builtin (gimple *call)
2624 tree callee, lhs, rhs, cfun_va_list;
2625 bool va_list_simple_ptr;
2626 location_t loc = gimple_location (call);
2628 if (gimple_code (call) != GIMPLE_CALL)
2629 return NULL_TREE;
2631 callee = gimple_call_fndecl (call);
2633 cfun_va_list = targetm.fn_abi_va_list (callee);
2634 va_list_simple_ptr = POINTER_TYPE_P (cfun_va_list)
2635 && (TREE_TYPE (cfun_va_list) == void_type_node
2636 || TREE_TYPE (cfun_va_list) == char_type_node);
2638 switch (DECL_FUNCTION_CODE (callee))
2640 case BUILT_IN_VA_START:
2641 if (!va_list_simple_ptr
2642 || targetm.expand_builtin_va_start != NULL
2643 || !builtin_decl_explicit_p (BUILT_IN_NEXT_ARG))
2644 return NULL_TREE;
2646 if (gimple_call_num_args (call) != 2)
2647 return NULL_TREE;
2649 lhs = gimple_call_arg (call, 0);
2650 if (!POINTER_TYPE_P (TREE_TYPE (lhs))
2651 || TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (lhs)))
2652 != TYPE_MAIN_VARIANT (cfun_va_list))
2653 return NULL_TREE;
2655 lhs = build_fold_indirect_ref_loc (loc, lhs);
2656 rhs = build_call_expr_loc (loc, builtin_decl_explicit (BUILT_IN_NEXT_ARG),
2657 1, integer_zero_node);
2658 rhs = fold_convert_loc (loc, TREE_TYPE (lhs), rhs);
2659 return build2 (MODIFY_EXPR, TREE_TYPE (lhs), lhs, rhs);
2661 case BUILT_IN_VA_COPY:
2662 if (!va_list_simple_ptr)
2663 return NULL_TREE;
2665 if (gimple_call_num_args (call) != 2)
2666 return NULL_TREE;
2668 lhs = gimple_call_arg (call, 0);
2669 if (!POINTER_TYPE_P (TREE_TYPE (lhs))
2670 || TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (lhs)))
2671 != TYPE_MAIN_VARIANT (cfun_va_list))
2672 return NULL_TREE;
2674 lhs = build_fold_indirect_ref_loc (loc, lhs);
2675 rhs = gimple_call_arg (call, 1);
2676 if (TYPE_MAIN_VARIANT (TREE_TYPE (rhs))
2677 != TYPE_MAIN_VARIANT (cfun_va_list))
2678 return NULL_TREE;
2680 rhs = fold_convert_loc (loc, TREE_TYPE (lhs), rhs);
2681 return build2 (MODIFY_EXPR, TREE_TYPE (lhs), lhs, rhs);
2683 case BUILT_IN_VA_END:
2684 /* No effect, so the statement will be deleted. */
2685 return integer_zero_node;
2687 default:
2688 gcc_unreachable ();
2692 /* Attemp to make the block of __builtin_unreachable I unreachable by changing
2693 the incoming jumps. Return true if at least one jump was changed. */
2695 static bool
2696 optimize_unreachable (gimple_stmt_iterator i)
2698 basic_block bb = gsi_bb (i);
2699 gimple_stmt_iterator gsi;
2700 gimple *stmt;
2701 edge_iterator ei;
2702 edge e;
2703 bool ret;
2705 if (flag_sanitize & SANITIZE_UNREACHABLE)
2706 return false;
2708 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
2710 stmt = gsi_stmt (gsi);
2712 if (is_gimple_debug (stmt))
2713 continue;
2715 if (glabel *label_stmt = dyn_cast <glabel *> (stmt))
2717 /* Verify we do not need to preserve the label. */
2718 if (FORCED_LABEL (gimple_label_label (label_stmt)))
2719 return false;
2721 continue;
2724 /* Only handle the case that __builtin_unreachable is the first statement
2725 in the block. We rely on DCE to remove stmts without side-effects
2726 before __builtin_unreachable. */
2727 if (gsi_stmt (gsi) != gsi_stmt (i))
2728 return false;
2731 ret = false;
2732 FOR_EACH_EDGE (e, ei, bb->preds)
2734 gsi = gsi_last_bb (e->src);
2735 if (gsi_end_p (gsi))
2736 continue;
2738 stmt = gsi_stmt (gsi);
2739 if (gcond *cond_stmt = dyn_cast <gcond *> (stmt))
2741 if (e->flags & EDGE_TRUE_VALUE)
2742 gimple_cond_make_false (cond_stmt);
2743 else if (e->flags & EDGE_FALSE_VALUE)
2744 gimple_cond_make_true (cond_stmt);
2745 else
2746 gcc_unreachable ();
2747 update_stmt (cond_stmt);
2749 else
2751 /* Todo: handle other cases. Note that unreachable switch case
2752 statements have already been removed. */
2753 continue;
2756 ret = true;
2759 return ret;
2762 /* Optimize
2763 mask_2 = 1 << cnt_1;
2764 _4 = __atomic_fetch_or_* (ptr_6, mask_2, _3);
2765 _5 = _4 & mask_2;
2767 _4 = ATOMIC_BIT_TEST_AND_SET (ptr_6, cnt_1, 0, _3);
2768 _5 = _4;
2769 If _5 is only used in _5 != 0 or _5 == 0 comparisons, 1
2770 is passed instead of 0, and the builtin just returns a zero
2771 or 1 value instead of the actual bit.
2772 Similarly for __sync_fetch_and_or_* (without the ", _3" part
2773 in there), and/or if mask_2 is a power of 2 constant.
2774 Similarly for xor instead of or, use ATOMIC_BIT_TEST_AND_COMPLEMENT
2775 in that case. And similarly for and instead of or, except that
2776 the second argument to the builtin needs to be one's complement
2777 of the mask instead of mask. */
2779 static void
2780 optimize_atomic_bit_test_and (gimple_stmt_iterator *gsip,
2781 enum internal_fn fn, bool has_model_arg,
2782 bool after)
2784 gimple *call = gsi_stmt (*gsip);
2785 tree lhs = gimple_call_lhs (call);
2786 use_operand_p use_p;
2787 gimple *use_stmt;
2788 tree mask, bit;
2789 optab optab;
2791 if (!flag_inline_atomics
2792 || optimize_debug
2793 || !gimple_call_builtin_p (call, BUILT_IN_NORMAL)
2794 || !lhs
2795 || SSA_NAME_OCCURS_IN_ABNORMAL_PHI (lhs)
2796 || !single_imm_use (lhs, &use_p, &use_stmt)
2797 || !is_gimple_assign (use_stmt)
2798 || gimple_assign_rhs_code (use_stmt) != BIT_AND_EXPR
2799 || !gimple_vdef (call))
2800 return;
2802 switch (fn)
2804 case IFN_ATOMIC_BIT_TEST_AND_SET:
2805 optab = atomic_bit_test_and_set_optab;
2806 break;
2807 case IFN_ATOMIC_BIT_TEST_AND_COMPLEMENT:
2808 optab = atomic_bit_test_and_complement_optab;
2809 break;
2810 case IFN_ATOMIC_BIT_TEST_AND_RESET:
2811 optab = atomic_bit_test_and_reset_optab;
2812 break;
2813 default:
2814 return;
2817 if (optab_handler (optab, TYPE_MODE (TREE_TYPE (lhs))) == CODE_FOR_nothing)
2818 return;
2820 mask = gimple_call_arg (call, 1);
2821 tree use_lhs = gimple_assign_lhs (use_stmt);
2822 if (!use_lhs)
2823 return;
2825 if (TREE_CODE (mask) == INTEGER_CST)
2827 if (fn == IFN_ATOMIC_BIT_TEST_AND_RESET)
2828 mask = const_unop (BIT_NOT_EXPR, TREE_TYPE (mask), mask);
2829 mask = fold_convert (TREE_TYPE (lhs), mask);
2830 int ibit = tree_log2 (mask);
2831 if (ibit < 0)
2832 return;
2833 bit = build_int_cst (TREE_TYPE (lhs), ibit);
2835 else if (TREE_CODE (mask) == SSA_NAME)
2837 gimple *g = SSA_NAME_DEF_STMT (mask);
2838 if (fn == IFN_ATOMIC_BIT_TEST_AND_RESET)
2840 if (!is_gimple_assign (g)
2841 || gimple_assign_rhs_code (g) != BIT_NOT_EXPR)
2842 return;
2843 mask = gimple_assign_rhs1 (g);
2844 if (TREE_CODE (mask) != SSA_NAME)
2845 return;
2846 g = SSA_NAME_DEF_STMT (mask);
2848 if (!is_gimple_assign (g)
2849 || gimple_assign_rhs_code (g) != LSHIFT_EXPR
2850 || !integer_onep (gimple_assign_rhs1 (g)))
2851 return;
2852 bit = gimple_assign_rhs2 (g);
2854 else
2855 return;
2857 if (gimple_assign_rhs1 (use_stmt) == lhs)
2859 if (!operand_equal_p (gimple_assign_rhs2 (use_stmt), mask, 0))
2860 return;
2862 else if (gimple_assign_rhs2 (use_stmt) != lhs
2863 || !operand_equal_p (gimple_assign_rhs1 (use_stmt), mask, 0))
2864 return;
2866 bool use_bool = true;
2867 bool has_debug_uses = false;
2868 imm_use_iterator iter;
2869 gimple *g;
2871 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (use_lhs))
2872 use_bool = false;
2873 FOR_EACH_IMM_USE_STMT (g, iter, use_lhs)
2875 enum tree_code code = ERROR_MARK;
2876 tree op0 = NULL_TREE, op1 = NULL_TREE;
2877 if (is_gimple_debug (g))
2879 has_debug_uses = true;
2880 continue;
2882 else if (is_gimple_assign (g))
2883 switch (gimple_assign_rhs_code (g))
2885 case COND_EXPR:
2886 op1 = gimple_assign_rhs1 (g);
2887 code = TREE_CODE (op1);
2888 op0 = TREE_OPERAND (op1, 0);
2889 op1 = TREE_OPERAND (op1, 1);
2890 break;
2891 case EQ_EXPR:
2892 case NE_EXPR:
2893 code = gimple_assign_rhs_code (g);
2894 op0 = gimple_assign_rhs1 (g);
2895 op1 = gimple_assign_rhs2 (g);
2896 break;
2897 default:
2898 break;
2900 else if (gimple_code (g) == GIMPLE_COND)
2902 code = gimple_cond_code (g);
2903 op0 = gimple_cond_lhs (g);
2904 op1 = gimple_cond_rhs (g);
2907 if ((code == EQ_EXPR || code == NE_EXPR)
2908 && op0 == use_lhs
2909 && integer_zerop (op1))
2911 use_operand_p use_p;
2912 int n = 0;
2913 FOR_EACH_IMM_USE_ON_STMT (use_p, iter)
2914 n++;
2915 if (n == 1)
2916 continue;
2919 use_bool = false;
2920 BREAK_FROM_IMM_USE_STMT (iter);
2923 tree new_lhs = make_ssa_name (TREE_TYPE (lhs));
2924 tree flag = build_int_cst (TREE_TYPE (lhs), use_bool);
2925 if (has_model_arg)
2926 g = gimple_build_call_internal (fn, 4, gimple_call_arg (call, 0),
2927 bit, flag, gimple_call_arg (call, 2));
2928 else
2929 g = gimple_build_call_internal (fn, 3, gimple_call_arg (call, 0),
2930 bit, flag);
2931 gimple_call_set_lhs (g, new_lhs);
2932 gimple_set_location (g, gimple_location (call));
2933 gimple_set_vuse (g, gimple_vuse (call));
2934 gimple_set_vdef (g, gimple_vdef (call));
2935 bool throws = stmt_can_throw_internal (call);
2936 gimple_call_set_nothrow (as_a <gcall *> (g),
2937 gimple_call_nothrow_p (as_a <gcall *> (call)));
2938 SSA_NAME_DEF_STMT (gimple_vdef (call)) = g;
2939 gimple_stmt_iterator gsi = *gsip;
2940 gsi_insert_after (&gsi, g, GSI_NEW_STMT);
2941 edge e = NULL;
2942 if (throws)
2944 maybe_clean_or_replace_eh_stmt (call, g);
2945 if (after || (use_bool && has_debug_uses))
2946 e = find_fallthru_edge (gsi_bb (gsi)->succs);
2948 if (after)
2950 /* The internal function returns the value of the specified bit
2951 before the atomic operation. If we are interested in the value
2952 of the specified bit after the atomic operation (makes only sense
2953 for xor, otherwise the bit content is compile time known),
2954 we need to invert the bit. */
2955 g = gimple_build_assign (make_ssa_name (TREE_TYPE (lhs)),
2956 BIT_XOR_EXPR, new_lhs,
2957 use_bool ? build_int_cst (TREE_TYPE (lhs), 1)
2958 : mask);
2959 new_lhs = gimple_assign_lhs (g);
2960 if (throws)
2962 gsi_insert_on_edge_immediate (e, g);
2963 gsi = gsi_for_stmt (g);
2965 else
2966 gsi_insert_after (&gsi, g, GSI_NEW_STMT);
2968 if (use_bool && has_debug_uses)
2970 tree temp = NULL_TREE;
2971 if (!throws || after || single_pred_p (e->dest))
2973 temp = make_node (DEBUG_EXPR_DECL);
2974 DECL_ARTIFICIAL (temp) = 1;
2975 TREE_TYPE (temp) = TREE_TYPE (lhs);
2976 SET_DECL_MODE (temp, TYPE_MODE (TREE_TYPE (lhs)));
2977 tree t = build2 (LSHIFT_EXPR, TREE_TYPE (lhs), new_lhs, bit);
2978 g = gimple_build_debug_bind (temp, t, g);
2979 if (throws && !after)
2981 gsi = gsi_after_labels (e->dest);
2982 gsi_insert_before (&gsi, g, GSI_SAME_STMT);
2984 else
2985 gsi_insert_after (&gsi, g, GSI_NEW_STMT);
2987 FOR_EACH_IMM_USE_STMT (g, iter, use_lhs)
2988 if (is_gimple_debug (g))
2990 use_operand_p use_p;
2991 if (temp == NULL_TREE)
2992 gimple_debug_bind_reset_value (g);
2993 else
2994 FOR_EACH_IMM_USE_ON_STMT (use_p, iter)
2995 SET_USE (use_p, temp);
2996 update_stmt (g);
2999 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (new_lhs)
3000 = SSA_NAME_OCCURS_IN_ABNORMAL_PHI (use_lhs);
3001 replace_uses_by (use_lhs, new_lhs);
3002 gsi = gsi_for_stmt (use_stmt);
3003 gsi_remove (&gsi, true);
3004 release_defs (use_stmt);
3005 gsi_remove (gsip, true);
3006 release_ssa_name (lhs);
3009 /* Optimize
3010 a = {};
3011 b = a;
3012 into
3013 a = {};
3014 b = {};
3015 Similarly for memset (&a, ..., sizeof (a)); instead of a = {};
3016 and/or memcpy (&b, &a, sizeof (a)); instead of b = a; */
3018 static void
3019 optimize_memcpy (gimple_stmt_iterator *gsip, tree dest, tree src, tree len)
3021 gimple *stmt = gsi_stmt (*gsip);
3022 if (gimple_has_volatile_ops (stmt))
3023 return;
3025 tree vuse = gimple_vuse (stmt);
3026 if (vuse == NULL)
3027 return;
3029 gimple *defstmt = SSA_NAME_DEF_STMT (vuse);
3030 tree src2 = NULL_TREE, len2 = NULL_TREE;
3031 HOST_WIDE_INT offset, offset2;
3032 tree val = integer_zero_node;
3033 if (gimple_store_p (defstmt)
3034 && gimple_assign_single_p (defstmt)
3035 && TREE_CODE (gimple_assign_rhs1 (defstmt)) == CONSTRUCTOR
3036 && !gimple_clobber_p (defstmt))
3037 src2 = gimple_assign_lhs (defstmt);
3038 else if (gimple_call_builtin_p (defstmt, BUILT_IN_MEMSET)
3039 && TREE_CODE (gimple_call_arg (defstmt, 0)) == ADDR_EXPR
3040 && TREE_CODE (gimple_call_arg (defstmt, 1)) == INTEGER_CST)
3042 src2 = TREE_OPERAND (gimple_call_arg (defstmt, 0), 0);
3043 len2 = gimple_call_arg (defstmt, 2);
3044 val = gimple_call_arg (defstmt, 1);
3045 /* For non-0 val, we'd have to transform stmt from assignment
3046 into memset (only if dest is addressable). */
3047 if (!integer_zerop (val) && is_gimple_assign (stmt))
3048 src2 = NULL_TREE;
3051 if (src2 == NULL_TREE)
3052 return;
3054 if (len == NULL_TREE)
3055 len = (TREE_CODE (src) == COMPONENT_REF
3056 ? DECL_SIZE_UNIT (TREE_OPERAND (src, 1))
3057 : TYPE_SIZE_UNIT (TREE_TYPE (src)));
3058 if (len2 == NULL_TREE)
3059 len2 = (TREE_CODE (src2) == COMPONENT_REF
3060 ? DECL_SIZE_UNIT (TREE_OPERAND (src2, 1))
3061 : TYPE_SIZE_UNIT (TREE_TYPE (src2)));
3062 if (len == NULL_TREE
3063 || TREE_CODE (len) != INTEGER_CST
3064 || len2 == NULL_TREE
3065 || TREE_CODE (len2) != INTEGER_CST)
3066 return;
3068 src = get_addr_base_and_unit_offset (src, &offset);
3069 src2 = get_addr_base_and_unit_offset (src2, &offset2);
3070 if (src == NULL_TREE
3071 || src2 == NULL_TREE
3072 || offset < offset2)
3073 return;
3075 if (!operand_equal_p (src, src2, 0))
3076 return;
3078 /* [ src + offset2, src + offset2 + len2 - 1 ] is set to val.
3079 Make sure that
3080 [ src + offset, src + offset + len - 1 ] is a subset of that. */
3081 if (wi::to_offset (len) + (offset - offset2) > wi::to_offset (len2))
3082 return;
3084 if (dump_file && (dump_flags & TDF_DETAILS))
3086 fprintf (dump_file, "Simplified\n ");
3087 print_gimple_stmt (dump_file, stmt, 0, dump_flags);
3088 fprintf (dump_file, "after previous\n ");
3089 print_gimple_stmt (dump_file, defstmt, 0, dump_flags);
3092 /* For simplicity, don't change the kind of the stmt,
3093 turn dest = src; into dest = {}; and memcpy (&dest, &src, len);
3094 into memset (&dest, val, len);
3095 In theory we could change dest = src into memset if dest
3096 is addressable (maybe beneficial if val is not 0), or
3097 memcpy (&dest, &src, len) into dest = {} if len is the size
3098 of dest, dest isn't volatile. */
3099 if (is_gimple_assign (stmt))
3101 tree ctor = build_constructor (TREE_TYPE (dest), NULL);
3102 gimple_assign_set_rhs_from_tree (gsip, ctor);
3103 update_stmt (stmt);
3105 else /* If stmt is memcpy, transform it into memset. */
3107 gcall *call = as_a <gcall *> (stmt);
3108 tree fndecl = builtin_decl_implicit (BUILT_IN_MEMSET);
3109 gimple_call_set_fndecl (call, fndecl);
3110 gimple_call_set_fntype (call, TREE_TYPE (fndecl));
3111 gimple_call_set_arg (call, 1, val);
3112 update_stmt (stmt);
3115 if (dump_file && (dump_flags & TDF_DETAILS))
3117 fprintf (dump_file, "into\n ");
3118 print_gimple_stmt (dump_file, stmt, 0, dump_flags);
3122 /* A simple pass that attempts to fold all builtin functions. This pass
3123 is run after we've propagated as many constants as we can. */
3125 namespace {
3127 const pass_data pass_data_fold_builtins =
3129 GIMPLE_PASS, /* type */
3130 "fab", /* name */
3131 OPTGROUP_NONE, /* optinfo_flags */
3132 TV_NONE, /* tv_id */
3133 ( PROP_cfg | PROP_ssa ), /* properties_required */
3134 0, /* properties_provided */
3135 0, /* properties_destroyed */
3136 0, /* todo_flags_start */
3137 TODO_update_ssa, /* todo_flags_finish */
3140 class pass_fold_builtins : public gimple_opt_pass
3142 public:
3143 pass_fold_builtins (gcc::context *ctxt)
3144 : gimple_opt_pass (pass_data_fold_builtins, ctxt)
3147 /* opt_pass methods: */
3148 opt_pass * clone () { return new pass_fold_builtins (m_ctxt); }
3149 virtual unsigned int execute (function *);
3151 }; // class pass_fold_builtins
3153 unsigned int
3154 pass_fold_builtins::execute (function *fun)
3156 bool cfg_changed = false;
3157 basic_block bb;
3158 unsigned int todoflags = 0;
3160 FOR_EACH_BB_FN (bb, fun)
3162 gimple_stmt_iterator i;
3163 for (i = gsi_start_bb (bb); !gsi_end_p (i); )
3165 gimple *stmt, *old_stmt;
3166 tree callee;
3167 enum built_in_function fcode;
3169 stmt = gsi_stmt (i);
3171 if (gimple_code (stmt) != GIMPLE_CALL)
3173 /* Remove all *ssaname_N ={v} {CLOBBER}; stmts,
3174 after the last GIMPLE DSE they aren't needed and might
3175 unnecessarily keep the SSA_NAMEs live. */
3176 if (gimple_clobber_p (stmt))
3178 tree lhs = gimple_assign_lhs (stmt);
3179 if (TREE_CODE (lhs) == MEM_REF
3180 && TREE_CODE (TREE_OPERAND (lhs, 0)) == SSA_NAME)
3182 unlink_stmt_vdef (stmt);
3183 gsi_remove (&i, true);
3184 release_defs (stmt);
3185 continue;
3188 else if (gimple_assign_load_p (stmt) && gimple_store_p (stmt))
3189 optimize_memcpy (&i, gimple_assign_lhs (stmt),
3190 gimple_assign_rhs1 (stmt), NULL_TREE);
3191 gsi_next (&i);
3192 continue;
3195 callee = gimple_call_fndecl (stmt);
3196 if (!callee || DECL_BUILT_IN_CLASS (callee) != BUILT_IN_NORMAL)
3198 gsi_next (&i);
3199 continue;
3202 fcode = DECL_FUNCTION_CODE (callee);
3203 if (fold_stmt (&i))
3205 else
3207 tree result = NULL_TREE;
3208 switch (DECL_FUNCTION_CODE (callee))
3210 case BUILT_IN_CONSTANT_P:
3211 /* Resolve __builtin_constant_p. If it hasn't been
3212 folded to integer_one_node by now, it's fairly
3213 certain that the value simply isn't constant. */
3214 result = integer_zero_node;
3215 break;
3217 case BUILT_IN_ASSUME_ALIGNED:
3218 /* Remove __builtin_assume_aligned. */
3219 result = gimple_call_arg (stmt, 0);
3220 break;
3222 case BUILT_IN_STACK_RESTORE:
3223 result = optimize_stack_restore (i);
3224 if (result)
3225 break;
3226 gsi_next (&i);
3227 continue;
3229 case BUILT_IN_UNREACHABLE:
3230 if (optimize_unreachable (i))
3231 cfg_changed = true;
3232 break;
3234 case BUILT_IN_ATOMIC_FETCH_OR_1:
3235 case BUILT_IN_ATOMIC_FETCH_OR_2:
3236 case BUILT_IN_ATOMIC_FETCH_OR_4:
3237 case BUILT_IN_ATOMIC_FETCH_OR_8:
3238 case BUILT_IN_ATOMIC_FETCH_OR_16:
3239 optimize_atomic_bit_test_and (&i,
3240 IFN_ATOMIC_BIT_TEST_AND_SET,
3241 true, false);
3242 break;
3243 case BUILT_IN_SYNC_FETCH_AND_OR_1:
3244 case BUILT_IN_SYNC_FETCH_AND_OR_2:
3245 case BUILT_IN_SYNC_FETCH_AND_OR_4:
3246 case BUILT_IN_SYNC_FETCH_AND_OR_8:
3247 case BUILT_IN_SYNC_FETCH_AND_OR_16:
3248 optimize_atomic_bit_test_and (&i,
3249 IFN_ATOMIC_BIT_TEST_AND_SET,
3250 false, false);
3251 break;
3253 case BUILT_IN_ATOMIC_FETCH_XOR_1:
3254 case BUILT_IN_ATOMIC_FETCH_XOR_2:
3255 case BUILT_IN_ATOMIC_FETCH_XOR_4:
3256 case BUILT_IN_ATOMIC_FETCH_XOR_8:
3257 case BUILT_IN_ATOMIC_FETCH_XOR_16:
3258 optimize_atomic_bit_test_and
3259 (&i, IFN_ATOMIC_BIT_TEST_AND_COMPLEMENT, true, false);
3260 break;
3261 case BUILT_IN_SYNC_FETCH_AND_XOR_1:
3262 case BUILT_IN_SYNC_FETCH_AND_XOR_2:
3263 case BUILT_IN_SYNC_FETCH_AND_XOR_4:
3264 case BUILT_IN_SYNC_FETCH_AND_XOR_8:
3265 case BUILT_IN_SYNC_FETCH_AND_XOR_16:
3266 optimize_atomic_bit_test_and
3267 (&i, IFN_ATOMIC_BIT_TEST_AND_COMPLEMENT, false, false);
3268 break;
3270 case BUILT_IN_ATOMIC_XOR_FETCH_1:
3271 case BUILT_IN_ATOMIC_XOR_FETCH_2:
3272 case BUILT_IN_ATOMIC_XOR_FETCH_4:
3273 case BUILT_IN_ATOMIC_XOR_FETCH_8:
3274 case BUILT_IN_ATOMIC_XOR_FETCH_16:
3275 optimize_atomic_bit_test_and
3276 (&i, IFN_ATOMIC_BIT_TEST_AND_COMPLEMENT, true, true);
3277 break;
3278 case BUILT_IN_SYNC_XOR_AND_FETCH_1:
3279 case BUILT_IN_SYNC_XOR_AND_FETCH_2:
3280 case BUILT_IN_SYNC_XOR_AND_FETCH_4:
3281 case BUILT_IN_SYNC_XOR_AND_FETCH_8:
3282 case BUILT_IN_SYNC_XOR_AND_FETCH_16:
3283 optimize_atomic_bit_test_and
3284 (&i, IFN_ATOMIC_BIT_TEST_AND_COMPLEMENT, false, true);
3285 break;
3287 case BUILT_IN_ATOMIC_FETCH_AND_1:
3288 case BUILT_IN_ATOMIC_FETCH_AND_2:
3289 case BUILT_IN_ATOMIC_FETCH_AND_4:
3290 case BUILT_IN_ATOMIC_FETCH_AND_8:
3291 case BUILT_IN_ATOMIC_FETCH_AND_16:
3292 optimize_atomic_bit_test_and (&i,
3293 IFN_ATOMIC_BIT_TEST_AND_RESET,
3294 true, false);
3295 break;
3296 case BUILT_IN_SYNC_FETCH_AND_AND_1:
3297 case BUILT_IN_SYNC_FETCH_AND_AND_2:
3298 case BUILT_IN_SYNC_FETCH_AND_AND_4:
3299 case BUILT_IN_SYNC_FETCH_AND_AND_8:
3300 case BUILT_IN_SYNC_FETCH_AND_AND_16:
3301 optimize_atomic_bit_test_and (&i,
3302 IFN_ATOMIC_BIT_TEST_AND_RESET,
3303 false, false);
3304 break;
3306 case BUILT_IN_MEMCPY:
3307 if (gimple_call_builtin_p (stmt, BUILT_IN_NORMAL)
3308 && TREE_CODE (gimple_call_arg (stmt, 0)) == ADDR_EXPR
3309 && TREE_CODE (gimple_call_arg (stmt, 1)) == ADDR_EXPR
3310 && TREE_CODE (gimple_call_arg (stmt, 2)) == INTEGER_CST)
3312 tree dest = TREE_OPERAND (gimple_call_arg (stmt, 0), 0);
3313 tree src = TREE_OPERAND (gimple_call_arg (stmt, 1), 0);
3314 tree len = gimple_call_arg (stmt, 2);
3315 optimize_memcpy (&i, dest, src, len);
3317 break;
3319 case BUILT_IN_VA_START:
3320 case BUILT_IN_VA_END:
3321 case BUILT_IN_VA_COPY:
3322 /* These shouldn't be folded before pass_stdarg. */
3323 result = optimize_stdarg_builtin (stmt);
3324 break;
3326 default:;
3329 if (!result)
3331 gsi_next (&i);
3332 continue;
3335 if (!update_call_from_tree (&i, result))
3336 gimplify_and_update_call_from_tree (&i, result);
3339 todoflags |= TODO_update_address_taken;
3341 if (dump_file && (dump_flags & TDF_DETAILS))
3343 fprintf (dump_file, "Simplified\n ");
3344 print_gimple_stmt (dump_file, stmt, 0, dump_flags);
3347 old_stmt = stmt;
3348 stmt = gsi_stmt (i);
3349 update_stmt (stmt);
3351 if (maybe_clean_or_replace_eh_stmt (old_stmt, stmt)
3352 && gimple_purge_dead_eh_edges (bb))
3353 cfg_changed = true;
3355 if (dump_file && (dump_flags & TDF_DETAILS))
3357 fprintf (dump_file, "to\n ");
3358 print_gimple_stmt (dump_file, stmt, 0, dump_flags);
3359 fprintf (dump_file, "\n");
3362 /* Retry the same statement if it changed into another
3363 builtin, there might be new opportunities now. */
3364 if (gimple_code (stmt) != GIMPLE_CALL)
3366 gsi_next (&i);
3367 continue;
3369 callee = gimple_call_fndecl (stmt);
3370 if (!callee
3371 || DECL_BUILT_IN_CLASS (callee) != BUILT_IN_NORMAL
3372 || DECL_FUNCTION_CODE (callee) == fcode)
3373 gsi_next (&i);
3377 /* Delete unreachable blocks. */
3378 if (cfg_changed)
3379 todoflags |= TODO_cleanup_cfg;
3381 return todoflags;
3384 } // anon namespace
3386 gimple_opt_pass *
3387 make_pass_fold_builtins (gcc::context *ctxt)
3389 return new pass_fold_builtins (ctxt);
3392 /* A simple pass that emits some warnings post IPA. */
3394 namespace {
3396 const pass_data pass_data_post_ipa_warn =
3398 GIMPLE_PASS, /* type */
3399 "post_ipa_warn", /* name */
3400 OPTGROUP_NONE, /* optinfo_flags */
3401 TV_NONE, /* tv_id */
3402 ( PROP_cfg | PROP_ssa ), /* properties_required */
3403 0, /* properties_provided */
3404 0, /* properties_destroyed */
3405 0, /* todo_flags_start */
3406 0, /* todo_flags_finish */
3409 class pass_post_ipa_warn : public gimple_opt_pass
3411 public:
3412 pass_post_ipa_warn (gcc::context *ctxt)
3413 : gimple_opt_pass (pass_data_post_ipa_warn, ctxt)
3416 /* opt_pass methods: */
3417 opt_pass * clone () { return new pass_post_ipa_warn (m_ctxt); }
3418 virtual bool gate (function *) { return warn_nonnull != 0; }
3419 virtual unsigned int execute (function *);
3421 }; // class pass_fold_builtins
3423 unsigned int
3424 pass_post_ipa_warn::execute (function *fun)
3426 basic_block bb;
3428 FOR_EACH_BB_FN (bb, fun)
3430 gimple_stmt_iterator gsi;
3431 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
3433 gimple *stmt = gsi_stmt (gsi);
3434 if (!is_gimple_call (stmt) || gimple_no_warning_p (stmt))
3435 continue;
3437 if (warn_nonnull)
3439 bitmap nonnullargs
3440 = get_nonnull_args (gimple_call_fntype (stmt));
3441 if (nonnullargs)
3443 for (unsigned i = 0; i < gimple_call_num_args (stmt); i++)
3445 tree arg = gimple_call_arg (stmt, i);
3446 if (TREE_CODE (TREE_TYPE (arg)) != POINTER_TYPE)
3447 continue;
3448 if (!integer_zerop (arg))
3449 continue;
3450 if (!bitmap_empty_p (nonnullargs)
3451 && !bitmap_bit_p (nonnullargs, i))
3452 continue;
3454 location_t loc = gimple_location (stmt);
3455 if (warning_at (loc, OPT_Wnonnull,
3456 "argument %u null where non-null "
3457 "expected", i + 1))
3459 tree fndecl = gimple_call_fndecl (stmt);
3460 if (fndecl && DECL_IS_BUILTIN (fndecl))
3461 inform (loc, "in a call to built-in function %qD",
3462 fndecl);
3463 else if (fndecl)
3464 inform (DECL_SOURCE_LOCATION (fndecl),
3465 "in a call to function %qD declared here",
3466 fndecl);
3470 BITMAP_FREE (nonnullargs);
3475 return 0;
3478 } // anon namespace
3480 gimple_opt_pass *
3481 make_pass_post_ipa_warn (gcc::context *ctxt)
3483 return new pass_post_ipa_warn (ctxt);