1 /* Support routines for Value Range Propagation (VRP).
2 Copyright (C) 2005-2017 Free Software Foundation, Inc.
3 Contributed by Diego Novillo <dnovillo@redhat.com>.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
25 #include "insn-codes.h"
30 #include "tree-pass.h"
32 #include "optabs-tree.h"
33 #include "gimple-pretty-print.h"
34 #include "diagnostic-core.h"
36 #include "fold-const.h"
37 #include "stor-layout.h"
40 #include "gimple-fold.h"
42 #include "gimple-iterator.h"
43 #include "gimple-walk.h"
45 #include "tree-ssa-loop-manip.h"
46 #include "tree-ssa-loop-niter.h"
47 #include "tree-ssa-loop.h"
48 #include "tree-into-ssa.h"
52 #include "tree-scalar-evolution.h"
53 #include "tree-ssa-propagate.h"
54 #include "tree-chrec.h"
55 #include "tree-ssa-threadupdate.h"
56 #include "tree-ssa-scopedtables.h"
57 #include "tree-ssa-threadedge.h"
58 #include "omp-general.h"
60 #include "case-cfn-macros.h"
62 #include "alloc-pool.h"
64 #include "tree-cfgcleanup.h"
66 #define VR_INITIALIZER { VR_UNDEFINED, NULL_TREE, NULL_TREE, NULL }
68 /* Allocation pools for tree-vrp allocations. */
69 static object_allocator
<value_range
> vrp_value_range_pool ("Tree VRP value ranges");
70 static bitmap_obstack vrp_equiv_obstack
;
72 /* Set of SSA names found live during the RPO traversal of the function
73 for still active basic-blocks. */
76 /* Return true if the SSA name NAME is live on the edge E. */
79 live_on_edge (edge e
, tree name
)
81 return (live
[e
->dest
->index
]
82 && bitmap_bit_p (live
[e
->dest
->index
], SSA_NAME_VERSION (name
)));
85 /* Local functions. */
86 static int compare_values (tree val1
, tree val2
);
87 static int compare_values_warnv (tree val1
, tree val2
, bool *);
88 static tree
vrp_evaluate_conditional_warnv_with_ops (enum tree_code
,
89 tree
, tree
, bool, bool *,
94 /* Predicate code for the ASSERT_EXPR. Must be COMPARISON_CLASS_P. */
95 enum tree_code comp_code
;
97 /* Name to register the assert for. */
100 /* Value being compared against. */
103 /* Expression to compare. */
107 /* Location information for ASSERT_EXPRs. Each instance of this
108 structure describes an ASSERT_EXPR for an SSA name. Since a single
109 SSA name may have more than one assertion associated with it, these
110 locations are kept in a linked list attached to the corresponding
114 /* Basic block where the assertion would be inserted. */
117 /* Some assertions need to be inserted on an edge (e.g., assertions
118 generated by COND_EXPRs). In those cases, BB will be NULL. */
121 /* Pointer to the statement that generated this assertion. */
122 gimple_stmt_iterator si
;
124 /* Predicate code for the ASSERT_EXPR. Must be COMPARISON_CLASS_P. */
125 enum tree_code comp_code
;
127 /* Value being compared against. */
130 /* Expression to compare. */
133 /* Next node in the linked list. */
137 /* If bit I is present, it means that SSA name N_i has a list of
138 assertions that should be inserted in the IL. */
139 static bitmap need_assert_for
;
141 /* Array of locations lists where to insert assertions. ASSERTS_FOR[I]
142 holds a list of ASSERT_LOCUS_T nodes that describe where
143 ASSERT_EXPRs for SSA name N_I should be inserted. */
144 static assert_locus
**asserts_for
;
146 /* Value range array. After propagation, VR_VALUE[I] holds the range
147 of values that SSA name N_I may take. */
148 static unsigned num_vr_values
;
149 static value_range
**vr_value
;
150 static bool values_propagated
;
152 /* For a PHI node which sets SSA name N_I, VR_COUNTS[I] holds the
153 number of executable edges we saw the last time we visited the
155 static int *vr_phi_edge_counts
;
157 struct switch_update
{
162 static vec
<edge
> to_remove_edges
;
163 static vec
<switch_update
> to_update_switch_stmts
;
166 /* Return the maximum value for TYPE. */
169 vrp_val_max (const_tree type
)
171 if (!INTEGRAL_TYPE_P (type
))
174 return TYPE_MAX_VALUE (type
);
177 /* Return the minimum value for TYPE. */
180 vrp_val_min (const_tree type
)
182 if (!INTEGRAL_TYPE_P (type
))
185 return TYPE_MIN_VALUE (type
);
188 /* Return whether VAL is equal to the maximum value of its type.
189 We can't do a simple equality comparison with TYPE_MAX_VALUE because
190 C typedefs and Ada subtypes can produce types whose TYPE_MAX_VALUE
191 is not == to the integer constant with the same value in the type. */
194 vrp_val_is_max (const_tree val
)
196 tree type_max
= vrp_val_max (TREE_TYPE (val
));
197 return (val
== type_max
198 || (type_max
!= NULL_TREE
199 && operand_equal_p (val
, type_max
, 0)));
202 /* Return whether VAL is equal to the minimum value of its type. */
205 vrp_val_is_min (const_tree val
)
207 tree type_min
= vrp_val_min (TREE_TYPE (val
));
208 return (val
== type_min
209 || (type_min
!= NULL_TREE
210 && operand_equal_p (val
, type_min
, 0)));
214 /* Set value range VR to VR_UNDEFINED. */
217 set_value_range_to_undefined (value_range
*vr
)
219 vr
->type
= VR_UNDEFINED
;
220 vr
->min
= vr
->max
= NULL_TREE
;
222 bitmap_clear (vr
->equiv
);
226 /* Set value range VR to VR_VARYING. */
229 set_value_range_to_varying (value_range
*vr
)
231 vr
->type
= VR_VARYING
;
232 vr
->min
= vr
->max
= NULL_TREE
;
234 bitmap_clear (vr
->equiv
);
238 /* Set value range VR to {T, MIN, MAX, EQUIV}. */
241 set_value_range (value_range
*vr
, enum value_range_type t
, tree min
,
242 tree max
, bitmap equiv
)
244 /* Check the validity of the range. */
246 && (t
== VR_RANGE
|| t
== VR_ANTI_RANGE
))
250 gcc_assert (min
&& max
);
252 gcc_assert (!TREE_OVERFLOW_P (min
) && !TREE_OVERFLOW_P (max
));
254 if (INTEGRAL_TYPE_P (TREE_TYPE (min
)) && t
== VR_ANTI_RANGE
)
255 gcc_assert (!vrp_val_is_min (min
) || !vrp_val_is_max (max
));
257 cmp
= compare_values (min
, max
);
258 gcc_assert (cmp
== 0 || cmp
== -1 || cmp
== -2);
262 && (t
== VR_UNDEFINED
|| t
== VR_VARYING
))
264 gcc_assert (min
== NULL_TREE
&& max
== NULL_TREE
);
265 gcc_assert (equiv
== NULL
|| bitmap_empty_p (equiv
));
272 /* Since updating the equivalence set involves deep copying the
273 bitmaps, only do it if absolutely necessary. */
274 if (vr
->equiv
== NULL
276 vr
->equiv
= BITMAP_ALLOC (&vrp_equiv_obstack
);
278 if (equiv
!= vr
->equiv
)
280 if (equiv
&& !bitmap_empty_p (equiv
))
281 bitmap_copy (vr
->equiv
, equiv
);
283 bitmap_clear (vr
->equiv
);
288 /* Set value range VR to the canonical form of {T, MIN, MAX, EQUIV}.
289 This means adjusting T, MIN and MAX representing the case of a
290 wrapping range with MAX < MIN covering [MIN, type_max] U [type_min, MAX]
291 as anti-rage ~[MAX+1, MIN-1]. Likewise for wrapping anti-ranges.
292 In corner cases where MAX+1 or MIN-1 wraps this will fall back
294 This routine exists to ease canonicalization in the case where we
295 extract ranges from var + CST op limit. */
298 set_and_canonicalize_value_range (value_range
*vr
, enum value_range_type t
,
299 tree min
, tree max
, bitmap equiv
)
301 /* Use the canonical setters for VR_UNDEFINED and VR_VARYING. */
302 if (t
== VR_UNDEFINED
)
304 set_value_range_to_undefined (vr
);
307 else if (t
== VR_VARYING
)
309 set_value_range_to_varying (vr
);
313 /* Nothing to canonicalize for symbolic ranges. */
314 if (TREE_CODE (min
) != INTEGER_CST
315 || TREE_CODE (max
) != INTEGER_CST
)
317 set_value_range (vr
, t
, min
, max
, equiv
);
321 /* Wrong order for min and max, to swap them and the VR type we need
323 if (tree_int_cst_lt (max
, min
))
327 /* For one bit precision if max < min, then the swapped
328 range covers all values, so for VR_RANGE it is varying and
329 for VR_ANTI_RANGE empty range, so drop to varying as well. */
330 if (TYPE_PRECISION (TREE_TYPE (min
)) == 1)
332 set_value_range_to_varying (vr
);
336 one
= build_int_cst (TREE_TYPE (min
), 1);
337 tmp
= int_const_binop (PLUS_EXPR
, max
, one
);
338 max
= int_const_binop (MINUS_EXPR
, min
, one
);
341 /* There's one corner case, if we had [C+1, C] before we now have
342 that again. But this represents an empty value range, so drop
343 to varying in this case. */
344 if (tree_int_cst_lt (max
, min
))
346 set_value_range_to_varying (vr
);
350 t
= t
== VR_RANGE
? VR_ANTI_RANGE
: VR_RANGE
;
353 /* Anti-ranges that can be represented as ranges should be so. */
354 if (t
== VR_ANTI_RANGE
)
356 bool is_min
= vrp_val_is_min (min
);
357 bool is_max
= vrp_val_is_max (max
);
359 if (is_min
&& is_max
)
361 /* We cannot deal with empty ranges, drop to varying.
362 ??? This could be VR_UNDEFINED instead. */
363 set_value_range_to_varying (vr
);
366 else if (TYPE_PRECISION (TREE_TYPE (min
)) == 1
367 && (is_min
|| is_max
))
369 /* Non-empty boolean ranges can always be represented
370 as a singleton range. */
372 min
= max
= vrp_val_max (TREE_TYPE (min
));
374 min
= max
= vrp_val_min (TREE_TYPE (min
));
378 /* As a special exception preserve non-null ranges. */
379 && !(TYPE_UNSIGNED (TREE_TYPE (min
))
380 && integer_zerop (max
)))
382 tree one
= build_int_cst (TREE_TYPE (max
), 1);
383 min
= int_const_binop (PLUS_EXPR
, max
, one
);
384 max
= vrp_val_max (TREE_TYPE (max
));
389 tree one
= build_int_cst (TREE_TYPE (min
), 1);
390 max
= int_const_binop (MINUS_EXPR
, min
, one
);
391 min
= vrp_val_min (TREE_TYPE (min
));
396 /* Do not drop [-INF(OVF), +INF(OVF)] to varying. (OVF) has to be sticky
397 to make sure VRP iteration terminates, otherwise we can get into
400 set_value_range (vr
, t
, min
, max
, equiv
);
403 /* Copy value range FROM into value range TO. */
406 copy_value_range (value_range
*to
, value_range
*from
)
408 set_value_range (to
, from
->type
, from
->min
, from
->max
, from
->equiv
);
411 /* Set value range VR to a single value. This function is only called
412 with values we get from statements, and exists to clear the
413 TREE_OVERFLOW flag. */
416 set_value_range_to_value (value_range
*vr
, tree val
, bitmap equiv
)
418 gcc_assert (is_gimple_min_invariant (val
));
419 if (TREE_OVERFLOW_P (val
))
420 val
= drop_tree_overflow (val
);
421 set_value_range (vr
, VR_RANGE
, val
, val
, equiv
);
424 /* Set value range VR to a non-negative range of type TYPE. */
427 set_value_range_to_nonnegative (value_range
*vr
, tree type
)
429 tree zero
= build_int_cst (type
, 0);
430 set_value_range (vr
, VR_RANGE
, zero
, vrp_val_max (type
), vr
->equiv
);
433 /* Set value range VR to a non-NULL range of type TYPE. */
436 set_value_range_to_nonnull (value_range
*vr
, tree type
)
438 tree zero
= build_int_cst (type
, 0);
439 set_value_range (vr
, VR_ANTI_RANGE
, zero
, zero
, vr
->equiv
);
443 /* Set value range VR to a NULL range of type TYPE. */
446 set_value_range_to_null (value_range
*vr
, tree type
)
448 set_value_range_to_value (vr
, build_int_cst (type
, 0), vr
->equiv
);
452 /* Set value range VR to a range of a truthvalue of type TYPE. */
455 set_value_range_to_truthvalue (value_range
*vr
, tree type
)
457 if (TYPE_PRECISION (type
) == 1)
458 set_value_range_to_varying (vr
);
460 set_value_range (vr
, VR_RANGE
,
461 build_int_cst (type
, 0), build_int_cst (type
, 1),
466 /* If abs (min) < abs (max), set VR to [-max, max], if
467 abs (min) >= abs (max), set VR to [-min, min]. */
470 abs_extent_range (value_range
*vr
, tree min
, tree max
)
474 gcc_assert (TREE_CODE (min
) == INTEGER_CST
);
475 gcc_assert (TREE_CODE (max
) == INTEGER_CST
);
476 gcc_assert (INTEGRAL_TYPE_P (TREE_TYPE (min
)));
477 gcc_assert (!TYPE_UNSIGNED (TREE_TYPE (min
)));
478 min
= fold_unary (ABS_EXPR
, TREE_TYPE (min
), min
);
479 max
= fold_unary (ABS_EXPR
, TREE_TYPE (max
), max
);
480 if (TREE_OVERFLOW (min
) || TREE_OVERFLOW (max
))
482 set_value_range_to_varying (vr
);
485 cmp
= compare_values (min
, max
);
487 min
= fold_unary (NEGATE_EXPR
, TREE_TYPE (min
), max
);
488 else if (cmp
== 0 || cmp
== 1)
491 min
= fold_unary (NEGATE_EXPR
, TREE_TYPE (min
), min
);
495 set_value_range_to_varying (vr
);
498 set_and_canonicalize_value_range (vr
, VR_RANGE
, min
, max
, NULL
);
502 /* Return value range information for VAR.
504 If we have no values ranges recorded (ie, VRP is not running), then
505 return NULL. Otherwise create an empty range if none existed for VAR. */
508 get_value_range (const_tree var
)
510 static const value_range vr_const_varying
511 = { VR_VARYING
, NULL_TREE
, NULL_TREE
, NULL
};
514 unsigned ver
= SSA_NAME_VERSION (var
);
516 /* If we have no recorded ranges, then return NULL. */
520 /* If we query the range for a new SSA name return an unmodifiable VARYING.
521 We should get here at most from the substitute-and-fold stage which
522 will never try to change values. */
523 if (ver
>= num_vr_values
)
524 return CONST_CAST (value_range
*, &vr_const_varying
);
530 /* After propagation finished do not allocate new value-ranges. */
531 if (values_propagated
)
532 return CONST_CAST (value_range
*, &vr_const_varying
);
534 /* Create a default value range. */
535 vr_value
[ver
] = vr
= vrp_value_range_pool
.allocate ();
536 memset (vr
, 0, sizeof (*vr
));
538 /* Defer allocating the equivalence set. */
541 /* If VAR is a default definition of a parameter, the variable can
542 take any value in VAR's type. */
543 if (SSA_NAME_IS_DEFAULT_DEF (var
))
545 sym
= SSA_NAME_VAR (var
);
546 if (TREE_CODE (sym
) == PARM_DECL
)
548 /* Try to use the "nonnull" attribute to create ~[0, 0]
549 anti-ranges for pointers. Note that this is only valid with
550 default definitions of PARM_DECLs. */
551 if (POINTER_TYPE_P (TREE_TYPE (sym
))
552 && (nonnull_arg_p (sym
)
553 || get_ptr_nonnull (var
)))
554 set_value_range_to_nonnull (vr
, TREE_TYPE (sym
));
555 else if (INTEGRAL_TYPE_P (TREE_TYPE (sym
)))
558 value_range_type rtype
= get_range_info (var
, &min
, &max
);
559 if (rtype
== VR_RANGE
|| rtype
== VR_ANTI_RANGE
)
560 set_value_range (vr
, rtype
,
561 wide_int_to_tree (TREE_TYPE (var
), min
),
562 wide_int_to_tree (TREE_TYPE (var
), max
),
565 set_value_range_to_varying (vr
);
568 set_value_range_to_varying (vr
);
570 else if (TREE_CODE (sym
) == RESULT_DECL
571 && DECL_BY_REFERENCE (sym
))
572 set_value_range_to_nonnull (vr
, TREE_TYPE (sym
));
578 /* Set value-ranges of all SSA names defined by STMT to varying. */
581 set_defs_to_varying (gimple
*stmt
)
585 FOR_EACH_SSA_TREE_OPERAND (def
, stmt
, i
, SSA_OP_DEF
)
587 value_range
*vr
= get_value_range (def
);
588 /* Avoid writing to vr_const_varying get_value_range may return. */
589 if (vr
->type
!= VR_VARYING
)
590 set_value_range_to_varying (vr
);
595 /* Return true, if VAL1 and VAL2 are equal values for VRP purposes. */
598 vrp_operand_equal_p (const_tree val1
, const_tree val2
)
602 if (!val1
|| !val2
|| !operand_equal_p (val1
, val2
, 0))
607 /* Return true, if the bitmaps B1 and B2 are equal. */
610 vrp_bitmap_equal_p (const_bitmap b1
, const_bitmap b2
)
613 || ((!b1
|| bitmap_empty_p (b1
))
614 && (!b2
|| bitmap_empty_p (b2
)))
616 && bitmap_equal_p (b1
, b2
)));
619 /* Update the value range and equivalence set for variable VAR to
620 NEW_VR. Return true if NEW_VR is different from VAR's previous
623 NOTE: This function assumes that NEW_VR is a temporary value range
624 object created for the sole purpose of updating VAR's range. The
625 storage used by the equivalence set from NEW_VR will be freed by
626 this function. Do not call update_value_range when NEW_VR
627 is the range object associated with another SSA name. */
630 update_value_range (const_tree var
, value_range
*new_vr
)
635 /* If there is a value-range on the SSA name from earlier analysis
637 if (INTEGRAL_TYPE_P (TREE_TYPE (var
)))
640 value_range_type rtype
= get_range_info (var
, &min
, &max
);
641 if (rtype
== VR_RANGE
|| rtype
== VR_ANTI_RANGE
)
644 nr_min
= wide_int_to_tree (TREE_TYPE (var
), min
);
645 nr_max
= wide_int_to_tree (TREE_TYPE (var
), max
);
646 value_range nr
= VR_INITIALIZER
;
647 set_and_canonicalize_value_range (&nr
, rtype
, nr_min
, nr_max
, NULL
);
648 vrp_intersect_ranges (new_vr
, &nr
);
652 /* Update the value range, if necessary. */
653 old_vr
= get_value_range (var
);
654 is_new
= old_vr
->type
!= new_vr
->type
655 || !vrp_operand_equal_p (old_vr
->min
, new_vr
->min
)
656 || !vrp_operand_equal_p (old_vr
->max
, new_vr
->max
)
657 || !vrp_bitmap_equal_p (old_vr
->equiv
, new_vr
->equiv
);
661 /* Do not allow transitions up the lattice. The following
662 is slightly more awkward than just new_vr->type < old_vr->type
663 because VR_RANGE and VR_ANTI_RANGE need to be considered
664 the same. We may not have is_new when transitioning to
665 UNDEFINED. If old_vr->type is VARYING, we shouldn't be
667 if (new_vr
->type
== VR_UNDEFINED
)
669 BITMAP_FREE (new_vr
->equiv
);
670 set_value_range_to_varying (old_vr
);
671 set_value_range_to_varying (new_vr
);
675 set_value_range (old_vr
, new_vr
->type
, new_vr
->min
, new_vr
->max
,
679 BITMAP_FREE (new_vr
->equiv
);
685 /* Add VAR and VAR's equivalence set to EQUIV. This is the central
686 point where equivalence processing can be turned on/off. */
689 add_equivalence (bitmap
*equiv
, const_tree var
)
691 unsigned ver
= SSA_NAME_VERSION (var
);
692 value_range
*vr
= get_value_range (var
);
695 *equiv
= BITMAP_ALLOC (&vrp_equiv_obstack
);
696 bitmap_set_bit (*equiv
, ver
);
698 bitmap_ior_into (*equiv
, vr
->equiv
);
702 /* Return true if VR is ~[0, 0]. */
705 range_is_nonnull (value_range
*vr
)
707 return vr
->type
== VR_ANTI_RANGE
708 && integer_zerop (vr
->min
)
709 && integer_zerop (vr
->max
);
713 /* Return true if VR is [0, 0]. */
716 range_is_null (value_range
*vr
)
718 return vr
->type
== VR_RANGE
719 && integer_zerop (vr
->min
)
720 && integer_zerop (vr
->max
);
723 /* Return true if max and min of VR are INTEGER_CST. It's not necessary
727 range_int_cst_p (value_range
*vr
)
729 return (vr
->type
== VR_RANGE
730 && TREE_CODE (vr
->max
) == INTEGER_CST
731 && TREE_CODE (vr
->min
) == INTEGER_CST
);
734 /* Return true if VR is a INTEGER_CST singleton. */
737 range_int_cst_singleton_p (value_range
*vr
)
739 return (range_int_cst_p (vr
)
740 && tree_int_cst_equal (vr
->min
, vr
->max
));
743 /* Return true if value range VR involves at least one symbol. */
746 symbolic_range_p (value_range
*vr
)
748 return (!is_gimple_min_invariant (vr
->min
)
749 || !is_gimple_min_invariant (vr
->max
));
752 /* Return the single symbol (an SSA_NAME) contained in T if any, or NULL_TREE
753 otherwise. We only handle additive operations and set NEG to true if the
754 symbol is negated and INV to the invariant part, if any. */
757 get_single_symbol (tree t
, bool *neg
, tree
*inv
)
765 if (TREE_CODE (t
) == PLUS_EXPR
766 || TREE_CODE (t
) == POINTER_PLUS_EXPR
767 || TREE_CODE (t
) == MINUS_EXPR
)
769 if (is_gimple_min_invariant (TREE_OPERAND (t
, 0)))
771 neg_
= (TREE_CODE (t
) == MINUS_EXPR
);
772 inv_
= TREE_OPERAND (t
, 0);
773 t
= TREE_OPERAND (t
, 1);
775 else if (is_gimple_min_invariant (TREE_OPERAND (t
, 1)))
778 inv_
= TREE_OPERAND (t
, 1);
779 t
= TREE_OPERAND (t
, 0);
790 if (TREE_CODE (t
) == NEGATE_EXPR
)
792 t
= TREE_OPERAND (t
, 0);
796 if (TREE_CODE (t
) != SSA_NAME
)
799 gcc_assert (! inv_
|| ! TREE_OVERFLOW_P (inv_
));
806 /* The reverse operation: build a symbolic expression with TYPE
807 from symbol SYM, negated according to NEG, and invariant INV. */
810 build_symbolic_expr (tree type
, tree sym
, bool neg
, tree inv
)
812 const bool pointer_p
= POINTER_TYPE_P (type
);
816 t
= build1 (NEGATE_EXPR
, type
, t
);
818 if (integer_zerop (inv
))
821 return build2 (pointer_p
? POINTER_PLUS_EXPR
: PLUS_EXPR
, type
, t
, inv
);
824 /* Return true if value range VR involves exactly one symbol SYM. */
827 symbolic_range_based_on_p (value_range
*vr
, const_tree sym
)
829 bool neg
, min_has_symbol
, max_has_symbol
;
832 if (is_gimple_min_invariant (vr
->min
))
833 min_has_symbol
= false;
834 else if (get_single_symbol (vr
->min
, &neg
, &inv
) == sym
)
835 min_has_symbol
= true;
839 if (is_gimple_min_invariant (vr
->max
))
840 max_has_symbol
= false;
841 else if (get_single_symbol (vr
->max
, &neg
, &inv
) == sym
)
842 max_has_symbol
= true;
846 return (min_has_symbol
|| max_has_symbol
);
849 /* Return true if the result of assignment STMT is know to be non-zero. */
852 gimple_assign_nonzero_p (gimple
*stmt
)
854 enum tree_code code
= gimple_assign_rhs_code (stmt
);
855 bool strict_overflow_p
;
856 switch (get_gimple_rhs_class (code
))
858 case GIMPLE_UNARY_RHS
:
859 return tree_unary_nonzero_warnv_p (gimple_assign_rhs_code (stmt
),
860 gimple_expr_type (stmt
),
861 gimple_assign_rhs1 (stmt
),
863 case GIMPLE_BINARY_RHS
:
864 return tree_binary_nonzero_warnv_p (gimple_assign_rhs_code (stmt
),
865 gimple_expr_type (stmt
),
866 gimple_assign_rhs1 (stmt
),
867 gimple_assign_rhs2 (stmt
),
869 case GIMPLE_TERNARY_RHS
:
871 case GIMPLE_SINGLE_RHS
:
872 return tree_single_nonzero_warnv_p (gimple_assign_rhs1 (stmt
),
874 case GIMPLE_INVALID_RHS
:
881 /* Return true if STMT is known to compute a non-zero value. */
884 gimple_stmt_nonzero_p (gimple
*stmt
)
886 switch (gimple_code (stmt
))
889 return gimple_assign_nonzero_p (stmt
);
892 tree fndecl
= gimple_call_fndecl (stmt
);
893 if (!fndecl
) return false;
894 if (flag_delete_null_pointer_checks
&& !flag_check_new
895 && DECL_IS_OPERATOR_NEW (fndecl
)
896 && !TREE_NOTHROW (fndecl
))
898 /* References are always non-NULL. */
899 if (flag_delete_null_pointer_checks
900 && TREE_CODE (TREE_TYPE (fndecl
)) == REFERENCE_TYPE
)
902 if (flag_delete_null_pointer_checks
&&
903 lookup_attribute ("returns_nonnull",
904 TYPE_ATTRIBUTES (gimple_call_fntype (stmt
))))
907 gcall
*call_stmt
= as_a
<gcall
*> (stmt
);
908 unsigned rf
= gimple_call_return_flags (call_stmt
);
909 if (rf
& ERF_RETURNS_ARG
)
911 unsigned argnum
= rf
& ERF_RETURN_ARG_MASK
;
912 if (argnum
< gimple_call_num_args (call_stmt
))
914 tree arg
= gimple_call_arg (call_stmt
, argnum
);
916 && infer_nonnull_range_by_attribute (stmt
, arg
))
920 return gimple_alloca_call_p (stmt
);
927 /* Like tree_expr_nonzero_p, but this function uses value ranges
931 vrp_stmt_computes_nonzero (gimple
*stmt
)
933 if (gimple_stmt_nonzero_p (stmt
))
936 /* If we have an expression of the form &X->a, then the expression
937 is nonnull if X is nonnull. */
938 if (is_gimple_assign (stmt
)
939 && gimple_assign_rhs_code (stmt
) == ADDR_EXPR
)
941 tree expr
= gimple_assign_rhs1 (stmt
);
942 tree base
= get_base_address (TREE_OPERAND (expr
, 0));
944 if (base
!= NULL_TREE
945 && TREE_CODE (base
) == MEM_REF
946 && TREE_CODE (TREE_OPERAND (base
, 0)) == SSA_NAME
)
948 value_range
*vr
= get_value_range (TREE_OPERAND (base
, 0));
949 if (range_is_nonnull (vr
))
957 /* Returns true if EXPR is a valid value (as expected by compare_values) --
958 a gimple invariant, or SSA_NAME +- CST. */
961 valid_value_p (tree expr
)
963 if (TREE_CODE (expr
) == SSA_NAME
)
966 if (TREE_CODE (expr
) == PLUS_EXPR
967 || TREE_CODE (expr
) == MINUS_EXPR
)
968 return (TREE_CODE (TREE_OPERAND (expr
, 0)) == SSA_NAME
969 && TREE_CODE (TREE_OPERAND (expr
, 1)) == INTEGER_CST
);
971 return is_gimple_min_invariant (expr
);
977 -2 if those are incomparable. */
979 operand_less_p (tree val
, tree val2
)
981 /* LT is folded faster than GE and others. Inline the common case. */
982 if (TREE_CODE (val
) == INTEGER_CST
&& TREE_CODE (val2
) == INTEGER_CST
)
983 return tree_int_cst_lt (val
, val2
);
988 fold_defer_overflow_warnings ();
990 tcmp
= fold_binary_to_constant (LT_EXPR
, boolean_type_node
, val
, val2
);
992 fold_undefer_and_ignore_overflow_warnings ();
995 || TREE_CODE (tcmp
) != INTEGER_CST
)
998 if (!integer_zerop (tcmp
))
1005 /* Compare two values VAL1 and VAL2. Return
1007 -2 if VAL1 and VAL2 cannot be compared at compile-time,
1010 +1 if VAL1 > VAL2, and
1013 This is similar to tree_int_cst_compare but supports pointer values
1014 and values that cannot be compared at compile time.
1016 If STRICT_OVERFLOW_P is not NULL, then set *STRICT_OVERFLOW_P to
1017 true if the return value is only valid if we assume that signed
1018 overflow is undefined. */
1021 compare_values_warnv (tree val1
, tree val2
, bool *strict_overflow_p
)
1026 /* Below we rely on the fact that VAL1 and VAL2 are both pointers or
1028 gcc_assert (POINTER_TYPE_P (TREE_TYPE (val1
))
1029 == POINTER_TYPE_P (TREE_TYPE (val2
)));
1031 /* Convert the two values into the same type. This is needed because
1032 sizetype causes sign extension even for unsigned types. */
1033 val2
= fold_convert (TREE_TYPE (val1
), val2
);
1034 STRIP_USELESS_TYPE_CONVERSION (val2
);
1036 const bool overflow_undefined
1037 = INTEGRAL_TYPE_P (TREE_TYPE (val1
))
1038 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (val1
));
1041 tree sym1
= get_single_symbol (val1
, &neg1
, &inv1
);
1042 tree sym2
= get_single_symbol (val2
, &neg2
, &inv2
);
1044 /* If VAL1 and VAL2 are of the form '[-]NAME [+ CST]', return -1 or +1
1045 accordingly. If VAL1 and VAL2 don't use the same name, return -2. */
1048 /* Both values must use the same name with the same sign. */
1049 if (sym1
!= sym2
|| neg1
!= neg2
)
1052 /* [-]NAME + CST == [-]NAME + CST. */
1056 /* If overflow is defined we cannot simplify more. */
1057 if (!overflow_undefined
)
1060 if (strict_overflow_p
!= NULL
1061 /* Symbolic range building sets TREE_NO_WARNING to declare
1062 that overflow doesn't happen. */
1063 && (!inv1
|| !TREE_NO_WARNING (val1
))
1064 && (!inv2
|| !TREE_NO_WARNING (val2
)))
1065 *strict_overflow_p
= true;
1068 inv1
= build_int_cst (TREE_TYPE (val1
), 0);
1070 inv2
= build_int_cst (TREE_TYPE (val2
), 0);
1072 return wi::cmp (inv1
, inv2
, TYPE_SIGN (TREE_TYPE (val1
)));
1075 const bool cst1
= is_gimple_min_invariant (val1
);
1076 const bool cst2
= is_gimple_min_invariant (val2
);
1078 /* If one is of the form '[-]NAME + CST' and the other is constant, then
1079 it might be possible to say something depending on the constants. */
1080 if ((sym1
&& inv1
&& cst2
) || (sym2
&& inv2
&& cst1
))
1082 if (!overflow_undefined
)
1085 if (strict_overflow_p
!= NULL
1086 /* Symbolic range building sets TREE_NO_WARNING to declare
1087 that overflow doesn't happen. */
1088 && (!sym1
|| !TREE_NO_WARNING (val1
))
1089 && (!sym2
|| !TREE_NO_WARNING (val2
)))
1090 *strict_overflow_p
= true;
1092 const signop sgn
= TYPE_SIGN (TREE_TYPE (val1
));
1093 tree cst
= cst1
? val1
: val2
;
1094 tree inv
= cst1
? inv2
: inv1
;
1096 /* Compute the difference between the constants. If it overflows or
1097 underflows, this means that we can trivially compare the NAME with
1098 it and, consequently, the two values with each other. */
1099 wide_int diff
= wi::sub (cst
, inv
);
1100 if (wi::cmp (0, inv
, sgn
) != wi::cmp (diff
, cst
, sgn
))
1102 const int res
= wi::cmp (cst
, inv
, sgn
);
1103 return cst1
? res
: -res
;
1109 /* We cannot say anything more for non-constants. */
1113 if (!POINTER_TYPE_P (TREE_TYPE (val1
)))
1115 /* We cannot compare overflowed values. */
1116 if (TREE_OVERFLOW (val1
) || TREE_OVERFLOW (val2
))
1119 return tree_int_cst_compare (val1
, val2
);
1125 /* First see if VAL1 and VAL2 are not the same. */
1126 if (val1
== val2
|| operand_equal_p (val1
, val2
, 0))
1129 /* If VAL1 is a lower address than VAL2, return -1. */
1130 if (operand_less_p (val1
, val2
) == 1)
1133 /* If VAL1 is a higher address than VAL2, return +1. */
1134 if (operand_less_p (val2
, val1
) == 1)
1137 /* If VAL1 is different than VAL2, return +2.
1138 For integer constants we either have already returned -1 or 1
1139 or they are equivalent. We still might succeed in proving
1140 something about non-trivial operands. */
1141 if (TREE_CODE (val1
) != INTEGER_CST
1142 || TREE_CODE (val2
) != INTEGER_CST
)
1144 t
= fold_binary_to_constant (NE_EXPR
, boolean_type_node
, val1
, val2
);
1145 if (t
&& integer_onep (t
))
1153 /* Compare values like compare_values_warnv. */
1156 compare_values (tree val1
, tree val2
)
1159 return compare_values_warnv (val1
, val2
, &sop
);
1163 /* Return 1 if VAL is inside value range MIN <= VAL <= MAX,
1164 0 if VAL is not inside [MIN, MAX],
1165 -2 if we cannot tell either way.
1167 Benchmark compile/20001226-1.c compilation time after changing this
1171 value_inside_range (tree val
, tree min
, tree max
)
1175 cmp1
= operand_less_p (val
, min
);
1181 cmp2
= operand_less_p (max
, val
);
1189 /* Return true if value ranges VR0 and VR1 have a non-empty
1192 Benchmark compile/20001226-1.c compilation time after changing this
1197 value_ranges_intersect_p (value_range
*vr0
, value_range
*vr1
)
1199 /* The value ranges do not intersect if the maximum of the first range is
1200 less than the minimum of the second range or vice versa.
1201 When those relations are unknown, we can't do any better. */
1202 if (operand_less_p (vr0
->max
, vr1
->min
) != 0)
1204 if (operand_less_p (vr1
->max
, vr0
->min
) != 0)
1210 /* Return 1 if [MIN, MAX] includes the value zero, 0 if it does not
1211 include the value zero, -2 if we cannot tell. */
1214 range_includes_zero_p (tree min
, tree max
)
1216 tree zero
= build_int_cst (TREE_TYPE (min
), 0);
1217 return value_inside_range (zero
, min
, max
);
1220 /* Return true if *VR is know to only contain nonnegative values. */
1223 value_range_nonnegative_p (value_range
*vr
)
1225 /* Testing for VR_ANTI_RANGE is not useful here as any anti-range
1226 which would return a useful value should be encoded as a
1228 if (vr
->type
== VR_RANGE
)
1230 int result
= compare_values (vr
->min
, integer_zero_node
);
1231 return (result
== 0 || result
== 1);
1237 /* If *VR has a value rante that is a single constant value return that,
1238 otherwise return NULL_TREE. */
1241 value_range_constant_singleton (value_range
*vr
)
1243 if (vr
->type
== VR_RANGE
1244 && vrp_operand_equal_p (vr
->min
, vr
->max
)
1245 && is_gimple_min_invariant (vr
->min
))
1251 /* If OP has a value range with a single constant value return that,
1252 otherwise return NULL_TREE. This returns OP itself if OP is a
1256 op_with_constant_singleton_value_range (tree op
)
1258 if (is_gimple_min_invariant (op
))
1261 if (TREE_CODE (op
) != SSA_NAME
)
1264 return value_range_constant_singleton (get_value_range (op
));
1267 /* Return true if op is in a boolean [0, 1] value-range. */
1270 op_with_boolean_value_range_p (tree op
)
1274 if (TYPE_PRECISION (TREE_TYPE (op
)) == 1)
1277 if (integer_zerop (op
)
1278 || integer_onep (op
))
1281 if (TREE_CODE (op
) != SSA_NAME
)
1284 vr
= get_value_range (op
);
1285 return (vr
->type
== VR_RANGE
1286 && integer_zerop (vr
->min
)
1287 && integer_onep (vr
->max
));
1290 /* Extract value range information for VAR when (OP COND_CODE LIMIT) is
1291 true and store it in *VR_P. */
1294 extract_range_for_var_from_comparison_expr (tree var
, enum tree_code cond_code
,
1295 tree op
, tree limit
,
1298 tree min
, max
, type
;
1299 value_range
*limit_vr
;
1300 type
= TREE_TYPE (var
);
1301 gcc_assert (limit
!= var
);
1303 /* For pointer arithmetic, we only keep track of pointer equality
1305 if (POINTER_TYPE_P (type
) && cond_code
!= NE_EXPR
&& cond_code
!= EQ_EXPR
)
1307 set_value_range_to_varying (vr_p
);
1311 /* If LIMIT is another SSA name and LIMIT has a range of its own,
1312 try to use LIMIT's range to avoid creating symbolic ranges
1314 limit_vr
= (TREE_CODE (limit
) == SSA_NAME
) ? get_value_range (limit
) : NULL
;
1316 /* LIMIT's range is only interesting if it has any useful information. */
1318 || limit_vr
->type
== VR_UNDEFINED
1319 || limit_vr
->type
== VR_VARYING
1320 || (symbolic_range_p (limit_vr
)
1321 && ! (limit_vr
->type
== VR_RANGE
1322 && (limit_vr
->min
== limit_vr
->max
1323 || operand_equal_p (limit_vr
->min
, limit_vr
->max
, 0)))))
1326 /* Initially, the new range has the same set of equivalences of
1327 VAR's range. This will be revised before returning the final
1328 value. Since assertions may be chained via mutually exclusive
1329 predicates, we will need to trim the set of equivalences before
1331 gcc_assert (vr_p
->equiv
== NULL
);
1332 add_equivalence (&vr_p
->equiv
, var
);
1334 /* Extract a new range based on the asserted comparison for VAR and
1335 LIMIT's value range. Notice that if LIMIT has an anti-range, we
1336 will only use it for equality comparisons (EQ_EXPR). For any
1337 other kind of assertion, we cannot derive a range from LIMIT's
1338 anti-range that can be used to describe the new range. For
1339 instance, ASSERT_EXPR <x_2, x_2 <= b_4>. If b_4 is ~[2, 10],
1340 then b_4 takes on the ranges [-INF, 1] and [11, +INF]. There is
1341 no single range for x_2 that could describe LE_EXPR, so we might
1342 as well build the range [b_4, +INF] for it.
1343 One special case we handle is extracting a range from a
1344 range test encoded as (unsigned)var + CST <= limit. */
1345 if (TREE_CODE (op
) == NOP_EXPR
1346 || TREE_CODE (op
) == PLUS_EXPR
)
1348 if (TREE_CODE (op
) == PLUS_EXPR
)
1350 min
= fold_build1 (NEGATE_EXPR
, TREE_TYPE (TREE_OPERAND (op
, 1)),
1351 TREE_OPERAND (op
, 1));
1352 max
= int_const_binop (PLUS_EXPR
, limit
, min
);
1353 op
= TREE_OPERAND (op
, 0);
1357 min
= build_int_cst (TREE_TYPE (var
), 0);
1361 /* Make sure to not set TREE_OVERFLOW on the final type
1362 conversion. We are willingly interpreting large positive
1363 unsigned values as negative signed values here. */
1364 min
= force_fit_type (TREE_TYPE (var
), wi::to_widest (min
), 0, false);
1365 max
= force_fit_type (TREE_TYPE (var
), wi::to_widest (max
), 0, false);
1367 /* We can transform a max, min range to an anti-range or
1368 vice-versa. Use set_and_canonicalize_value_range which does
1370 if (cond_code
== LE_EXPR
)
1371 set_and_canonicalize_value_range (vr_p
, VR_RANGE
,
1372 min
, max
, vr_p
->equiv
);
1373 else if (cond_code
== GT_EXPR
)
1374 set_and_canonicalize_value_range (vr_p
, VR_ANTI_RANGE
,
1375 min
, max
, vr_p
->equiv
);
1379 else if (cond_code
== EQ_EXPR
)
1381 enum value_range_type range_type
;
1385 range_type
= limit_vr
->type
;
1386 min
= limit_vr
->min
;
1387 max
= limit_vr
->max
;
1391 range_type
= VR_RANGE
;
1396 set_value_range (vr_p
, range_type
, min
, max
, vr_p
->equiv
);
1398 /* When asserting the equality VAR == LIMIT and LIMIT is another
1399 SSA name, the new range will also inherit the equivalence set
1401 if (TREE_CODE (limit
) == SSA_NAME
)
1402 add_equivalence (&vr_p
->equiv
, limit
);
1404 else if (cond_code
== NE_EXPR
)
1406 /* As described above, when LIMIT's range is an anti-range and
1407 this assertion is an inequality (NE_EXPR), then we cannot
1408 derive anything from the anti-range. For instance, if
1409 LIMIT's range was ~[0, 0], the assertion 'VAR != LIMIT' does
1410 not imply that VAR's range is [0, 0]. So, in the case of
1411 anti-ranges, we just assert the inequality using LIMIT and
1414 If LIMIT_VR is a range, we can only use it to build a new
1415 anti-range if LIMIT_VR is a single-valued range. For
1416 instance, if LIMIT_VR is [0, 1], the predicate
1417 VAR != [0, 1] does not mean that VAR's range is ~[0, 1].
1418 Rather, it means that for value 0 VAR should be ~[0, 0]
1419 and for value 1, VAR should be ~[1, 1]. We cannot
1420 represent these ranges.
1422 The only situation in which we can build a valid
1423 anti-range is when LIMIT_VR is a single-valued range
1424 (i.e., LIMIT_VR->MIN == LIMIT_VR->MAX). In that case,
1425 build the anti-range ~[LIMIT_VR->MIN, LIMIT_VR->MAX]. */
1427 && limit_vr
->type
== VR_RANGE
1428 && compare_values (limit_vr
->min
, limit_vr
->max
) == 0)
1430 min
= limit_vr
->min
;
1431 max
= limit_vr
->max
;
1435 /* In any other case, we cannot use LIMIT's range to build a
1436 valid anti-range. */
1440 /* If MIN and MAX cover the whole range for their type, then
1441 just use the original LIMIT. */
1442 if (INTEGRAL_TYPE_P (type
)
1443 && vrp_val_is_min (min
)
1444 && vrp_val_is_max (max
))
1447 set_and_canonicalize_value_range (vr_p
, VR_ANTI_RANGE
,
1448 min
, max
, vr_p
->equiv
);
1450 else if (cond_code
== LE_EXPR
|| cond_code
== LT_EXPR
)
1452 min
= TYPE_MIN_VALUE (type
);
1454 if (limit_vr
== NULL
|| limit_vr
->type
== VR_ANTI_RANGE
)
1458 /* If LIMIT_VR is of the form [N1, N2], we need to build the
1459 range [MIN, N2] for LE_EXPR and [MIN, N2 - 1] for
1461 max
= limit_vr
->max
;
1464 /* If the maximum value forces us to be out of bounds, simply punt.
1465 It would be pointless to try and do anything more since this
1466 all should be optimized away above us. */
1467 if (cond_code
== LT_EXPR
1468 && compare_values (max
, min
) == 0)
1469 set_value_range_to_varying (vr_p
);
1472 /* For LT_EXPR, we create the range [MIN, MAX - 1]. */
1473 if (cond_code
== LT_EXPR
)
1475 if (TYPE_PRECISION (TREE_TYPE (max
)) == 1
1476 && !TYPE_UNSIGNED (TREE_TYPE (max
)))
1477 max
= fold_build2 (PLUS_EXPR
, TREE_TYPE (max
), max
,
1478 build_int_cst (TREE_TYPE (max
), -1));
1480 max
= fold_build2 (MINUS_EXPR
, TREE_TYPE (max
), max
,
1481 build_int_cst (TREE_TYPE (max
), 1));
1482 /* Signal to compare_values_warnv this expr doesn't overflow. */
1484 TREE_NO_WARNING (max
) = 1;
1487 set_value_range (vr_p
, VR_RANGE
, min
, max
, vr_p
->equiv
);
1490 else if (cond_code
== GE_EXPR
|| cond_code
== GT_EXPR
)
1492 max
= TYPE_MAX_VALUE (type
);
1494 if (limit_vr
== NULL
|| limit_vr
->type
== VR_ANTI_RANGE
)
1498 /* If LIMIT_VR is of the form [N1, N2], we need to build the
1499 range [N1, MAX] for GE_EXPR and [N1 + 1, MAX] for
1501 min
= limit_vr
->min
;
1504 /* If the minimum value forces us to be out of bounds, simply punt.
1505 It would be pointless to try and do anything more since this
1506 all should be optimized away above us. */
1507 if (cond_code
== GT_EXPR
1508 && compare_values (min
, max
) == 0)
1509 set_value_range_to_varying (vr_p
);
1512 /* For GT_EXPR, we create the range [MIN + 1, MAX]. */
1513 if (cond_code
== GT_EXPR
)
1515 if (TYPE_PRECISION (TREE_TYPE (min
)) == 1
1516 && !TYPE_UNSIGNED (TREE_TYPE (min
)))
1517 min
= fold_build2 (MINUS_EXPR
, TREE_TYPE (min
), min
,
1518 build_int_cst (TREE_TYPE (min
), -1));
1520 min
= fold_build2 (PLUS_EXPR
, TREE_TYPE (min
), min
,
1521 build_int_cst (TREE_TYPE (min
), 1));
1522 /* Signal to compare_values_warnv this expr doesn't overflow. */
1524 TREE_NO_WARNING (min
) = 1;
1527 set_value_range (vr_p
, VR_RANGE
, min
, max
, vr_p
->equiv
);
1533 /* Finally intersect the new range with what we already know about var. */
1534 vrp_intersect_ranges (vr_p
, get_value_range (var
));
1537 /* Extract value range information from an ASSERT_EXPR EXPR and store
1541 extract_range_from_assert (value_range
*vr_p
, tree expr
)
1543 tree var
= ASSERT_EXPR_VAR (expr
);
1544 tree cond
= ASSERT_EXPR_COND (expr
);
1546 enum tree_code cond_code
;
1547 gcc_assert (COMPARISON_CLASS_P (cond
));
1549 /* Find VAR in the ASSERT_EXPR conditional. */
1550 if (var
== TREE_OPERAND (cond
, 0)
1551 || TREE_CODE (TREE_OPERAND (cond
, 0)) == PLUS_EXPR
1552 || TREE_CODE (TREE_OPERAND (cond
, 0)) == NOP_EXPR
)
1554 /* If the predicate is of the form VAR COMP LIMIT, then we just
1555 take LIMIT from the RHS and use the same comparison code. */
1556 cond_code
= TREE_CODE (cond
);
1557 limit
= TREE_OPERAND (cond
, 1);
1558 op
= TREE_OPERAND (cond
, 0);
1562 /* If the predicate is of the form LIMIT COMP VAR, then we need
1563 to flip around the comparison code to create the proper range
1565 cond_code
= swap_tree_comparison (TREE_CODE (cond
));
1566 limit
= TREE_OPERAND (cond
, 0);
1567 op
= TREE_OPERAND (cond
, 1);
1569 extract_range_for_var_from_comparison_expr (var
, cond_code
, op
,
1573 /* Extract range information from SSA name VAR and store it in VR. If
1574 VAR has an interesting range, use it. Otherwise, create the
1575 range [VAR, VAR] and return it. This is useful in situations where
1576 we may have conditionals testing values of VARYING names. For
1583 Even if y_5 is deemed VARYING, we can determine that x_3 > y_5 is
1587 extract_range_from_ssa_name (value_range
*vr
, tree var
)
1589 value_range
*var_vr
= get_value_range (var
);
1591 if (var_vr
->type
!= VR_VARYING
)
1592 copy_value_range (vr
, var_vr
);
1594 set_value_range (vr
, VR_RANGE
, var
, var
, NULL
);
1596 add_equivalence (&vr
->equiv
, var
);
1600 /* Wrapper around int_const_binop. If the operation overflows and
1601 overflow is undefined, then adjust the result to be
1602 -INF or +INF depending on CODE, VAL1 and VAL2. Sets *OVERFLOW_P
1603 to whether the operation overflowed. For division by zero
1604 the result is indeterminate but *OVERFLOW_P is set. */
1607 vrp_int_const_binop (enum tree_code code
, tree val1
, tree val2
,
1610 bool overflow
= false;
1611 signop sign
= TYPE_SIGN (TREE_TYPE (val1
));
1619 wide_int wval2
= wi::to_wide (val2
, TYPE_PRECISION (TREE_TYPE (val1
)));
1620 if (wi::neg_p (wval2
))
1623 if (code
== RSHIFT_EXPR
)
1629 if (code
== RSHIFT_EXPR
)
1630 /* It's unclear from the C standard whether shifts can overflow.
1631 The following code ignores overflow; perhaps a C standard
1632 interpretation ruling is needed. */
1633 res
= wi::rshift (val1
, wval2
, sign
);
1635 res
= wi::lshift (val1
, wval2
);
1640 res
= wi::mul (val1
, val2
, sign
, &overflow
);
1643 case TRUNC_DIV_EXPR
:
1644 case EXACT_DIV_EXPR
:
1651 res
= wi::div_trunc (val1
, val2
, sign
, &overflow
);
1654 case FLOOR_DIV_EXPR
:
1660 res
= wi::div_floor (val1
, val2
, sign
, &overflow
);
1669 res
= wi::div_ceil (val1
, val2
, sign
, &overflow
);
1672 case ROUND_DIV_EXPR
:
1678 res
= wi::div_round (val1
, val2
, sign
, &overflow
);
1685 *overflow_p
= overflow
;
1688 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (val1
)))
1690 /* If the operation overflowed return -INF or +INF depending
1691 on the operation and the combination of signs of the operands. */
1692 int sgn1
= tree_int_cst_sgn (val1
);
1693 int sgn2
= tree_int_cst_sgn (val2
);
1695 /* Notice that we only need to handle the restricted set of
1696 operations handled by extract_range_from_binary_expr.
1697 Among them, only multiplication, addition and subtraction
1698 can yield overflow without overflown operands because we
1699 are working with integral types only... except in the
1700 case VAL1 = -INF and VAL2 = -1 which overflows to +INF
1701 for division too. */
1703 /* For multiplication, the sign of the overflow is given
1704 by the comparison of the signs of the operands. */
1705 if ((code
== MULT_EXPR
&& sgn1
== sgn2
)
1706 /* For addition, the operands must be of the same sign
1707 to yield an overflow. Its sign is therefore that
1708 of one of the operands, for example the first. */
1709 || (code
== PLUS_EXPR
&& sgn1
>= 0)
1710 /* For subtraction, operands must be of
1711 different signs to yield an overflow. Its sign is
1712 therefore that of the first operand or the opposite of
1713 that of the second operand. A first operand of 0 counts
1714 as positive here, for the corner case 0 - (-INF), which
1715 overflows, but must yield +INF. */
1716 || (code
== MINUS_EXPR
&& sgn1
>= 0)
1717 /* For division, the only case is -INF / -1 = +INF. */
1718 || code
== TRUNC_DIV_EXPR
1719 || code
== FLOOR_DIV_EXPR
1720 || code
== CEIL_DIV_EXPR
1721 || code
== EXACT_DIV_EXPR
1722 || code
== ROUND_DIV_EXPR
)
1723 return wi::max_value (TYPE_PRECISION (TREE_TYPE (val1
)),
1724 TYPE_SIGN (TREE_TYPE (val1
)));
1726 return wi::min_value (TYPE_PRECISION (TREE_TYPE (val1
)),
1727 TYPE_SIGN (TREE_TYPE (val1
)));
1734 /* For range VR compute two wide_int bitmasks. In *MAY_BE_NONZERO
1735 bitmask if some bit is unset, it means for all numbers in the range
1736 the bit is 0, otherwise it might be 0 or 1. In *MUST_BE_NONZERO
1737 bitmask if some bit is set, it means for all numbers in the range
1738 the bit is 1, otherwise it might be 0 or 1. */
1741 zero_nonzero_bits_from_vr (const tree expr_type
,
1743 wide_int
*may_be_nonzero
,
1744 wide_int
*must_be_nonzero
)
1746 *may_be_nonzero
= wi::minus_one (TYPE_PRECISION (expr_type
));
1747 *must_be_nonzero
= wi::zero (TYPE_PRECISION (expr_type
));
1748 if (!range_int_cst_p (vr
))
1751 if (range_int_cst_singleton_p (vr
))
1753 *may_be_nonzero
= vr
->min
;
1754 *must_be_nonzero
= *may_be_nonzero
;
1756 else if (tree_int_cst_sgn (vr
->min
) >= 0
1757 || tree_int_cst_sgn (vr
->max
) < 0)
1759 wide_int xor_mask
= wi::bit_xor (vr
->min
, vr
->max
);
1760 *may_be_nonzero
= wi::bit_or (vr
->min
, vr
->max
);
1761 *must_be_nonzero
= wi::bit_and (vr
->min
, vr
->max
);
1764 wide_int mask
= wi::mask (wi::floor_log2 (xor_mask
), false,
1765 may_be_nonzero
->get_precision ());
1766 *may_be_nonzero
= *may_be_nonzero
| mask
;
1767 *must_be_nonzero
= must_be_nonzero
->and_not (mask
);
1774 /* Create two value-ranges in *VR0 and *VR1 from the anti-range *AR
1775 so that *VR0 U *VR1 == *AR. Returns true if that is possible,
1776 false otherwise. If *AR can be represented with a single range
1777 *VR1 will be VR_UNDEFINED. */
1780 ranges_from_anti_range (value_range
*ar
,
1781 value_range
*vr0
, value_range
*vr1
)
1783 tree type
= TREE_TYPE (ar
->min
);
1785 vr0
->type
= VR_UNDEFINED
;
1786 vr1
->type
= VR_UNDEFINED
;
1788 if (ar
->type
!= VR_ANTI_RANGE
1789 || TREE_CODE (ar
->min
) != INTEGER_CST
1790 || TREE_CODE (ar
->max
) != INTEGER_CST
1791 || !vrp_val_min (type
)
1792 || !vrp_val_max (type
))
1795 if (!vrp_val_is_min (ar
->min
))
1797 vr0
->type
= VR_RANGE
;
1798 vr0
->min
= vrp_val_min (type
);
1799 vr0
->max
= wide_int_to_tree (type
, wi::sub (ar
->min
, 1));
1801 if (!vrp_val_is_max (ar
->max
))
1803 vr1
->type
= VR_RANGE
;
1804 vr1
->min
= wide_int_to_tree (type
, wi::add (ar
->max
, 1));
1805 vr1
->max
= vrp_val_max (type
);
1807 if (vr0
->type
== VR_UNDEFINED
)
1810 vr1
->type
= VR_UNDEFINED
;
1813 return vr0
->type
!= VR_UNDEFINED
;
1816 /* Helper to extract a value-range *VR for a multiplicative operation
1820 extract_range_from_multiplicative_op_1 (value_range
*vr
,
1821 enum tree_code code
,
1822 value_range
*vr0
, value_range
*vr1
)
1824 enum value_range_type rtype
;
1825 wide_int val
, min
, max
;
1829 /* Multiplications, divisions and shifts are a bit tricky to handle,
1830 depending on the mix of signs we have in the two ranges, we
1831 need to operate on different values to get the minimum and
1832 maximum values for the new range. One approach is to figure
1833 out all the variations of range combinations and do the
1836 However, this involves several calls to compare_values and it
1837 is pretty convoluted. It's simpler to do the 4 operations
1838 (MIN0 OP MIN1, MIN0 OP MAX1, MAX0 OP MIN1 and MAX0 OP MAX0 OP
1839 MAX1) and then figure the smallest and largest values to form
1841 gcc_assert (code
== MULT_EXPR
1842 || code
== TRUNC_DIV_EXPR
1843 || code
== FLOOR_DIV_EXPR
1844 || code
== CEIL_DIV_EXPR
1845 || code
== EXACT_DIV_EXPR
1846 || code
== ROUND_DIV_EXPR
1847 || code
== RSHIFT_EXPR
1848 || code
== LSHIFT_EXPR
);
1849 gcc_assert ((vr0
->type
== VR_RANGE
1850 || (code
== MULT_EXPR
&& vr0
->type
== VR_ANTI_RANGE
))
1851 && vr0
->type
== vr1
->type
);
1854 type
= TREE_TYPE (vr0
->min
);
1855 signop sgn
= TYPE_SIGN (type
);
1857 /* Compute the 4 cross operations and their minimum and maximum value. */
1859 val
= vrp_int_const_binop (code
, vr0
->min
, vr1
->min
, &sop
);
1863 if (vr1
->max
== vr1
->min
)
1867 val
= vrp_int_const_binop (code
, vr0
->min
, vr1
->max
, &sop
);
1870 if (wi::lt_p (val
, min
, sgn
))
1872 else if (wi::gt_p (val
, max
, sgn
))
1877 if (vr0
->max
== vr0
->min
)
1881 val
= vrp_int_const_binop (code
, vr0
->max
, vr1
->min
, &sop
);
1884 if (wi::lt_p (val
, min
, sgn
))
1886 else if (wi::gt_p (val
, max
, sgn
))
1891 if (vr0
->min
== vr0
->max
|| vr1
->min
== vr1
->max
)
1895 val
= vrp_int_const_binop (code
, vr0
->max
, vr1
->max
, &sop
);
1898 if (wi::lt_p (val
, min
, sgn
))
1900 else if (wi::gt_p (val
, max
, sgn
))
1905 /* If either operation overflowed, drop to VARYING. */
1908 set_value_range_to_varying (vr
);
1912 /* If the new range has its limits swapped around (MIN > MAX),
1913 then the operation caused one of them to wrap around, mark
1914 the new range VARYING. */
1915 if (wi::gt_p (min
, max
, sgn
))
1917 set_value_range_to_varying (vr
);
1921 /* We punt for [-INF, +INF].
1922 We learn nothing when we have INF on both sides.
1923 Note that we do accept [-INF, -INF] and [+INF, +INF]. */
1924 if (wi::eq_p (min
, wi::min_value (TYPE_PRECISION (type
), sgn
))
1925 && wi::eq_p (max
, wi::max_value (TYPE_PRECISION (type
), sgn
)))
1927 set_value_range_to_varying (vr
);
1931 set_value_range (vr
, rtype
,
1932 wide_int_to_tree (type
, min
),
1933 wide_int_to_tree (type
, max
), NULL
);
1936 /* Extract range information from a binary operation CODE based on
1937 the ranges of each of its operands *VR0 and *VR1 with resulting
1938 type EXPR_TYPE. The resulting range is stored in *VR. */
1941 extract_range_from_binary_expr_1 (value_range
*vr
,
1942 enum tree_code code
, tree expr_type
,
1943 value_range
*vr0_
, value_range
*vr1_
)
1945 value_range vr0
= *vr0_
, vr1
= *vr1_
;
1946 value_range vrtem0
= VR_INITIALIZER
, vrtem1
= VR_INITIALIZER
;
1947 enum value_range_type type
;
1948 tree min
= NULL_TREE
, max
= NULL_TREE
;
1951 if (!INTEGRAL_TYPE_P (expr_type
)
1952 && !POINTER_TYPE_P (expr_type
))
1954 set_value_range_to_varying (vr
);
1958 /* Not all binary expressions can be applied to ranges in a
1959 meaningful way. Handle only arithmetic operations. */
1960 if (code
!= PLUS_EXPR
1961 && code
!= MINUS_EXPR
1962 && code
!= POINTER_PLUS_EXPR
1963 && code
!= MULT_EXPR
1964 && code
!= TRUNC_DIV_EXPR
1965 && code
!= FLOOR_DIV_EXPR
1966 && code
!= CEIL_DIV_EXPR
1967 && code
!= EXACT_DIV_EXPR
1968 && code
!= ROUND_DIV_EXPR
1969 && code
!= TRUNC_MOD_EXPR
1970 && code
!= RSHIFT_EXPR
1971 && code
!= LSHIFT_EXPR
1974 && code
!= BIT_AND_EXPR
1975 && code
!= BIT_IOR_EXPR
1976 && code
!= BIT_XOR_EXPR
)
1978 set_value_range_to_varying (vr
);
1982 /* If both ranges are UNDEFINED, so is the result. */
1983 if (vr0
.type
== VR_UNDEFINED
&& vr1
.type
== VR_UNDEFINED
)
1985 set_value_range_to_undefined (vr
);
1988 /* If one of the ranges is UNDEFINED drop it to VARYING for the following
1989 code. At some point we may want to special-case operations that
1990 have UNDEFINED result for all or some value-ranges of the not UNDEFINED
1992 else if (vr0
.type
== VR_UNDEFINED
)
1993 set_value_range_to_varying (&vr0
);
1994 else if (vr1
.type
== VR_UNDEFINED
)
1995 set_value_range_to_varying (&vr1
);
1997 /* We get imprecise results from ranges_from_anti_range when
1998 code is EXACT_DIV_EXPR. We could mask out bits in the resulting
1999 range, but then we also need to hack up vrp_meet. It's just
2000 easier to special case when vr0 is ~[0,0] for EXACT_DIV_EXPR. */
2001 if (code
== EXACT_DIV_EXPR
2002 && vr0
.type
== VR_ANTI_RANGE
2003 && vr0
.min
== vr0
.max
2004 && integer_zerop (vr0
.min
))
2006 set_value_range_to_nonnull (vr
, expr_type
);
2010 /* Now canonicalize anti-ranges to ranges when they are not symbolic
2011 and express ~[] op X as ([]' op X) U ([]'' op X). */
2012 if (vr0
.type
== VR_ANTI_RANGE
2013 && ranges_from_anti_range (&vr0
, &vrtem0
, &vrtem1
))
2015 extract_range_from_binary_expr_1 (vr
, code
, expr_type
, &vrtem0
, vr1_
);
2016 if (vrtem1
.type
!= VR_UNDEFINED
)
2018 value_range vrres
= VR_INITIALIZER
;
2019 extract_range_from_binary_expr_1 (&vrres
, code
, expr_type
,
2021 vrp_meet (vr
, &vrres
);
2025 /* Likewise for X op ~[]. */
2026 if (vr1
.type
== VR_ANTI_RANGE
2027 && ranges_from_anti_range (&vr1
, &vrtem0
, &vrtem1
))
2029 extract_range_from_binary_expr_1 (vr
, code
, expr_type
, vr0_
, &vrtem0
);
2030 if (vrtem1
.type
!= VR_UNDEFINED
)
2032 value_range vrres
= VR_INITIALIZER
;
2033 extract_range_from_binary_expr_1 (&vrres
, code
, expr_type
,
2035 vrp_meet (vr
, &vrres
);
2040 /* The type of the resulting value range defaults to VR0.TYPE. */
2043 /* Refuse to operate on VARYING ranges, ranges of different kinds
2044 and symbolic ranges. As an exception, we allow BIT_{AND,IOR}
2045 because we may be able to derive a useful range even if one of
2046 the operands is VR_VARYING or symbolic range. Similarly for
2047 divisions, MIN/MAX and PLUS/MINUS.
2049 TODO, we may be able to derive anti-ranges in some cases. */
2050 if (code
!= BIT_AND_EXPR
2051 && code
!= BIT_IOR_EXPR
2052 && code
!= TRUNC_DIV_EXPR
2053 && code
!= FLOOR_DIV_EXPR
2054 && code
!= CEIL_DIV_EXPR
2055 && code
!= EXACT_DIV_EXPR
2056 && code
!= ROUND_DIV_EXPR
2057 && code
!= TRUNC_MOD_EXPR
2060 && code
!= PLUS_EXPR
2061 && code
!= MINUS_EXPR
2062 && code
!= RSHIFT_EXPR
2063 && (vr0
.type
== VR_VARYING
2064 || vr1
.type
== VR_VARYING
2065 || vr0
.type
!= vr1
.type
2066 || symbolic_range_p (&vr0
)
2067 || symbolic_range_p (&vr1
)))
2069 set_value_range_to_varying (vr
);
2073 /* Now evaluate the expression to determine the new range. */
2074 if (POINTER_TYPE_P (expr_type
))
2076 if (code
== MIN_EXPR
|| code
== MAX_EXPR
)
2078 /* For MIN/MAX expressions with pointers, we only care about
2079 nullness, if both are non null, then the result is nonnull.
2080 If both are null, then the result is null. Otherwise they
2082 if (range_is_nonnull (&vr0
) && range_is_nonnull (&vr1
))
2083 set_value_range_to_nonnull (vr
, expr_type
);
2084 else if (range_is_null (&vr0
) && range_is_null (&vr1
))
2085 set_value_range_to_null (vr
, expr_type
);
2087 set_value_range_to_varying (vr
);
2089 else if (code
== POINTER_PLUS_EXPR
)
2091 /* For pointer types, we are really only interested in asserting
2092 whether the expression evaluates to non-NULL. */
2093 if (range_is_nonnull (&vr0
) || range_is_nonnull (&vr1
))
2094 set_value_range_to_nonnull (vr
, expr_type
);
2095 else if (range_is_null (&vr0
) && range_is_null (&vr1
))
2096 set_value_range_to_null (vr
, expr_type
);
2098 set_value_range_to_varying (vr
);
2100 else if (code
== BIT_AND_EXPR
)
2102 /* For pointer types, we are really only interested in asserting
2103 whether the expression evaluates to non-NULL. */
2104 if (range_is_nonnull (&vr0
) && range_is_nonnull (&vr1
))
2105 set_value_range_to_nonnull (vr
, expr_type
);
2106 else if (range_is_null (&vr0
) || range_is_null (&vr1
))
2107 set_value_range_to_null (vr
, expr_type
);
2109 set_value_range_to_varying (vr
);
2112 set_value_range_to_varying (vr
);
2117 /* For integer ranges, apply the operation to each end of the
2118 range and see what we end up with. */
2119 if (code
== PLUS_EXPR
|| code
== MINUS_EXPR
)
2121 const bool minus_p
= (code
== MINUS_EXPR
);
2122 tree min_op0
= vr0
.min
;
2123 tree min_op1
= minus_p
? vr1
.max
: vr1
.min
;
2124 tree max_op0
= vr0
.max
;
2125 tree max_op1
= minus_p
? vr1
.min
: vr1
.max
;
2126 tree sym_min_op0
= NULL_TREE
;
2127 tree sym_min_op1
= NULL_TREE
;
2128 tree sym_max_op0
= NULL_TREE
;
2129 tree sym_max_op1
= NULL_TREE
;
2130 bool neg_min_op0
, neg_min_op1
, neg_max_op0
, neg_max_op1
;
2132 /* If we have a PLUS or MINUS with two VR_RANGEs, either constant or
2133 single-symbolic ranges, try to compute the precise resulting range,
2134 but only if we know that this resulting range will also be constant
2135 or single-symbolic. */
2136 if (vr0
.type
== VR_RANGE
&& vr1
.type
== VR_RANGE
2137 && (TREE_CODE (min_op0
) == INTEGER_CST
2139 = get_single_symbol (min_op0
, &neg_min_op0
, &min_op0
)))
2140 && (TREE_CODE (min_op1
) == INTEGER_CST
2142 = get_single_symbol (min_op1
, &neg_min_op1
, &min_op1
)))
2143 && (!(sym_min_op0
&& sym_min_op1
)
2144 || (sym_min_op0
== sym_min_op1
2145 && neg_min_op0
== (minus_p
? neg_min_op1
: !neg_min_op1
)))
2146 && (TREE_CODE (max_op0
) == INTEGER_CST
2148 = get_single_symbol (max_op0
, &neg_max_op0
, &max_op0
)))
2149 && (TREE_CODE (max_op1
) == INTEGER_CST
2151 = get_single_symbol (max_op1
, &neg_max_op1
, &max_op1
)))
2152 && (!(sym_max_op0
&& sym_max_op1
)
2153 || (sym_max_op0
== sym_max_op1
2154 && neg_max_op0
== (minus_p
? neg_max_op1
: !neg_max_op1
))))
2156 const signop sgn
= TYPE_SIGN (expr_type
);
2157 const unsigned int prec
= TYPE_PRECISION (expr_type
);
2158 wide_int type_min
, type_max
, wmin
, wmax
;
2162 /* Get the lower and upper bounds of the type. */
2163 if (TYPE_OVERFLOW_WRAPS (expr_type
))
2165 type_min
= wi::min_value (prec
, sgn
);
2166 type_max
= wi::max_value (prec
, sgn
);
2170 type_min
= vrp_val_min (expr_type
);
2171 type_max
= vrp_val_max (expr_type
);
2174 /* Combine the lower bounds, if any. */
2175 if (min_op0
&& min_op1
)
2179 wmin
= wi::sub (min_op0
, min_op1
);
2181 /* Check for overflow. */
2182 if (wi::cmp (0, min_op1
, sgn
)
2183 != wi::cmp (wmin
, min_op0
, sgn
))
2184 min_ovf
= wi::cmp (min_op0
, min_op1
, sgn
);
2188 wmin
= wi::add (min_op0
, min_op1
);
2190 /* Check for overflow. */
2191 if (wi::cmp (min_op1
, 0, sgn
)
2192 != wi::cmp (wmin
, min_op0
, sgn
))
2193 min_ovf
= wi::cmp (min_op0
, wmin
, sgn
);
2202 wmin
= wi::neg (min_op1
);
2204 /* Check for overflow. */
2205 if (sgn
== SIGNED
&& wi::neg_p (min_op1
) && wi::neg_p (wmin
))
2207 else if (sgn
== UNSIGNED
&& wi::ne_p (min_op1
, 0))
2214 wmin
= wi::shwi (0, prec
);
2216 /* Combine the upper bounds, if any. */
2217 if (max_op0
&& max_op1
)
2221 wmax
= wi::sub (max_op0
, max_op1
);
2223 /* Check for overflow. */
2224 if (wi::cmp (0, max_op1
, sgn
)
2225 != wi::cmp (wmax
, max_op0
, sgn
))
2226 max_ovf
= wi::cmp (max_op0
, max_op1
, sgn
);
2230 wmax
= wi::add (max_op0
, max_op1
);
2232 if (wi::cmp (max_op1
, 0, sgn
)
2233 != wi::cmp (wmax
, max_op0
, sgn
))
2234 max_ovf
= wi::cmp (max_op0
, wmax
, sgn
);
2243 wmax
= wi::neg (max_op1
);
2245 /* Check for overflow. */
2246 if (sgn
== SIGNED
&& wi::neg_p (max_op1
) && wi::neg_p (wmax
))
2248 else if (sgn
== UNSIGNED
&& wi::ne_p (max_op1
, 0))
2255 wmax
= wi::shwi (0, prec
);
2257 /* Check for type overflow. */
2260 if (wi::cmp (wmin
, type_min
, sgn
) == -1)
2262 else if (wi::cmp (wmin
, type_max
, sgn
) == 1)
2267 if (wi::cmp (wmax
, type_min
, sgn
) == -1)
2269 else if (wi::cmp (wmax
, type_max
, sgn
) == 1)
2273 /* If we have overflow for the constant part and the resulting
2274 range will be symbolic, drop to VR_VARYING. */
2275 if ((min_ovf
&& sym_min_op0
!= sym_min_op1
)
2276 || (max_ovf
&& sym_max_op0
!= sym_max_op1
))
2278 set_value_range_to_varying (vr
);
2282 if (TYPE_OVERFLOW_WRAPS (expr_type
))
2284 /* If overflow wraps, truncate the values and adjust the
2285 range kind and bounds appropriately. */
2286 wide_int tmin
= wide_int::from (wmin
, prec
, sgn
);
2287 wide_int tmax
= wide_int::from (wmax
, prec
, sgn
);
2288 if (min_ovf
== max_ovf
)
2290 /* No overflow or both overflow or underflow. The
2291 range kind stays VR_RANGE. */
2292 min
= wide_int_to_tree (expr_type
, tmin
);
2293 max
= wide_int_to_tree (expr_type
, tmax
);
2295 else if ((min_ovf
== -1 && max_ovf
== 0)
2296 || (max_ovf
== 1 && min_ovf
== 0))
2298 /* Min underflow or max overflow. The range kind
2299 changes to VR_ANTI_RANGE. */
2300 bool covers
= false;
2301 wide_int tem
= tmin
;
2302 type
= VR_ANTI_RANGE
;
2304 if (wi::cmp (tmin
, tmax
, sgn
) < 0)
2307 if (wi::cmp (tmax
, tem
, sgn
) > 0)
2309 /* If the anti-range would cover nothing, drop to varying.
2310 Likewise if the anti-range bounds are outside of the
2312 if (covers
|| wi::cmp (tmin
, tmax
, sgn
) > 0)
2314 set_value_range_to_varying (vr
);
2317 min
= wide_int_to_tree (expr_type
, tmin
);
2318 max
= wide_int_to_tree (expr_type
, tmax
);
2322 /* Other underflow and/or overflow, drop to VR_VARYING. */
2323 set_value_range_to_varying (vr
);
2329 /* If overflow does not wrap, saturate to the types min/max
2332 min
= wide_int_to_tree (expr_type
, type_min
);
2333 else if (min_ovf
== 1)
2334 min
= wide_int_to_tree (expr_type
, type_max
);
2336 min
= wide_int_to_tree (expr_type
, wmin
);
2339 max
= wide_int_to_tree (expr_type
, type_min
);
2340 else if (max_ovf
== 1)
2341 max
= wide_int_to_tree (expr_type
, type_max
);
2343 max
= wide_int_to_tree (expr_type
, wmax
);
2346 /* If the result lower bound is constant, we're done;
2347 otherwise, build the symbolic lower bound. */
2348 if (sym_min_op0
== sym_min_op1
)
2350 else if (sym_min_op0
)
2351 min
= build_symbolic_expr (expr_type
, sym_min_op0
,
2353 else if (sym_min_op1
)
2355 /* We may not negate if that might introduce
2356 undefined overflow. */
2359 || TYPE_OVERFLOW_WRAPS (expr_type
))
2360 min
= build_symbolic_expr (expr_type
, sym_min_op1
,
2361 neg_min_op1
^ minus_p
, min
);
2366 /* Likewise for the upper bound. */
2367 if (sym_max_op0
== sym_max_op1
)
2369 else if (sym_max_op0
)
2370 max
= build_symbolic_expr (expr_type
, sym_max_op0
,
2372 else if (sym_max_op1
)
2374 /* We may not negate if that might introduce
2375 undefined overflow. */
2378 || TYPE_OVERFLOW_WRAPS (expr_type
))
2379 max
= build_symbolic_expr (expr_type
, sym_max_op1
,
2380 neg_max_op1
^ minus_p
, max
);
2387 /* For other cases, for example if we have a PLUS_EXPR with two
2388 VR_ANTI_RANGEs, drop to VR_VARYING. It would take more effort
2389 to compute a precise range for such a case.
2390 ??? General even mixed range kind operations can be expressed
2391 by for example transforming ~[3, 5] + [1, 2] to range-only
2392 operations and a union primitive:
2393 [-INF, 2] + [1, 2] U [5, +INF] + [1, 2]
2394 [-INF+1, 4] U [6, +INF(OVF)]
2395 though usually the union is not exactly representable with
2396 a single range or anti-range as the above is
2397 [-INF+1, +INF(OVF)] intersected with ~[5, 5]
2398 but one could use a scheme similar to equivalences for this. */
2399 set_value_range_to_varying (vr
);
2403 else if (code
== MIN_EXPR
2404 || code
== MAX_EXPR
)
2406 if (vr0
.type
== VR_RANGE
2407 && !symbolic_range_p (&vr0
))
2410 if (vr1
.type
== VR_RANGE
2411 && !symbolic_range_p (&vr1
))
2413 /* For operations that make the resulting range directly
2414 proportional to the original ranges, apply the operation to
2415 the same end of each range. */
2416 min
= int_const_binop (code
, vr0
.min
, vr1
.min
);
2417 max
= int_const_binop (code
, vr0
.max
, vr1
.max
);
2419 else if (code
== MIN_EXPR
)
2421 min
= vrp_val_min (expr_type
);
2424 else if (code
== MAX_EXPR
)
2427 max
= vrp_val_max (expr_type
);
2430 else if (vr1
.type
== VR_RANGE
2431 && !symbolic_range_p (&vr1
))
2434 if (code
== MIN_EXPR
)
2436 min
= vrp_val_min (expr_type
);
2439 else if (code
== MAX_EXPR
)
2442 max
= vrp_val_max (expr_type
);
2447 set_value_range_to_varying (vr
);
2451 else if (code
== MULT_EXPR
)
2453 /* Fancy code so that with unsigned, [-3,-1]*[-3,-1] does not
2454 drop to varying. This test requires 2*prec bits if both
2455 operands are signed and 2*prec + 2 bits if either is not. */
2457 signop sign
= TYPE_SIGN (expr_type
);
2458 unsigned int prec
= TYPE_PRECISION (expr_type
);
2460 if (range_int_cst_p (&vr0
)
2461 && range_int_cst_p (&vr1
)
2462 && TYPE_OVERFLOW_WRAPS (expr_type
))
2464 typedef FIXED_WIDE_INT (WIDE_INT_MAX_PRECISION
* 2) vrp_int
;
2465 typedef generic_wide_int
2466 <wi::extended_tree
<WIDE_INT_MAX_PRECISION
* 2> > vrp_int_cst
;
2467 vrp_int sizem1
= wi::mask
<vrp_int
> (prec
, false);
2468 vrp_int size
= sizem1
+ 1;
2470 /* Extend the values using the sign of the result to PREC2.
2471 From here on out, everthing is just signed math no matter
2472 what the input types were. */
2473 vrp_int min0
= vrp_int_cst (vr0
.min
);
2474 vrp_int max0
= vrp_int_cst (vr0
.max
);
2475 vrp_int min1
= vrp_int_cst (vr1
.min
);
2476 vrp_int max1
= vrp_int_cst (vr1
.max
);
2477 /* Canonicalize the intervals. */
2478 if (sign
== UNSIGNED
)
2480 if (wi::ltu_p (size
, min0
+ max0
))
2486 if (wi::ltu_p (size
, min1
+ max1
))
2493 vrp_int prod0
= min0
* min1
;
2494 vrp_int prod1
= min0
* max1
;
2495 vrp_int prod2
= max0
* min1
;
2496 vrp_int prod3
= max0
* max1
;
2498 /* Sort the 4 products so that min is in prod0 and max is in
2500 /* min0min1 > max0max1 */
2502 std::swap (prod0
, prod3
);
2504 /* min0max1 > max0min1 */
2506 std::swap (prod1
, prod2
);
2509 std::swap (prod0
, prod1
);
2512 std::swap (prod2
, prod3
);
2514 /* diff = max - min. */
2515 prod2
= prod3
- prod0
;
2516 if (wi::geu_p (prod2
, sizem1
))
2518 /* the range covers all values. */
2519 set_value_range_to_varying (vr
);
2523 /* The following should handle the wrapping and selecting
2524 VR_ANTI_RANGE for us. */
2525 min
= wide_int_to_tree (expr_type
, prod0
);
2526 max
= wide_int_to_tree (expr_type
, prod3
);
2527 set_and_canonicalize_value_range (vr
, VR_RANGE
, min
, max
, NULL
);
2531 /* If we have an unsigned MULT_EXPR with two VR_ANTI_RANGEs,
2532 drop to VR_VARYING. It would take more effort to compute a
2533 precise range for such a case. For example, if we have
2534 op0 == 65536 and op1 == 65536 with their ranges both being
2535 ~[0,0] on a 32-bit machine, we would have op0 * op1 == 0, so
2536 we cannot claim that the product is in ~[0,0]. Note that we
2537 are guaranteed to have vr0.type == vr1.type at this
2539 if (vr0
.type
== VR_ANTI_RANGE
2540 && !TYPE_OVERFLOW_UNDEFINED (expr_type
))
2542 set_value_range_to_varying (vr
);
2546 extract_range_from_multiplicative_op_1 (vr
, code
, &vr0
, &vr1
);
2549 else if (code
== RSHIFT_EXPR
2550 || code
== LSHIFT_EXPR
)
2552 /* If we have a RSHIFT_EXPR with any shift values outside [0..prec-1],
2553 then drop to VR_VARYING. Outside of this range we get undefined
2554 behavior from the shift operation. We cannot even trust
2555 SHIFT_COUNT_TRUNCATED at this stage, because that applies to rtl
2556 shifts, and the operation at the tree level may be widened. */
2557 if (range_int_cst_p (&vr1
)
2558 && compare_tree_int (vr1
.min
, 0) >= 0
2559 && compare_tree_int (vr1
.max
, TYPE_PRECISION (expr_type
)) == -1)
2561 if (code
== RSHIFT_EXPR
)
2563 /* Even if vr0 is VARYING or otherwise not usable, we can derive
2564 useful ranges just from the shift count. E.g.
2565 x >> 63 for signed 64-bit x is always [-1, 0]. */
2566 if (vr0
.type
!= VR_RANGE
|| symbolic_range_p (&vr0
))
2568 vr0
.type
= type
= VR_RANGE
;
2569 vr0
.min
= vrp_val_min (expr_type
);
2570 vr0
.max
= vrp_val_max (expr_type
);
2572 extract_range_from_multiplicative_op_1 (vr
, code
, &vr0
, &vr1
);
2575 /* We can map lshifts by constants to MULT_EXPR handling. */
2576 else if (code
== LSHIFT_EXPR
2577 && range_int_cst_singleton_p (&vr1
))
2579 bool saved_flag_wrapv
;
2580 value_range vr1p
= VR_INITIALIZER
;
2581 vr1p
.type
= VR_RANGE
;
2582 vr1p
.min
= (wide_int_to_tree
2584 wi::set_bit_in_zero (tree_to_shwi (vr1
.min
),
2585 TYPE_PRECISION (expr_type
))));
2586 vr1p
.max
= vr1p
.min
;
2587 /* We have to use a wrapping multiply though as signed overflow
2588 on lshifts is implementation defined in C89. */
2589 saved_flag_wrapv
= flag_wrapv
;
2591 extract_range_from_binary_expr_1 (vr
, MULT_EXPR
, expr_type
,
2593 flag_wrapv
= saved_flag_wrapv
;
2596 else if (code
== LSHIFT_EXPR
2597 && range_int_cst_p (&vr0
))
2599 int prec
= TYPE_PRECISION (expr_type
);
2600 int overflow_pos
= prec
;
2602 wide_int low_bound
, high_bound
;
2603 bool uns
= TYPE_UNSIGNED (expr_type
);
2604 bool in_bounds
= false;
2609 bound_shift
= overflow_pos
- tree_to_shwi (vr1
.max
);
2610 /* If bound_shift == HOST_BITS_PER_WIDE_INT, the llshift can
2611 overflow. However, for that to happen, vr1.max needs to be
2612 zero, which means vr1 is a singleton range of zero, which
2613 means it should be handled by the previous LSHIFT_EXPR
2615 wide_int bound
= wi::set_bit_in_zero (bound_shift
, prec
);
2616 wide_int complement
= ~(bound
- 1);
2621 high_bound
= complement
;
2622 if (wi::ltu_p (vr0
.max
, low_bound
))
2624 /* [5, 6] << [1, 2] == [10, 24]. */
2625 /* We're shifting out only zeroes, the value increases
2629 else if (wi::ltu_p (high_bound
, vr0
.min
))
2631 /* [0xffffff00, 0xffffffff] << [1, 2]
2632 == [0xfffffc00, 0xfffffffe]. */
2633 /* We're shifting out only ones, the value decreases
2640 /* [-1, 1] << [1, 2] == [-4, 4]. */
2641 low_bound
= complement
;
2643 if (wi::lts_p (vr0
.max
, high_bound
)
2644 && wi::lts_p (low_bound
, vr0
.min
))
2646 /* For non-negative numbers, we're shifting out only
2647 zeroes, the value increases monotonically.
2648 For negative numbers, we're shifting out only ones, the
2649 value decreases monotomically. */
2656 extract_range_from_multiplicative_op_1 (vr
, code
, &vr0
, &vr1
);
2661 set_value_range_to_varying (vr
);
2664 else if (code
== TRUNC_DIV_EXPR
2665 || code
== FLOOR_DIV_EXPR
2666 || code
== CEIL_DIV_EXPR
2667 || code
== EXACT_DIV_EXPR
2668 || code
== ROUND_DIV_EXPR
)
2670 if (vr0
.type
!= VR_RANGE
|| symbolic_range_p (&vr0
))
2672 /* For division, if op1 has VR_RANGE but op0 does not, something
2673 can be deduced just from that range. Say [min, max] / [4, max]
2674 gives [min / 4, max / 4] range. */
2675 if (vr1
.type
== VR_RANGE
2676 && !symbolic_range_p (&vr1
)
2677 && range_includes_zero_p (vr1
.min
, vr1
.max
) == 0)
2679 vr0
.type
= type
= VR_RANGE
;
2680 vr0
.min
= vrp_val_min (expr_type
);
2681 vr0
.max
= vrp_val_max (expr_type
);
2685 set_value_range_to_varying (vr
);
2690 /* For divisions, if flag_non_call_exceptions is true, we must
2691 not eliminate a division by zero. */
2692 if (cfun
->can_throw_non_call_exceptions
2693 && (vr1
.type
!= VR_RANGE
2694 || range_includes_zero_p (vr1
.min
, vr1
.max
) != 0))
2696 set_value_range_to_varying (vr
);
2700 /* For divisions, if op0 is VR_RANGE, we can deduce a range
2701 even if op1 is VR_VARYING, VR_ANTI_RANGE, symbolic or can
2703 if (vr0
.type
== VR_RANGE
2704 && (vr1
.type
!= VR_RANGE
2705 || range_includes_zero_p (vr1
.min
, vr1
.max
) != 0))
2707 tree zero
= build_int_cst (TREE_TYPE (vr0
.min
), 0);
2712 if (TYPE_UNSIGNED (expr_type
)
2713 || value_range_nonnegative_p (&vr1
))
2715 /* For unsigned division or when divisor is known
2716 to be non-negative, the range has to cover
2717 all numbers from 0 to max for positive max
2718 and all numbers from min to 0 for negative min. */
2719 cmp
= compare_values (vr0
.max
, zero
);
2722 /* When vr0.max < 0, vr1.min != 0 and value
2723 ranges for dividend and divisor are available. */
2724 if (vr1
.type
== VR_RANGE
2725 && !symbolic_range_p (&vr0
)
2726 && !symbolic_range_p (&vr1
)
2727 && compare_values (vr1
.min
, zero
) != 0)
2728 max
= int_const_binop (code
, vr0
.max
, vr1
.min
);
2732 else if (cmp
== 0 || cmp
== 1)
2736 cmp
= compare_values (vr0
.min
, zero
);
2739 /* For unsigned division when value ranges for dividend
2740 and divisor are available. */
2741 if (vr1
.type
== VR_RANGE
2742 && !symbolic_range_p (&vr0
)
2743 && !symbolic_range_p (&vr1
)
2744 && compare_values (vr1
.max
, zero
) != 0)
2745 min
= int_const_binop (code
, vr0
.min
, vr1
.max
);
2749 else if (cmp
== 0 || cmp
== -1)
2756 /* Otherwise the range is -max .. max or min .. -min
2757 depending on which bound is bigger in absolute value,
2758 as the division can change the sign. */
2759 abs_extent_range (vr
, vr0
.min
, vr0
.max
);
2762 if (type
== VR_VARYING
)
2764 set_value_range_to_varying (vr
);
2768 else if (!symbolic_range_p (&vr0
) && !symbolic_range_p (&vr1
))
2770 extract_range_from_multiplicative_op_1 (vr
, code
, &vr0
, &vr1
);
2774 else if (code
== TRUNC_MOD_EXPR
)
2776 if (range_is_null (&vr1
))
2778 set_value_range_to_undefined (vr
);
2781 /* ABS (A % B) < ABS (B) and either
2782 0 <= A % B <= A or A <= A % B <= 0. */
2784 signop sgn
= TYPE_SIGN (expr_type
);
2785 unsigned int prec
= TYPE_PRECISION (expr_type
);
2786 wide_int wmin
, wmax
, tmp
;
2787 wide_int zero
= wi::zero (prec
);
2788 wide_int one
= wi::one (prec
);
2789 if (vr1
.type
== VR_RANGE
&& !symbolic_range_p (&vr1
))
2791 wmax
= wi::sub (vr1
.max
, one
);
2794 tmp
= wi::sub (wi::minus_one (prec
), vr1
.min
);
2795 wmax
= wi::smax (wmax
, tmp
);
2800 wmax
= wi::max_value (prec
, sgn
);
2801 /* X % INT_MIN may be INT_MAX. */
2802 if (sgn
== UNSIGNED
)
2806 if (sgn
== UNSIGNED
)
2811 if (vr0
.type
== VR_RANGE
&& TREE_CODE (vr0
.min
) == INTEGER_CST
)
2814 if (wi::gts_p (tmp
, zero
))
2816 wmin
= wi::smax (wmin
, tmp
);
2820 if (vr0
.type
== VR_RANGE
&& TREE_CODE (vr0
.max
) == INTEGER_CST
)
2823 if (sgn
== SIGNED
&& wi::neg_p (tmp
))
2825 wmax
= wi::min (wmax
, tmp
, sgn
);
2828 min
= wide_int_to_tree (expr_type
, wmin
);
2829 max
= wide_int_to_tree (expr_type
, wmax
);
2831 else if (code
== BIT_AND_EXPR
|| code
== BIT_IOR_EXPR
|| code
== BIT_XOR_EXPR
)
2833 bool int_cst_range0
, int_cst_range1
;
2834 wide_int may_be_nonzero0
, may_be_nonzero1
;
2835 wide_int must_be_nonzero0
, must_be_nonzero1
;
2837 int_cst_range0
= zero_nonzero_bits_from_vr (expr_type
, &vr0
,
2840 int_cst_range1
= zero_nonzero_bits_from_vr (expr_type
, &vr1
,
2844 if (code
== BIT_AND_EXPR
|| code
== BIT_IOR_EXPR
)
2846 value_range
*vr0p
= NULL
, *vr1p
= NULL
;
2847 if (range_int_cst_singleton_p (&vr1
))
2852 else if (range_int_cst_singleton_p (&vr0
))
2857 /* For op & or | attempt to optimize:
2858 [x, y] op z into [x op z, y op z]
2859 if z is a constant which (for op | its bitwise not) has n
2860 consecutive least significant bits cleared followed by m 1
2861 consecutive bits set immediately above it and either
2862 m + n == precision, or (x >> (m + n)) == (y >> (m + n)).
2863 The least significant n bits of all the values in the range are
2864 cleared or set, the m bits above it are preserved and any bits
2865 above these are required to be the same for all values in the
2867 if (vr0p
&& range_int_cst_p (vr0p
))
2869 wide_int w
= vr1p
->min
;
2871 if (code
== BIT_IOR_EXPR
)
2873 if (wi::eq_p (w
, 0))
2874 n
= TYPE_PRECISION (expr_type
);
2878 w
= ~(w
| wi::mask (n
, false, w
.get_precision ()));
2879 if (wi::eq_p (w
, 0))
2880 m
= TYPE_PRECISION (expr_type
) - n
;
2882 m
= wi::ctz (w
) - n
;
2884 wide_int mask
= wi::mask (m
+ n
, true, w
.get_precision ());
2885 if (wi::eq_p (mask
& vr0p
->min
, mask
& vr0p
->max
))
2887 min
= int_const_binop (code
, vr0p
->min
, vr1p
->min
);
2888 max
= int_const_binop (code
, vr0p
->max
, vr1p
->min
);
2895 /* Optimized above already. */;
2896 else if (code
== BIT_AND_EXPR
)
2898 min
= wide_int_to_tree (expr_type
,
2899 must_be_nonzero0
& must_be_nonzero1
);
2900 wide_int wmax
= may_be_nonzero0
& may_be_nonzero1
;
2901 /* If both input ranges contain only negative values we can
2902 truncate the result range maximum to the minimum of the
2903 input range maxima. */
2904 if (int_cst_range0
&& int_cst_range1
2905 && tree_int_cst_sgn (vr0
.max
) < 0
2906 && tree_int_cst_sgn (vr1
.max
) < 0)
2908 wmax
= wi::min (wmax
, vr0
.max
, TYPE_SIGN (expr_type
));
2909 wmax
= wi::min (wmax
, vr1
.max
, TYPE_SIGN (expr_type
));
2911 /* If either input range contains only non-negative values
2912 we can truncate the result range maximum to the respective
2913 maximum of the input range. */
2914 if (int_cst_range0
&& tree_int_cst_sgn (vr0
.min
) >= 0)
2915 wmax
= wi::min (wmax
, vr0
.max
, TYPE_SIGN (expr_type
));
2916 if (int_cst_range1
&& tree_int_cst_sgn (vr1
.min
) >= 0)
2917 wmax
= wi::min (wmax
, vr1
.max
, TYPE_SIGN (expr_type
));
2918 max
= wide_int_to_tree (expr_type
, wmax
);
2919 cmp
= compare_values (min
, max
);
2920 /* PR68217: In case of signed & sign-bit-CST should
2921 result in [-INF, 0] instead of [-INF, INF]. */
2922 if (cmp
== -2 || cmp
== 1)
2925 = wi::set_bit_in_zero (TYPE_PRECISION (expr_type
) - 1,
2926 TYPE_PRECISION (expr_type
));
2927 if (!TYPE_UNSIGNED (expr_type
)
2928 && ((value_range_constant_singleton (&vr0
)
2929 && !wi::cmps (vr0
.min
, sign_bit
))
2930 || (value_range_constant_singleton (&vr1
)
2931 && !wi::cmps (vr1
.min
, sign_bit
))))
2933 min
= TYPE_MIN_VALUE (expr_type
);
2934 max
= build_int_cst (expr_type
, 0);
2938 else if (code
== BIT_IOR_EXPR
)
2940 max
= wide_int_to_tree (expr_type
,
2941 may_be_nonzero0
| may_be_nonzero1
);
2942 wide_int wmin
= must_be_nonzero0
| must_be_nonzero1
;
2943 /* If the input ranges contain only positive values we can
2944 truncate the minimum of the result range to the maximum
2945 of the input range minima. */
2946 if (int_cst_range0
&& int_cst_range1
2947 && tree_int_cst_sgn (vr0
.min
) >= 0
2948 && tree_int_cst_sgn (vr1
.min
) >= 0)
2950 wmin
= wi::max (wmin
, vr0
.min
, TYPE_SIGN (expr_type
));
2951 wmin
= wi::max (wmin
, vr1
.min
, TYPE_SIGN (expr_type
));
2953 /* If either input range contains only negative values
2954 we can truncate the minimum of the result range to the
2955 respective minimum range. */
2956 if (int_cst_range0
&& tree_int_cst_sgn (vr0
.max
) < 0)
2957 wmin
= wi::max (wmin
, vr0
.min
, TYPE_SIGN (expr_type
));
2958 if (int_cst_range1
&& tree_int_cst_sgn (vr1
.max
) < 0)
2959 wmin
= wi::max (wmin
, vr1
.min
, TYPE_SIGN (expr_type
));
2960 min
= wide_int_to_tree (expr_type
, wmin
);
2962 else if (code
== BIT_XOR_EXPR
)
2964 wide_int result_zero_bits
= ((must_be_nonzero0
& must_be_nonzero1
)
2965 | ~(may_be_nonzero0
| may_be_nonzero1
));
2966 wide_int result_one_bits
2967 = (must_be_nonzero0
.and_not (may_be_nonzero1
)
2968 | must_be_nonzero1
.and_not (may_be_nonzero0
));
2969 max
= wide_int_to_tree (expr_type
, ~result_zero_bits
);
2970 min
= wide_int_to_tree (expr_type
, result_one_bits
);
2971 /* If the range has all positive or all negative values the
2972 result is better than VARYING. */
2973 if (tree_int_cst_sgn (min
) < 0
2974 || tree_int_cst_sgn (max
) >= 0)
2977 max
= min
= NULL_TREE
;
2983 /* If either MIN or MAX overflowed, then set the resulting range to
2985 if (min
== NULL_TREE
2986 || TREE_OVERFLOW_P (min
)
2988 || TREE_OVERFLOW_P (max
))
2990 set_value_range_to_varying (vr
);
2994 /* We punt for [-INF, +INF].
2995 We learn nothing when we have INF on both sides.
2996 Note that we do accept [-INF, -INF] and [+INF, +INF]. */
2997 if (vrp_val_is_min (min
) && vrp_val_is_max (max
))
2999 set_value_range_to_varying (vr
);
3003 cmp
= compare_values (min
, max
);
3004 if (cmp
== -2 || cmp
== 1)
3006 /* If the new range has its limits swapped around (MIN > MAX),
3007 then the operation caused one of them to wrap around, mark
3008 the new range VARYING. */
3009 set_value_range_to_varying (vr
);
3012 set_value_range (vr
, type
, min
, max
, NULL
);
3015 /* Extract range information from a binary expression OP0 CODE OP1 based on
3016 the ranges of each of its operands with resulting type EXPR_TYPE.
3017 The resulting range is stored in *VR. */
3020 extract_range_from_binary_expr (value_range
*vr
,
3021 enum tree_code code
,
3022 tree expr_type
, tree op0
, tree op1
)
3024 value_range vr0
= VR_INITIALIZER
;
3025 value_range vr1
= VR_INITIALIZER
;
3027 /* Get value ranges for each operand. For constant operands, create
3028 a new value range with the operand to simplify processing. */
3029 if (TREE_CODE (op0
) == SSA_NAME
)
3030 vr0
= *(get_value_range (op0
));
3031 else if (is_gimple_min_invariant (op0
))
3032 set_value_range_to_value (&vr0
, op0
, NULL
);
3034 set_value_range_to_varying (&vr0
);
3036 if (TREE_CODE (op1
) == SSA_NAME
)
3037 vr1
= *(get_value_range (op1
));
3038 else if (is_gimple_min_invariant (op1
))
3039 set_value_range_to_value (&vr1
, op1
, NULL
);
3041 set_value_range_to_varying (&vr1
);
3043 extract_range_from_binary_expr_1 (vr
, code
, expr_type
, &vr0
, &vr1
);
3045 /* Try harder for PLUS and MINUS if the range of one operand is symbolic
3046 and based on the other operand, for example if it was deduced from a
3047 symbolic comparison. When a bound of the range of the first operand
3048 is invariant, we set the corresponding bound of the new range to INF
3049 in order to avoid recursing on the range of the second operand. */
3050 if (vr
->type
== VR_VARYING
3051 && (code
== PLUS_EXPR
|| code
== MINUS_EXPR
)
3052 && TREE_CODE (op1
) == SSA_NAME
3053 && vr0
.type
== VR_RANGE
3054 && symbolic_range_based_on_p (&vr0
, op1
))
3056 const bool minus_p
= (code
== MINUS_EXPR
);
3057 value_range n_vr1
= VR_INITIALIZER
;
3059 /* Try with VR0 and [-INF, OP1]. */
3060 if (is_gimple_min_invariant (minus_p
? vr0
.max
: vr0
.min
))
3061 set_value_range (&n_vr1
, VR_RANGE
, vrp_val_min (expr_type
), op1
, NULL
);
3063 /* Try with VR0 and [OP1, +INF]. */
3064 else if (is_gimple_min_invariant (minus_p
? vr0
.min
: vr0
.max
))
3065 set_value_range (&n_vr1
, VR_RANGE
, op1
, vrp_val_max (expr_type
), NULL
);
3067 /* Try with VR0 and [OP1, OP1]. */
3069 set_value_range (&n_vr1
, VR_RANGE
, op1
, op1
, NULL
);
3071 extract_range_from_binary_expr_1 (vr
, code
, expr_type
, &vr0
, &n_vr1
);
3074 if (vr
->type
== VR_VARYING
3075 && (code
== PLUS_EXPR
|| code
== MINUS_EXPR
)
3076 && TREE_CODE (op0
) == SSA_NAME
3077 && vr1
.type
== VR_RANGE
3078 && symbolic_range_based_on_p (&vr1
, op0
))
3080 const bool minus_p
= (code
== MINUS_EXPR
);
3081 value_range n_vr0
= VR_INITIALIZER
;
3083 /* Try with [-INF, OP0] and VR1. */
3084 if (is_gimple_min_invariant (minus_p
? vr1
.max
: vr1
.min
))
3085 set_value_range (&n_vr0
, VR_RANGE
, vrp_val_min (expr_type
), op0
, NULL
);
3087 /* Try with [OP0, +INF] and VR1. */
3088 else if (is_gimple_min_invariant (minus_p
? vr1
.min
: vr1
.max
))
3089 set_value_range (&n_vr0
, VR_RANGE
, op0
, vrp_val_max (expr_type
), NULL
);
3091 /* Try with [OP0, OP0] and VR1. */
3093 set_value_range (&n_vr0
, VR_RANGE
, op0
, op0
, NULL
);
3095 extract_range_from_binary_expr_1 (vr
, code
, expr_type
, &n_vr0
, &vr1
);
3098 /* If we didn't derive a range for MINUS_EXPR, and
3099 op1's range is ~[op0,op0] or vice-versa, then we
3100 can derive a non-null range. This happens often for
3101 pointer subtraction. */
3102 if (vr
->type
== VR_VARYING
3103 && code
== MINUS_EXPR
3104 && TREE_CODE (op0
) == SSA_NAME
3105 && ((vr0
.type
== VR_ANTI_RANGE
3107 && vr0
.min
== vr0
.max
)
3108 || (vr1
.type
== VR_ANTI_RANGE
3110 && vr1
.min
== vr1
.max
)))
3111 set_value_range_to_nonnull (vr
, TREE_TYPE (op0
));
3114 /* Extract range information from a unary operation CODE based on
3115 the range of its operand *VR0 with type OP0_TYPE with resulting type TYPE.
3116 The resulting range is stored in *VR. */
3119 extract_range_from_unary_expr (value_range
*vr
,
3120 enum tree_code code
, tree type
,
3121 value_range
*vr0_
, tree op0_type
)
3123 value_range vr0
= *vr0_
, vrtem0
= VR_INITIALIZER
, vrtem1
= VR_INITIALIZER
;
3125 /* VRP only operates on integral and pointer types. */
3126 if (!(INTEGRAL_TYPE_P (op0_type
)
3127 || POINTER_TYPE_P (op0_type
))
3128 || !(INTEGRAL_TYPE_P (type
)
3129 || POINTER_TYPE_P (type
)))
3131 set_value_range_to_varying (vr
);
3135 /* If VR0 is UNDEFINED, so is the result. */
3136 if (vr0
.type
== VR_UNDEFINED
)
3138 set_value_range_to_undefined (vr
);
3142 /* Handle operations that we express in terms of others. */
3143 if (code
== PAREN_EXPR
|| code
== OBJ_TYPE_REF
)
3145 /* PAREN_EXPR and OBJ_TYPE_REF are simple copies. */
3146 copy_value_range (vr
, &vr0
);
3149 else if (code
== NEGATE_EXPR
)
3151 /* -X is simply 0 - X, so re-use existing code that also handles
3152 anti-ranges fine. */
3153 value_range zero
= VR_INITIALIZER
;
3154 set_value_range_to_value (&zero
, build_int_cst (type
, 0), NULL
);
3155 extract_range_from_binary_expr_1 (vr
, MINUS_EXPR
, type
, &zero
, &vr0
);
3158 else if (code
== BIT_NOT_EXPR
)
3160 /* ~X is simply -1 - X, so re-use existing code that also handles
3161 anti-ranges fine. */
3162 value_range minusone
= VR_INITIALIZER
;
3163 set_value_range_to_value (&minusone
, build_int_cst (type
, -1), NULL
);
3164 extract_range_from_binary_expr_1 (vr
, MINUS_EXPR
,
3165 type
, &minusone
, &vr0
);
3169 /* Now canonicalize anti-ranges to ranges when they are not symbolic
3170 and express op ~[] as (op []') U (op []''). */
3171 if (vr0
.type
== VR_ANTI_RANGE
3172 && ranges_from_anti_range (&vr0
, &vrtem0
, &vrtem1
))
3174 extract_range_from_unary_expr (vr
, code
, type
, &vrtem0
, op0_type
);
3175 if (vrtem1
.type
!= VR_UNDEFINED
)
3177 value_range vrres
= VR_INITIALIZER
;
3178 extract_range_from_unary_expr (&vrres
, code
, type
,
3180 vrp_meet (vr
, &vrres
);
3185 if (CONVERT_EXPR_CODE_P (code
))
3187 tree inner_type
= op0_type
;
3188 tree outer_type
= type
;
3190 /* If the expression evaluates to a pointer, we are only interested in
3191 determining if it evaluates to NULL [0, 0] or non-NULL (~[0, 0]). */
3192 if (POINTER_TYPE_P (type
))
3194 if (range_is_nonnull (&vr0
))
3195 set_value_range_to_nonnull (vr
, type
);
3196 else if (range_is_null (&vr0
))
3197 set_value_range_to_null (vr
, type
);
3199 set_value_range_to_varying (vr
);
3203 /* If VR0 is varying and we increase the type precision, assume
3204 a full range for the following transformation. */
3205 if (vr0
.type
== VR_VARYING
3206 && INTEGRAL_TYPE_P (inner_type
)
3207 && TYPE_PRECISION (inner_type
) < TYPE_PRECISION (outer_type
))
3209 vr0
.type
= VR_RANGE
;
3210 vr0
.min
= TYPE_MIN_VALUE (inner_type
);
3211 vr0
.max
= TYPE_MAX_VALUE (inner_type
);
3214 /* If VR0 is a constant range or anti-range and the conversion is
3215 not truncating we can convert the min and max values and
3216 canonicalize the resulting range. Otherwise we can do the
3217 conversion if the size of the range is less than what the
3218 precision of the target type can represent and the range is
3219 not an anti-range. */
3220 if ((vr0
.type
== VR_RANGE
3221 || vr0
.type
== VR_ANTI_RANGE
)
3222 && TREE_CODE (vr0
.min
) == INTEGER_CST
3223 && TREE_CODE (vr0
.max
) == INTEGER_CST
3224 && (TYPE_PRECISION (outer_type
) >= TYPE_PRECISION (inner_type
)
3225 || (vr0
.type
== VR_RANGE
3226 && integer_zerop (int_const_binop (RSHIFT_EXPR
,
3227 int_const_binop (MINUS_EXPR
, vr0
.max
, vr0
.min
),
3228 size_int (TYPE_PRECISION (outer_type
)))))))
3230 tree new_min
, new_max
;
3231 new_min
= force_fit_type (outer_type
, wi::to_widest (vr0
.min
),
3233 new_max
= force_fit_type (outer_type
, wi::to_widest (vr0
.max
),
3235 set_and_canonicalize_value_range (vr
, vr0
.type
,
3236 new_min
, new_max
, NULL
);
3240 set_value_range_to_varying (vr
);
3243 else if (code
== ABS_EXPR
)
3248 /* Pass through vr0 in the easy cases. */
3249 if (TYPE_UNSIGNED (type
)
3250 || value_range_nonnegative_p (&vr0
))
3252 copy_value_range (vr
, &vr0
);
3256 /* For the remaining varying or symbolic ranges we can't do anything
3258 if (vr0
.type
== VR_VARYING
3259 || symbolic_range_p (&vr0
))
3261 set_value_range_to_varying (vr
);
3265 /* -TYPE_MIN_VALUE = TYPE_MIN_VALUE with flag_wrapv so we can't get a
3267 if (!TYPE_OVERFLOW_UNDEFINED (type
)
3268 && ((vr0
.type
== VR_RANGE
3269 && vrp_val_is_min (vr0
.min
))
3270 || (vr0
.type
== VR_ANTI_RANGE
3271 && !vrp_val_is_min (vr0
.min
))))
3273 set_value_range_to_varying (vr
);
3277 /* ABS_EXPR may flip the range around, if the original range
3278 included negative values. */
3279 if (!vrp_val_is_min (vr0
.min
))
3280 min
= fold_unary_to_constant (code
, type
, vr0
.min
);
3282 min
= TYPE_MAX_VALUE (type
);
3284 if (!vrp_val_is_min (vr0
.max
))
3285 max
= fold_unary_to_constant (code
, type
, vr0
.max
);
3287 max
= TYPE_MAX_VALUE (type
);
3289 cmp
= compare_values (min
, max
);
3291 /* If a VR_ANTI_RANGEs contains zero, then we have
3292 ~[-INF, min(MIN, MAX)]. */
3293 if (vr0
.type
== VR_ANTI_RANGE
)
3295 if (range_includes_zero_p (vr0
.min
, vr0
.max
) == 1)
3297 /* Take the lower of the two values. */
3301 /* Create ~[-INF, min (abs(MIN), abs(MAX))]
3302 or ~[-INF + 1, min (abs(MIN), abs(MAX))] when
3303 flag_wrapv is set and the original anti-range doesn't include
3304 TYPE_MIN_VALUE, remember -TYPE_MIN_VALUE = TYPE_MIN_VALUE. */
3305 if (TYPE_OVERFLOW_WRAPS (type
))
3307 tree type_min_value
= TYPE_MIN_VALUE (type
);
3309 min
= (vr0
.min
!= type_min_value
3310 ? int_const_binop (PLUS_EXPR
, type_min_value
,
3311 build_int_cst (TREE_TYPE (type_min_value
), 1))
3315 min
= TYPE_MIN_VALUE (type
);
3319 /* All else has failed, so create the range [0, INF], even for
3320 flag_wrapv since TYPE_MIN_VALUE is in the original
3322 vr0
.type
= VR_RANGE
;
3323 min
= build_int_cst (type
, 0);
3324 max
= TYPE_MAX_VALUE (type
);
3328 /* If the range contains zero then we know that the minimum value in the
3329 range will be zero. */
3330 else if (range_includes_zero_p (vr0
.min
, vr0
.max
) == 1)
3334 min
= build_int_cst (type
, 0);
3338 /* If the range was reversed, swap MIN and MAX. */
3340 std::swap (min
, max
);
3343 cmp
= compare_values (min
, max
);
3344 if (cmp
== -2 || cmp
== 1)
3346 /* If the new range has its limits swapped around (MIN > MAX),
3347 then the operation caused one of them to wrap around, mark
3348 the new range VARYING. */
3349 set_value_range_to_varying (vr
);
3352 set_value_range (vr
, vr0
.type
, min
, max
, NULL
);
3356 /* For unhandled operations fall back to varying. */
3357 set_value_range_to_varying (vr
);
3362 /* Extract range information from a unary expression CODE OP0 based on
3363 the range of its operand with resulting type TYPE.
3364 The resulting range is stored in *VR. */
3367 extract_range_from_unary_expr (value_range
*vr
, enum tree_code code
,
3368 tree type
, tree op0
)
3370 value_range vr0
= VR_INITIALIZER
;
3372 /* Get value ranges for the operand. For constant operands, create
3373 a new value range with the operand to simplify processing. */
3374 if (TREE_CODE (op0
) == SSA_NAME
)
3375 vr0
= *(get_value_range (op0
));
3376 else if (is_gimple_min_invariant (op0
))
3377 set_value_range_to_value (&vr0
, op0
, NULL
);
3379 set_value_range_to_varying (&vr0
);
3381 extract_range_from_unary_expr (vr
, code
, type
, &vr0
, TREE_TYPE (op0
));
3385 /* Extract range information from a conditional expression STMT based on
3386 the ranges of each of its operands and the expression code. */
3389 extract_range_from_cond_expr (value_range
*vr
, gassign
*stmt
)
3392 value_range vr0
= VR_INITIALIZER
;
3393 value_range vr1
= VR_INITIALIZER
;
3395 /* Get value ranges for each operand. For constant operands, create
3396 a new value range with the operand to simplify processing. */
3397 op0
= gimple_assign_rhs2 (stmt
);
3398 if (TREE_CODE (op0
) == SSA_NAME
)
3399 vr0
= *(get_value_range (op0
));
3400 else if (is_gimple_min_invariant (op0
))
3401 set_value_range_to_value (&vr0
, op0
, NULL
);
3403 set_value_range_to_varying (&vr0
);
3405 op1
= gimple_assign_rhs3 (stmt
);
3406 if (TREE_CODE (op1
) == SSA_NAME
)
3407 vr1
= *(get_value_range (op1
));
3408 else if (is_gimple_min_invariant (op1
))
3409 set_value_range_to_value (&vr1
, op1
, NULL
);
3411 set_value_range_to_varying (&vr1
);
3413 /* The resulting value range is the union of the operand ranges */
3414 copy_value_range (vr
, &vr0
);
3415 vrp_meet (vr
, &vr1
);
3419 /* Extract range information from a comparison expression EXPR based
3420 on the range of its operand and the expression code. */
3423 extract_range_from_comparison (value_range
*vr
, enum tree_code code
,
3424 tree type
, tree op0
, tree op1
)
3429 val
= vrp_evaluate_conditional_warnv_with_ops (code
, op0
, op1
, false, &sop
,
3433 /* Since this expression was found on the RHS of an assignment,
3434 its type may be different from _Bool. Convert VAL to EXPR's
3436 val
= fold_convert (type
, val
);
3437 if (is_gimple_min_invariant (val
))
3438 set_value_range_to_value (vr
, val
, vr
->equiv
);
3440 set_value_range (vr
, VR_RANGE
, val
, val
, vr
->equiv
);
3443 /* The result of a comparison is always true or false. */
3444 set_value_range_to_truthvalue (vr
, type
);
3447 /* Helper function for simplify_internal_call_using_ranges and
3448 extract_range_basic. Return true if OP0 SUBCODE OP1 for
3449 SUBCODE {PLUS,MINUS,MULT}_EXPR is known to never overflow or
3450 always overflow. Set *OVF to true if it is known to always
3454 check_for_binary_op_overflow (enum tree_code subcode
, tree type
,
3455 tree op0
, tree op1
, bool *ovf
)
3457 value_range vr0
= VR_INITIALIZER
;
3458 value_range vr1
= VR_INITIALIZER
;
3459 if (TREE_CODE (op0
) == SSA_NAME
)
3460 vr0
= *get_value_range (op0
);
3461 else if (TREE_CODE (op0
) == INTEGER_CST
)
3462 set_value_range_to_value (&vr0
, op0
, NULL
);
3464 set_value_range_to_varying (&vr0
);
3466 if (TREE_CODE (op1
) == SSA_NAME
)
3467 vr1
= *get_value_range (op1
);
3468 else if (TREE_CODE (op1
) == INTEGER_CST
)
3469 set_value_range_to_value (&vr1
, op1
, NULL
);
3471 set_value_range_to_varying (&vr1
);
3473 if (!range_int_cst_p (&vr0
)
3474 || TREE_OVERFLOW (vr0
.min
)
3475 || TREE_OVERFLOW (vr0
.max
))
3477 vr0
.min
= vrp_val_min (TREE_TYPE (op0
));
3478 vr0
.max
= vrp_val_max (TREE_TYPE (op0
));
3480 if (!range_int_cst_p (&vr1
)
3481 || TREE_OVERFLOW (vr1
.min
)
3482 || TREE_OVERFLOW (vr1
.max
))
3484 vr1
.min
= vrp_val_min (TREE_TYPE (op1
));
3485 vr1
.max
= vrp_val_max (TREE_TYPE (op1
));
3487 *ovf
= arith_overflowed_p (subcode
, type
, vr0
.min
,
3488 subcode
== MINUS_EXPR
? vr1
.max
: vr1
.min
);
3489 if (arith_overflowed_p (subcode
, type
, vr0
.max
,
3490 subcode
== MINUS_EXPR
? vr1
.min
: vr1
.max
) != *ovf
)
3492 if (subcode
== MULT_EXPR
)
3494 if (arith_overflowed_p (subcode
, type
, vr0
.min
, vr1
.max
) != *ovf
3495 || arith_overflowed_p (subcode
, type
, vr0
.max
, vr1
.min
) != *ovf
)
3500 /* So far we found that there is an overflow on the boundaries.
3501 That doesn't prove that there is an overflow even for all values
3502 in between the boundaries. For that compute widest_int range
3503 of the result and see if it doesn't overlap the range of
3505 widest_int wmin
, wmax
;
3508 w
[0] = wi::to_widest (vr0
.min
);
3509 w
[1] = wi::to_widest (vr0
.max
);
3510 w
[2] = wi::to_widest (vr1
.min
);
3511 w
[3] = wi::to_widest (vr1
.max
);
3512 for (i
= 0; i
< 4; i
++)
3518 wt
= wi::add (w
[i
& 1], w
[2 + (i
& 2) / 2]);
3521 wt
= wi::sub (w
[i
& 1], w
[2 + (i
& 2) / 2]);
3524 wt
= wi::mul (w
[i
& 1], w
[2 + (i
& 2) / 2]);
3536 wmin
= wi::smin (wmin
, wt
);
3537 wmax
= wi::smax (wmax
, wt
);
3540 /* The result of op0 CODE op1 is known to be in range
3542 widest_int wtmin
= wi::to_widest (vrp_val_min (type
));
3543 widest_int wtmax
= wi::to_widest (vrp_val_max (type
));
3544 /* If all values in [wmin, wmax] are smaller than
3545 [wtmin, wtmax] or all are larger than [wtmin, wtmax],
3546 the arithmetic operation will always overflow. */
3547 if (wmax
< wtmin
|| wmin
> wtmax
)
3554 /* Try to derive a nonnegative or nonzero range out of STMT relying
3555 primarily on generic routines in fold in conjunction with range data.
3556 Store the result in *VR */
3559 extract_range_basic (value_range
*vr
, gimple
*stmt
)
3562 tree type
= gimple_expr_type (stmt
);
3564 if (is_gimple_call (stmt
))
3567 int mini
, maxi
, zerov
= 0, prec
;
3568 enum tree_code subcode
= ERROR_MARK
;
3569 combined_fn cfn
= gimple_call_combined_fn (stmt
);
3573 case CFN_BUILT_IN_CONSTANT_P
:
3574 /* If the call is __builtin_constant_p and the argument is a
3575 function parameter resolve it to false. This avoids bogus
3576 array bound warnings.
3577 ??? We could do this as early as inlining is finished. */
3578 arg
= gimple_call_arg (stmt
, 0);
3579 if (TREE_CODE (arg
) == SSA_NAME
3580 && SSA_NAME_IS_DEFAULT_DEF (arg
)
3581 && TREE_CODE (SSA_NAME_VAR (arg
)) == PARM_DECL
3582 && cfun
->after_inlining
)
3584 set_value_range_to_null (vr
, type
);
3588 /* Both __builtin_ffs* and __builtin_popcount return
3592 arg
= gimple_call_arg (stmt
, 0);
3593 prec
= TYPE_PRECISION (TREE_TYPE (arg
));
3596 if (TREE_CODE (arg
) == SSA_NAME
)
3598 value_range
*vr0
= get_value_range (arg
);
3599 /* If arg is non-zero, then ffs or popcount
3601 if ((vr0
->type
== VR_RANGE
3602 && range_includes_zero_p (vr0
->min
, vr0
->max
) == 0)
3603 || (vr0
->type
== VR_ANTI_RANGE
3604 && range_includes_zero_p (vr0
->min
, vr0
->max
) == 1))
3606 /* If some high bits are known to be zero,
3607 we can decrease the maximum. */
3608 if (vr0
->type
== VR_RANGE
3609 && TREE_CODE (vr0
->max
) == INTEGER_CST
3610 && !operand_less_p (vr0
->min
,
3611 build_zero_cst (TREE_TYPE (vr0
->min
))))
3612 maxi
= tree_floor_log2 (vr0
->max
) + 1;
3615 /* __builtin_parity* returns [0, 1]. */
3620 /* __builtin_c[lt]z* return [0, prec-1], except for
3621 when the argument is 0, but that is undefined behavior.
3622 On many targets where the CLZ RTL or optab value is defined
3623 for 0 the value is prec, so include that in the range
3626 arg
= gimple_call_arg (stmt
, 0);
3627 prec
= TYPE_PRECISION (TREE_TYPE (arg
));
3630 if (optab_handler (clz_optab
, TYPE_MODE (TREE_TYPE (arg
)))
3632 && CLZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (TREE_TYPE (arg
)),
3634 /* Handle only the single common value. */
3636 /* Magic value to give up, unless vr0 proves
3639 if (TREE_CODE (arg
) == SSA_NAME
)
3641 value_range
*vr0
= get_value_range (arg
);
3642 /* From clz of VR_RANGE minimum we can compute
3644 if (vr0
->type
== VR_RANGE
3645 && TREE_CODE (vr0
->min
) == INTEGER_CST
)
3647 maxi
= prec
- 1 - tree_floor_log2 (vr0
->min
);
3651 else if (vr0
->type
== VR_ANTI_RANGE
3652 && integer_zerop (vr0
->min
))
3659 /* From clz of VR_RANGE maximum we can compute
3661 if (vr0
->type
== VR_RANGE
3662 && TREE_CODE (vr0
->max
) == INTEGER_CST
)
3664 mini
= prec
- 1 - tree_floor_log2 (vr0
->max
);
3672 /* __builtin_ctz* return [0, prec-1], except for
3673 when the argument is 0, but that is undefined behavior.
3674 If there is a ctz optab for this mode and
3675 CTZ_DEFINED_VALUE_AT_ZERO, include that in the range,
3676 otherwise just assume 0 won't be seen. */
3678 arg
= gimple_call_arg (stmt
, 0);
3679 prec
= TYPE_PRECISION (TREE_TYPE (arg
));
3682 if (optab_handler (ctz_optab
, TYPE_MODE (TREE_TYPE (arg
)))
3684 && CTZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (TREE_TYPE (arg
)),
3687 /* Handle only the two common values. */
3690 else if (zerov
== prec
)
3693 /* Magic value to give up, unless vr0 proves
3697 if (TREE_CODE (arg
) == SSA_NAME
)
3699 value_range
*vr0
= get_value_range (arg
);
3700 /* If arg is non-zero, then use [0, prec - 1]. */
3701 if ((vr0
->type
== VR_RANGE
3702 && integer_nonzerop (vr0
->min
))
3703 || (vr0
->type
== VR_ANTI_RANGE
3704 && integer_zerop (vr0
->min
)))
3709 /* If some high bits are known to be zero,
3710 we can decrease the result maximum. */
3711 if (vr0
->type
== VR_RANGE
3712 && TREE_CODE (vr0
->max
) == INTEGER_CST
)
3714 maxi
= tree_floor_log2 (vr0
->max
);
3715 /* For vr0 [0, 0] give up. */
3723 /* __builtin_clrsb* returns [0, prec-1]. */
3725 arg
= gimple_call_arg (stmt
, 0);
3726 prec
= TYPE_PRECISION (TREE_TYPE (arg
));
3731 set_value_range (vr
, VR_RANGE
, build_int_cst (type
, mini
),
3732 build_int_cst (type
, maxi
), NULL
);
3734 case CFN_UBSAN_CHECK_ADD
:
3735 subcode
= PLUS_EXPR
;
3737 case CFN_UBSAN_CHECK_SUB
:
3738 subcode
= MINUS_EXPR
;
3740 case CFN_UBSAN_CHECK_MUL
:
3741 subcode
= MULT_EXPR
;
3743 case CFN_GOACC_DIM_SIZE
:
3744 case CFN_GOACC_DIM_POS
:
3745 /* Optimizing these two internal functions helps the loop
3746 optimizer eliminate outer comparisons. Size is [1,N]
3747 and pos is [0,N-1]. */
3749 bool is_pos
= cfn
== CFN_GOACC_DIM_POS
;
3750 int axis
= oacc_get_ifn_dim_arg (stmt
);
3751 int size
= oacc_get_fn_dim_size (current_function_decl
, axis
);
3754 /* If it's dynamic, the backend might know a hardware
3756 size
= targetm
.goacc
.dim_limit (axis
);
3758 tree type
= TREE_TYPE (gimple_call_lhs (stmt
));
3759 set_value_range (vr
, VR_RANGE
,
3760 build_int_cst (type
, is_pos
? 0 : 1),
3761 size
? build_int_cst (type
, size
- is_pos
)
3762 : vrp_val_max (type
), NULL
);
3765 case CFN_BUILT_IN_STRLEN
:
3766 if (tree lhs
= gimple_call_lhs (stmt
))
3767 if (ptrdiff_type_node
3768 && (TYPE_PRECISION (ptrdiff_type_node
)
3769 == TYPE_PRECISION (TREE_TYPE (lhs
))))
3771 tree type
= TREE_TYPE (lhs
);
3772 tree max
= vrp_val_max (ptrdiff_type_node
);
3773 wide_int wmax
= wi::to_wide (max
, TYPE_PRECISION (TREE_TYPE (max
)));
3774 tree range_min
= build_zero_cst (type
);
3775 tree range_max
= wide_int_to_tree (type
, wmax
- 1);
3776 set_value_range (vr
, VR_RANGE
, range_min
, range_max
, NULL
);
3783 if (subcode
!= ERROR_MARK
)
3785 bool saved_flag_wrapv
= flag_wrapv
;
3786 /* Pretend the arithmetics is wrapping. If there is
3787 any overflow, we'll complain, but will actually do
3788 wrapping operation. */
3790 extract_range_from_binary_expr (vr
, subcode
, type
,
3791 gimple_call_arg (stmt
, 0),
3792 gimple_call_arg (stmt
, 1));
3793 flag_wrapv
= saved_flag_wrapv
;
3795 /* If for both arguments vrp_valueize returned non-NULL,
3796 this should have been already folded and if not, it
3797 wasn't folded because of overflow. Avoid removing the
3798 UBSAN_CHECK_* calls in that case. */
3799 if (vr
->type
== VR_RANGE
3800 && (vr
->min
== vr
->max
3801 || operand_equal_p (vr
->min
, vr
->max
, 0)))
3802 set_value_range_to_varying (vr
);
3806 /* Handle extraction of the two results (result of arithmetics and
3807 a flag whether arithmetics overflowed) from {ADD,SUB,MUL}_OVERFLOW
3808 internal function. Similarly from ATOMIC_COMPARE_EXCHANGE. */
3809 else if (is_gimple_assign (stmt
)
3810 && (gimple_assign_rhs_code (stmt
) == REALPART_EXPR
3811 || gimple_assign_rhs_code (stmt
) == IMAGPART_EXPR
)
3812 && INTEGRAL_TYPE_P (type
))
3814 enum tree_code code
= gimple_assign_rhs_code (stmt
);
3815 tree op
= gimple_assign_rhs1 (stmt
);
3816 if (TREE_CODE (op
) == code
&& TREE_CODE (TREE_OPERAND (op
, 0)) == SSA_NAME
)
3818 gimple
*g
= SSA_NAME_DEF_STMT (TREE_OPERAND (op
, 0));
3819 if (is_gimple_call (g
) && gimple_call_internal_p (g
))
3821 enum tree_code subcode
= ERROR_MARK
;
3822 switch (gimple_call_internal_fn (g
))
3824 case IFN_ADD_OVERFLOW
:
3825 subcode
= PLUS_EXPR
;
3827 case IFN_SUB_OVERFLOW
:
3828 subcode
= MINUS_EXPR
;
3830 case IFN_MUL_OVERFLOW
:
3831 subcode
= MULT_EXPR
;
3833 case IFN_ATOMIC_COMPARE_EXCHANGE
:
3834 if (code
== IMAGPART_EXPR
)
3836 /* This is the boolean return value whether compare and
3837 exchange changed anything or not. */
3838 set_value_range (vr
, VR_RANGE
, build_int_cst (type
, 0),
3839 build_int_cst (type
, 1), NULL
);
3846 if (subcode
!= ERROR_MARK
)
3848 tree op0
= gimple_call_arg (g
, 0);
3849 tree op1
= gimple_call_arg (g
, 1);
3850 if (code
== IMAGPART_EXPR
)
3853 if (check_for_binary_op_overflow (subcode
, type
,
3855 set_value_range_to_value (vr
,
3856 build_int_cst (type
, ovf
),
3858 else if (TYPE_PRECISION (type
) == 1
3859 && !TYPE_UNSIGNED (type
))
3860 set_value_range_to_varying (vr
);
3862 set_value_range (vr
, VR_RANGE
, build_int_cst (type
, 0),
3863 build_int_cst (type
, 1), NULL
);
3865 else if (types_compatible_p (type
, TREE_TYPE (op0
))
3866 && types_compatible_p (type
, TREE_TYPE (op1
)))
3868 bool saved_flag_wrapv
= flag_wrapv
;
3869 /* Pretend the arithmetics is wrapping. If there is
3870 any overflow, IMAGPART_EXPR will be set. */
3872 extract_range_from_binary_expr (vr
, subcode
, type
,
3874 flag_wrapv
= saved_flag_wrapv
;
3878 value_range vr0
= VR_INITIALIZER
;
3879 value_range vr1
= VR_INITIALIZER
;
3880 bool saved_flag_wrapv
= flag_wrapv
;
3881 /* Pretend the arithmetics is wrapping. If there is
3882 any overflow, IMAGPART_EXPR will be set. */
3884 extract_range_from_unary_expr (&vr0
, NOP_EXPR
,
3886 extract_range_from_unary_expr (&vr1
, NOP_EXPR
,
3888 extract_range_from_binary_expr_1 (vr
, subcode
, type
,
3890 flag_wrapv
= saved_flag_wrapv
;
3897 if (INTEGRAL_TYPE_P (type
)
3898 && gimple_stmt_nonnegative_warnv_p (stmt
, &sop
))
3899 set_value_range_to_nonnegative (vr
, type
);
3900 else if (vrp_stmt_computes_nonzero (stmt
))
3901 set_value_range_to_nonnull (vr
, type
);
3903 set_value_range_to_varying (vr
);
3907 /* Try to compute a useful range out of assignment STMT and store it
3911 extract_range_from_assignment (value_range
*vr
, gassign
*stmt
)
3913 enum tree_code code
= gimple_assign_rhs_code (stmt
);
3915 if (code
== ASSERT_EXPR
)
3916 extract_range_from_assert (vr
, gimple_assign_rhs1 (stmt
));
3917 else if (code
== SSA_NAME
)
3918 extract_range_from_ssa_name (vr
, gimple_assign_rhs1 (stmt
));
3919 else if (TREE_CODE_CLASS (code
) == tcc_binary
)
3920 extract_range_from_binary_expr (vr
, gimple_assign_rhs_code (stmt
),
3921 gimple_expr_type (stmt
),
3922 gimple_assign_rhs1 (stmt
),
3923 gimple_assign_rhs2 (stmt
));
3924 else if (TREE_CODE_CLASS (code
) == tcc_unary
)
3925 extract_range_from_unary_expr (vr
, gimple_assign_rhs_code (stmt
),
3926 gimple_expr_type (stmt
),
3927 gimple_assign_rhs1 (stmt
));
3928 else if (code
== COND_EXPR
)
3929 extract_range_from_cond_expr (vr
, stmt
);
3930 else if (TREE_CODE_CLASS (code
) == tcc_comparison
)
3931 extract_range_from_comparison (vr
, gimple_assign_rhs_code (stmt
),
3932 gimple_expr_type (stmt
),
3933 gimple_assign_rhs1 (stmt
),
3934 gimple_assign_rhs2 (stmt
));
3935 else if (get_gimple_rhs_class (code
) == GIMPLE_SINGLE_RHS
3936 && is_gimple_min_invariant (gimple_assign_rhs1 (stmt
)))
3937 set_value_range_to_value (vr
, gimple_assign_rhs1 (stmt
), NULL
);
3939 set_value_range_to_varying (vr
);
3941 if (vr
->type
== VR_VARYING
)
3942 extract_range_basic (vr
, stmt
);
3945 /* Given a range VR, a LOOP and a variable VAR, determine whether it
3946 would be profitable to adjust VR using scalar evolution information
3947 for VAR. If so, update VR with the new limits. */
3950 adjust_range_with_scev (value_range
*vr
, struct loop
*loop
,
3951 gimple
*stmt
, tree var
)
3953 tree init
, step
, chrec
, tmin
, tmax
, min
, max
, type
, tem
;
3954 enum ev_direction dir
;
3956 /* TODO. Don't adjust anti-ranges. An anti-range may provide
3957 better opportunities than a regular range, but I'm not sure. */
3958 if (vr
->type
== VR_ANTI_RANGE
)
3961 chrec
= instantiate_parameters (loop
, analyze_scalar_evolution (loop
, var
));
3963 /* Like in PR19590, scev can return a constant function. */
3964 if (is_gimple_min_invariant (chrec
))
3966 set_value_range_to_value (vr
, chrec
, vr
->equiv
);
3970 if (TREE_CODE (chrec
) != POLYNOMIAL_CHREC
)
3973 init
= initial_condition_in_loop_num (chrec
, loop
->num
);
3974 tem
= op_with_constant_singleton_value_range (init
);
3977 step
= evolution_part_in_loop_num (chrec
, loop
->num
);
3978 tem
= op_with_constant_singleton_value_range (step
);
3982 /* If STEP is symbolic, we can't know whether INIT will be the
3983 minimum or maximum value in the range. Also, unless INIT is
3984 a simple expression, compare_values and possibly other functions
3985 in tree-vrp won't be able to handle it. */
3986 if (step
== NULL_TREE
3987 || !is_gimple_min_invariant (step
)
3988 || !valid_value_p (init
))
3991 dir
= scev_direction (chrec
);
3992 if (/* Do not adjust ranges if we do not know whether the iv increases
3993 or decreases, ... */
3994 dir
== EV_DIR_UNKNOWN
3995 /* ... or if it may wrap. */
3996 || scev_probably_wraps_p (NULL_TREE
, init
, step
, stmt
,
3997 get_chrec_loop (chrec
), true))
4000 type
= TREE_TYPE (var
);
4001 if (POINTER_TYPE_P (type
) || !TYPE_MIN_VALUE (type
))
4002 tmin
= lower_bound_in_type (type
, type
);
4004 tmin
= TYPE_MIN_VALUE (type
);
4005 if (POINTER_TYPE_P (type
) || !TYPE_MAX_VALUE (type
))
4006 tmax
= upper_bound_in_type (type
, type
);
4008 tmax
= TYPE_MAX_VALUE (type
);
4010 /* Try to use estimated number of iterations for the loop to constrain the
4011 final value in the evolution. */
4012 if (TREE_CODE (step
) == INTEGER_CST
4013 && is_gimple_val (init
)
4014 && (TREE_CODE (init
) != SSA_NAME
4015 || get_value_range (init
)->type
== VR_RANGE
))
4019 /* We are only entering here for loop header PHI nodes, so using
4020 the number of latch executions is the correct thing to use. */
4021 if (max_loop_iterations (loop
, &nit
))
4023 value_range maxvr
= VR_INITIALIZER
;
4024 signop sgn
= TYPE_SIGN (TREE_TYPE (step
));
4027 widest_int wtmp
= wi::mul (wi::to_widest (step
), nit
, sgn
,
4029 /* If the multiplication overflowed we can't do a meaningful
4030 adjustment. Likewise if the result doesn't fit in the type
4031 of the induction variable. For a signed type we have to
4032 check whether the result has the expected signedness which
4033 is that of the step as number of iterations is unsigned. */
4035 && wi::fits_to_tree_p (wtmp
, TREE_TYPE (init
))
4037 || wi::gts_p (wtmp
, 0) == wi::gts_p (step
, 0)))
4039 tem
= wide_int_to_tree (TREE_TYPE (init
), wtmp
);
4040 extract_range_from_binary_expr (&maxvr
, PLUS_EXPR
,
4041 TREE_TYPE (init
), init
, tem
);
4042 /* Likewise if the addition did. */
4043 if (maxvr
.type
== VR_RANGE
)
4045 value_range initvr
= VR_INITIALIZER
;
4047 if (TREE_CODE (init
) == SSA_NAME
)
4048 initvr
= *(get_value_range (init
));
4049 else if (is_gimple_min_invariant (init
))
4050 set_value_range_to_value (&initvr
, init
, NULL
);
4054 /* Check if init + nit * step overflows. Though we checked
4055 scev {init, step}_loop doesn't wrap, it is not enough
4056 because the loop may exit immediately. Overflow could
4057 happen in the plus expression in this case. */
4058 if ((dir
== EV_DIR_DECREASES
4059 && compare_values (maxvr
.min
, initvr
.min
) != -1)
4060 || (dir
== EV_DIR_GROWS
4061 && compare_values (maxvr
.max
, initvr
.max
) != 1))
4071 if (vr
->type
== VR_VARYING
|| vr
->type
== VR_UNDEFINED
)
4076 /* For VARYING or UNDEFINED ranges, just about anything we get
4077 from scalar evolutions should be better. */
4079 if (dir
== EV_DIR_DECREASES
)
4084 else if (vr
->type
== VR_RANGE
)
4089 if (dir
== EV_DIR_DECREASES
)
4091 /* INIT is the maximum value. If INIT is lower than VR->MAX
4092 but no smaller than VR->MIN, set VR->MAX to INIT. */
4093 if (compare_values (init
, max
) == -1)
4096 /* According to the loop information, the variable does not
4098 if (compare_values (min
, tmin
) == -1)
4104 /* If INIT is bigger than VR->MIN, set VR->MIN to INIT. */
4105 if (compare_values (init
, min
) == 1)
4108 if (compare_values (tmax
, max
) == -1)
4115 /* If we just created an invalid range with the minimum
4116 greater than the maximum, we fail conservatively.
4117 This should happen only in unreachable
4118 parts of code, or for invalid programs. */
4119 if (compare_values (min
, max
) == 1)
4122 /* Even for valid range info, sometimes overflow flag will leak in.
4123 As GIMPLE IL should have no constants with TREE_OVERFLOW set, we
4125 if (TREE_OVERFLOW_P (min
))
4126 min
= drop_tree_overflow (min
);
4127 if (TREE_OVERFLOW_P (max
))
4128 max
= drop_tree_overflow (max
);
4130 set_value_range (vr
, VR_RANGE
, min
, max
, vr
->equiv
);
4134 /* Given two numeric value ranges VR0, VR1 and a comparison code COMP:
4136 - Return BOOLEAN_TRUE_NODE if VR0 COMP VR1 always returns true for
4137 all the values in the ranges.
4139 - Return BOOLEAN_FALSE_NODE if the comparison always returns false.
4141 - Return NULL_TREE if it is not always possible to determine the
4142 value of the comparison.
4144 Also set *STRICT_OVERFLOW_P to indicate whether comparision evaluation
4145 assumed signed overflow is undefined. */
4149 compare_ranges (enum tree_code comp
, value_range
*vr0
, value_range
*vr1
,
4150 bool *strict_overflow_p
)
4152 /* VARYING or UNDEFINED ranges cannot be compared. */
4153 if (vr0
->type
== VR_VARYING
4154 || vr0
->type
== VR_UNDEFINED
4155 || vr1
->type
== VR_VARYING
4156 || vr1
->type
== VR_UNDEFINED
)
4159 /* Anti-ranges need to be handled separately. */
4160 if (vr0
->type
== VR_ANTI_RANGE
|| vr1
->type
== VR_ANTI_RANGE
)
4162 /* If both are anti-ranges, then we cannot compute any
4164 if (vr0
->type
== VR_ANTI_RANGE
&& vr1
->type
== VR_ANTI_RANGE
)
4167 /* These comparisons are never statically computable. */
4174 /* Equality can be computed only between a range and an
4175 anti-range. ~[VAL1, VAL2] == [VAL1, VAL2] is always false. */
4176 if (vr0
->type
== VR_RANGE
)
4178 /* To simplify processing, make VR0 the anti-range. */
4179 value_range
*tmp
= vr0
;
4184 gcc_assert (comp
== NE_EXPR
|| comp
== EQ_EXPR
);
4186 if (compare_values_warnv (vr0
->min
, vr1
->min
, strict_overflow_p
) == 0
4187 && compare_values_warnv (vr0
->max
, vr1
->max
, strict_overflow_p
) == 0)
4188 return (comp
== NE_EXPR
) ? boolean_true_node
: boolean_false_node
;
4193 /* Simplify processing. If COMP is GT_EXPR or GE_EXPR, switch the
4194 operands around and change the comparison code. */
4195 if (comp
== GT_EXPR
|| comp
== GE_EXPR
)
4197 comp
= (comp
== GT_EXPR
) ? LT_EXPR
: LE_EXPR
;
4198 std::swap (vr0
, vr1
);
4201 if (comp
== EQ_EXPR
)
4203 /* Equality may only be computed if both ranges represent
4204 exactly one value. */
4205 if (compare_values_warnv (vr0
->min
, vr0
->max
, strict_overflow_p
) == 0
4206 && compare_values_warnv (vr1
->min
, vr1
->max
, strict_overflow_p
) == 0)
4208 int cmp_min
= compare_values_warnv (vr0
->min
, vr1
->min
,
4210 int cmp_max
= compare_values_warnv (vr0
->max
, vr1
->max
,
4212 if (cmp_min
== 0 && cmp_max
== 0)
4213 return boolean_true_node
;
4214 else if (cmp_min
!= -2 && cmp_max
!= -2)
4215 return boolean_false_node
;
4217 /* If [V0_MIN, V1_MAX] < [V1_MIN, V1_MAX] then V0 != V1. */
4218 else if (compare_values_warnv (vr0
->min
, vr1
->max
,
4219 strict_overflow_p
) == 1
4220 || compare_values_warnv (vr1
->min
, vr0
->max
,
4221 strict_overflow_p
) == 1)
4222 return boolean_false_node
;
4226 else if (comp
== NE_EXPR
)
4230 /* If VR0 is completely to the left or completely to the right
4231 of VR1, they are always different. Notice that we need to
4232 make sure that both comparisons yield similar results to
4233 avoid comparing values that cannot be compared at
4235 cmp1
= compare_values_warnv (vr0
->max
, vr1
->min
, strict_overflow_p
);
4236 cmp2
= compare_values_warnv (vr0
->min
, vr1
->max
, strict_overflow_p
);
4237 if ((cmp1
== -1 && cmp2
== -1) || (cmp1
== 1 && cmp2
== 1))
4238 return boolean_true_node
;
4240 /* If VR0 and VR1 represent a single value and are identical,
4242 else if (compare_values_warnv (vr0
->min
, vr0
->max
,
4243 strict_overflow_p
) == 0
4244 && compare_values_warnv (vr1
->min
, vr1
->max
,
4245 strict_overflow_p
) == 0
4246 && compare_values_warnv (vr0
->min
, vr1
->min
,
4247 strict_overflow_p
) == 0
4248 && compare_values_warnv (vr0
->max
, vr1
->max
,
4249 strict_overflow_p
) == 0)
4250 return boolean_false_node
;
4252 /* Otherwise, they may or may not be different. */
4256 else if (comp
== LT_EXPR
|| comp
== LE_EXPR
)
4260 /* If VR0 is to the left of VR1, return true. */
4261 tst
= compare_values_warnv (vr0
->max
, vr1
->min
, strict_overflow_p
);
4262 if ((comp
== LT_EXPR
&& tst
== -1)
4263 || (comp
== LE_EXPR
&& (tst
== -1 || tst
== 0)))
4264 return boolean_true_node
;
4266 /* If VR0 is to the right of VR1, return false. */
4267 tst
= compare_values_warnv (vr0
->min
, vr1
->max
, strict_overflow_p
);
4268 if ((comp
== LT_EXPR
&& (tst
== 0 || tst
== 1))
4269 || (comp
== LE_EXPR
&& tst
== 1))
4270 return boolean_false_node
;
4272 /* Otherwise, we don't know. */
4280 /* Given a value range VR, a value VAL and a comparison code COMP, return
4281 BOOLEAN_TRUE_NODE if VR COMP VAL always returns true for all the
4282 values in VR. Return BOOLEAN_FALSE_NODE if the comparison
4283 always returns false. Return NULL_TREE if it is not always
4284 possible to determine the value of the comparison. Also set
4285 *STRICT_OVERFLOW_P to indicate whether comparision evaluation
4286 assumed signed overflow is undefined. */
4289 compare_range_with_value (enum tree_code comp
, value_range
*vr
, tree val
,
4290 bool *strict_overflow_p
)
4292 if (vr
->type
== VR_VARYING
|| vr
->type
== VR_UNDEFINED
)
4295 /* Anti-ranges need to be handled separately. */
4296 if (vr
->type
== VR_ANTI_RANGE
)
4298 /* For anti-ranges, the only predicates that we can compute at
4299 compile time are equality and inequality. */
4306 /* ~[VAL_1, VAL_2] OP VAL is known if VAL_1 <= VAL <= VAL_2. */
4307 if (value_inside_range (val
, vr
->min
, vr
->max
) == 1)
4308 return (comp
== NE_EXPR
) ? boolean_true_node
: boolean_false_node
;
4313 if (comp
== EQ_EXPR
)
4315 /* EQ_EXPR may only be computed if VR represents exactly
4317 if (compare_values_warnv (vr
->min
, vr
->max
, strict_overflow_p
) == 0)
4319 int cmp
= compare_values_warnv (vr
->min
, val
, strict_overflow_p
);
4321 return boolean_true_node
;
4322 else if (cmp
== -1 || cmp
== 1 || cmp
== 2)
4323 return boolean_false_node
;
4325 else if (compare_values_warnv (val
, vr
->min
, strict_overflow_p
) == -1
4326 || compare_values_warnv (vr
->max
, val
, strict_overflow_p
) == -1)
4327 return boolean_false_node
;
4331 else if (comp
== NE_EXPR
)
4333 /* If VAL is not inside VR, then they are always different. */
4334 if (compare_values_warnv (vr
->max
, val
, strict_overflow_p
) == -1
4335 || compare_values_warnv (vr
->min
, val
, strict_overflow_p
) == 1)
4336 return boolean_true_node
;
4338 /* If VR represents exactly one value equal to VAL, then return
4340 if (compare_values_warnv (vr
->min
, vr
->max
, strict_overflow_p
) == 0
4341 && compare_values_warnv (vr
->min
, val
, strict_overflow_p
) == 0)
4342 return boolean_false_node
;
4344 /* Otherwise, they may or may not be different. */
4347 else if (comp
== LT_EXPR
|| comp
== LE_EXPR
)
4351 /* If VR is to the left of VAL, return true. */
4352 tst
= compare_values_warnv (vr
->max
, val
, strict_overflow_p
);
4353 if ((comp
== LT_EXPR
&& tst
== -1)
4354 || (comp
== LE_EXPR
&& (tst
== -1 || tst
== 0)))
4355 return boolean_true_node
;
4357 /* If VR is to the right of VAL, return false. */
4358 tst
= compare_values_warnv (vr
->min
, val
, strict_overflow_p
);
4359 if ((comp
== LT_EXPR
&& (tst
== 0 || tst
== 1))
4360 || (comp
== LE_EXPR
&& tst
== 1))
4361 return boolean_false_node
;
4363 /* Otherwise, we don't know. */
4366 else if (comp
== GT_EXPR
|| comp
== GE_EXPR
)
4370 /* If VR is to the right of VAL, return true. */
4371 tst
= compare_values_warnv (vr
->min
, val
, strict_overflow_p
);
4372 if ((comp
== GT_EXPR
&& tst
== 1)
4373 || (comp
== GE_EXPR
&& (tst
== 0 || tst
== 1)))
4374 return boolean_true_node
;
4376 /* If VR is to the left of VAL, return false. */
4377 tst
= compare_values_warnv (vr
->max
, val
, strict_overflow_p
);
4378 if ((comp
== GT_EXPR
&& (tst
== -1 || tst
== 0))
4379 || (comp
== GE_EXPR
&& tst
== -1))
4380 return boolean_false_node
;
4382 /* Otherwise, we don't know. */
4390 /* Debugging dumps. */
4392 void dump_value_range (FILE *, const value_range
*);
4393 void debug_value_range (value_range
*);
4394 void dump_all_value_ranges (FILE *);
4395 void debug_all_value_ranges (void);
4396 void dump_vr_equiv (FILE *, bitmap
);
4397 void debug_vr_equiv (bitmap
);
4400 /* Dump value range VR to FILE. */
4403 dump_value_range (FILE *file
, const value_range
*vr
)
4406 fprintf (file
, "[]");
4407 else if (vr
->type
== VR_UNDEFINED
)
4408 fprintf (file
, "UNDEFINED");
4409 else if (vr
->type
== VR_RANGE
|| vr
->type
== VR_ANTI_RANGE
)
4411 tree type
= TREE_TYPE (vr
->min
);
4413 fprintf (file
, "%s[", (vr
->type
== VR_ANTI_RANGE
) ? "~" : "");
4415 if (INTEGRAL_TYPE_P (type
)
4416 && !TYPE_UNSIGNED (type
)
4417 && vrp_val_is_min (vr
->min
))
4418 fprintf (file
, "-INF");
4420 print_generic_expr (file
, vr
->min
);
4422 fprintf (file
, ", ");
4424 if (INTEGRAL_TYPE_P (type
)
4425 && vrp_val_is_max (vr
->max
))
4426 fprintf (file
, "+INF");
4428 print_generic_expr (file
, vr
->max
);
4430 fprintf (file
, "]");
4437 fprintf (file
, " EQUIVALENCES: { ");
4439 EXECUTE_IF_SET_IN_BITMAP (vr
->equiv
, 0, i
, bi
)
4441 print_generic_expr (file
, ssa_name (i
));
4442 fprintf (file
, " ");
4446 fprintf (file
, "} (%u elements)", c
);
4449 else if (vr
->type
== VR_VARYING
)
4450 fprintf (file
, "VARYING");
4452 fprintf (file
, "INVALID RANGE");
4456 /* Dump value range VR to stderr. */
4459 debug_value_range (value_range
*vr
)
4461 dump_value_range (stderr
, vr
);
4462 fprintf (stderr
, "\n");
4466 /* Dump value ranges of all SSA_NAMEs to FILE. */
4469 dump_all_value_ranges (FILE *file
)
4473 for (i
= 0; i
< num_vr_values
; i
++)
4477 print_generic_expr (file
, ssa_name (i
));
4478 fprintf (file
, ": ");
4479 dump_value_range (file
, vr_value
[i
]);
4480 fprintf (file
, "\n");
4484 fprintf (file
, "\n");
4488 /* Dump all value ranges to stderr. */
4491 debug_all_value_ranges (void)
4493 dump_all_value_ranges (stderr
);
4497 /* Given a COND_EXPR COND of the form 'V OP W', and an SSA name V,
4498 create a new SSA name N and return the assertion assignment
4499 'N = ASSERT_EXPR <V, V OP W>'. */
4502 build_assert_expr_for (tree cond
, tree v
)
4507 gcc_assert (TREE_CODE (v
) == SSA_NAME
4508 && COMPARISON_CLASS_P (cond
));
4510 a
= build2 (ASSERT_EXPR
, TREE_TYPE (v
), v
, cond
);
4511 assertion
= gimple_build_assign (NULL_TREE
, a
);
4513 /* The new ASSERT_EXPR, creates a new SSA name that replaces the
4514 operand of the ASSERT_EXPR. Create it so the new name and the old one
4515 are registered in the replacement table so that we can fix the SSA web
4516 after adding all the ASSERT_EXPRs. */
4517 create_new_def_for (v
, assertion
, NULL
);
4523 /* Return false if EXPR is a predicate expression involving floating
4527 fp_predicate (gimple
*stmt
)
4529 GIMPLE_CHECK (stmt
, GIMPLE_COND
);
4531 return FLOAT_TYPE_P (TREE_TYPE (gimple_cond_lhs (stmt
)));
4534 /* If the range of values taken by OP can be inferred after STMT executes,
4535 return the comparison code (COMP_CODE_P) and value (VAL_P) that
4536 describes the inferred range. Return true if a range could be
4540 infer_value_range (gimple
*stmt
, tree op
, tree_code
*comp_code_p
, tree
*val_p
)
4543 *comp_code_p
= ERROR_MARK
;
4545 /* Do not attempt to infer anything in names that flow through
4547 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (op
))
4550 /* If STMT is the last statement of a basic block with no normal
4551 successors, there is no point inferring anything about any of its
4552 operands. We would not be able to find a proper insertion point
4553 for the assertion, anyway. */
4554 if (stmt_ends_bb_p (stmt
))
4559 FOR_EACH_EDGE (e
, ei
, gimple_bb (stmt
)->succs
)
4560 if (!(e
->flags
& (EDGE_ABNORMAL
|EDGE_EH
)))
4566 if (infer_nonnull_range (stmt
, op
))
4568 *val_p
= build_int_cst (TREE_TYPE (op
), 0);
4569 *comp_code_p
= NE_EXPR
;
4577 void dump_asserts_for (FILE *, tree
);
4578 void debug_asserts_for (tree
);
4579 void dump_all_asserts (FILE *);
4580 void debug_all_asserts (void);
4582 /* Dump all the registered assertions for NAME to FILE. */
4585 dump_asserts_for (FILE *file
, tree name
)
4589 fprintf (file
, "Assertions to be inserted for ");
4590 print_generic_expr (file
, name
);
4591 fprintf (file
, "\n");
4593 loc
= asserts_for
[SSA_NAME_VERSION (name
)];
4596 fprintf (file
, "\t");
4597 print_gimple_stmt (file
, gsi_stmt (loc
->si
), 0);
4598 fprintf (file
, "\n\tBB #%d", loc
->bb
->index
);
4601 fprintf (file
, "\n\tEDGE %d->%d", loc
->e
->src
->index
,
4602 loc
->e
->dest
->index
);
4603 dump_edge_info (file
, loc
->e
, dump_flags
, 0);
4605 fprintf (file
, "\n\tPREDICATE: ");
4606 print_generic_expr (file
, loc
->expr
);
4607 fprintf (file
, " %s ", get_tree_code_name (loc
->comp_code
));
4608 print_generic_expr (file
, loc
->val
);
4609 fprintf (file
, "\n\n");
4613 fprintf (file
, "\n");
4617 /* Dump all the registered assertions for NAME to stderr. */
4620 debug_asserts_for (tree name
)
4622 dump_asserts_for (stderr
, name
);
4626 /* Dump all the registered assertions for all the names to FILE. */
4629 dump_all_asserts (FILE *file
)
4634 fprintf (file
, "\nASSERT_EXPRs to be inserted\n\n");
4635 EXECUTE_IF_SET_IN_BITMAP (need_assert_for
, 0, i
, bi
)
4636 dump_asserts_for (file
, ssa_name (i
));
4637 fprintf (file
, "\n");
4641 /* Dump all the registered assertions for all the names to stderr. */
4644 debug_all_asserts (void)
4646 dump_all_asserts (stderr
);
4649 /* Push the assert info for NAME, EXPR, COMP_CODE and VAL to ASSERTS. */
4652 add_assert_info (vec
<assert_info
> &asserts
,
4653 tree name
, tree expr
, enum tree_code comp_code
, tree val
)
4656 info
.comp_code
= comp_code
;
4660 asserts
.safe_push (info
);
4663 /* If NAME doesn't have an ASSERT_EXPR registered for asserting
4664 'EXPR COMP_CODE VAL' at a location that dominates block BB or
4665 E->DEST, then register this location as a possible insertion point
4666 for ASSERT_EXPR <NAME, EXPR COMP_CODE VAL>.
4668 BB, E and SI provide the exact insertion point for the new
4669 ASSERT_EXPR. If BB is NULL, then the ASSERT_EXPR is to be inserted
4670 on edge E. Otherwise, if E is NULL, the ASSERT_EXPR is inserted on
4671 BB. If SI points to a COND_EXPR or a SWITCH_EXPR statement, then E
4672 must not be NULL. */
4675 register_new_assert_for (tree name
, tree expr
,
4676 enum tree_code comp_code
,
4680 gimple_stmt_iterator si
)
4682 assert_locus
*n
, *loc
, *last_loc
;
4683 basic_block dest_bb
;
4685 gcc_checking_assert (bb
== NULL
|| e
== NULL
);
4688 gcc_checking_assert (gimple_code (gsi_stmt (si
)) != GIMPLE_COND
4689 && gimple_code (gsi_stmt (si
)) != GIMPLE_SWITCH
);
4691 /* Never build an assert comparing against an integer constant with
4692 TREE_OVERFLOW set. This confuses our undefined overflow warning
4694 if (TREE_OVERFLOW_P (val
))
4695 val
= drop_tree_overflow (val
);
4697 /* The new assertion A will be inserted at BB or E. We need to
4698 determine if the new location is dominated by a previously
4699 registered location for A. If we are doing an edge insertion,
4700 assume that A will be inserted at E->DEST. Note that this is not
4703 If E is a critical edge, it will be split. But even if E is
4704 split, the new block will dominate the same set of blocks that
4707 The reverse, however, is not true, blocks dominated by E->DEST
4708 will not be dominated by the new block created to split E. So,
4709 if the insertion location is on a critical edge, we will not use
4710 the new location to move another assertion previously registered
4711 at a block dominated by E->DEST. */
4712 dest_bb
= (bb
) ? bb
: e
->dest
;
4714 /* If NAME already has an ASSERT_EXPR registered for COMP_CODE and
4715 VAL at a block dominating DEST_BB, then we don't need to insert a new
4716 one. Similarly, if the same assertion already exists at a block
4717 dominated by DEST_BB and the new location is not on a critical
4718 edge, then update the existing location for the assertion (i.e.,
4719 move the assertion up in the dominance tree).
4721 Note, this is implemented as a simple linked list because there
4722 should not be more than a handful of assertions registered per
4723 name. If this becomes a performance problem, a table hashed by
4724 COMP_CODE and VAL could be implemented. */
4725 loc
= asserts_for
[SSA_NAME_VERSION (name
)];
4729 if (loc
->comp_code
== comp_code
4731 || operand_equal_p (loc
->val
, val
, 0))
4732 && (loc
->expr
== expr
4733 || operand_equal_p (loc
->expr
, expr
, 0)))
4735 /* If E is not a critical edge and DEST_BB
4736 dominates the existing location for the assertion, move
4737 the assertion up in the dominance tree by updating its
4738 location information. */
4739 if ((e
== NULL
|| !EDGE_CRITICAL_P (e
))
4740 && dominated_by_p (CDI_DOMINATORS
, loc
->bb
, dest_bb
))
4749 /* Update the last node of the list and move to the next one. */
4754 /* If we didn't find an assertion already registered for
4755 NAME COMP_CODE VAL, add a new one at the end of the list of
4756 assertions associated with NAME. */
4757 n
= XNEW (struct assert_locus
);
4761 n
->comp_code
= comp_code
;
4769 asserts_for
[SSA_NAME_VERSION (name
)] = n
;
4771 bitmap_set_bit (need_assert_for
, SSA_NAME_VERSION (name
));
4774 /* (COND_OP0 COND_CODE COND_OP1) is a predicate which uses NAME.
4775 Extract a suitable test code and value and store them into *CODE_P and
4776 *VAL_P so the predicate is normalized to NAME *CODE_P *VAL_P.
4778 If no extraction was possible, return FALSE, otherwise return TRUE.
4780 If INVERT is true, then we invert the result stored into *CODE_P. */
4783 extract_code_and_val_from_cond_with_ops (tree name
, enum tree_code cond_code
,
4784 tree cond_op0
, tree cond_op1
,
4785 bool invert
, enum tree_code
*code_p
,
4788 enum tree_code comp_code
;
4791 /* Otherwise, we have a comparison of the form NAME COMP VAL
4792 or VAL COMP NAME. */
4793 if (name
== cond_op1
)
4795 /* If the predicate is of the form VAL COMP NAME, flip
4796 COMP around because we need to register NAME as the
4797 first operand in the predicate. */
4798 comp_code
= swap_tree_comparison (cond_code
);
4801 else if (name
== cond_op0
)
4803 /* The comparison is of the form NAME COMP VAL, so the
4804 comparison code remains unchanged. */
4805 comp_code
= cond_code
;
4811 /* Invert the comparison code as necessary. */
4813 comp_code
= invert_tree_comparison (comp_code
, 0);
4815 /* VRP only handles integral and pointer types. */
4816 if (! INTEGRAL_TYPE_P (TREE_TYPE (val
))
4817 && ! POINTER_TYPE_P (TREE_TYPE (val
)))
4820 /* Do not register always-false predicates.
4821 FIXME: this works around a limitation in fold() when dealing with
4822 enumerations. Given 'enum { N1, N2 } x;', fold will not
4823 fold 'if (x > N2)' to 'if (0)'. */
4824 if ((comp_code
== GT_EXPR
|| comp_code
== LT_EXPR
)
4825 && INTEGRAL_TYPE_P (TREE_TYPE (val
)))
4827 tree min
= TYPE_MIN_VALUE (TREE_TYPE (val
));
4828 tree max
= TYPE_MAX_VALUE (TREE_TYPE (val
));
4830 if (comp_code
== GT_EXPR
4832 || compare_values (val
, max
) == 0))
4835 if (comp_code
== LT_EXPR
4837 || compare_values (val
, min
) == 0))
4840 *code_p
= comp_code
;
4845 /* Find out smallest RES where RES > VAL && (RES & MASK) == RES, if any
4846 (otherwise return VAL). VAL and MASK must be zero-extended for
4847 precision PREC. If SGNBIT is non-zero, first xor VAL with SGNBIT
4848 (to transform signed values into unsigned) and at the end xor
4852 masked_increment (const wide_int
&val_in
, const wide_int
&mask
,
4853 const wide_int
&sgnbit
, unsigned int prec
)
4855 wide_int bit
= wi::one (prec
), res
;
4858 wide_int val
= val_in
^ sgnbit
;
4859 for (i
= 0; i
< prec
; i
++, bit
+= bit
)
4862 if ((res
& bit
) == 0)
4865 res
= (val
+ bit
).and_not (res
);
4867 if (wi::gtu_p (res
, val
))
4868 return res
^ sgnbit
;
4870 return val
^ sgnbit
;
4873 /* Helper for overflow_comparison_p
4875 OP0 CODE OP1 is a comparison. Examine the comparison and potentially
4876 OP1's defining statement to see if it ultimately has the form
4877 OP0 CODE (OP0 PLUS INTEGER_CST)
4879 If so, return TRUE indicating this is an overflow test and store into
4880 *NEW_CST an updated constant that can be used in a narrowed range test.
4882 REVERSED indicates if the comparison was originally:
4886 This affects how we build the updated constant. */
4889 overflow_comparison_p_1 (enum tree_code code
, tree op0
, tree op1
,
4890 bool follow_assert_exprs
, bool reversed
, tree
*new_cst
)
4892 /* See if this is a relational operation between two SSA_NAMES with
4893 unsigned, overflow wrapping values. If so, check it more deeply. */
4894 if ((code
== LT_EXPR
|| code
== LE_EXPR
4895 || code
== GE_EXPR
|| code
== GT_EXPR
)
4896 && TREE_CODE (op0
) == SSA_NAME
4897 && TREE_CODE (op1
) == SSA_NAME
4898 && INTEGRAL_TYPE_P (TREE_TYPE (op0
))
4899 && TYPE_UNSIGNED (TREE_TYPE (op0
))
4900 && TYPE_OVERFLOW_WRAPS (TREE_TYPE (op0
)))
4902 gimple
*op1_def
= SSA_NAME_DEF_STMT (op1
);
4904 /* If requested, follow any ASSERT_EXPRs backwards for OP1. */
4905 if (follow_assert_exprs
)
4907 while (gimple_assign_single_p (op1_def
)
4908 && TREE_CODE (gimple_assign_rhs1 (op1_def
)) == ASSERT_EXPR
)
4910 op1
= TREE_OPERAND (gimple_assign_rhs1 (op1_def
), 0);
4911 if (TREE_CODE (op1
) != SSA_NAME
)
4913 op1_def
= SSA_NAME_DEF_STMT (op1
);
4917 /* Now look at the defining statement of OP1 to see if it adds
4918 or subtracts a nonzero constant from another operand. */
4920 && is_gimple_assign (op1_def
)
4921 && gimple_assign_rhs_code (op1_def
) == PLUS_EXPR
4922 && TREE_CODE (gimple_assign_rhs2 (op1_def
)) == INTEGER_CST
4923 && !integer_zerop (gimple_assign_rhs2 (op1_def
)))
4925 tree target
= gimple_assign_rhs1 (op1_def
);
4927 /* If requested, follow ASSERT_EXPRs backwards for op0 looking
4928 for one where TARGET appears on the RHS. */
4929 if (follow_assert_exprs
)
4931 /* Now see if that "other operand" is op0, following the chain
4932 of ASSERT_EXPRs if necessary. */
4933 gimple
*op0_def
= SSA_NAME_DEF_STMT (op0
);
4934 while (op0
!= target
4935 && gimple_assign_single_p (op0_def
)
4936 && TREE_CODE (gimple_assign_rhs1 (op0_def
)) == ASSERT_EXPR
)
4938 op0
= TREE_OPERAND (gimple_assign_rhs1 (op0_def
), 0);
4939 if (TREE_CODE (op0
) != SSA_NAME
)
4941 op0_def
= SSA_NAME_DEF_STMT (op0
);
4945 /* If we did not find our target SSA_NAME, then this is not
4946 an overflow test. */
4950 tree type
= TREE_TYPE (op0
);
4951 wide_int max
= wi::max_value (TYPE_PRECISION (type
), UNSIGNED
);
4952 tree inc
= gimple_assign_rhs2 (op1_def
);
4954 *new_cst
= wide_int_to_tree (type
, max
+ inc
);
4956 *new_cst
= wide_int_to_tree (type
, max
- inc
);
4963 /* OP0 CODE OP1 is a comparison. Examine the comparison and potentially
4964 OP1's defining statement to see if it ultimately has the form
4965 OP0 CODE (OP0 PLUS INTEGER_CST)
4967 If so, return TRUE indicating this is an overflow test and store into
4968 *NEW_CST an updated constant that can be used in a narrowed range test.
4970 These statements are left as-is in the IL to facilitate discovery of
4971 {ADD,SUB}_OVERFLOW sequences later in the optimizer pipeline. But
4972 the alternate range representation is often useful within VRP. */
4975 overflow_comparison_p (tree_code code
, tree name
, tree val
,
4976 bool use_equiv_p
, tree
*new_cst
)
4978 if (overflow_comparison_p_1 (code
, name
, val
, use_equiv_p
, false, new_cst
))
4980 return overflow_comparison_p_1 (swap_tree_comparison (code
), val
, name
,
4981 use_equiv_p
, true, new_cst
);
4985 /* Try to register an edge assertion for SSA name NAME on edge E for
4986 the condition COND contributing to the conditional jump pointed to by BSI.
4987 Invert the condition COND if INVERT is true. */
4990 register_edge_assert_for_2 (tree name
, edge e
,
4991 enum tree_code cond_code
,
4992 tree cond_op0
, tree cond_op1
, bool invert
,
4993 vec
<assert_info
> &asserts
)
4996 enum tree_code comp_code
;
4998 if (!extract_code_and_val_from_cond_with_ops (name
, cond_code
,
5001 invert
, &comp_code
, &val
))
5004 /* Queue the assert. */
5006 if (overflow_comparison_p (comp_code
, name
, val
, false, &x
))
5008 enum tree_code new_code
= ((comp_code
== GT_EXPR
|| comp_code
== GE_EXPR
)
5009 ? GT_EXPR
: LE_EXPR
);
5010 add_assert_info (asserts
, name
, name
, new_code
, x
);
5012 add_assert_info (asserts
, name
, name
, comp_code
, val
);
5014 /* In the case of NAME <= CST and NAME being defined as
5015 NAME = (unsigned) NAME2 + CST2 we can assert NAME2 >= -CST2
5016 and NAME2 <= CST - CST2. We can do the same for NAME > CST.
5017 This catches range and anti-range tests. */
5018 if ((comp_code
== LE_EXPR
5019 || comp_code
== GT_EXPR
)
5020 && TREE_CODE (val
) == INTEGER_CST
5021 && TYPE_UNSIGNED (TREE_TYPE (val
)))
5023 gimple
*def_stmt
= SSA_NAME_DEF_STMT (name
);
5024 tree cst2
= NULL_TREE
, name2
= NULL_TREE
, name3
= NULL_TREE
;
5026 /* Extract CST2 from the (optional) addition. */
5027 if (is_gimple_assign (def_stmt
)
5028 && gimple_assign_rhs_code (def_stmt
) == PLUS_EXPR
)
5030 name2
= gimple_assign_rhs1 (def_stmt
);
5031 cst2
= gimple_assign_rhs2 (def_stmt
);
5032 if (TREE_CODE (name2
) == SSA_NAME
5033 && TREE_CODE (cst2
) == INTEGER_CST
)
5034 def_stmt
= SSA_NAME_DEF_STMT (name2
);
5037 /* Extract NAME2 from the (optional) sign-changing cast. */
5038 if (gimple_assign_cast_p (def_stmt
))
5040 if (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def_stmt
))
5041 && ! TYPE_UNSIGNED (TREE_TYPE (gimple_assign_rhs1 (def_stmt
)))
5042 && (TYPE_PRECISION (gimple_expr_type (def_stmt
))
5043 == TYPE_PRECISION (TREE_TYPE (gimple_assign_rhs1 (def_stmt
)))))
5044 name3
= gimple_assign_rhs1 (def_stmt
);
5047 /* If name3 is used later, create an ASSERT_EXPR for it. */
5048 if (name3
!= NULL_TREE
5049 && TREE_CODE (name3
) == SSA_NAME
5050 && (cst2
== NULL_TREE
5051 || TREE_CODE (cst2
) == INTEGER_CST
)
5052 && INTEGRAL_TYPE_P (TREE_TYPE (name3
)))
5056 /* Build an expression for the range test. */
5057 tmp
= build1 (NOP_EXPR
, TREE_TYPE (name
), name3
);
5058 if (cst2
!= NULL_TREE
)
5059 tmp
= build2 (PLUS_EXPR
, TREE_TYPE (name
), tmp
, cst2
);
5063 fprintf (dump_file
, "Adding assert for ");
5064 print_generic_expr (dump_file
, name3
);
5065 fprintf (dump_file
, " from ");
5066 print_generic_expr (dump_file
, tmp
);
5067 fprintf (dump_file
, "\n");
5070 add_assert_info (asserts
, name3
, tmp
, comp_code
, val
);
5073 /* If name2 is used later, create an ASSERT_EXPR for it. */
5074 if (name2
!= NULL_TREE
5075 && TREE_CODE (name2
) == SSA_NAME
5076 && TREE_CODE (cst2
) == INTEGER_CST
5077 && INTEGRAL_TYPE_P (TREE_TYPE (name2
)))
5081 /* Build an expression for the range test. */
5083 if (TREE_TYPE (name
) != TREE_TYPE (name2
))
5084 tmp
= build1 (NOP_EXPR
, TREE_TYPE (name
), tmp
);
5085 if (cst2
!= NULL_TREE
)
5086 tmp
= build2 (PLUS_EXPR
, TREE_TYPE (name
), tmp
, cst2
);
5090 fprintf (dump_file
, "Adding assert for ");
5091 print_generic_expr (dump_file
, name2
);
5092 fprintf (dump_file
, " from ");
5093 print_generic_expr (dump_file
, tmp
);
5094 fprintf (dump_file
, "\n");
5097 add_assert_info (asserts
, name2
, tmp
, comp_code
, val
);
5101 /* In the case of post-in/decrement tests like if (i++) ... and uses
5102 of the in/decremented value on the edge the extra name we want to
5103 assert for is not on the def chain of the name compared. Instead
5104 it is in the set of use stmts.
5105 Similar cases happen for conversions that were simplified through
5106 fold_{sign_changed,widened}_comparison. */
5107 if ((comp_code
== NE_EXPR
5108 || comp_code
== EQ_EXPR
)
5109 && TREE_CODE (val
) == INTEGER_CST
)
5111 imm_use_iterator ui
;
5113 FOR_EACH_IMM_USE_STMT (use_stmt
, ui
, name
)
5115 if (!is_gimple_assign (use_stmt
))
5118 /* Cut off to use-stmts that are dominating the predecessor. */
5119 if (!dominated_by_p (CDI_DOMINATORS
, e
->src
, gimple_bb (use_stmt
)))
5122 tree name2
= gimple_assign_lhs (use_stmt
);
5123 if (TREE_CODE (name2
) != SSA_NAME
)
5126 enum tree_code code
= gimple_assign_rhs_code (use_stmt
);
5128 if (code
== PLUS_EXPR
5129 || code
== MINUS_EXPR
)
5131 cst
= gimple_assign_rhs2 (use_stmt
);
5132 if (TREE_CODE (cst
) != INTEGER_CST
)
5134 cst
= int_const_binop (code
, val
, cst
);
5136 else if (CONVERT_EXPR_CODE_P (code
))
5138 /* For truncating conversions we cannot record
5140 if (comp_code
== NE_EXPR
5141 && (TYPE_PRECISION (TREE_TYPE (name2
))
5142 < TYPE_PRECISION (TREE_TYPE (name
))))
5144 cst
= fold_convert (TREE_TYPE (name2
), val
);
5149 if (TREE_OVERFLOW_P (cst
))
5150 cst
= drop_tree_overflow (cst
);
5151 add_assert_info (asserts
, name2
, name2
, comp_code
, cst
);
5155 if (TREE_CODE_CLASS (comp_code
) == tcc_comparison
5156 && TREE_CODE (val
) == INTEGER_CST
)
5158 gimple
*def_stmt
= SSA_NAME_DEF_STMT (name
);
5159 tree name2
= NULL_TREE
, names
[2], cst2
= NULL_TREE
;
5160 tree val2
= NULL_TREE
;
5161 unsigned int prec
= TYPE_PRECISION (TREE_TYPE (val
));
5162 wide_int mask
= wi::zero (prec
);
5163 unsigned int nprec
= prec
;
5164 enum tree_code rhs_code
= ERROR_MARK
;
5166 if (is_gimple_assign (def_stmt
))
5167 rhs_code
= gimple_assign_rhs_code (def_stmt
);
5169 /* In the case of NAME != CST1 where NAME = A +- CST2 we can
5170 assert that A != CST1 -+ CST2. */
5171 if ((comp_code
== EQ_EXPR
|| comp_code
== NE_EXPR
)
5172 && (rhs_code
== PLUS_EXPR
|| rhs_code
== MINUS_EXPR
))
5174 tree op0
= gimple_assign_rhs1 (def_stmt
);
5175 tree op1
= gimple_assign_rhs2 (def_stmt
);
5176 if (TREE_CODE (op0
) == SSA_NAME
5177 && TREE_CODE (op1
) == INTEGER_CST
)
5179 enum tree_code reverse_op
= (rhs_code
== PLUS_EXPR
5180 ? MINUS_EXPR
: PLUS_EXPR
);
5181 op1
= int_const_binop (reverse_op
, val
, op1
);
5182 if (TREE_OVERFLOW (op1
))
5183 op1
= drop_tree_overflow (op1
);
5184 add_assert_info (asserts
, op0
, op0
, comp_code
, op1
);
5188 /* Add asserts for NAME cmp CST and NAME being defined
5189 as NAME = (int) NAME2. */
5190 if (!TYPE_UNSIGNED (TREE_TYPE (val
))
5191 && (comp_code
== LE_EXPR
|| comp_code
== LT_EXPR
5192 || comp_code
== GT_EXPR
|| comp_code
== GE_EXPR
)
5193 && gimple_assign_cast_p (def_stmt
))
5195 name2
= gimple_assign_rhs1 (def_stmt
);
5196 if (CONVERT_EXPR_CODE_P (rhs_code
)
5197 && INTEGRAL_TYPE_P (TREE_TYPE (name2
))
5198 && TYPE_UNSIGNED (TREE_TYPE (name2
))
5199 && prec
== TYPE_PRECISION (TREE_TYPE (name2
))
5200 && (comp_code
== LE_EXPR
|| comp_code
== GT_EXPR
5201 || !tree_int_cst_equal (val
,
5202 TYPE_MIN_VALUE (TREE_TYPE (val
)))))
5205 enum tree_code new_comp_code
= comp_code
;
5207 cst
= fold_convert (TREE_TYPE (name2
),
5208 TYPE_MIN_VALUE (TREE_TYPE (val
)));
5209 /* Build an expression for the range test. */
5210 tmp
= build2 (PLUS_EXPR
, TREE_TYPE (name2
), name2
, cst
);
5211 cst
= fold_build2 (PLUS_EXPR
, TREE_TYPE (name2
), cst
,
5212 fold_convert (TREE_TYPE (name2
), val
));
5213 if (comp_code
== LT_EXPR
|| comp_code
== GE_EXPR
)
5215 new_comp_code
= comp_code
== LT_EXPR
? LE_EXPR
: GT_EXPR
;
5216 cst
= fold_build2 (MINUS_EXPR
, TREE_TYPE (name2
), cst
,
5217 build_int_cst (TREE_TYPE (name2
), 1));
5222 fprintf (dump_file
, "Adding assert for ");
5223 print_generic_expr (dump_file
, name2
);
5224 fprintf (dump_file
, " from ");
5225 print_generic_expr (dump_file
, tmp
);
5226 fprintf (dump_file
, "\n");
5229 add_assert_info (asserts
, name2
, tmp
, new_comp_code
, cst
);
5233 /* Add asserts for NAME cmp CST and NAME being defined as
5234 NAME = NAME2 >> CST2.
5236 Extract CST2 from the right shift. */
5237 if (rhs_code
== RSHIFT_EXPR
)
5239 name2
= gimple_assign_rhs1 (def_stmt
);
5240 cst2
= gimple_assign_rhs2 (def_stmt
);
5241 if (TREE_CODE (name2
) == SSA_NAME
5242 && tree_fits_uhwi_p (cst2
)
5243 && INTEGRAL_TYPE_P (TREE_TYPE (name2
))
5244 && IN_RANGE (tree_to_uhwi (cst2
), 1, prec
- 1)
5245 && prec
== GET_MODE_PRECISION (TYPE_MODE (TREE_TYPE (val
))))
5247 mask
= wi::mask (tree_to_uhwi (cst2
), false, prec
);
5248 val2
= fold_binary (LSHIFT_EXPR
, TREE_TYPE (val
), val
, cst2
);
5251 if (val2
!= NULL_TREE
5252 && TREE_CODE (val2
) == INTEGER_CST
5253 && simple_cst_equal (fold_build2 (RSHIFT_EXPR
,
5257 enum tree_code new_comp_code
= comp_code
;
5261 if (comp_code
== EQ_EXPR
|| comp_code
== NE_EXPR
)
5263 if (!TYPE_UNSIGNED (TREE_TYPE (val
)))
5265 tree type
= build_nonstandard_integer_type (prec
, 1);
5266 tmp
= build1 (NOP_EXPR
, type
, name2
);
5267 val2
= fold_convert (type
, val2
);
5269 tmp
= fold_build2 (MINUS_EXPR
, TREE_TYPE (tmp
), tmp
, val2
);
5270 new_val
= wide_int_to_tree (TREE_TYPE (tmp
), mask
);
5271 new_comp_code
= comp_code
== EQ_EXPR
? LE_EXPR
: GT_EXPR
;
5273 else if (comp_code
== LT_EXPR
|| comp_code
== GE_EXPR
)
5276 = wi::min_value (prec
, TYPE_SIGN (TREE_TYPE (val
)));
5278 if (minval
== new_val
)
5279 new_val
= NULL_TREE
;
5284 = wi::max_value (prec
, TYPE_SIGN (TREE_TYPE (val
)));
5287 new_val
= NULL_TREE
;
5289 new_val
= wide_int_to_tree (TREE_TYPE (val2
), mask
);
5296 fprintf (dump_file
, "Adding assert for ");
5297 print_generic_expr (dump_file
, name2
);
5298 fprintf (dump_file
, " from ");
5299 print_generic_expr (dump_file
, tmp
);
5300 fprintf (dump_file
, "\n");
5303 add_assert_info (asserts
, name2
, tmp
, new_comp_code
, new_val
);
5307 /* Add asserts for NAME cmp CST and NAME being defined as
5308 NAME = NAME2 & CST2.
5310 Extract CST2 from the and.
5313 NAME = (unsigned) NAME2;
5314 casts where NAME's type is unsigned and has smaller precision
5315 than NAME2's type as if it was NAME = NAME2 & MASK. */
5316 names
[0] = NULL_TREE
;
5317 names
[1] = NULL_TREE
;
5319 if (rhs_code
== BIT_AND_EXPR
5320 || (CONVERT_EXPR_CODE_P (rhs_code
)
5321 && INTEGRAL_TYPE_P (TREE_TYPE (val
))
5322 && TYPE_UNSIGNED (TREE_TYPE (val
))
5323 && TYPE_PRECISION (TREE_TYPE (gimple_assign_rhs1 (def_stmt
)))
5326 name2
= gimple_assign_rhs1 (def_stmt
);
5327 if (rhs_code
== BIT_AND_EXPR
)
5328 cst2
= gimple_assign_rhs2 (def_stmt
);
5331 cst2
= TYPE_MAX_VALUE (TREE_TYPE (val
));
5332 nprec
= TYPE_PRECISION (TREE_TYPE (name2
));
5334 if (TREE_CODE (name2
) == SSA_NAME
5335 && INTEGRAL_TYPE_P (TREE_TYPE (name2
))
5336 && TREE_CODE (cst2
) == INTEGER_CST
5337 && !integer_zerop (cst2
)
5339 || TYPE_UNSIGNED (TREE_TYPE (val
))))
5341 gimple
*def_stmt2
= SSA_NAME_DEF_STMT (name2
);
5342 if (gimple_assign_cast_p (def_stmt2
))
5344 names
[1] = gimple_assign_rhs1 (def_stmt2
);
5345 if (!CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def_stmt2
))
5346 || !INTEGRAL_TYPE_P (TREE_TYPE (names
[1]))
5347 || (TYPE_PRECISION (TREE_TYPE (name2
))
5348 != TYPE_PRECISION (TREE_TYPE (names
[1]))))
5349 names
[1] = NULL_TREE
;
5354 if (names
[0] || names
[1])
5356 wide_int minv
, maxv
, valv
, cst2v
;
5357 wide_int tem
, sgnbit
;
5358 bool valid_p
= false, valn
, cst2n
;
5359 enum tree_code ccode
= comp_code
;
5361 valv
= wide_int::from (val
, nprec
, UNSIGNED
);
5362 cst2v
= wide_int::from (cst2
, nprec
, UNSIGNED
);
5363 valn
= wi::neg_p (valv
, TYPE_SIGN (TREE_TYPE (val
)));
5364 cst2n
= wi::neg_p (cst2v
, TYPE_SIGN (TREE_TYPE (val
)));
5365 /* If CST2 doesn't have most significant bit set,
5366 but VAL is negative, we have comparison like
5367 if ((x & 0x123) > -4) (always true). Just give up. */
5371 sgnbit
= wi::set_bit_in_zero (nprec
- 1, nprec
);
5373 sgnbit
= wi::zero (nprec
);
5374 minv
= valv
& cst2v
;
5378 /* Minimum unsigned value for equality is VAL & CST2
5379 (should be equal to VAL, otherwise we probably should
5380 have folded the comparison into false) and
5381 maximum unsigned value is VAL | ~CST2. */
5382 maxv
= valv
| ~cst2v
;
5387 tem
= valv
| ~cst2v
;
5388 /* If VAL is 0, handle (X & CST2) != 0 as (X & CST2) > 0U. */
5392 sgnbit
= wi::zero (nprec
);
5395 /* If (VAL | ~CST2) is all ones, handle it as
5396 (X & CST2) < VAL. */
5401 sgnbit
= wi::zero (nprec
);
5404 if (!cst2n
&& wi::neg_p (cst2v
))
5405 sgnbit
= wi::set_bit_in_zero (nprec
- 1, nprec
);
5414 if (tem
== wi::mask (nprec
- 1, false, nprec
))
5420 sgnbit
= wi::zero (nprec
);
5425 /* Minimum unsigned value for >= if (VAL & CST2) == VAL
5426 is VAL and maximum unsigned value is ~0. For signed
5427 comparison, if CST2 doesn't have most significant bit
5428 set, handle it similarly. If CST2 has MSB set,
5429 the minimum is the same, and maximum is ~0U/2. */
5432 /* If (VAL & CST2) != VAL, X & CST2 can't be equal to
5434 minv
= masked_increment (valv
, cst2v
, sgnbit
, nprec
);
5438 maxv
= wi::mask (nprec
- (cst2n
? 1 : 0), false, nprec
);
5444 /* Find out smallest MINV where MINV > VAL
5445 && (MINV & CST2) == MINV, if any. If VAL is signed and
5446 CST2 has MSB set, compute it biased by 1 << (nprec - 1). */
5447 minv
= masked_increment (valv
, cst2v
, sgnbit
, nprec
);
5450 maxv
= wi::mask (nprec
- (cst2n
? 1 : 0), false, nprec
);
5455 /* Minimum unsigned value for <= is 0 and maximum
5456 unsigned value is VAL | ~CST2 if (VAL & CST2) == VAL.
5457 Otherwise, find smallest VAL2 where VAL2 > VAL
5458 && (VAL2 & CST2) == VAL2 and use (VAL2 - 1) | ~CST2
5460 For signed comparison, if CST2 doesn't have most
5461 significant bit set, handle it similarly. If CST2 has
5462 MSB set, the maximum is the same and minimum is INT_MIN. */
5467 maxv
= masked_increment (valv
, cst2v
, sgnbit
, nprec
);
5479 /* Minimum unsigned value for < is 0 and maximum
5480 unsigned value is (VAL-1) | ~CST2 if (VAL & CST2) == VAL.
5481 Otherwise, find smallest VAL2 where VAL2 > VAL
5482 && (VAL2 & CST2) == VAL2 and use (VAL2 - 1) | ~CST2
5484 For signed comparison, if CST2 doesn't have most
5485 significant bit set, handle it similarly. If CST2 has
5486 MSB set, the maximum is the same and minimum is INT_MIN. */
5495 maxv
= masked_increment (valv
, cst2v
, sgnbit
, nprec
);
5509 && (maxv
- minv
) != -1)
5511 tree tmp
, new_val
, type
;
5514 for (i
= 0; i
< 2; i
++)
5517 wide_int maxv2
= maxv
;
5519 type
= TREE_TYPE (names
[i
]);
5520 if (!TYPE_UNSIGNED (type
))
5522 type
= build_nonstandard_integer_type (nprec
, 1);
5523 tmp
= build1 (NOP_EXPR
, type
, names
[i
]);
5527 tmp
= build2 (PLUS_EXPR
, type
, tmp
,
5528 wide_int_to_tree (type
, -minv
));
5529 maxv2
= maxv
- minv
;
5531 new_val
= wide_int_to_tree (type
, maxv2
);
5535 fprintf (dump_file
, "Adding assert for ");
5536 print_generic_expr (dump_file
, names
[i
]);
5537 fprintf (dump_file
, " from ");
5538 print_generic_expr (dump_file
, tmp
);
5539 fprintf (dump_file
, "\n");
5542 add_assert_info (asserts
, names
[i
], tmp
, LE_EXPR
, new_val
);
5549 /* OP is an operand of a truth value expression which is known to have
5550 a particular value. Register any asserts for OP and for any
5551 operands in OP's defining statement.
5553 If CODE is EQ_EXPR, then we want to register OP is zero (false),
5554 if CODE is NE_EXPR, then we want to register OP is nonzero (true). */
5557 register_edge_assert_for_1 (tree op
, enum tree_code code
,
5558 edge e
, vec
<assert_info
> &asserts
)
5562 enum tree_code rhs_code
;
5564 /* We only care about SSA_NAMEs. */
5565 if (TREE_CODE (op
) != SSA_NAME
)
5568 /* We know that OP will have a zero or nonzero value. */
5569 val
= build_int_cst (TREE_TYPE (op
), 0);
5570 add_assert_info (asserts
, op
, op
, code
, val
);
5572 /* Now look at how OP is set. If it's set from a comparison,
5573 a truth operation or some bit operations, then we may be able
5574 to register information about the operands of that assignment. */
5575 op_def
= SSA_NAME_DEF_STMT (op
);
5576 if (gimple_code (op_def
) != GIMPLE_ASSIGN
)
5579 rhs_code
= gimple_assign_rhs_code (op_def
);
5581 if (TREE_CODE_CLASS (rhs_code
) == tcc_comparison
)
5583 bool invert
= (code
== EQ_EXPR
? true : false);
5584 tree op0
= gimple_assign_rhs1 (op_def
);
5585 tree op1
= gimple_assign_rhs2 (op_def
);
5587 if (TREE_CODE (op0
) == SSA_NAME
)
5588 register_edge_assert_for_2 (op0
, e
, rhs_code
, op0
, op1
, invert
, asserts
);
5589 if (TREE_CODE (op1
) == SSA_NAME
)
5590 register_edge_assert_for_2 (op1
, e
, rhs_code
, op0
, op1
, invert
, asserts
);
5592 else if ((code
== NE_EXPR
5593 && gimple_assign_rhs_code (op_def
) == BIT_AND_EXPR
)
5595 && gimple_assign_rhs_code (op_def
) == BIT_IOR_EXPR
))
5597 /* Recurse on each operand. */
5598 tree op0
= gimple_assign_rhs1 (op_def
);
5599 tree op1
= gimple_assign_rhs2 (op_def
);
5600 if (TREE_CODE (op0
) == SSA_NAME
5601 && has_single_use (op0
))
5602 register_edge_assert_for_1 (op0
, code
, e
, asserts
);
5603 if (TREE_CODE (op1
) == SSA_NAME
5604 && has_single_use (op1
))
5605 register_edge_assert_for_1 (op1
, code
, e
, asserts
);
5607 else if (gimple_assign_rhs_code (op_def
) == BIT_NOT_EXPR
5608 && TYPE_PRECISION (TREE_TYPE (gimple_assign_lhs (op_def
))) == 1)
5610 /* Recurse, flipping CODE. */
5611 code
= invert_tree_comparison (code
, false);
5612 register_edge_assert_for_1 (gimple_assign_rhs1 (op_def
), code
, e
, asserts
);
5614 else if (gimple_assign_rhs_code (op_def
) == SSA_NAME
)
5616 /* Recurse through the copy. */
5617 register_edge_assert_for_1 (gimple_assign_rhs1 (op_def
), code
, e
, asserts
);
5619 else if (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (op_def
)))
5621 /* Recurse through the type conversion, unless it is a narrowing
5622 conversion or conversion from non-integral type. */
5623 tree rhs
= gimple_assign_rhs1 (op_def
);
5624 if (INTEGRAL_TYPE_P (TREE_TYPE (rhs
))
5625 && (TYPE_PRECISION (TREE_TYPE (rhs
))
5626 <= TYPE_PRECISION (TREE_TYPE (op
))))
5627 register_edge_assert_for_1 (rhs
, code
, e
, asserts
);
5631 /* Check if comparison
5632 NAME COND_OP INTEGER_CST
5634 (X & 11...100..0) COND_OP XX...X00...0
5635 Such comparison can yield assertions like
5638 in case of COND_OP being NE_EXPR or
5641 in case of EQ_EXPR. */
5644 is_masked_range_test (tree name
, tree valt
, enum tree_code cond_code
,
5645 tree
*new_name
, tree
*low
, enum tree_code
*low_code
,
5646 tree
*high
, enum tree_code
*high_code
)
5648 gimple
*def_stmt
= SSA_NAME_DEF_STMT (name
);
5650 if (!is_gimple_assign (def_stmt
)
5651 || gimple_assign_rhs_code (def_stmt
) != BIT_AND_EXPR
)
5654 tree maskt
= gimple_assign_rhs2 (def_stmt
);
5655 if (TREE_CODE (maskt
) != INTEGER_CST
)
5658 wide_int mask
= maskt
;
5659 wide_int inv_mask
= ~mask
;
5660 wide_int val
= valt
; // Assume VALT is INTEGER_CST
5662 if ((inv_mask
& (inv_mask
+ 1)) != 0
5663 || (val
& mask
) != val
)
5666 tree t
= gimple_assign_rhs1 (def_stmt
);
5667 tree type
= TREE_TYPE (t
);
5669 bool is_range
= cond_code
== EQ_EXPR
;
5671 wide_int min
= wi::min_value (type
),
5672 max
= wi::max_value (type
);
5676 *low_code
= val
== min
? ERROR_MARK
: GE_EXPR
;
5677 *high_code
= val
== max
? ERROR_MARK
: LE_EXPR
;
5681 /* We can still generate assertion if one of alternatives
5682 is known to always be false. */
5685 *low_code
= (enum tree_code
) 0;
5686 *high_code
= GT_EXPR
;
5688 else if ((val
| inv_mask
) == max
)
5690 *low_code
= LT_EXPR
;
5691 *high_code
= (enum tree_code
) 0;
5698 *low
= wide_int_to_tree (type
, val
);
5699 *high
= wide_int_to_tree (type
, val
| inv_mask
);
5701 if (wi::neg_p (val
, TYPE_SIGN (type
)))
5702 std::swap (*low
, *high
);
5707 /* Try to register an edge assertion for SSA name NAME on edge E for
5708 the condition COND contributing to the conditional jump pointed to by
5712 register_edge_assert_for (tree name
, edge e
,
5713 enum tree_code cond_code
, tree cond_op0
,
5714 tree cond_op1
, vec
<assert_info
> &asserts
)
5717 enum tree_code comp_code
;
5718 bool is_else_edge
= (e
->flags
& EDGE_FALSE_VALUE
) != 0;
5720 /* Do not attempt to infer anything in names that flow through
5722 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name
))
5725 if (!extract_code_and_val_from_cond_with_ops (name
, cond_code
,
5731 /* Register ASSERT_EXPRs for name. */
5732 register_edge_assert_for_2 (name
, e
, cond_code
, cond_op0
,
5733 cond_op1
, is_else_edge
, asserts
);
5736 /* If COND is effectively an equality test of an SSA_NAME against
5737 the value zero or one, then we may be able to assert values
5738 for SSA_NAMEs which flow into COND. */
5740 /* In the case of NAME == 1 or NAME != 0, for BIT_AND_EXPR defining
5741 statement of NAME we can assert both operands of the BIT_AND_EXPR
5742 have nonzero value. */
5743 if (((comp_code
== EQ_EXPR
&& integer_onep (val
))
5744 || (comp_code
== NE_EXPR
&& integer_zerop (val
))))
5746 gimple
*def_stmt
= SSA_NAME_DEF_STMT (name
);
5748 if (is_gimple_assign (def_stmt
)
5749 && gimple_assign_rhs_code (def_stmt
) == BIT_AND_EXPR
)
5751 tree op0
= gimple_assign_rhs1 (def_stmt
);
5752 tree op1
= gimple_assign_rhs2 (def_stmt
);
5753 register_edge_assert_for_1 (op0
, NE_EXPR
, e
, asserts
);
5754 register_edge_assert_for_1 (op1
, NE_EXPR
, e
, asserts
);
5758 /* In the case of NAME == 0 or NAME != 1, for BIT_IOR_EXPR defining
5759 statement of NAME we can assert both operands of the BIT_IOR_EXPR
5761 if (((comp_code
== EQ_EXPR
&& integer_zerop (val
))
5762 || (comp_code
== NE_EXPR
&& integer_onep (val
))))
5764 gimple
*def_stmt
= SSA_NAME_DEF_STMT (name
);
5766 /* For BIT_IOR_EXPR only if NAME == 0 both operands have
5767 necessarily zero value, or if type-precision is one. */
5768 if (is_gimple_assign (def_stmt
)
5769 && (gimple_assign_rhs_code (def_stmt
) == BIT_IOR_EXPR
5770 && (TYPE_PRECISION (TREE_TYPE (name
)) == 1
5771 || comp_code
== EQ_EXPR
)))
5773 tree op0
= gimple_assign_rhs1 (def_stmt
);
5774 tree op1
= gimple_assign_rhs2 (def_stmt
);
5775 register_edge_assert_for_1 (op0
, EQ_EXPR
, e
, asserts
);
5776 register_edge_assert_for_1 (op1
, EQ_EXPR
, e
, asserts
);
5780 /* Sometimes we can infer ranges from (NAME & MASK) == VALUE. */
5781 if ((comp_code
== EQ_EXPR
|| comp_code
== NE_EXPR
)
5782 && TREE_CODE (val
) == INTEGER_CST
)
5784 enum tree_code low_code
, high_code
;
5786 if (is_masked_range_test (name
, val
, comp_code
, &name
, &low
,
5787 &low_code
, &high
, &high_code
))
5789 if (low_code
!= ERROR_MARK
)
5790 register_edge_assert_for_2 (name
, e
, low_code
, name
,
5791 low
, /*invert*/false, asserts
);
5792 if (high_code
!= ERROR_MARK
)
5793 register_edge_assert_for_2 (name
, e
, high_code
, name
,
5794 high
, /*invert*/false, asserts
);
5799 /* Finish found ASSERTS for E and register them at GSI. */
5802 finish_register_edge_assert_for (edge e
, gimple_stmt_iterator gsi
,
5803 vec
<assert_info
> &asserts
)
5805 for (unsigned i
= 0; i
< asserts
.length (); ++i
)
5806 /* Only register an ASSERT_EXPR if NAME was found in the sub-graph
5807 reachable from E. */
5808 if (live_on_edge (e
, asserts
[i
].name
))
5809 register_new_assert_for (asserts
[i
].name
, asserts
[i
].expr
,
5810 asserts
[i
].comp_code
, asserts
[i
].val
,
5816 /* Determine whether the outgoing edges of BB should receive an
5817 ASSERT_EXPR for each of the operands of BB's LAST statement.
5818 The last statement of BB must be a COND_EXPR.
5820 If any of the sub-graphs rooted at BB have an interesting use of
5821 the predicate operands, an assert location node is added to the
5822 list of assertions for the corresponding operands. */
5825 find_conditional_asserts (basic_block bb
, gcond
*last
)
5827 gimple_stmt_iterator bsi
;
5833 bsi
= gsi_for_stmt (last
);
5835 /* Look for uses of the operands in each of the sub-graphs
5836 rooted at BB. We need to check each of the outgoing edges
5837 separately, so that we know what kind of ASSERT_EXPR to
5839 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
5844 /* Register the necessary assertions for each operand in the
5845 conditional predicate. */
5846 auto_vec
<assert_info
, 8> asserts
;
5847 FOR_EACH_SSA_TREE_OPERAND (op
, last
, iter
, SSA_OP_USE
)
5848 register_edge_assert_for (op
, e
,
5849 gimple_cond_code (last
),
5850 gimple_cond_lhs (last
),
5851 gimple_cond_rhs (last
), asserts
);
5852 finish_register_edge_assert_for (e
, bsi
, asserts
);
5862 /* Compare two case labels sorting first by the destination bb index
5863 and then by the case value. */
5866 compare_case_labels (const void *p1
, const void *p2
)
5868 const struct case_info
*ci1
= (const struct case_info
*) p1
;
5869 const struct case_info
*ci2
= (const struct case_info
*) p2
;
5870 int idx1
= ci1
->bb
->index
;
5871 int idx2
= ci2
->bb
->index
;
5875 else if (idx1
== idx2
)
5877 /* Make sure the default label is first in a group. */
5878 if (!CASE_LOW (ci1
->expr
))
5880 else if (!CASE_LOW (ci2
->expr
))
5883 return tree_int_cst_compare (CASE_LOW (ci1
->expr
),
5884 CASE_LOW (ci2
->expr
));
5890 /* Determine whether the outgoing edges of BB should receive an
5891 ASSERT_EXPR for each of the operands of BB's LAST statement.
5892 The last statement of BB must be a SWITCH_EXPR.
5894 If any of the sub-graphs rooted at BB have an interesting use of
5895 the predicate operands, an assert location node is added to the
5896 list of assertions for the corresponding operands. */
5899 find_switch_asserts (basic_block bb
, gswitch
*last
)
5901 gimple_stmt_iterator bsi
;
5904 struct case_info
*ci
;
5905 size_t n
= gimple_switch_num_labels (last
);
5906 #if GCC_VERSION >= 4000
5909 /* Work around GCC 3.4 bug (PR 37086). */
5910 volatile unsigned int idx
;
5913 bsi
= gsi_for_stmt (last
);
5914 op
= gimple_switch_index (last
);
5915 if (TREE_CODE (op
) != SSA_NAME
)
5918 /* Build a vector of case labels sorted by destination label. */
5919 ci
= XNEWVEC (struct case_info
, n
);
5920 for (idx
= 0; idx
< n
; ++idx
)
5922 ci
[idx
].expr
= gimple_switch_label (last
, idx
);
5923 ci
[idx
].bb
= label_to_block (CASE_LABEL (ci
[idx
].expr
));
5925 edge default_edge
= find_edge (bb
, ci
[0].bb
);
5926 qsort (ci
, n
, sizeof (struct case_info
), compare_case_labels
);
5928 for (idx
= 0; idx
< n
; ++idx
)
5931 tree cl
= ci
[idx
].expr
;
5932 basic_block cbb
= ci
[idx
].bb
;
5934 min
= CASE_LOW (cl
);
5935 max
= CASE_HIGH (cl
);
5937 /* If there are multiple case labels with the same destination
5938 we need to combine them to a single value range for the edge. */
5939 if (idx
+ 1 < n
&& cbb
== ci
[idx
+ 1].bb
)
5941 /* Skip labels until the last of the group. */
5944 } while (idx
< n
&& cbb
== ci
[idx
].bb
);
5947 /* Pick up the maximum of the case label range. */
5948 if (CASE_HIGH (ci
[idx
].expr
))
5949 max
= CASE_HIGH (ci
[idx
].expr
);
5951 max
= CASE_LOW (ci
[idx
].expr
);
5954 /* Can't extract a useful assertion out of a range that includes the
5956 if (min
== NULL_TREE
)
5959 /* Find the edge to register the assert expr on. */
5960 e
= find_edge (bb
, cbb
);
5962 /* Register the necessary assertions for the operand in the
5964 auto_vec
<assert_info
, 8> asserts
;
5965 register_edge_assert_for (op
, e
,
5966 max
? GE_EXPR
: EQ_EXPR
,
5967 op
, fold_convert (TREE_TYPE (op
), min
),
5970 register_edge_assert_for (op
, e
, LE_EXPR
, op
,
5971 fold_convert (TREE_TYPE (op
), max
),
5973 finish_register_edge_assert_for (e
, bsi
, asserts
);
5978 if (!live_on_edge (default_edge
, op
))
5981 /* Now register along the default label assertions that correspond to the
5982 anti-range of each label. */
5983 int insertion_limit
= PARAM_VALUE (PARAM_MAX_VRP_SWITCH_ASSERTIONS
);
5984 if (insertion_limit
== 0)
5987 /* We can't do this if the default case shares a label with another case. */
5988 tree default_cl
= gimple_switch_default_label (last
);
5989 for (idx
= 1; idx
< n
; idx
++)
5992 tree cl
= gimple_switch_label (last
, idx
);
5993 if (CASE_LABEL (cl
) == CASE_LABEL (default_cl
))
5996 min
= CASE_LOW (cl
);
5997 max
= CASE_HIGH (cl
);
5999 /* Combine contiguous case ranges to reduce the number of assertions
6001 for (idx
= idx
+ 1; idx
< n
; idx
++)
6003 tree next_min
, next_max
;
6004 tree next_cl
= gimple_switch_label (last
, idx
);
6005 if (CASE_LABEL (next_cl
) == CASE_LABEL (default_cl
))
6008 next_min
= CASE_LOW (next_cl
);
6009 next_max
= CASE_HIGH (next_cl
);
6011 wide_int difference
= wi::sub (next_min
, max
? max
: min
);
6012 if (wi::eq_p (difference
, 1))
6013 max
= next_max
? next_max
: next_min
;
6019 if (max
== NULL_TREE
)
6021 /* Register the assertion OP != MIN. */
6022 auto_vec
<assert_info
, 8> asserts
;
6023 min
= fold_convert (TREE_TYPE (op
), min
);
6024 register_edge_assert_for (op
, default_edge
, NE_EXPR
, op
, min
,
6026 finish_register_edge_assert_for (default_edge
, bsi
, asserts
);
6030 /* Register the assertion (unsigned)OP - MIN > (MAX - MIN),
6031 which will give OP the anti-range ~[MIN,MAX]. */
6032 tree uop
= fold_convert (unsigned_type_for (TREE_TYPE (op
)), op
);
6033 min
= fold_convert (TREE_TYPE (uop
), min
);
6034 max
= fold_convert (TREE_TYPE (uop
), max
);
6036 tree lhs
= fold_build2 (MINUS_EXPR
, TREE_TYPE (uop
), uop
, min
);
6037 tree rhs
= int_const_binop (MINUS_EXPR
, max
, min
);
6038 register_new_assert_for (op
, lhs
, GT_EXPR
, rhs
,
6039 NULL
, default_edge
, bsi
);
6042 if (--insertion_limit
== 0)
6048 /* Traverse all the statements in block BB looking for statements that
6049 may generate useful assertions for the SSA names in their operand.
6050 If a statement produces a useful assertion A for name N_i, then the
6051 list of assertions already generated for N_i is scanned to
6052 determine if A is actually needed.
6054 If N_i already had the assertion A at a location dominating the
6055 current location, then nothing needs to be done. Otherwise, the
6056 new location for A is recorded instead.
6058 1- For every statement S in BB, all the variables used by S are
6059 added to bitmap FOUND_IN_SUBGRAPH.
6061 2- If statement S uses an operand N in a way that exposes a known
6062 value range for N, then if N was not already generated by an
6063 ASSERT_EXPR, create a new assert location for N. For instance,
6064 if N is a pointer and the statement dereferences it, we can
6065 assume that N is not NULL.
6067 3- COND_EXPRs are a special case of #2. We can derive range
6068 information from the predicate but need to insert different
6069 ASSERT_EXPRs for each of the sub-graphs rooted at the
6070 conditional block. If the last statement of BB is a conditional
6071 expression of the form 'X op Y', then
6073 a) Remove X and Y from the set FOUND_IN_SUBGRAPH.
6075 b) If the conditional is the only entry point to the sub-graph
6076 corresponding to the THEN_CLAUSE, recurse into it. On
6077 return, if X and/or Y are marked in FOUND_IN_SUBGRAPH, then
6078 an ASSERT_EXPR is added for the corresponding variable.
6080 c) Repeat step (b) on the ELSE_CLAUSE.
6082 d) Mark X and Y in FOUND_IN_SUBGRAPH.
6091 In this case, an assertion on the THEN clause is useful to
6092 determine that 'a' is always 9 on that edge. However, an assertion
6093 on the ELSE clause would be unnecessary.
6095 4- If BB does not end in a conditional expression, then we recurse
6096 into BB's dominator children.
6098 At the end of the recursive traversal, every SSA name will have a
6099 list of locations where ASSERT_EXPRs should be added. When a new
6100 location for name N is found, it is registered by calling
6101 register_new_assert_for. That function keeps track of all the
6102 registered assertions to prevent adding unnecessary assertions.
6103 For instance, if a pointer P_4 is dereferenced more than once in a
6104 dominator tree, only the location dominating all the dereference of
6105 P_4 will receive an ASSERT_EXPR. */
6108 find_assert_locations_1 (basic_block bb
, sbitmap live
)
6112 last
= last_stmt (bb
);
6114 /* If BB's last statement is a conditional statement involving integer
6115 operands, determine if we need to add ASSERT_EXPRs. */
6117 && gimple_code (last
) == GIMPLE_COND
6118 && !fp_predicate (last
)
6119 && !ZERO_SSA_OPERANDS (last
, SSA_OP_USE
))
6120 find_conditional_asserts (bb
, as_a
<gcond
*> (last
));
6122 /* If BB's last statement is a switch statement involving integer
6123 operands, determine if we need to add ASSERT_EXPRs. */
6125 && gimple_code (last
) == GIMPLE_SWITCH
6126 && !ZERO_SSA_OPERANDS (last
, SSA_OP_USE
))
6127 find_switch_asserts (bb
, as_a
<gswitch
*> (last
));
6129 /* Traverse all the statements in BB marking used names and looking
6130 for statements that may infer assertions for their used operands. */
6131 for (gimple_stmt_iterator si
= gsi_last_bb (bb
); !gsi_end_p (si
);
6138 stmt
= gsi_stmt (si
);
6140 if (is_gimple_debug (stmt
))
6143 /* See if we can derive an assertion for any of STMT's operands. */
6144 FOR_EACH_SSA_TREE_OPERAND (op
, stmt
, i
, SSA_OP_USE
)
6147 enum tree_code comp_code
;
6149 /* If op is not live beyond this stmt, do not bother to insert
6151 if (!bitmap_bit_p (live
, SSA_NAME_VERSION (op
)))
6154 /* If OP is used in such a way that we can infer a value
6155 range for it, and we don't find a previous assertion for
6156 it, create a new assertion location node for OP. */
6157 if (infer_value_range (stmt
, op
, &comp_code
, &value
))
6159 /* If we are able to infer a nonzero value range for OP,
6160 then walk backwards through the use-def chain to see if OP
6161 was set via a typecast.
6163 If so, then we can also infer a nonzero value range
6164 for the operand of the NOP_EXPR. */
6165 if (comp_code
== NE_EXPR
&& integer_zerop (value
))
6168 gimple
*def_stmt
= SSA_NAME_DEF_STMT (t
);
6170 while (is_gimple_assign (def_stmt
)
6171 && CONVERT_EXPR_CODE_P
6172 (gimple_assign_rhs_code (def_stmt
))
6174 (gimple_assign_rhs1 (def_stmt
)) == SSA_NAME
6176 (TREE_TYPE (gimple_assign_rhs1 (def_stmt
))))
6178 t
= gimple_assign_rhs1 (def_stmt
);
6179 def_stmt
= SSA_NAME_DEF_STMT (t
);
6181 /* Note we want to register the assert for the
6182 operand of the NOP_EXPR after SI, not after the
6184 if (bitmap_bit_p (live
, SSA_NAME_VERSION (t
)))
6185 register_new_assert_for (t
, t
, comp_code
, value
,
6190 register_new_assert_for (op
, op
, comp_code
, value
, bb
, NULL
, si
);
6195 FOR_EACH_SSA_TREE_OPERAND (op
, stmt
, i
, SSA_OP_USE
)
6196 bitmap_set_bit (live
, SSA_NAME_VERSION (op
));
6197 FOR_EACH_SSA_TREE_OPERAND (op
, stmt
, i
, SSA_OP_DEF
)
6198 bitmap_clear_bit (live
, SSA_NAME_VERSION (op
));
6201 /* Traverse all PHI nodes in BB, updating live. */
6202 for (gphi_iterator si
= gsi_start_phis (bb
); !gsi_end_p (si
);
6205 use_operand_p arg_p
;
6207 gphi
*phi
= si
.phi ();
6208 tree res
= gimple_phi_result (phi
);
6210 if (virtual_operand_p (res
))
6213 FOR_EACH_PHI_ARG (arg_p
, phi
, i
, SSA_OP_USE
)
6215 tree arg
= USE_FROM_PTR (arg_p
);
6216 if (TREE_CODE (arg
) == SSA_NAME
)
6217 bitmap_set_bit (live
, SSA_NAME_VERSION (arg
));
6220 bitmap_clear_bit (live
, SSA_NAME_VERSION (res
));
6224 /* Do an RPO walk over the function computing SSA name liveness
6225 on-the-fly and deciding on assert expressions to insert. */
6228 find_assert_locations (void)
6230 int *rpo
= XNEWVEC (int, last_basic_block_for_fn (cfun
));
6231 int *bb_rpo
= XNEWVEC (int, last_basic_block_for_fn (cfun
));
6232 int *last_rpo
= XCNEWVEC (int, last_basic_block_for_fn (cfun
));
6235 live
= XCNEWVEC (sbitmap
, last_basic_block_for_fn (cfun
));
6236 rpo_cnt
= pre_and_rev_post_order_compute (NULL
, rpo
, false);
6237 for (i
= 0; i
< rpo_cnt
; ++i
)
6240 /* Pre-seed loop latch liveness from loop header PHI nodes. Due to
6241 the order we compute liveness and insert asserts we otherwise
6242 fail to insert asserts into the loop latch. */
6244 FOR_EACH_LOOP (loop
, 0)
6246 i
= loop
->latch
->index
;
6247 unsigned int j
= single_succ_edge (loop
->latch
)->dest_idx
;
6248 for (gphi_iterator gsi
= gsi_start_phis (loop
->header
);
6249 !gsi_end_p (gsi
); gsi_next (&gsi
))
6251 gphi
*phi
= gsi
.phi ();
6252 if (virtual_operand_p (gimple_phi_result (phi
)))
6254 tree arg
= gimple_phi_arg_def (phi
, j
);
6255 if (TREE_CODE (arg
) == SSA_NAME
)
6257 if (live
[i
] == NULL
)
6259 live
[i
] = sbitmap_alloc (num_ssa_names
);
6260 bitmap_clear (live
[i
]);
6262 bitmap_set_bit (live
[i
], SSA_NAME_VERSION (arg
));
6267 for (i
= rpo_cnt
- 1; i
>= 0; --i
)
6269 basic_block bb
= BASIC_BLOCK_FOR_FN (cfun
, rpo
[i
]);
6275 live
[rpo
[i
]] = sbitmap_alloc (num_ssa_names
);
6276 bitmap_clear (live
[rpo
[i
]]);
6279 /* Process BB and update the live information with uses in
6281 find_assert_locations_1 (bb
, live
[rpo
[i
]]);
6283 /* Merge liveness into the predecessor blocks and free it. */
6284 if (!bitmap_empty_p (live
[rpo
[i
]]))
6287 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
6289 int pred
= e
->src
->index
;
6290 if ((e
->flags
& EDGE_DFS_BACK
) || pred
== ENTRY_BLOCK
)
6295 live
[pred
] = sbitmap_alloc (num_ssa_names
);
6296 bitmap_clear (live
[pred
]);
6298 bitmap_ior (live
[pred
], live
[pred
], live
[rpo
[i
]]);
6300 if (bb_rpo
[pred
] < pred_rpo
)
6301 pred_rpo
= bb_rpo
[pred
];
6304 /* Record the RPO number of the last visited block that needs
6305 live information from this block. */
6306 last_rpo
[rpo
[i
]] = pred_rpo
;
6310 sbitmap_free (live
[rpo
[i
]]);
6311 live
[rpo
[i
]] = NULL
;
6314 /* We can free all successors live bitmaps if all their
6315 predecessors have been visited already. */
6316 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
6317 if (last_rpo
[e
->dest
->index
] == i
6318 && live
[e
->dest
->index
])
6320 sbitmap_free (live
[e
->dest
->index
]);
6321 live
[e
->dest
->index
] = NULL
;
6326 XDELETEVEC (bb_rpo
);
6327 XDELETEVEC (last_rpo
);
6328 for (i
= 0; i
< last_basic_block_for_fn (cfun
); ++i
)
6330 sbitmap_free (live
[i
]);
6334 /* Create an ASSERT_EXPR for NAME and insert it in the location
6335 indicated by LOC. Return true if we made any edge insertions. */
6338 process_assert_insertions_for (tree name
, assert_locus
*loc
)
6340 /* Build the comparison expression NAME_i COMP_CODE VAL. */
6343 gimple
*assert_stmt
;
6347 /* If we have X <=> X do not insert an assert expr for that. */
6348 if (loc
->expr
== loc
->val
)
6351 cond
= build2 (loc
->comp_code
, boolean_type_node
, loc
->expr
, loc
->val
);
6352 assert_stmt
= build_assert_expr_for (cond
, name
);
6355 /* We have been asked to insert the assertion on an edge. This
6356 is used only by COND_EXPR and SWITCH_EXPR assertions. */
6357 gcc_checking_assert (gimple_code (gsi_stmt (loc
->si
)) == GIMPLE_COND
6358 || (gimple_code (gsi_stmt (loc
->si
))
6361 gsi_insert_on_edge (loc
->e
, assert_stmt
);
6365 /* If the stmt iterator points at the end then this is an insertion
6366 at the beginning of a block. */
6367 if (gsi_end_p (loc
->si
))
6369 gimple_stmt_iterator si
= gsi_after_labels (loc
->bb
);
6370 gsi_insert_before (&si
, assert_stmt
, GSI_SAME_STMT
);
6374 /* Otherwise, we can insert right after LOC->SI iff the
6375 statement must not be the last statement in the block. */
6376 stmt
= gsi_stmt (loc
->si
);
6377 if (!stmt_ends_bb_p (stmt
))
6379 gsi_insert_after (&loc
->si
, assert_stmt
, GSI_SAME_STMT
);
6383 /* If STMT must be the last statement in BB, we can only insert new
6384 assertions on the non-abnormal edge out of BB. Note that since
6385 STMT is not control flow, there may only be one non-abnormal/eh edge
6387 FOR_EACH_EDGE (e
, ei
, loc
->bb
->succs
)
6388 if (!(e
->flags
& (EDGE_ABNORMAL
|EDGE_EH
)))
6390 gsi_insert_on_edge (e
, assert_stmt
);
6397 /* Qsort helper for sorting assert locations. */
6400 compare_assert_loc (const void *pa
, const void *pb
)
6402 assert_locus
* const a
= *(assert_locus
* const *)pa
;
6403 assert_locus
* const b
= *(assert_locus
* const *)pb
;
6406 else if (a
->e
&& ! b
->e
)
6409 /* Sort after destination index. */
6410 if (! a
->e
&& ! b
->e
)
6412 else if (a
->e
->dest
->index
> b
->e
->dest
->index
)
6414 else if (a
->e
->dest
->index
< b
->e
->dest
->index
)
6417 /* Sort after comp_code. */
6418 if (a
->comp_code
> b
->comp_code
)
6420 else if (a
->comp_code
< b
->comp_code
)
6423 /* Break the tie using hashing and source/bb index. */
6424 hashval_t ha
= iterative_hash_expr (a
->expr
, iterative_hash_expr (a
->val
, 0));
6425 hashval_t hb
= iterative_hash_expr (b
->expr
, iterative_hash_expr (b
->val
, 0));
6427 return (a
->e
&& b
->e
6428 ? a
->e
->src
->index
- b
->e
->src
->index
6429 : a
->bb
->index
- b
->bb
->index
);
6433 /* Process all the insertions registered for every name N_i registered
6434 in NEED_ASSERT_FOR. The list of assertions to be inserted are
6435 found in ASSERTS_FOR[i]. */
6438 process_assert_insertions (void)
6442 bool update_edges_p
= false;
6443 int num_asserts
= 0;
6445 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
6446 dump_all_asserts (dump_file
);
6448 EXECUTE_IF_SET_IN_BITMAP (need_assert_for
, 0, i
, bi
)
6450 assert_locus
*loc
= asserts_for
[i
];
6453 auto_vec
<assert_locus
*, 16> asserts
;
6454 for (; loc
; loc
= loc
->next
)
6455 asserts
.safe_push (loc
);
6456 asserts
.qsort (compare_assert_loc
);
6458 /* Push down common asserts to successors and remove redundant ones. */
6460 assert_locus
*common
= NULL
;
6461 unsigned commonj
= 0;
6462 for (unsigned j
= 0; j
< asserts
.length (); ++j
)
6468 || loc
->e
->dest
!= common
->e
->dest
6469 || loc
->comp_code
!= common
->comp_code
6470 || ! operand_equal_p (loc
->val
, common
->val
, 0)
6471 || ! operand_equal_p (loc
->expr
, common
->expr
, 0))
6477 else if (loc
->e
== asserts
[j
-1]->e
)
6479 /* Remove duplicate asserts. */
6480 if (commonj
== j
- 1)
6485 free (asserts
[j
-1]);
6486 asserts
[j
-1] = NULL
;
6491 if (EDGE_COUNT (common
->e
->dest
->preds
) == ecnt
)
6493 /* We have the same assertion on all incoming edges of a BB.
6494 Insert it at the beginning of that block. */
6495 loc
->bb
= loc
->e
->dest
;
6497 loc
->si
= gsi_none ();
6499 /* Clear asserts commoned. */
6500 for (; commonj
!= j
; ++commonj
)
6501 if (asserts
[commonj
])
6503 free (asserts
[commonj
]);
6504 asserts
[commonj
] = NULL
;
6510 for (unsigned j
= 0; j
< asserts
.length (); ++j
)
6515 update_edges_p
|= process_assert_insertions_for (ssa_name (i
), loc
);
6522 gsi_commit_edge_inserts ();
6524 statistics_counter_event (cfun
, "Number of ASSERT_EXPR expressions inserted",
6529 /* Traverse the flowgraph looking for conditional jumps to insert range
6530 expressions. These range expressions are meant to provide information
6531 to optimizations that need to reason in terms of value ranges. They
6532 will not be expanded into RTL. For instance, given:
6541 this pass will transform the code into:
6547 x = ASSERT_EXPR <x, x < y>
6552 y = ASSERT_EXPR <y, x >= y>
6556 The idea is that once copy and constant propagation have run, other
6557 optimizations will be able to determine what ranges of values can 'x'
6558 take in different paths of the code, simply by checking the reaching
6559 definition of 'x'. */
6562 insert_range_assertions (void)
6564 need_assert_for
= BITMAP_ALLOC (NULL
);
6565 asserts_for
= XCNEWVEC (assert_locus
*, num_ssa_names
);
6567 calculate_dominance_info (CDI_DOMINATORS
);
6569 find_assert_locations ();
6570 if (!bitmap_empty_p (need_assert_for
))
6572 process_assert_insertions ();
6573 update_ssa (TODO_update_ssa_no_phi
);
6576 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
6578 fprintf (dump_file
, "\nSSA form after inserting ASSERT_EXPRs\n");
6579 dump_function_to_file (current_function_decl
, dump_file
, dump_flags
);
6583 BITMAP_FREE (need_assert_for
);
6586 /* Checks one ARRAY_REF in REF, located at LOCUS. Ignores flexible arrays
6587 and "struct" hacks. If VRP can determine that the
6588 array subscript is a constant, check if it is outside valid
6589 range. If the array subscript is a RANGE, warn if it is
6590 non-overlapping with valid range.
6591 IGNORE_OFF_BY_ONE is true if the ARRAY_REF is inside a ADDR_EXPR. */
6594 check_array_ref (location_t location
, tree ref
, bool ignore_off_by_one
)
6596 value_range
*vr
= NULL
;
6597 tree low_sub
, up_sub
;
6598 tree low_bound
, up_bound
, up_bound_p1
;
6600 if (TREE_NO_WARNING (ref
))
6603 low_sub
= up_sub
= TREE_OPERAND (ref
, 1);
6604 up_bound
= array_ref_up_bound (ref
);
6606 /* Can not check flexible arrays. */
6608 || TREE_CODE (up_bound
) != INTEGER_CST
)
6611 /* Accesses to trailing arrays via pointers may access storage
6612 beyond the types array bounds. */
6613 if (warn_array_bounds
< 2
6614 && array_at_struct_end_p (ref
))
6617 low_bound
= array_ref_low_bound (ref
);
6618 up_bound_p1
= int_const_binop (PLUS_EXPR
, up_bound
,
6619 build_int_cst (TREE_TYPE (up_bound
), 1));
6622 if (tree_int_cst_equal (low_bound
, up_bound_p1
))
6624 warning_at (location
, OPT_Warray_bounds
,
6625 "array subscript is above array bounds");
6626 TREE_NO_WARNING (ref
) = 1;
6629 if (TREE_CODE (low_sub
) == SSA_NAME
)
6631 vr
= get_value_range (low_sub
);
6632 if (vr
->type
== VR_RANGE
|| vr
->type
== VR_ANTI_RANGE
)
6634 low_sub
= vr
->type
== VR_RANGE
? vr
->max
: vr
->min
;
6635 up_sub
= vr
->type
== VR_RANGE
? vr
->min
: vr
->max
;
6639 if (vr
&& vr
->type
== VR_ANTI_RANGE
)
6641 if (TREE_CODE (up_sub
) == INTEGER_CST
6642 && (ignore_off_by_one
6643 ? tree_int_cst_lt (up_bound
, up_sub
)
6644 : tree_int_cst_le (up_bound
, up_sub
))
6645 && TREE_CODE (low_sub
) == INTEGER_CST
6646 && tree_int_cst_le (low_sub
, low_bound
))
6648 warning_at (location
, OPT_Warray_bounds
,
6649 "array subscript is outside array bounds");
6650 TREE_NO_WARNING (ref
) = 1;
6653 else if (TREE_CODE (up_sub
) == INTEGER_CST
6654 && (ignore_off_by_one
6655 ? !tree_int_cst_le (up_sub
, up_bound_p1
)
6656 : !tree_int_cst_le (up_sub
, up_bound
)))
6658 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
6660 fprintf (dump_file
, "Array bound warning for ");
6661 dump_generic_expr (MSG_NOTE
, TDF_SLIM
, ref
);
6662 fprintf (dump_file
, "\n");
6664 warning_at (location
, OPT_Warray_bounds
,
6665 "array subscript is above array bounds");
6666 TREE_NO_WARNING (ref
) = 1;
6668 else if (TREE_CODE (low_sub
) == INTEGER_CST
6669 && tree_int_cst_lt (low_sub
, low_bound
))
6671 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
6673 fprintf (dump_file
, "Array bound warning for ");
6674 dump_generic_expr (MSG_NOTE
, TDF_SLIM
, ref
);
6675 fprintf (dump_file
, "\n");
6677 warning_at (location
, OPT_Warray_bounds
,
6678 "array subscript is below array bounds");
6679 TREE_NO_WARNING (ref
) = 1;
6683 /* Searches if the expr T, located at LOCATION computes
6684 address of an ARRAY_REF, and call check_array_ref on it. */
6687 search_for_addr_array (tree t
, location_t location
)
6689 /* Check each ARRAY_REFs in the reference chain. */
6692 if (TREE_CODE (t
) == ARRAY_REF
)
6693 check_array_ref (location
, t
, true /*ignore_off_by_one*/);
6695 t
= TREE_OPERAND (t
, 0);
6697 while (handled_component_p (t
));
6699 if (TREE_CODE (t
) == MEM_REF
6700 && TREE_CODE (TREE_OPERAND (t
, 0)) == ADDR_EXPR
6701 && !TREE_NO_WARNING (t
))
6703 tree tem
= TREE_OPERAND (TREE_OPERAND (t
, 0), 0);
6704 tree low_bound
, up_bound
, el_sz
;
6706 if (TREE_CODE (TREE_TYPE (tem
)) != ARRAY_TYPE
6707 || TREE_CODE (TREE_TYPE (TREE_TYPE (tem
))) == ARRAY_TYPE
6708 || !TYPE_DOMAIN (TREE_TYPE (tem
)))
6711 low_bound
= TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (tem
)));
6712 up_bound
= TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (tem
)));
6713 el_sz
= TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (tem
)));
6715 || TREE_CODE (low_bound
) != INTEGER_CST
6717 || TREE_CODE (up_bound
) != INTEGER_CST
6719 || TREE_CODE (el_sz
) != INTEGER_CST
)
6722 idx
= mem_ref_offset (t
);
6723 idx
= wi::sdiv_trunc (idx
, wi::to_offset (el_sz
));
6726 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
6728 fprintf (dump_file
, "Array bound warning for ");
6729 dump_generic_expr (MSG_NOTE
, TDF_SLIM
, t
);
6730 fprintf (dump_file
, "\n");
6732 warning_at (location
, OPT_Warray_bounds
,
6733 "array subscript is below array bounds");
6734 TREE_NO_WARNING (t
) = 1;
6736 else if (idx
> (wi::to_offset (up_bound
)
6737 - wi::to_offset (low_bound
) + 1))
6739 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
6741 fprintf (dump_file
, "Array bound warning for ");
6742 dump_generic_expr (MSG_NOTE
, TDF_SLIM
, t
);
6743 fprintf (dump_file
, "\n");
6745 warning_at (location
, OPT_Warray_bounds
,
6746 "array subscript is above array bounds");
6747 TREE_NO_WARNING (t
) = 1;
6752 /* walk_tree() callback that checks if *TP is
6753 an ARRAY_REF inside an ADDR_EXPR (in which an array
6754 subscript one outside the valid range is allowed). Call
6755 check_array_ref for each ARRAY_REF found. The location is
6759 check_array_bounds (tree
*tp
, int *walk_subtree
, void *data
)
6762 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
6763 location_t location
;
6765 if (EXPR_HAS_LOCATION (t
))
6766 location
= EXPR_LOCATION (t
);
6769 location_t
*locp
= (location_t
*) wi
->info
;
6773 *walk_subtree
= TRUE
;
6775 if (TREE_CODE (t
) == ARRAY_REF
)
6776 check_array_ref (location
, t
, false /*ignore_off_by_one*/);
6778 else if (TREE_CODE (t
) == ADDR_EXPR
)
6780 search_for_addr_array (t
, location
);
6781 *walk_subtree
= FALSE
;
6787 /* Walk over all statements of all reachable BBs and call check_array_bounds
6791 check_all_array_refs (void)
6794 gimple_stmt_iterator si
;
6796 FOR_EACH_BB_FN (bb
, cfun
)
6800 bool executable
= false;
6802 /* Skip blocks that were found to be unreachable. */
6803 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
6804 executable
|= !!(e
->flags
& EDGE_EXECUTABLE
);
6808 for (si
= gsi_start_bb (bb
); !gsi_end_p (si
); gsi_next (&si
))
6810 gimple
*stmt
= gsi_stmt (si
);
6811 struct walk_stmt_info wi
;
6812 if (!gimple_has_location (stmt
)
6813 || is_gimple_debug (stmt
))
6816 memset (&wi
, 0, sizeof (wi
));
6818 location_t loc
= gimple_location (stmt
);
6821 walk_gimple_op (gsi_stmt (si
),
6828 /* Return true if all imm uses of VAR are either in STMT, or
6829 feed (optionally through a chain of single imm uses) GIMPLE_COND
6830 in basic block COND_BB. */
6833 all_imm_uses_in_stmt_or_feed_cond (tree var
, gimple
*stmt
, basic_block cond_bb
)
6835 use_operand_p use_p
, use2_p
;
6836 imm_use_iterator iter
;
6838 FOR_EACH_IMM_USE_FAST (use_p
, iter
, var
)
6839 if (USE_STMT (use_p
) != stmt
)
6841 gimple
*use_stmt
= USE_STMT (use_p
), *use_stmt2
;
6842 if (is_gimple_debug (use_stmt
))
6844 while (is_gimple_assign (use_stmt
)
6845 && TREE_CODE (gimple_assign_lhs (use_stmt
)) == SSA_NAME
6846 && single_imm_use (gimple_assign_lhs (use_stmt
),
6847 &use2_p
, &use_stmt2
))
6848 use_stmt
= use_stmt2
;
6849 if (gimple_code (use_stmt
) != GIMPLE_COND
6850 || gimple_bb (use_stmt
) != cond_bb
)
6863 __builtin_unreachable ();
6865 x_5 = ASSERT_EXPR <x_3, ...>;
6866 If x_3 has no other immediate uses (checked by caller),
6867 var is the x_3 var from ASSERT_EXPR, we can clear low 5 bits
6868 from the non-zero bitmask. */
6871 maybe_set_nonzero_bits (basic_block bb
, tree var
)
6873 edge e
= single_pred_edge (bb
);
6874 basic_block cond_bb
= e
->src
;
6875 gimple
*stmt
= last_stmt (cond_bb
);
6879 || gimple_code (stmt
) != GIMPLE_COND
6880 || gimple_cond_code (stmt
) != ((e
->flags
& EDGE_TRUE_VALUE
)
6881 ? EQ_EXPR
: NE_EXPR
)
6882 || TREE_CODE (gimple_cond_lhs (stmt
)) != SSA_NAME
6883 || !integer_zerop (gimple_cond_rhs (stmt
)))
6886 stmt
= SSA_NAME_DEF_STMT (gimple_cond_lhs (stmt
));
6887 if (!is_gimple_assign (stmt
)
6888 || gimple_assign_rhs_code (stmt
) != BIT_AND_EXPR
6889 || TREE_CODE (gimple_assign_rhs2 (stmt
)) != INTEGER_CST
)
6891 if (gimple_assign_rhs1 (stmt
) != var
)
6895 if (TREE_CODE (gimple_assign_rhs1 (stmt
)) != SSA_NAME
)
6897 stmt2
= SSA_NAME_DEF_STMT (gimple_assign_rhs1 (stmt
));
6898 if (!gimple_assign_cast_p (stmt2
)
6899 || gimple_assign_rhs1 (stmt2
) != var
6900 || !CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (stmt2
))
6901 || (TYPE_PRECISION (TREE_TYPE (gimple_assign_rhs1 (stmt
)))
6902 != TYPE_PRECISION (TREE_TYPE (var
))))
6905 cst
= gimple_assign_rhs2 (stmt
);
6906 set_nonzero_bits (var
, wi::bit_and_not (get_nonzero_bits (var
), cst
));
6909 /* Convert range assertion expressions into the implied copies and
6910 copy propagate away the copies. Doing the trivial copy propagation
6911 here avoids the need to run the full copy propagation pass after
6914 FIXME, this will eventually lead to copy propagation removing the
6915 names that had useful range information attached to them. For
6916 instance, if we had the assertion N_i = ASSERT_EXPR <N_j, N_j > 3>,
6917 then N_i will have the range [3, +INF].
6919 However, by converting the assertion into the implied copy
6920 operation N_i = N_j, we will then copy-propagate N_j into the uses
6921 of N_i and lose the range information. We may want to hold on to
6922 ASSERT_EXPRs a little while longer as the ranges could be used in
6923 things like jump threading.
6925 The problem with keeping ASSERT_EXPRs around is that passes after
6926 VRP need to handle them appropriately.
6928 Another approach would be to make the range information a first
6929 class property of the SSA_NAME so that it can be queried from
6930 any pass. This is made somewhat more complex by the need for
6931 multiple ranges to be associated with one SSA_NAME. */
6934 remove_range_assertions (void)
6937 gimple_stmt_iterator si
;
6938 /* 1 if looking at ASSERT_EXPRs immediately at the beginning of
6939 a basic block preceeded by GIMPLE_COND branching to it and
6940 __builtin_trap, -1 if not yet checked, 0 otherwise. */
6943 /* Note that the BSI iterator bump happens at the bottom of the
6944 loop and no bump is necessary if we're removing the statement
6945 referenced by the current BSI. */
6946 FOR_EACH_BB_FN (bb
, cfun
)
6947 for (si
= gsi_after_labels (bb
), is_unreachable
= -1; !gsi_end_p (si
);)
6949 gimple
*stmt
= gsi_stmt (si
);
6951 if (is_gimple_assign (stmt
)
6952 && gimple_assign_rhs_code (stmt
) == ASSERT_EXPR
)
6954 tree lhs
= gimple_assign_lhs (stmt
);
6955 tree rhs
= gimple_assign_rhs1 (stmt
);
6958 var
= ASSERT_EXPR_VAR (rhs
);
6960 if (TREE_CODE (var
) == SSA_NAME
6961 && !POINTER_TYPE_P (TREE_TYPE (lhs
))
6962 && SSA_NAME_RANGE_INFO (lhs
))
6964 if (is_unreachable
== -1)
6967 if (single_pred_p (bb
)
6968 && assert_unreachable_fallthru_edge_p
6969 (single_pred_edge (bb
)))
6973 if (x_7 >= 10 && x_7 < 20)
6974 __builtin_unreachable ();
6975 x_8 = ASSERT_EXPR <x_7, ...>;
6976 if the only uses of x_7 are in the ASSERT_EXPR and
6977 in the condition. In that case, we can copy the
6978 range info from x_8 computed in this pass also
6981 && all_imm_uses_in_stmt_or_feed_cond (var
, stmt
,
6984 set_range_info (var
, SSA_NAME_RANGE_TYPE (lhs
),
6985 SSA_NAME_RANGE_INFO (lhs
)->get_min (),
6986 SSA_NAME_RANGE_INFO (lhs
)->get_max ());
6987 maybe_set_nonzero_bits (bb
, var
);
6991 /* Propagate the RHS into every use of the LHS. For SSA names
6992 also propagate abnormals as it merely restores the original
6993 IL in this case (an replace_uses_by would assert). */
6994 if (TREE_CODE (var
) == SSA_NAME
)
6996 imm_use_iterator iter
;
6997 use_operand_p use_p
;
6999 FOR_EACH_IMM_USE_STMT (use_stmt
, iter
, lhs
)
7000 FOR_EACH_IMM_USE_ON_STMT (use_p
, iter
)
7001 SET_USE (use_p
, var
);
7004 replace_uses_by (lhs
, var
);
7006 /* And finally, remove the copy, it is not needed. */
7007 gsi_remove (&si
, true);
7008 release_defs (stmt
);
7012 if (!is_gimple_debug (gsi_stmt (si
)))
7020 /* Return true if STMT is interesting for VRP. */
7023 stmt_interesting_for_vrp (gimple
*stmt
)
7025 if (gimple_code (stmt
) == GIMPLE_PHI
)
7027 tree res
= gimple_phi_result (stmt
);
7028 return (!virtual_operand_p (res
)
7029 && (INTEGRAL_TYPE_P (TREE_TYPE (res
))
7030 || POINTER_TYPE_P (TREE_TYPE (res
))));
7032 else if (is_gimple_assign (stmt
) || is_gimple_call (stmt
))
7034 tree lhs
= gimple_get_lhs (stmt
);
7036 /* In general, assignments with virtual operands are not useful
7037 for deriving ranges, with the obvious exception of calls to
7038 builtin functions. */
7039 if (lhs
&& TREE_CODE (lhs
) == SSA_NAME
7040 && (INTEGRAL_TYPE_P (TREE_TYPE (lhs
))
7041 || POINTER_TYPE_P (TREE_TYPE (lhs
)))
7042 && (is_gimple_call (stmt
)
7043 || !gimple_vuse (stmt
)))
7045 else if (is_gimple_call (stmt
) && gimple_call_internal_p (stmt
))
7046 switch (gimple_call_internal_fn (stmt
))
7048 case IFN_ADD_OVERFLOW
:
7049 case IFN_SUB_OVERFLOW
:
7050 case IFN_MUL_OVERFLOW
:
7051 case IFN_ATOMIC_COMPARE_EXCHANGE
:
7052 /* These internal calls return _Complex integer type,
7053 but are interesting to VRP nevertheless. */
7054 if (lhs
&& TREE_CODE (lhs
) == SSA_NAME
)
7061 else if (gimple_code (stmt
) == GIMPLE_COND
7062 || gimple_code (stmt
) == GIMPLE_SWITCH
)
7068 /* Initialize VRP lattice. */
7071 vrp_initialize_lattice ()
7073 values_propagated
= false;
7074 num_vr_values
= num_ssa_names
;
7075 vr_value
= XCNEWVEC (value_range
*, num_vr_values
);
7076 vr_phi_edge_counts
= XCNEWVEC (int, num_ssa_names
);
7077 bitmap_obstack_initialize (&vrp_equiv_obstack
);
7080 /* Initialization required by ssa_propagate engine. */
7087 FOR_EACH_BB_FN (bb
, cfun
)
7089 for (gphi_iterator si
= gsi_start_phis (bb
); !gsi_end_p (si
);
7092 gphi
*phi
= si
.phi ();
7093 if (!stmt_interesting_for_vrp (phi
))
7095 tree lhs
= PHI_RESULT (phi
);
7096 set_value_range_to_varying (get_value_range (lhs
));
7097 prop_set_simulate_again (phi
, false);
7100 prop_set_simulate_again (phi
, true);
7103 for (gimple_stmt_iterator si
= gsi_start_bb (bb
); !gsi_end_p (si
);
7106 gimple
*stmt
= gsi_stmt (si
);
7108 /* If the statement is a control insn, then we do not
7109 want to avoid simulating the statement once. Failure
7110 to do so means that those edges will never get added. */
7111 if (stmt_ends_bb_p (stmt
))
7112 prop_set_simulate_again (stmt
, true);
7113 else if (!stmt_interesting_for_vrp (stmt
))
7115 set_defs_to_varying (stmt
);
7116 prop_set_simulate_again (stmt
, false);
7119 prop_set_simulate_again (stmt
, true);
7124 /* Return the singleton value-range for NAME or NAME. */
7127 vrp_valueize (tree name
)
7129 if (TREE_CODE (name
) == SSA_NAME
)
7131 value_range
*vr
= get_value_range (name
);
7132 if (vr
->type
== VR_RANGE
7133 && (TREE_CODE (vr
->min
) == SSA_NAME
7134 || is_gimple_min_invariant (vr
->min
))
7135 && vrp_operand_equal_p (vr
->min
, vr
->max
))
7141 /* Return the singleton value-range for NAME if that is a constant
7142 but signal to not follow SSA edges. */
7145 vrp_valueize_1 (tree name
)
7147 if (TREE_CODE (name
) == SSA_NAME
)
7149 /* If the definition may be simulated again we cannot follow
7150 this SSA edge as the SSA propagator does not necessarily
7151 re-visit the use. */
7152 gimple
*def_stmt
= SSA_NAME_DEF_STMT (name
);
7153 if (!gimple_nop_p (def_stmt
)
7154 && prop_simulate_again_p (def_stmt
))
7156 value_range
*vr
= get_value_range (name
);
7157 if (range_int_cst_singleton_p (vr
))
7163 /* Visit assignment STMT. If it produces an interesting range, record
7164 the range in VR and set LHS to OUTPUT_P. */
7167 vrp_visit_assignment_or_call (gimple
*stmt
, tree
*output_p
, value_range
*vr
)
7170 enum gimple_code code
= gimple_code (stmt
);
7171 lhs
= gimple_get_lhs (stmt
);
7172 *output_p
= NULL_TREE
;
7174 /* We only keep track of ranges in integral and pointer types. */
7175 if (TREE_CODE (lhs
) == SSA_NAME
7176 && ((INTEGRAL_TYPE_P (TREE_TYPE (lhs
))
7177 /* It is valid to have NULL MIN/MAX values on a type. See
7178 build_range_type. */
7179 && TYPE_MIN_VALUE (TREE_TYPE (lhs
))
7180 && TYPE_MAX_VALUE (TREE_TYPE (lhs
)))
7181 || POINTER_TYPE_P (TREE_TYPE (lhs
))))
7185 /* Try folding the statement to a constant first. */
7186 tree tem
= gimple_fold_stmt_to_constant_1 (stmt
, vrp_valueize
,
7190 if (TREE_CODE (tem
) == SSA_NAME
7191 && (SSA_NAME_IS_DEFAULT_DEF (tem
)
7192 || ! prop_simulate_again_p (SSA_NAME_DEF_STMT (tem
))))
7194 extract_range_from_ssa_name (vr
, tem
);
7197 else if (is_gimple_min_invariant (tem
))
7199 set_value_range_to_value (vr
, tem
, NULL
);
7203 /* Then dispatch to value-range extracting functions. */
7204 if (code
== GIMPLE_CALL
)
7205 extract_range_basic (vr
, stmt
);
7207 extract_range_from_assignment (vr
, as_a
<gassign
*> (stmt
));
7211 /* Helper that gets the value range of the SSA_NAME with version I
7212 or a symbolic range containing the SSA_NAME only if the value range
7213 is varying or undefined. */
7215 static inline value_range
7216 get_vr_for_comparison (int i
)
7218 value_range vr
= *get_value_range (ssa_name (i
));
7220 /* If name N_i does not have a valid range, use N_i as its own
7221 range. This allows us to compare against names that may
7222 have N_i in their ranges. */
7223 if (vr
.type
== VR_VARYING
|| vr
.type
== VR_UNDEFINED
)
7226 vr
.min
= ssa_name (i
);
7227 vr
.max
= ssa_name (i
);
7233 /* Compare all the value ranges for names equivalent to VAR with VAL
7234 using comparison code COMP. Return the same value returned by
7235 compare_range_with_value, including the setting of
7236 *STRICT_OVERFLOW_P. */
7239 compare_name_with_value (enum tree_code comp
, tree var
, tree val
,
7240 bool *strict_overflow_p
, bool use_equiv_p
)
7246 int used_strict_overflow
;
7248 value_range equiv_vr
;
7250 /* Get the set of equivalences for VAR. */
7251 e
= get_value_range (var
)->equiv
;
7253 /* Start at -1. Set it to 0 if we do a comparison without relying
7254 on overflow, or 1 if all comparisons rely on overflow. */
7255 used_strict_overflow
= -1;
7257 /* Compare vars' value range with val. */
7258 equiv_vr
= get_vr_for_comparison (SSA_NAME_VERSION (var
));
7260 retval
= compare_range_with_value (comp
, &equiv_vr
, val
, &sop
);
7262 used_strict_overflow
= sop
? 1 : 0;
7264 /* If the equiv set is empty we have done all work we need to do. */
7268 && used_strict_overflow
> 0)
7269 *strict_overflow_p
= true;
7273 EXECUTE_IF_SET_IN_BITMAP (e
, 0, i
, bi
)
7275 tree name
= ssa_name (i
);
7280 && ! SSA_NAME_IS_DEFAULT_DEF (name
)
7281 && prop_simulate_again_p (SSA_NAME_DEF_STMT (name
)))
7284 equiv_vr
= get_vr_for_comparison (i
);
7286 t
= compare_range_with_value (comp
, &equiv_vr
, val
, &sop
);
7289 /* If we get different answers from different members
7290 of the equivalence set this check must be in a dead
7291 code region. Folding it to a trap representation
7292 would be correct here. For now just return don't-know. */
7302 used_strict_overflow
= 0;
7303 else if (used_strict_overflow
< 0)
7304 used_strict_overflow
= 1;
7309 && used_strict_overflow
> 0)
7310 *strict_overflow_p
= true;
7316 /* Given a comparison code COMP and names N1 and N2, compare all the
7317 ranges equivalent to N1 against all the ranges equivalent to N2
7318 to determine the value of N1 COMP N2. Return the same value
7319 returned by compare_ranges. Set *STRICT_OVERFLOW_P to indicate
7320 whether we relied on undefined signed overflow in the comparison. */
7324 compare_names (enum tree_code comp
, tree n1
, tree n2
,
7325 bool *strict_overflow_p
)
7329 bitmap_iterator bi1
, bi2
;
7331 int used_strict_overflow
;
7332 static bitmap_obstack
*s_obstack
= NULL
;
7333 static bitmap s_e1
= NULL
, s_e2
= NULL
;
7335 /* Compare the ranges of every name equivalent to N1 against the
7336 ranges of every name equivalent to N2. */
7337 e1
= get_value_range (n1
)->equiv
;
7338 e2
= get_value_range (n2
)->equiv
;
7340 /* Use the fake bitmaps if e1 or e2 are not available. */
7341 if (s_obstack
== NULL
)
7343 s_obstack
= XNEW (bitmap_obstack
);
7344 bitmap_obstack_initialize (s_obstack
);
7345 s_e1
= BITMAP_ALLOC (s_obstack
);
7346 s_e2
= BITMAP_ALLOC (s_obstack
);
7353 /* Add N1 and N2 to their own set of equivalences to avoid
7354 duplicating the body of the loop just to check N1 and N2
7356 bitmap_set_bit (e1
, SSA_NAME_VERSION (n1
));
7357 bitmap_set_bit (e2
, SSA_NAME_VERSION (n2
));
7359 /* If the equivalence sets have a common intersection, then the two
7360 names can be compared without checking their ranges. */
7361 if (bitmap_intersect_p (e1
, e2
))
7363 bitmap_clear_bit (e1
, SSA_NAME_VERSION (n1
));
7364 bitmap_clear_bit (e2
, SSA_NAME_VERSION (n2
));
7366 return (comp
== EQ_EXPR
|| comp
== GE_EXPR
|| comp
== LE_EXPR
)
7368 : boolean_false_node
;
7371 /* Start at -1. Set it to 0 if we do a comparison without relying
7372 on overflow, or 1 if all comparisons rely on overflow. */
7373 used_strict_overflow
= -1;
7375 /* Otherwise, compare all the equivalent ranges. First, add N1 and
7376 N2 to their own set of equivalences to avoid duplicating the body
7377 of the loop just to check N1 and N2 ranges. */
7378 EXECUTE_IF_SET_IN_BITMAP (e1
, 0, i1
, bi1
)
7380 if (! ssa_name (i1
))
7383 value_range vr1
= get_vr_for_comparison (i1
);
7385 t
= retval
= NULL_TREE
;
7386 EXECUTE_IF_SET_IN_BITMAP (e2
, 0, i2
, bi2
)
7388 if (! ssa_name (i2
))
7393 value_range vr2
= get_vr_for_comparison (i2
);
7395 t
= compare_ranges (comp
, &vr1
, &vr2
, &sop
);
7398 /* If we get different answers from different members
7399 of the equivalence set this check must be in a dead
7400 code region. Folding it to a trap representation
7401 would be correct here. For now just return don't-know. */
7405 bitmap_clear_bit (e1
, SSA_NAME_VERSION (n1
));
7406 bitmap_clear_bit (e2
, SSA_NAME_VERSION (n2
));
7412 used_strict_overflow
= 0;
7413 else if (used_strict_overflow
< 0)
7414 used_strict_overflow
= 1;
7420 bitmap_clear_bit (e1
, SSA_NAME_VERSION (n1
));
7421 bitmap_clear_bit (e2
, SSA_NAME_VERSION (n2
));
7422 if (used_strict_overflow
> 0)
7423 *strict_overflow_p
= true;
7428 /* None of the equivalent ranges are useful in computing this
7430 bitmap_clear_bit (e1
, SSA_NAME_VERSION (n1
));
7431 bitmap_clear_bit (e2
, SSA_NAME_VERSION (n2
));
7435 /* Helper function for vrp_evaluate_conditional_warnv & other
7439 vrp_evaluate_conditional_warnv_with_ops_using_ranges (enum tree_code code
,
7441 bool * strict_overflow_p
)
7443 value_range
*vr0
, *vr1
;
7445 vr0
= (TREE_CODE (op0
) == SSA_NAME
) ? get_value_range (op0
) : NULL
;
7446 vr1
= (TREE_CODE (op1
) == SSA_NAME
) ? get_value_range (op1
) : NULL
;
7448 tree res
= NULL_TREE
;
7450 res
= compare_ranges (code
, vr0
, vr1
, strict_overflow_p
);
7452 res
= compare_range_with_value (code
, vr0
, op1
, strict_overflow_p
);
7454 res
= (compare_range_with_value
7455 (swap_tree_comparison (code
), vr1
, op0
, strict_overflow_p
));
7459 /* Helper function for vrp_evaluate_conditional_warnv. */
7462 vrp_evaluate_conditional_warnv_with_ops (enum tree_code code
, tree op0
,
7463 tree op1
, bool use_equiv_p
,
7464 bool *strict_overflow_p
, bool *only_ranges
)
7468 *only_ranges
= true;
7470 /* We only deal with integral and pointer types. */
7471 if (!INTEGRAL_TYPE_P (TREE_TYPE (op0
))
7472 && !POINTER_TYPE_P (TREE_TYPE (op0
)))
7475 /* If OP0 CODE OP1 is an overflow comparison, if it can be expressed
7476 as a simple equality test, then prefer that over its current form
7479 An overflow test which collapses to an equality test can always be
7480 expressed as a comparison of one argument against zero. Overflow
7481 occurs when the chosen argument is zero and does not occur if the
7482 chosen argument is not zero. */
7484 if (overflow_comparison_p (code
, op0
, op1
, use_equiv_p
, &x
))
7486 wide_int max
= wi::max_value (TYPE_PRECISION (TREE_TYPE (op0
)), UNSIGNED
);
7487 /* B = A - 1; if (A < B) -> B = A - 1; if (A == 0)
7488 B = A - 1; if (A > B) -> B = A - 1; if (A != 0)
7489 B = A + 1; if (B < A) -> B = A + 1; if (B == 0)
7490 B = A + 1; if (B > A) -> B = A + 1; if (B != 0) */
7491 if (integer_zerop (x
))
7494 code
= (code
== LT_EXPR
|| code
== LE_EXPR
) ? EQ_EXPR
: NE_EXPR
;
7496 /* B = A + 1; if (A > B) -> B = A + 1; if (B == 0)
7497 B = A + 1; if (A < B) -> B = A + 1; if (B != 0)
7498 B = A - 1; if (B > A) -> B = A - 1; if (A == 0)
7499 B = A - 1; if (B < A) -> B = A - 1; if (A != 0) */
7500 else if (wi::eq_p (x
, max
- 1))
7503 op1
= wide_int_to_tree (TREE_TYPE (op0
), 0);
7504 code
= (code
== GT_EXPR
|| code
== GE_EXPR
) ? EQ_EXPR
: NE_EXPR
;
7508 if ((ret
= vrp_evaluate_conditional_warnv_with_ops_using_ranges
7509 (code
, op0
, op1
, strict_overflow_p
)))
7512 *only_ranges
= false;
7513 /* Do not use compare_names during propagation, it's quadratic. */
7514 if (TREE_CODE (op0
) == SSA_NAME
&& TREE_CODE (op1
) == SSA_NAME
7516 return compare_names (code
, op0
, op1
, strict_overflow_p
);
7517 else if (TREE_CODE (op0
) == SSA_NAME
)
7518 return compare_name_with_value (code
, op0
, op1
,
7519 strict_overflow_p
, use_equiv_p
);
7520 else if (TREE_CODE (op1
) == SSA_NAME
)
7521 return compare_name_with_value (swap_tree_comparison (code
), op1
, op0
,
7522 strict_overflow_p
, use_equiv_p
);
7526 /* Given (CODE OP0 OP1) within STMT, try to simplify it based on value range
7527 information. Return NULL if the conditional can not be evaluated.
7528 The ranges of all the names equivalent with the operands in COND
7529 will be used when trying to compute the value. If the result is
7530 based on undefined signed overflow, issue a warning if
7534 vrp_evaluate_conditional (tree_code code
, tree op0
, tree op1
, gimple
*stmt
)
7540 /* Some passes and foldings leak constants with overflow flag set
7541 into the IL. Avoid doing wrong things with these and bail out. */
7542 if ((TREE_CODE (op0
) == INTEGER_CST
7543 && TREE_OVERFLOW (op0
))
7544 || (TREE_CODE (op1
) == INTEGER_CST
7545 && TREE_OVERFLOW (op1
)))
7549 ret
= vrp_evaluate_conditional_warnv_with_ops (code
, op0
, op1
, true, &sop
,
7554 enum warn_strict_overflow_code wc
;
7555 const char* warnmsg
;
7557 if (is_gimple_min_invariant (ret
))
7559 wc
= WARN_STRICT_OVERFLOW_CONDITIONAL
;
7560 warnmsg
= G_("assuming signed overflow does not occur when "
7561 "simplifying conditional to constant");
7565 wc
= WARN_STRICT_OVERFLOW_COMPARISON
;
7566 warnmsg
= G_("assuming signed overflow does not occur when "
7567 "simplifying conditional");
7570 if (issue_strict_overflow_warning (wc
))
7572 location_t location
;
7574 if (!gimple_has_location (stmt
))
7575 location
= input_location
;
7577 location
= gimple_location (stmt
);
7578 warning_at (location
, OPT_Wstrict_overflow
, "%s", warnmsg
);
7582 if (warn_type_limits
7583 && ret
&& only_ranges
7584 && TREE_CODE_CLASS (code
) == tcc_comparison
7585 && TREE_CODE (op0
) == SSA_NAME
)
7587 /* If the comparison is being folded and the operand on the LHS
7588 is being compared against a constant value that is outside of
7589 the natural range of OP0's type, then the predicate will
7590 always fold regardless of the value of OP0. If -Wtype-limits
7591 was specified, emit a warning. */
7592 tree type
= TREE_TYPE (op0
);
7593 value_range
*vr0
= get_value_range (op0
);
7595 if (vr0
->type
== VR_RANGE
7596 && INTEGRAL_TYPE_P (type
)
7597 && vrp_val_is_min (vr0
->min
)
7598 && vrp_val_is_max (vr0
->max
)
7599 && is_gimple_min_invariant (op1
))
7601 location_t location
;
7603 if (!gimple_has_location (stmt
))
7604 location
= input_location
;
7606 location
= gimple_location (stmt
);
7608 warning_at (location
, OPT_Wtype_limits
,
7610 ? G_("comparison always false "
7611 "due to limited range of data type")
7612 : G_("comparison always true "
7613 "due to limited range of data type"));
7621 /* Visit conditional statement STMT. If we can determine which edge
7622 will be taken out of STMT's basic block, record it in
7623 *TAKEN_EDGE_P. Otherwise, set *TAKEN_EDGE_P to NULL. */
7626 vrp_visit_cond_stmt (gcond
*stmt
, edge
*taken_edge_p
)
7630 *taken_edge_p
= NULL
;
7632 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
7637 fprintf (dump_file
, "\nVisiting conditional with predicate: ");
7638 print_gimple_stmt (dump_file
, stmt
, 0);
7639 fprintf (dump_file
, "\nWith known ranges\n");
7641 FOR_EACH_SSA_TREE_OPERAND (use
, stmt
, i
, SSA_OP_USE
)
7643 fprintf (dump_file
, "\t");
7644 print_generic_expr (dump_file
, use
);
7645 fprintf (dump_file
, ": ");
7646 dump_value_range (dump_file
, vr_value
[SSA_NAME_VERSION (use
)]);
7649 fprintf (dump_file
, "\n");
7652 /* Compute the value of the predicate COND by checking the known
7653 ranges of each of its operands.
7655 Note that we cannot evaluate all the equivalent ranges here
7656 because those ranges may not yet be final and with the current
7657 propagation strategy, we cannot determine when the value ranges
7658 of the names in the equivalence set have changed.
7660 For instance, given the following code fragment
7664 i_14 = ASSERT_EXPR <i_5, i_5 != 0>
7668 Assume that on the first visit to i_14, i_5 has the temporary
7669 range [8, 8] because the second argument to the PHI function is
7670 not yet executable. We derive the range ~[0, 0] for i_14 and the
7671 equivalence set { i_5 }. So, when we visit 'if (i_14 == 1)' for
7672 the first time, since i_14 is equivalent to the range [8, 8], we
7673 determine that the predicate is always false.
7675 On the next round of propagation, i_13 is determined to be
7676 VARYING, which causes i_5 to drop down to VARYING. So, another
7677 visit to i_14 is scheduled. In this second visit, we compute the
7678 exact same range and equivalence set for i_14, namely ~[0, 0] and
7679 { i_5 }. But we did not have the previous range for i_5
7680 registered, so vrp_visit_assignment thinks that the range for
7681 i_14 has not changed. Therefore, the predicate 'if (i_14 == 1)'
7682 is not visited again, which stops propagation from visiting
7683 statements in the THEN clause of that if().
7685 To properly fix this we would need to keep the previous range
7686 value for the names in the equivalence set. This way we would've
7687 discovered that from one visit to the other i_5 changed from
7688 range [8, 8] to VR_VARYING.
7690 However, fixing this apparent limitation may not be worth the
7691 additional checking. Testing on several code bases (GCC, DLV,
7692 MICO, TRAMP3D and SPEC2000) showed that doing this results in
7693 4 more predicates folded in SPEC. */
7696 val
= vrp_evaluate_conditional_warnv_with_ops (gimple_cond_code (stmt
),
7697 gimple_cond_lhs (stmt
),
7698 gimple_cond_rhs (stmt
),
7701 *taken_edge_p
= find_taken_edge (gimple_bb (stmt
), val
);
7703 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
7705 fprintf (dump_file
, "\nPredicate evaluates to: ");
7706 if (val
== NULL_TREE
)
7707 fprintf (dump_file
, "DON'T KNOW\n");
7709 print_generic_stmt (dump_file
, val
);
7713 /* Searches the case label vector VEC for the index *IDX of the CASE_LABEL
7714 that includes the value VAL. The search is restricted to the range
7715 [START_IDX, n - 1] where n is the size of VEC.
7717 If there is a CASE_LABEL for VAL, its index is placed in IDX and true is
7720 If there is no CASE_LABEL for VAL and there is one that is larger than VAL,
7721 it is placed in IDX and false is returned.
7723 If VAL is larger than any CASE_LABEL, n is placed on IDX and false is
7727 find_case_label_index (gswitch
*stmt
, size_t start_idx
, tree val
, size_t *idx
)
7729 size_t n
= gimple_switch_num_labels (stmt
);
7732 /* Find case label for minimum of the value range or the next one.
7733 At each iteration we are searching in [low, high - 1]. */
7735 for (low
= start_idx
, high
= n
; high
!= low
; )
7739 /* Note that i != high, so we never ask for n. */
7740 size_t i
= (high
+ low
) / 2;
7741 t
= gimple_switch_label (stmt
, i
);
7743 /* Cache the result of comparing CASE_LOW and val. */
7744 cmp
= tree_int_cst_compare (CASE_LOW (t
), val
);
7748 /* Ranges cannot be empty. */
7757 if (CASE_HIGH (t
) != NULL
7758 && tree_int_cst_compare (CASE_HIGH (t
), val
) >= 0)
7770 /* Searches the case label vector VEC for the range of CASE_LABELs that is used
7771 for values between MIN and MAX. The first index is placed in MIN_IDX. The
7772 last index is placed in MAX_IDX. If the range of CASE_LABELs is empty
7773 then MAX_IDX < MIN_IDX.
7774 Returns true if the default label is not needed. */
7777 find_case_label_range (gswitch
*stmt
, tree min
, tree max
, size_t *min_idx
,
7781 bool min_take_default
= !find_case_label_index (stmt
, 1, min
, &i
);
7782 bool max_take_default
= !find_case_label_index (stmt
, i
, max
, &j
);
7786 && max_take_default
)
7788 /* Only the default case label reached.
7789 Return an empty range. */
7796 bool take_default
= min_take_default
|| max_take_default
;
7800 if (max_take_default
)
7803 /* If the case label range is continuous, we do not need
7804 the default case label. Verify that. */
7805 high
= CASE_LOW (gimple_switch_label (stmt
, i
));
7806 if (CASE_HIGH (gimple_switch_label (stmt
, i
)))
7807 high
= CASE_HIGH (gimple_switch_label (stmt
, i
));
7808 for (k
= i
+ 1; k
<= j
; ++k
)
7810 low
= CASE_LOW (gimple_switch_label (stmt
, k
));
7811 if (!integer_onep (int_const_binop (MINUS_EXPR
, low
, high
)))
7813 take_default
= true;
7817 if (CASE_HIGH (gimple_switch_label (stmt
, k
)))
7818 high
= CASE_HIGH (gimple_switch_label (stmt
, k
));
7823 return !take_default
;
7827 /* Searches the case label vector VEC for the ranges of CASE_LABELs that are
7828 used in range VR. The indices are placed in MIN_IDX1, MAX_IDX, MIN_IDX2 and
7829 MAX_IDX2. If the ranges of CASE_LABELs are empty then MAX_IDX1 < MIN_IDX1.
7830 Returns true if the default label is not needed. */
7833 find_case_label_ranges (gswitch
*stmt
, value_range
*vr
, size_t *min_idx1
,
7834 size_t *max_idx1
, size_t *min_idx2
,
7838 unsigned int n
= gimple_switch_num_labels (stmt
);
7840 tree case_low
, case_high
;
7841 tree min
= vr
->min
, max
= vr
->max
;
7843 gcc_checking_assert (vr
->type
== VR_RANGE
|| vr
->type
== VR_ANTI_RANGE
);
7845 take_default
= !find_case_label_range (stmt
, min
, max
, &i
, &j
);
7847 /* Set second range to emtpy. */
7851 if (vr
->type
== VR_RANGE
)
7855 return !take_default
;
7858 /* Set first range to all case labels. */
7865 /* Make sure all the values of case labels [i , j] are contained in
7866 range [MIN, MAX]. */
7867 case_low
= CASE_LOW (gimple_switch_label (stmt
, i
));
7868 case_high
= CASE_HIGH (gimple_switch_label (stmt
, j
));
7869 if (tree_int_cst_compare (case_low
, min
) < 0)
7871 if (case_high
!= NULL_TREE
7872 && tree_int_cst_compare (max
, case_high
) < 0)
7878 /* If the range spans case labels [i, j], the corresponding anti-range spans
7879 the labels [1, i - 1] and [j + 1, n - 1]. */
7905 /* Visit switch statement STMT. If we can determine which edge
7906 will be taken out of STMT's basic block, record it in
7907 *TAKEN_EDGE_P. Otherwise, *TAKEN_EDGE_P set to NULL. */
7910 vrp_visit_switch_stmt (gswitch
*stmt
, edge
*taken_edge_p
)
7914 size_t i
= 0, j
= 0, k
, l
;
7917 *taken_edge_p
= NULL
;
7918 op
= gimple_switch_index (stmt
);
7919 if (TREE_CODE (op
) != SSA_NAME
)
7922 vr
= get_value_range (op
);
7923 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
7925 fprintf (dump_file
, "\nVisiting switch expression with operand ");
7926 print_generic_expr (dump_file
, op
);
7927 fprintf (dump_file
, " with known range ");
7928 dump_value_range (dump_file
, vr
);
7929 fprintf (dump_file
, "\n");
7932 if ((vr
->type
!= VR_RANGE
7933 && vr
->type
!= VR_ANTI_RANGE
)
7934 || symbolic_range_p (vr
))
7937 /* Find the single edge that is taken from the switch expression. */
7938 take_default
= !find_case_label_ranges (stmt
, vr
, &i
, &j
, &k
, &l
);
7940 /* Check if the range spans no CASE_LABEL. If so, we only reach the default
7944 gcc_assert (take_default
);
7945 val
= gimple_switch_default_label (stmt
);
7949 /* Check if labels with index i to j and maybe the default label
7950 are all reaching the same label. */
7952 val
= gimple_switch_label (stmt
, i
);
7954 && CASE_LABEL (gimple_switch_default_label (stmt
))
7955 != CASE_LABEL (val
))
7957 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
7958 fprintf (dump_file
, " not a single destination for this "
7962 for (++i
; i
<= j
; ++i
)
7964 if (CASE_LABEL (gimple_switch_label (stmt
, i
)) != CASE_LABEL (val
))
7966 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
7967 fprintf (dump_file
, " not a single destination for this "
7974 if (CASE_LABEL (gimple_switch_label (stmt
, k
)) != CASE_LABEL (val
))
7976 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
7977 fprintf (dump_file
, " not a single destination for this "
7984 *taken_edge_p
= find_edge (gimple_bb (stmt
),
7985 label_to_block (CASE_LABEL (val
)));
7987 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
7989 fprintf (dump_file
, " will take edge to ");
7990 print_generic_stmt (dump_file
, CASE_LABEL (val
));
7995 /* Evaluate statement STMT. If the statement produces a useful range,
7996 set VR and corepsponding OUTPUT_P.
7998 If STMT is a conditional branch and we can determine its truth
7999 value, the taken edge is recorded in *TAKEN_EDGE_P. */
8002 extract_range_from_stmt (gimple
*stmt
, edge
*taken_edge_p
,
8003 tree
*output_p
, value_range
*vr
)
8006 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
8008 fprintf (dump_file
, "\nVisiting statement:\n");
8009 print_gimple_stmt (dump_file
, stmt
, 0, dump_flags
);
8012 if (!stmt_interesting_for_vrp (stmt
))
8013 gcc_assert (stmt_ends_bb_p (stmt
));
8014 else if (is_gimple_assign (stmt
) || is_gimple_call (stmt
))
8015 vrp_visit_assignment_or_call (stmt
, output_p
, vr
);
8016 else if (gimple_code (stmt
) == GIMPLE_COND
)
8017 vrp_visit_cond_stmt (as_a
<gcond
*> (stmt
), taken_edge_p
);
8018 else if (gimple_code (stmt
) == GIMPLE_SWITCH
)
8019 vrp_visit_switch_stmt (as_a
<gswitch
*> (stmt
), taken_edge_p
);
8022 /* Evaluate statement STMT. If the statement produces a useful range,
8023 return SSA_PROP_INTERESTING and record the SSA name with the
8024 interesting range into *OUTPUT_P.
8026 If STMT is a conditional branch and we can determine its truth
8027 value, the taken edge is recorded in *TAKEN_EDGE_P.
8029 If STMT produces a varying value, return SSA_PROP_VARYING. */
8031 static enum ssa_prop_result
8032 vrp_visit_stmt (gimple
*stmt
, edge
*taken_edge_p
, tree
*output_p
)
8034 value_range vr
= VR_INITIALIZER
;
8035 tree lhs
= gimple_get_lhs (stmt
);
8036 extract_range_from_stmt (stmt
, taken_edge_p
, output_p
, &vr
);
8040 if (update_value_range (*output_p
, &vr
))
8042 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
8044 fprintf (dump_file
, "Found new range for ");
8045 print_generic_expr (dump_file
, *output_p
);
8046 fprintf (dump_file
, ": ");
8047 dump_value_range (dump_file
, &vr
);
8048 fprintf (dump_file
, "\n");
8051 if (vr
.type
== VR_VARYING
)
8052 return SSA_PROP_VARYING
;
8054 return SSA_PROP_INTERESTING
;
8056 return SSA_PROP_NOT_INTERESTING
;
8059 if (is_gimple_call (stmt
) && gimple_call_internal_p (stmt
))
8060 switch (gimple_call_internal_fn (stmt
))
8062 case IFN_ADD_OVERFLOW
:
8063 case IFN_SUB_OVERFLOW
:
8064 case IFN_MUL_OVERFLOW
:
8065 case IFN_ATOMIC_COMPARE_EXCHANGE
:
8066 /* These internal calls return _Complex integer type,
8067 which VRP does not track, but the immediate uses
8068 thereof might be interesting. */
8069 if (lhs
&& TREE_CODE (lhs
) == SSA_NAME
)
8071 imm_use_iterator iter
;
8072 use_operand_p use_p
;
8073 enum ssa_prop_result res
= SSA_PROP_VARYING
;
8075 set_value_range_to_varying (get_value_range (lhs
));
8077 FOR_EACH_IMM_USE_FAST (use_p
, iter
, lhs
)
8079 gimple
*use_stmt
= USE_STMT (use_p
);
8080 if (!is_gimple_assign (use_stmt
))
8082 enum tree_code rhs_code
= gimple_assign_rhs_code (use_stmt
);
8083 if (rhs_code
!= REALPART_EXPR
&& rhs_code
!= IMAGPART_EXPR
)
8085 tree rhs1
= gimple_assign_rhs1 (use_stmt
);
8086 tree use_lhs
= gimple_assign_lhs (use_stmt
);
8087 if (TREE_CODE (rhs1
) != rhs_code
8088 || TREE_OPERAND (rhs1
, 0) != lhs
8089 || TREE_CODE (use_lhs
) != SSA_NAME
8090 || !stmt_interesting_for_vrp (use_stmt
)
8091 || (!INTEGRAL_TYPE_P (TREE_TYPE (use_lhs
))
8092 || !TYPE_MIN_VALUE (TREE_TYPE (use_lhs
))
8093 || !TYPE_MAX_VALUE (TREE_TYPE (use_lhs
))))
8096 /* If there is a change in the value range for any of the
8097 REALPART_EXPR/IMAGPART_EXPR immediate uses, return
8098 SSA_PROP_INTERESTING. If there are any REALPART_EXPR
8099 or IMAGPART_EXPR immediate uses, but none of them have
8100 a change in their value ranges, return
8101 SSA_PROP_NOT_INTERESTING. If there are no
8102 {REAL,IMAG}PART_EXPR uses at all,
8103 return SSA_PROP_VARYING. */
8104 value_range new_vr
= VR_INITIALIZER
;
8105 extract_range_basic (&new_vr
, use_stmt
);
8106 value_range
*old_vr
= get_value_range (use_lhs
);
8107 if (old_vr
->type
!= new_vr
.type
8108 || !vrp_operand_equal_p (old_vr
->min
, new_vr
.min
)
8109 || !vrp_operand_equal_p (old_vr
->max
, new_vr
.max
)
8110 || !vrp_bitmap_equal_p (old_vr
->equiv
, new_vr
.equiv
))
8111 res
= SSA_PROP_INTERESTING
;
8113 res
= SSA_PROP_NOT_INTERESTING
;
8114 BITMAP_FREE (new_vr
.equiv
);
8115 if (res
== SSA_PROP_INTERESTING
)
8129 /* All other statements produce nothing of interest for VRP, so mark
8130 their outputs varying and prevent further simulation. */
8131 set_defs_to_varying (stmt
);
8133 return (*taken_edge_p
) ? SSA_PROP_INTERESTING
: SSA_PROP_VARYING
;
8136 /* Union the two value-ranges { *VR0TYPE, *VR0MIN, *VR0MAX } and
8137 { VR1TYPE, VR0MIN, VR0MAX } and store the result
8138 in { *VR0TYPE, *VR0MIN, *VR0MAX }. This may not be the smallest
8139 possible such range. The resulting range is not canonicalized. */
8142 union_ranges (enum value_range_type
*vr0type
,
8143 tree
*vr0min
, tree
*vr0max
,
8144 enum value_range_type vr1type
,
8145 tree vr1min
, tree vr1max
)
8147 bool mineq
= vrp_operand_equal_p (*vr0min
, vr1min
);
8148 bool maxeq
= vrp_operand_equal_p (*vr0max
, vr1max
);
8150 /* [] is vr0, () is vr1 in the following classification comments. */
8154 if (*vr0type
== vr1type
)
8155 /* Nothing to do for equal ranges. */
8157 else if ((*vr0type
== VR_RANGE
8158 && vr1type
== VR_ANTI_RANGE
)
8159 || (*vr0type
== VR_ANTI_RANGE
8160 && vr1type
== VR_RANGE
))
8162 /* For anti-range with range union the result is varying. */
8168 else if (operand_less_p (*vr0max
, vr1min
) == 1
8169 || operand_less_p (vr1max
, *vr0min
) == 1)
8171 /* [ ] ( ) or ( ) [ ]
8172 If the ranges have an empty intersection, result of the union
8173 operation is the anti-range or if both are anti-ranges
8175 if (*vr0type
== VR_ANTI_RANGE
8176 && vr1type
== VR_ANTI_RANGE
)
8178 else if (*vr0type
== VR_ANTI_RANGE
8179 && vr1type
== VR_RANGE
)
8181 else if (*vr0type
== VR_RANGE
8182 && vr1type
== VR_ANTI_RANGE
)
8188 else if (*vr0type
== VR_RANGE
8189 && vr1type
== VR_RANGE
)
8191 /* The result is the convex hull of both ranges. */
8192 if (operand_less_p (*vr0max
, vr1min
) == 1)
8194 /* If the result can be an anti-range, create one. */
8195 if (TREE_CODE (*vr0max
) == INTEGER_CST
8196 && TREE_CODE (vr1min
) == INTEGER_CST
8197 && vrp_val_is_min (*vr0min
)
8198 && vrp_val_is_max (vr1max
))
8200 tree min
= int_const_binop (PLUS_EXPR
,
8202 build_int_cst (TREE_TYPE (*vr0max
), 1));
8203 tree max
= int_const_binop (MINUS_EXPR
,
8205 build_int_cst (TREE_TYPE (vr1min
), 1));
8206 if (!operand_less_p (max
, min
))
8208 *vr0type
= VR_ANTI_RANGE
;
8220 /* If the result can be an anti-range, create one. */
8221 if (TREE_CODE (vr1max
) == INTEGER_CST
8222 && TREE_CODE (*vr0min
) == INTEGER_CST
8223 && vrp_val_is_min (vr1min
)
8224 && vrp_val_is_max (*vr0max
))
8226 tree min
= int_const_binop (PLUS_EXPR
,
8228 build_int_cst (TREE_TYPE (vr1max
), 1));
8229 tree max
= int_const_binop (MINUS_EXPR
,
8231 build_int_cst (TREE_TYPE (*vr0min
), 1));
8232 if (!operand_less_p (max
, min
))
8234 *vr0type
= VR_ANTI_RANGE
;
8248 else if ((maxeq
|| operand_less_p (vr1max
, *vr0max
) == 1)
8249 && (mineq
|| operand_less_p (*vr0min
, vr1min
) == 1))
8251 /* [ ( ) ] or [( ) ] or [ ( )] */
8252 if (*vr0type
== VR_RANGE
8253 && vr1type
== VR_RANGE
)
8255 else if (*vr0type
== VR_ANTI_RANGE
8256 && vr1type
== VR_ANTI_RANGE
)
8262 else if (*vr0type
== VR_ANTI_RANGE
8263 && vr1type
== VR_RANGE
)
8265 /* Arbitrarily choose the right or left gap. */
8266 if (!mineq
&& TREE_CODE (vr1min
) == INTEGER_CST
)
8267 *vr0max
= int_const_binop (MINUS_EXPR
, vr1min
,
8268 build_int_cst (TREE_TYPE (vr1min
), 1));
8269 else if (!maxeq
&& TREE_CODE (vr1max
) == INTEGER_CST
)
8270 *vr0min
= int_const_binop (PLUS_EXPR
, vr1max
,
8271 build_int_cst (TREE_TYPE (vr1max
), 1));
8275 else if (*vr0type
== VR_RANGE
8276 && vr1type
== VR_ANTI_RANGE
)
8277 /* The result covers everything. */
8282 else if ((maxeq
|| operand_less_p (*vr0max
, vr1max
) == 1)
8283 && (mineq
|| operand_less_p (vr1min
, *vr0min
) == 1))
8285 /* ( [ ] ) or ([ ] ) or ( [ ]) */
8286 if (*vr0type
== VR_RANGE
8287 && vr1type
== VR_RANGE
)
8293 else if (*vr0type
== VR_ANTI_RANGE
8294 && vr1type
== VR_ANTI_RANGE
)
8296 else if (*vr0type
== VR_RANGE
8297 && vr1type
== VR_ANTI_RANGE
)
8299 *vr0type
= VR_ANTI_RANGE
;
8300 if (!mineq
&& TREE_CODE (*vr0min
) == INTEGER_CST
)
8302 *vr0max
= int_const_binop (MINUS_EXPR
, *vr0min
,
8303 build_int_cst (TREE_TYPE (*vr0min
), 1));
8306 else if (!maxeq
&& TREE_CODE (*vr0max
) == INTEGER_CST
)
8308 *vr0min
= int_const_binop (PLUS_EXPR
, *vr0max
,
8309 build_int_cst (TREE_TYPE (*vr0max
), 1));
8315 else if (*vr0type
== VR_ANTI_RANGE
8316 && vr1type
== VR_RANGE
)
8317 /* The result covers everything. */
8322 else if ((operand_less_p (vr1min
, *vr0max
) == 1
8323 || operand_equal_p (vr1min
, *vr0max
, 0))
8324 && operand_less_p (*vr0min
, vr1min
) == 1
8325 && operand_less_p (*vr0max
, vr1max
) == 1)
8327 /* [ ( ] ) or [ ]( ) */
8328 if (*vr0type
== VR_RANGE
8329 && vr1type
== VR_RANGE
)
8331 else if (*vr0type
== VR_ANTI_RANGE
8332 && vr1type
== VR_ANTI_RANGE
)
8334 else if (*vr0type
== VR_ANTI_RANGE
8335 && vr1type
== VR_RANGE
)
8337 if (TREE_CODE (vr1min
) == INTEGER_CST
)
8338 *vr0max
= int_const_binop (MINUS_EXPR
, vr1min
,
8339 build_int_cst (TREE_TYPE (vr1min
), 1));
8343 else if (*vr0type
== VR_RANGE
8344 && vr1type
== VR_ANTI_RANGE
)
8346 if (TREE_CODE (*vr0max
) == INTEGER_CST
)
8349 *vr0min
= int_const_binop (PLUS_EXPR
, *vr0max
,
8350 build_int_cst (TREE_TYPE (*vr0max
), 1));
8359 else if ((operand_less_p (*vr0min
, vr1max
) == 1
8360 || operand_equal_p (*vr0min
, vr1max
, 0))
8361 && operand_less_p (vr1min
, *vr0min
) == 1
8362 && operand_less_p (vr1max
, *vr0max
) == 1)
8364 /* ( [ ) ] or ( )[ ] */
8365 if (*vr0type
== VR_RANGE
8366 && vr1type
== VR_RANGE
)
8368 else if (*vr0type
== VR_ANTI_RANGE
8369 && vr1type
== VR_ANTI_RANGE
)
8371 else if (*vr0type
== VR_ANTI_RANGE
8372 && vr1type
== VR_RANGE
)
8374 if (TREE_CODE (vr1max
) == INTEGER_CST
)
8375 *vr0min
= int_const_binop (PLUS_EXPR
, vr1max
,
8376 build_int_cst (TREE_TYPE (vr1max
), 1));
8380 else if (*vr0type
== VR_RANGE
8381 && vr1type
== VR_ANTI_RANGE
)
8383 if (TREE_CODE (*vr0min
) == INTEGER_CST
)
8387 *vr0max
= int_const_binop (MINUS_EXPR
, *vr0min
,
8388 build_int_cst (TREE_TYPE (*vr0min
), 1));
8402 *vr0type
= VR_VARYING
;
8403 *vr0min
= NULL_TREE
;
8404 *vr0max
= NULL_TREE
;
8407 /* Intersect the two value-ranges { *VR0TYPE, *VR0MIN, *VR0MAX } and
8408 { VR1TYPE, VR0MIN, VR0MAX } and store the result
8409 in { *VR0TYPE, *VR0MIN, *VR0MAX }. This may not be the smallest
8410 possible such range. The resulting range is not canonicalized. */
8413 intersect_ranges (enum value_range_type
*vr0type
,
8414 tree
*vr0min
, tree
*vr0max
,
8415 enum value_range_type vr1type
,
8416 tree vr1min
, tree vr1max
)
8418 bool mineq
= vrp_operand_equal_p (*vr0min
, vr1min
);
8419 bool maxeq
= vrp_operand_equal_p (*vr0max
, vr1max
);
8421 /* [] is vr0, () is vr1 in the following classification comments. */
8425 if (*vr0type
== vr1type
)
8426 /* Nothing to do for equal ranges. */
8428 else if ((*vr0type
== VR_RANGE
8429 && vr1type
== VR_ANTI_RANGE
)
8430 || (*vr0type
== VR_ANTI_RANGE
8431 && vr1type
== VR_RANGE
))
8433 /* For anti-range with range intersection the result is empty. */
8434 *vr0type
= VR_UNDEFINED
;
8435 *vr0min
= NULL_TREE
;
8436 *vr0max
= NULL_TREE
;
8441 else if (operand_less_p (*vr0max
, vr1min
) == 1
8442 || operand_less_p (vr1max
, *vr0min
) == 1)
8444 /* [ ] ( ) or ( ) [ ]
8445 If the ranges have an empty intersection, the result of the
8446 intersect operation is the range for intersecting an
8447 anti-range with a range or empty when intersecting two ranges. */
8448 if (*vr0type
== VR_RANGE
8449 && vr1type
== VR_ANTI_RANGE
)
8451 else if (*vr0type
== VR_ANTI_RANGE
8452 && vr1type
== VR_RANGE
)
8458 else if (*vr0type
== VR_RANGE
8459 && vr1type
== VR_RANGE
)
8461 *vr0type
= VR_UNDEFINED
;
8462 *vr0min
= NULL_TREE
;
8463 *vr0max
= NULL_TREE
;
8465 else if (*vr0type
== VR_ANTI_RANGE
8466 && vr1type
== VR_ANTI_RANGE
)
8468 /* If the anti-ranges are adjacent to each other merge them. */
8469 if (TREE_CODE (*vr0max
) == INTEGER_CST
8470 && TREE_CODE (vr1min
) == INTEGER_CST
8471 && operand_less_p (*vr0max
, vr1min
) == 1
8472 && integer_onep (int_const_binop (MINUS_EXPR
,
8475 else if (TREE_CODE (vr1max
) == INTEGER_CST
8476 && TREE_CODE (*vr0min
) == INTEGER_CST
8477 && operand_less_p (vr1max
, *vr0min
) == 1
8478 && integer_onep (int_const_binop (MINUS_EXPR
,
8481 /* Else arbitrarily take VR0. */
8484 else if ((maxeq
|| operand_less_p (vr1max
, *vr0max
) == 1)
8485 && (mineq
|| operand_less_p (*vr0min
, vr1min
) == 1))
8487 /* [ ( ) ] or [( ) ] or [ ( )] */
8488 if (*vr0type
== VR_RANGE
8489 && vr1type
== VR_RANGE
)
8491 /* If both are ranges the result is the inner one. */
8496 else if (*vr0type
== VR_RANGE
8497 && vr1type
== VR_ANTI_RANGE
)
8499 /* Choose the right gap if the left one is empty. */
8502 if (TREE_CODE (vr1max
) != INTEGER_CST
)
8504 else if (TYPE_PRECISION (TREE_TYPE (vr1max
)) == 1
8505 && !TYPE_UNSIGNED (TREE_TYPE (vr1max
)))
8507 = int_const_binop (MINUS_EXPR
, vr1max
,
8508 build_int_cst (TREE_TYPE (vr1max
), -1));
8511 = int_const_binop (PLUS_EXPR
, vr1max
,
8512 build_int_cst (TREE_TYPE (vr1max
), 1));
8514 /* Choose the left gap if the right one is empty. */
8517 if (TREE_CODE (vr1min
) != INTEGER_CST
)
8519 else if (TYPE_PRECISION (TREE_TYPE (vr1min
)) == 1
8520 && !TYPE_UNSIGNED (TREE_TYPE (vr1min
)))
8522 = int_const_binop (PLUS_EXPR
, vr1min
,
8523 build_int_cst (TREE_TYPE (vr1min
), -1));
8526 = int_const_binop (MINUS_EXPR
, vr1min
,
8527 build_int_cst (TREE_TYPE (vr1min
), 1));
8529 /* Choose the anti-range if the range is effectively varying. */
8530 else if (vrp_val_is_min (*vr0min
)
8531 && vrp_val_is_max (*vr0max
))
8537 /* Else choose the range. */
8539 else if (*vr0type
== VR_ANTI_RANGE
8540 && vr1type
== VR_ANTI_RANGE
)
8541 /* If both are anti-ranges the result is the outer one. */
8543 else if (*vr0type
== VR_ANTI_RANGE
8544 && vr1type
== VR_RANGE
)
8546 /* The intersection is empty. */
8547 *vr0type
= VR_UNDEFINED
;
8548 *vr0min
= NULL_TREE
;
8549 *vr0max
= NULL_TREE
;
8554 else if ((maxeq
|| operand_less_p (*vr0max
, vr1max
) == 1)
8555 && (mineq
|| operand_less_p (vr1min
, *vr0min
) == 1))
8557 /* ( [ ] ) or ([ ] ) or ( [ ]) */
8558 if (*vr0type
== VR_RANGE
8559 && vr1type
== VR_RANGE
)
8560 /* Choose the inner range. */
8562 else if (*vr0type
== VR_ANTI_RANGE
8563 && vr1type
== VR_RANGE
)
8565 /* Choose the right gap if the left is empty. */
8568 *vr0type
= VR_RANGE
;
8569 if (TREE_CODE (*vr0max
) != INTEGER_CST
)
8571 else if (TYPE_PRECISION (TREE_TYPE (*vr0max
)) == 1
8572 && !TYPE_UNSIGNED (TREE_TYPE (*vr0max
)))
8574 = int_const_binop (MINUS_EXPR
, *vr0max
,
8575 build_int_cst (TREE_TYPE (*vr0max
), -1));
8578 = int_const_binop (PLUS_EXPR
, *vr0max
,
8579 build_int_cst (TREE_TYPE (*vr0max
), 1));
8582 /* Choose the left gap if the right is empty. */
8585 *vr0type
= VR_RANGE
;
8586 if (TREE_CODE (*vr0min
) != INTEGER_CST
)
8588 else if (TYPE_PRECISION (TREE_TYPE (*vr0min
)) == 1
8589 && !TYPE_UNSIGNED (TREE_TYPE (*vr0min
)))
8591 = int_const_binop (PLUS_EXPR
, *vr0min
,
8592 build_int_cst (TREE_TYPE (*vr0min
), -1));
8595 = int_const_binop (MINUS_EXPR
, *vr0min
,
8596 build_int_cst (TREE_TYPE (*vr0min
), 1));
8599 /* Choose the anti-range if the range is effectively varying. */
8600 else if (vrp_val_is_min (vr1min
)
8601 && vrp_val_is_max (vr1max
))
8603 /* Choose the anti-range if it is ~[0,0], that range is special
8604 enough to special case when vr1's range is relatively wide. */
8605 else if (*vr0min
== *vr0max
8606 && integer_zerop (*vr0min
)
8607 && (TYPE_PRECISION (TREE_TYPE (*vr0min
))
8608 == TYPE_PRECISION (ptr_type_node
))
8609 && TREE_CODE (vr1max
) == INTEGER_CST
8610 && TREE_CODE (vr1min
) == INTEGER_CST
8611 && (wi::clz (wi::sub (vr1max
, vr1min
))
8612 < TYPE_PRECISION (TREE_TYPE (*vr0min
)) / 2))
8614 /* Else choose the range. */
8622 else if (*vr0type
== VR_ANTI_RANGE
8623 && vr1type
== VR_ANTI_RANGE
)
8625 /* If both are anti-ranges the result is the outer one. */
8630 else if (vr1type
== VR_ANTI_RANGE
8631 && *vr0type
== VR_RANGE
)
8633 /* The intersection is empty. */
8634 *vr0type
= VR_UNDEFINED
;
8635 *vr0min
= NULL_TREE
;
8636 *vr0max
= NULL_TREE
;
8641 else if ((operand_less_p (vr1min
, *vr0max
) == 1
8642 || operand_equal_p (vr1min
, *vr0max
, 0))
8643 && operand_less_p (*vr0min
, vr1min
) == 1)
8645 /* [ ( ] ) or [ ]( ) */
8646 if (*vr0type
== VR_ANTI_RANGE
8647 && vr1type
== VR_ANTI_RANGE
)
8649 else if (*vr0type
== VR_RANGE
8650 && vr1type
== VR_RANGE
)
8652 else if (*vr0type
== VR_RANGE
8653 && vr1type
== VR_ANTI_RANGE
)
8655 if (TREE_CODE (vr1min
) == INTEGER_CST
)
8656 *vr0max
= int_const_binop (MINUS_EXPR
, vr1min
,
8657 build_int_cst (TREE_TYPE (vr1min
), 1));
8661 else if (*vr0type
== VR_ANTI_RANGE
8662 && vr1type
== VR_RANGE
)
8664 *vr0type
= VR_RANGE
;
8665 if (TREE_CODE (*vr0max
) == INTEGER_CST
)
8666 *vr0min
= int_const_binop (PLUS_EXPR
, *vr0max
,
8667 build_int_cst (TREE_TYPE (*vr0max
), 1));
8675 else if ((operand_less_p (*vr0min
, vr1max
) == 1
8676 || operand_equal_p (*vr0min
, vr1max
, 0))
8677 && operand_less_p (vr1min
, *vr0min
) == 1)
8679 /* ( [ ) ] or ( )[ ] */
8680 if (*vr0type
== VR_ANTI_RANGE
8681 && vr1type
== VR_ANTI_RANGE
)
8683 else if (*vr0type
== VR_RANGE
8684 && vr1type
== VR_RANGE
)
8686 else if (*vr0type
== VR_RANGE
8687 && vr1type
== VR_ANTI_RANGE
)
8689 if (TREE_CODE (vr1max
) == INTEGER_CST
)
8690 *vr0min
= int_const_binop (PLUS_EXPR
, vr1max
,
8691 build_int_cst (TREE_TYPE (vr1max
), 1));
8695 else if (*vr0type
== VR_ANTI_RANGE
8696 && vr1type
== VR_RANGE
)
8698 *vr0type
= VR_RANGE
;
8699 if (TREE_CODE (*vr0min
) == INTEGER_CST
)
8700 *vr0max
= int_const_binop (MINUS_EXPR
, *vr0min
,
8701 build_int_cst (TREE_TYPE (*vr0min
), 1));
8710 /* As a fallback simply use { *VRTYPE, *VR0MIN, *VR0MAX } as
8711 result for the intersection. That's always a conservative
8712 correct estimate unless VR1 is a constant singleton range
8713 in which case we choose that. */
8714 if (vr1type
== VR_RANGE
8715 && is_gimple_min_invariant (vr1min
)
8716 && vrp_operand_equal_p (vr1min
, vr1max
))
8727 /* Intersect the two value-ranges *VR0 and *VR1 and store the result
8728 in *VR0. This may not be the smallest possible such range. */
8731 vrp_intersect_ranges_1 (value_range
*vr0
, value_range
*vr1
)
8735 /* If either range is VR_VARYING the other one wins. */
8736 if (vr1
->type
== VR_VARYING
)
8738 if (vr0
->type
== VR_VARYING
)
8740 copy_value_range (vr0
, vr1
);
8744 /* When either range is VR_UNDEFINED the resulting range is
8745 VR_UNDEFINED, too. */
8746 if (vr0
->type
== VR_UNDEFINED
)
8748 if (vr1
->type
== VR_UNDEFINED
)
8750 set_value_range_to_undefined (vr0
);
8754 /* Save the original vr0 so we can return it as conservative intersection
8755 result when our worker turns things to varying. */
8757 intersect_ranges (&vr0
->type
, &vr0
->min
, &vr0
->max
,
8758 vr1
->type
, vr1
->min
, vr1
->max
);
8759 /* Make sure to canonicalize the result though as the inversion of a
8760 VR_RANGE can still be a VR_RANGE. */
8761 set_and_canonicalize_value_range (vr0
, vr0
->type
,
8762 vr0
->min
, vr0
->max
, vr0
->equiv
);
8763 /* If that failed, use the saved original VR0. */
8764 if (vr0
->type
== VR_VARYING
)
8769 /* If the result is VR_UNDEFINED there is no need to mess with
8770 the equivalencies. */
8771 if (vr0
->type
== VR_UNDEFINED
)
8774 /* The resulting set of equivalences for range intersection is the union of
8776 if (vr0
->equiv
&& vr1
->equiv
&& vr0
->equiv
!= vr1
->equiv
)
8777 bitmap_ior_into (vr0
->equiv
, vr1
->equiv
);
8778 else if (vr1
->equiv
&& !vr0
->equiv
)
8780 vr0
->equiv
= BITMAP_ALLOC (&vrp_equiv_obstack
);
8781 bitmap_copy (vr0
->equiv
, vr1
->equiv
);
8786 vrp_intersect_ranges (value_range
*vr0
, value_range
*vr1
)
8788 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
8790 fprintf (dump_file
, "Intersecting\n ");
8791 dump_value_range (dump_file
, vr0
);
8792 fprintf (dump_file
, "\nand\n ");
8793 dump_value_range (dump_file
, vr1
);
8794 fprintf (dump_file
, "\n");
8796 vrp_intersect_ranges_1 (vr0
, vr1
);
8797 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
8799 fprintf (dump_file
, "to\n ");
8800 dump_value_range (dump_file
, vr0
);
8801 fprintf (dump_file
, "\n");
8805 /* Meet operation for value ranges. Given two value ranges VR0 and
8806 VR1, store in VR0 a range that contains both VR0 and VR1. This
8807 may not be the smallest possible such range. */
8810 vrp_meet_1 (value_range
*vr0
, const value_range
*vr1
)
8814 if (vr0
->type
== VR_UNDEFINED
)
8816 set_value_range (vr0
, vr1
->type
, vr1
->min
, vr1
->max
, vr1
->equiv
);
8820 if (vr1
->type
== VR_UNDEFINED
)
8822 /* VR0 already has the resulting range. */
8826 if (vr0
->type
== VR_VARYING
)
8828 /* Nothing to do. VR0 already has the resulting range. */
8832 if (vr1
->type
== VR_VARYING
)
8834 set_value_range_to_varying (vr0
);
8839 union_ranges (&vr0
->type
, &vr0
->min
, &vr0
->max
,
8840 vr1
->type
, vr1
->min
, vr1
->max
);
8841 if (vr0
->type
== VR_VARYING
)
8843 /* Failed to find an efficient meet. Before giving up and setting
8844 the result to VARYING, see if we can at least derive a useful
8845 anti-range. FIXME, all this nonsense about distinguishing
8846 anti-ranges from ranges is necessary because of the odd
8847 semantics of range_includes_zero_p and friends. */
8848 if (((saved
.type
== VR_RANGE
8849 && range_includes_zero_p (saved
.min
, saved
.max
) == 0)
8850 || (saved
.type
== VR_ANTI_RANGE
8851 && range_includes_zero_p (saved
.min
, saved
.max
) == 1))
8852 && ((vr1
->type
== VR_RANGE
8853 && range_includes_zero_p (vr1
->min
, vr1
->max
) == 0)
8854 || (vr1
->type
== VR_ANTI_RANGE
8855 && range_includes_zero_p (vr1
->min
, vr1
->max
) == 1)))
8857 set_value_range_to_nonnull (vr0
, TREE_TYPE (saved
.min
));
8859 /* Since this meet operation did not result from the meeting of
8860 two equivalent names, VR0 cannot have any equivalences. */
8862 bitmap_clear (vr0
->equiv
);
8866 set_value_range_to_varying (vr0
);
8869 set_and_canonicalize_value_range (vr0
, vr0
->type
, vr0
->min
, vr0
->max
,
8871 if (vr0
->type
== VR_VARYING
)
8874 /* The resulting set of equivalences is always the intersection of
8876 if (vr0
->equiv
&& vr1
->equiv
&& vr0
->equiv
!= vr1
->equiv
)
8877 bitmap_and_into (vr0
->equiv
, vr1
->equiv
);
8878 else if (vr0
->equiv
&& !vr1
->equiv
)
8879 bitmap_clear (vr0
->equiv
);
8883 vrp_meet (value_range
*vr0
, const value_range
*vr1
)
8885 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
8887 fprintf (dump_file
, "Meeting\n ");
8888 dump_value_range (dump_file
, vr0
);
8889 fprintf (dump_file
, "\nand\n ");
8890 dump_value_range (dump_file
, vr1
);
8891 fprintf (dump_file
, "\n");
8893 vrp_meet_1 (vr0
, vr1
);
8894 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
8896 fprintf (dump_file
, "to\n ");
8897 dump_value_range (dump_file
, vr0
);
8898 fprintf (dump_file
, "\n");
8903 /* Visit all arguments for PHI node PHI that flow through executable
8904 edges. If a valid value range can be derived from all the incoming
8905 value ranges, set a new range in VR_RESULT. */
8908 extract_range_from_phi_node (gphi
*phi
, value_range
*vr_result
)
8911 tree lhs
= PHI_RESULT (phi
);
8912 value_range
*lhs_vr
= get_value_range (lhs
);
8914 int edges
, old_edges
;
8917 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
8919 fprintf (dump_file
, "\nVisiting PHI node: ");
8920 print_gimple_stmt (dump_file
, phi
, 0, dump_flags
);
8923 bool may_simulate_backedge_again
= false;
8925 for (i
= 0; i
< gimple_phi_num_args (phi
); i
++)
8927 edge e
= gimple_phi_arg_edge (phi
, i
);
8929 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
8932 " Argument #%d (%d -> %d %sexecutable)\n",
8933 (int) i
, e
->src
->index
, e
->dest
->index
,
8934 (e
->flags
& EDGE_EXECUTABLE
) ? "" : "not ");
8937 if (e
->flags
& EDGE_EXECUTABLE
)
8939 tree arg
= PHI_ARG_DEF (phi
, i
);
8944 if (TREE_CODE (arg
) == SSA_NAME
)
8946 /* See if we are eventually going to change one of the args. */
8947 gimple
*def_stmt
= SSA_NAME_DEF_STMT (arg
);
8948 if (! gimple_nop_p (def_stmt
)
8949 && prop_simulate_again_p (def_stmt
)
8950 && e
->flags
& EDGE_DFS_BACK
)
8951 may_simulate_backedge_again
= true;
8953 vr_arg
= *(get_value_range (arg
));
8954 /* Do not allow equivalences or symbolic ranges to leak in from
8955 backedges. That creates invalid equivalencies.
8956 See PR53465 and PR54767. */
8957 if (e
->flags
& EDGE_DFS_BACK
)
8959 if (vr_arg
.type
== VR_RANGE
8960 || vr_arg
.type
== VR_ANTI_RANGE
)
8962 vr_arg
.equiv
= NULL
;
8963 if (symbolic_range_p (&vr_arg
))
8965 vr_arg
.type
= VR_VARYING
;
8966 vr_arg
.min
= NULL_TREE
;
8967 vr_arg
.max
= NULL_TREE
;
8973 /* If the non-backedge arguments range is VR_VARYING then
8974 we can still try recording a simple equivalence. */
8975 if (vr_arg
.type
== VR_VARYING
)
8977 vr_arg
.type
= VR_RANGE
;
8980 vr_arg
.equiv
= NULL
;
8986 if (TREE_OVERFLOW_P (arg
))
8987 arg
= drop_tree_overflow (arg
);
8989 vr_arg
.type
= VR_RANGE
;
8992 vr_arg
.equiv
= NULL
;
8995 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
8997 fprintf (dump_file
, "\t");
8998 print_generic_expr (dump_file
, arg
, dump_flags
);
8999 fprintf (dump_file
, ": ");
9000 dump_value_range (dump_file
, &vr_arg
);
9001 fprintf (dump_file
, "\n");
9005 copy_value_range (vr_result
, &vr_arg
);
9007 vrp_meet (vr_result
, &vr_arg
);
9010 if (vr_result
->type
== VR_VARYING
)
9015 if (vr_result
->type
== VR_VARYING
)
9017 else if (vr_result
->type
== VR_UNDEFINED
)
9020 old_edges
= vr_phi_edge_counts
[SSA_NAME_VERSION (lhs
)];
9021 vr_phi_edge_counts
[SSA_NAME_VERSION (lhs
)] = edges
;
9023 /* To prevent infinite iterations in the algorithm, derive ranges
9024 when the new value is slightly bigger or smaller than the
9025 previous one. We don't do this if we have seen a new executable
9026 edge; this helps us avoid an infinity for conditionals
9027 which are not in a loop. If the old value-range was VR_UNDEFINED
9028 use the updated range and iterate one more time. If we will not
9029 simulate this PHI again via the backedge allow us to iterate. */
9031 && gimple_phi_num_args (phi
) > 1
9032 && edges
== old_edges
9033 && lhs_vr
->type
!= VR_UNDEFINED
9034 && may_simulate_backedge_again
)
9036 /* Compare old and new ranges, fall back to varying if the
9037 values are not comparable. */
9038 int cmp_min
= compare_values (lhs_vr
->min
, vr_result
->min
);
9041 int cmp_max
= compare_values (lhs_vr
->max
, vr_result
->max
);
9045 /* For non VR_RANGE or for pointers fall back to varying if
9046 the range changed. */
9047 if ((lhs_vr
->type
!= VR_RANGE
|| vr_result
->type
!= VR_RANGE
9048 || POINTER_TYPE_P (TREE_TYPE (lhs
)))
9049 && (cmp_min
!= 0 || cmp_max
!= 0))
9052 /* If the new minimum is larger than the previous one
9053 retain the old value. If the new minimum value is smaller
9054 than the previous one and not -INF go all the way to -INF + 1.
9055 In the first case, to avoid infinite bouncing between different
9056 minimums, and in the other case to avoid iterating millions of
9057 times to reach -INF. Going to -INF + 1 also lets the following
9058 iteration compute whether there will be any overflow, at the
9059 expense of one additional iteration. */
9061 vr_result
->min
= lhs_vr
->min
;
9062 else if (cmp_min
> 0
9063 && !vrp_val_is_min (vr_result
->min
))
9065 = int_const_binop (PLUS_EXPR
,
9066 vrp_val_min (TREE_TYPE (vr_result
->min
)),
9067 build_int_cst (TREE_TYPE (vr_result
->min
), 1));
9069 /* Similarly for the maximum value. */
9071 vr_result
->max
= lhs_vr
->max
;
9072 else if (cmp_max
< 0
9073 && !vrp_val_is_max (vr_result
->max
))
9075 = int_const_binop (MINUS_EXPR
,
9076 vrp_val_max (TREE_TYPE (vr_result
->min
)),
9077 build_int_cst (TREE_TYPE (vr_result
->min
), 1));
9079 /* If we dropped either bound to +-INF then if this is a loop
9080 PHI node SCEV may known more about its value-range. */
9081 if (cmp_min
> 0 || cmp_min
< 0
9082 || cmp_max
< 0 || cmp_max
> 0)
9085 goto infinite_check
;
9091 set_value_range_to_varying (vr_result
);
9094 /* If this is a loop PHI node SCEV may known more about its value-range.
9095 scev_check can be reached from two paths, one is a fall through from above
9096 "varying" label, the other is direct goto from code block which tries to
9097 avoid infinite simulation. */
9098 if ((l
= loop_containing_stmt (phi
))
9099 && l
->header
== gimple_bb (phi
))
9100 adjust_range_with_scev (vr_result
, l
, phi
, lhs
);
9103 /* If we will end up with a (-INF, +INF) range, set it to
9104 VARYING. Same if the previous max value was invalid for
9105 the type and we end up with vr_result.min > vr_result.max. */
9106 if ((vr_result
->type
== VR_RANGE
|| vr_result
->type
== VR_ANTI_RANGE
)
9107 && !((vrp_val_is_max (vr_result
->max
) && vrp_val_is_min (vr_result
->min
))
9108 || compare_values (vr_result
->min
, vr_result
->max
) > 0))
9111 set_value_range_to_varying (vr_result
);
9113 /* If the new range is different than the previous value, keep
9119 /* Visit all arguments for PHI node PHI that flow through executable
9120 edges. If a valid value range can be derived from all the incoming
9121 value ranges, set a new range for the LHS of PHI. */
9123 static enum ssa_prop_result
9124 vrp_visit_phi_node (gphi
*phi
)
9126 tree lhs
= PHI_RESULT (phi
);
9127 value_range vr_result
= VR_INITIALIZER
;
9128 extract_range_from_phi_node (phi
, &vr_result
);
9129 if (update_value_range (lhs
, &vr_result
))
9131 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
9133 fprintf (dump_file
, "Found new range for ");
9134 print_generic_expr (dump_file
, lhs
);
9135 fprintf (dump_file
, ": ");
9136 dump_value_range (dump_file
, &vr_result
);
9137 fprintf (dump_file
, "\n");
9140 if (vr_result
.type
== VR_VARYING
)
9141 return SSA_PROP_VARYING
;
9143 return SSA_PROP_INTERESTING
;
9146 /* Nothing changed, don't add outgoing edges. */
9147 return SSA_PROP_NOT_INTERESTING
;
9150 /* Simplify boolean operations if the source is known
9151 to be already a boolean. */
9153 simplify_truth_ops_using_ranges (gimple_stmt_iterator
*gsi
, gimple
*stmt
)
9155 enum tree_code rhs_code
= gimple_assign_rhs_code (stmt
);
9157 bool need_conversion
;
9159 /* We handle only !=/== case here. */
9160 gcc_assert (rhs_code
== EQ_EXPR
|| rhs_code
== NE_EXPR
);
9162 op0
= gimple_assign_rhs1 (stmt
);
9163 if (!op_with_boolean_value_range_p (op0
))
9166 op1
= gimple_assign_rhs2 (stmt
);
9167 if (!op_with_boolean_value_range_p (op1
))
9170 /* Reduce number of cases to handle to NE_EXPR. As there is no
9171 BIT_XNOR_EXPR we cannot replace A == B with a single statement. */
9172 if (rhs_code
== EQ_EXPR
)
9174 if (TREE_CODE (op1
) == INTEGER_CST
)
9175 op1
= int_const_binop (BIT_XOR_EXPR
, op1
,
9176 build_int_cst (TREE_TYPE (op1
), 1));
9181 lhs
= gimple_assign_lhs (stmt
);
9183 = !useless_type_conversion_p (TREE_TYPE (lhs
), TREE_TYPE (op0
));
9185 /* Make sure to not sign-extend a 1-bit 1 when converting the result. */
9187 && !TYPE_UNSIGNED (TREE_TYPE (op0
))
9188 && TYPE_PRECISION (TREE_TYPE (op0
)) == 1
9189 && TYPE_PRECISION (TREE_TYPE (lhs
)) > 1)
9192 /* For A != 0 we can substitute A itself. */
9193 if (integer_zerop (op1
))
9194 gimple_assign_set_rhs_with_ops (gsi
,
9196 ? NOP_EXPR
: TREE_CODE (op0
), op0
);
9197 /* For A != B we substitute A ^ B. Either with conversion. */
9198 else if (need_conversion
)
9200 tree tem
= make_ssa_name (TREE_TYPE (op0
));
9202 = gimple_build_assign (tem
, BIT_XOR_EXPR
, op0
, op1
);
9203 gsi_insert_before (gsi
, newop
, GSI_SAME_STMT
);
9204 if (INTEGRAL_TYPE_P (TREE_TYPE (tem
))
9205 && TYPE_PRECISION (TREE_TYPE (tem
)) > 1)
9206 set_range_info (tem
, VR_RANGE
,
9207 wi::zero (TYPE_PRECISION (TREE_TYPE (tem
))),
9208 wi::one (TYPE_PRECISION (TREE_TYPE (tem
))));
9209 gimple_assign_set_rhs_with_ops (gsi
, NOP_EXPR
, tem
);
9213 gimple_assign_set_rhs_with_ops (gsi
, BIT_XOR_EXPR
, op0
, op1
);
9214 update_stmt (gsi_stmt (*gsi
));
9215 fold_stmt (gsi
, follow_single_use_edges
);
9220 /* Simplify a division or modulo operator to a right shift or bitwise and
9221 if the first operand is unsigned or is greater than zero and the second
9222 operand is an exact power of two. For TRUNC_MOD_EXPR op0 % op1 with
9223 constant op1 (op1min = op1) or with op1 in [op1min, op1max] range,
9224 optimize it into just op0 if op0's range is known to be a subset of
9225 [-op1min + 1, op1min - 1] for signed and [0, op1min - 1] for unsigned
9229 simplify_div_or_mod_using_ranges (gimple_stmt_iterator
*gsi
, gimple
*stmt
)
9231 enum tree_code rhs_code
= gimple_assign_rhs_code (stmt
);
9233 tree op0
= gimple_assign_rhs1 (stmt
);
9234 tree op1
= gimple_assign_rhs2 (stmt
);
9235 tree op0min
= NULL_TREE
, op0max
= NULL_TREE
;
9237 value_range
*vr
= NULL
;
9239 if (TREE_CODE (op0
) == INTEGER_CST
)
9246 vr
= get_value_range (op0
);
9247 if (range_int_cst_p (vr
))
9254 if (rhs_code
== TRUNC_MOD_EXPR
9255 && TREE_CODE (op1
) == SSA_NAME
)
9257 value_range
*vr1
= get_value_range (op1
);
9258 if (range_int_cst_p (vr1
))
9261 if (rhs_code
== TRUNC_MOD_EXPR
9262 && TREE_CODE (op1min
) == INTEGER_CST
9263 && tree_int_cst_sgn (op1min
) == 1
9265 && tree_int_cst_lt (op0max
, op1min
))
9267 if (TYPE_UNSIGNED (TREE_TYPE (op0
))
9268 || tree_int_cst_sgn (op0min
) >= 0
9269 || tree_int_cst_lt (fold_unary (NEGATE_EXPR
, TREE_TYPE (op1min
), op1min
),
9272 /* If op0 already has the range op0 % op1 has,
9273 then TRUNC_MOD_EXPR won't change anything. */
9274 gimple_assign_set_rhs_from_tree (gsi
, op0
);
9279 if (TREE_CODE (op0
) != SSA_NAME
)
9282 if (!integer_pow2p (op1
))
9284 /* X % -Y can be only optimized into X % Y either if
9285 X is not INT_MIN, or Y is not -1. Fold it now, as after
9286 remove_range_assertions the range info might be not available
9288 if (rhs_code
== TRUNC_MOD_EXPR
9289 && fold_stmt (gsi
, follow_single_use_edges
))
9294 if (TYPE_UNSIGNED (TREE_TYPE (op0
)))
9295 val
= integer_one_node
;
9300 val
= compare_range_with_value (GE_EXPR
, vr
, integer_zero_node
, &sop
);
9304 && integer_onep (val
)
9305 && issue_strict_overflow_warning (WARN_STRICT_OVERFLOW_MISC
))
9307 location_t location
;
9309 if (!gimple_has_location (stmt
))
9310 location
= input_location
;
9312 location
= gimple_location (stmt
);
9313 warning_at (location
, OPT_Wstrict_overflow
,
9314 "assuming signed overflow does not occur when "
9315 "simplifying %</%> or %<%%%> to %<>>%> or %<&%>");
9319 if (val
&& integer_onep (val
))
9323 if (rhs_code
== TRUNC_DIV_EXPR
)
9325 t
= build_int_cst (integer_type_node
, tree_log2 (op1
));
9326 gimple_assign_set_rhs_code (stmt
, RSHIFT_EXPR
);
9327 gimple_assign_set_rhs1 (stmt
, op0
);
9328 gimple_assign_set_rhs2 (stmt
, t
);
9332 t
= build_int_cst (TREE_TYPE (op1
), 1);
9333 t
= int_const_binop (MINUS_EXPR
, op1
, t
);
9334 t
= fold_convert (TREE_TYPE (op0
), t
);
9336 gimple_assign_set_rhs_code (stmt
, BIT_AND_EXPR
);
9337 gimple_assign_set_rhs1 (stmt
, op0
);
9338 gimple_assign_set_rhs2 (stmt
, t
);
9342 fold_stmt (gsi
, follow_single_use_edges
);
9349 /* Simplify a min or max if the ranges of the two operands are
9350 disjoint. Return true if we do simplify. */
9353 simplify_min_or_max_using_ranges (gimple_stmt_iterator
*gsi
, gimple
*stmt
)
9355 tree op0
= gimple_assign_rhs1 (stmt
);
9356 tree op1
= gimple_assign_rhs2 (stmt
);
9360 val
= (vrp_evaluate_conditional_warnv_with_ops_using_ranges
9361 (LE_EXPR
, op0
, op1
, &sop
));
9365 val
= (vrp_evaluate_conditional_warnv_with_ops_using_ranges
9366 (LT_EXPR
, op0
, op1
, &sop
));
9371 if (sop
&& issue_strict_overflow_warning (WARN_STRICT_OVERFLOW_MISC
))
9373 location_t location
;
9375 if (!gimple_has_location (stmt
))
9376 location
= input_location
;
9378 location
= gimple_location (stmt
);
9379 warning_at (location
, OPT_Wstrict_overflow
,
9380 "assuming signed overflow does not occur when "
9381 "simplifying %<min/max (X,Y)%> to %<X%> or %<Y%>");
9384 /* VAL == TRUE -> OP0 < or <= op1
9385 VAL == FALSE -> OP0 > or >= op1. */
9386 tree res
= ((gimple_assign_rhs_code (stmt
) == MAX_EXPR
)
9387 == integer_zerop (val
)) ? op0
: op1
;
9388 gimple_assign_set_rhs_from_tree (gsi
, res
);
9395 /* If the operand to an ABS_EXPR is >= 0, then eliminate the
9396 ABS_EXPR. If the operand is <= 0, then simplify the
9397 ABS_EXPR into a NEGATE_EXPR. */
9400 simplify_abs_using_ranges (gimple_stmt_iterator
*gsi
, gimple
*stmt
)
9402 tree op
= gimple_assign_rhs1 (stmt
);
9403 value_range
*vr
= get_value_range (op
);
9410 val
= compare_range_with_value (LE_EXPR
, vr
, integer_zero_node
, &sop
);
9413 /* The range is neither <= 0 nor > 0. Now see if it is
9414 either < 0 or >= 0. */
9416 val
= compare_range_with_value (LT_EXPR
, vr
, integer_zero_node
,
9422 if (sop
&& issue_strict_overflow_warning (WARN_STRICT_OVERFLOW_MISC
))
9424 location_t location
;
9426 if (!gimple_has_location (stmt
))
9427 location
= input_location
;
9429 location
= gimple_location (stmt
);
9430 warning_at (location
, OPT_Wstrict_overflow
,
9431 "assuming signed overflow does not occur when "
9432 "simplifying %<abs (X)%> to %<X%> or %<-X%>");
9435 gimple_assign_set_rhs1 (stmt
, op
);
9436 if (integer_zerop (val
))
9437 gimple_assign_set_rhs_code (stmt
, SSA_NAME
);
9439 gimple_assign_set_rhs_code (stmt
, NEGATE_EXPR
);
9441 fold_stmt (gsi
, follow_single_use_edges
);
9449 /* Optimize away redundant BIT_AND_EXPR and BIT_IOR_EXPR.
9450 If all the bits that are being cleared by & are already
9451 known to be zero from VR, or all the bits that are being
9452 set by | are already known to be one from VR, the bit
9453 operation is redundant. */
9456 simplify_bit_ops_using_ranges (gimple_stmt_iterator
*gsi
, gimple
*stmt
)
9458 tree op0
= gimple_assign_rhs1 (stmt
);
9459 tree op1
= gimple_assign_rhs2 (stmt
);
9460 tree op
= NULL_TREE
;
9461 value_range vr0
= VR_INITIALIZER
;
9462 value_range vr1
= VR_INITIALIZER
;
9463 wide_int may_be_nonzero0
, may_be_nonzero1
;
9464 wide_int must_be_nonzero0
, must_be_nonzero1
;
9467 if (TREE_CODE (op0
) == SSA_NAME
)
9468 vr0
= *(get_value_range (op0
));
9469 else if (is_gimple_min_invariant (op0
))
9470 set_value_range_to_value (&vr0
, op0
, NULL
);
9474 if (TREE_CODE (op1
) == SSA_NAME
)
9475 vr1
= *(get_value_range (op1
));
9476 else if (is_gimple_min_invariant (op1
))
9477 set_value_range_to_value (&vr1
, op1
, NULL
);
9481 if (!zero_nonzero_bits_from_vr (TREE_TYPE (op0
), &vr0
, &may_be_nonzero0
,
9484 if (!zero_nonzero_bits_from_vr (TREE_TYPE (op1
), &vr1
, &may_be_nonzero1
,
9488 switch (gimple_assign_rhs_code (stmt
))
9491 mask
= may_be_nonzero0
.and_not (must_be_nonzero1
);
9497 mask
= may_be_nonzero1
.and_not (must_be_nonzero0
);
9505 mask
= may_be_nonzero0
.and_not (must_be_nonzero1
);
9511 mask
= may_be_nonzero1
.and_not (must_be_nonzero0
);
9522 if (op
== NULL_TREE
)
9525 gimple_assign_set_rhs_with_ops (gsi
, TREE_CODE (op
), op
);
9526 update_stmt (gsi_stmt (*gsi
));
9530 /* We are comparing trees OP0 and OP1 using COND_CODE. OP0 has
9531 a known value range VR.
9533 If there is one and only one value which will satisfy the
9534 conditional, then return that value. Else return NULL.
9536 If signed overflow must be undefined for the value to satisfy
9537 the conditional, then set *STRICT_OVERFLOW_P to true. */
9540 test_for_singularity (enum tree_code cond_code
, tree op0
,
9541 tree op1
, value_range
*vr
)
9546 /* Extract minimum/maximum values which satisfy the conditional as it was
9548 if (cond_code
== LE_EXPR
|| cond_code
== LT_EXPR
)
9550 min
= TYPE_MIN_VALUE (TREE_TYPE (op0
));
9553 if (cond_code
== LT_EXPR
)
9555 tree one
= build_int_cst (TREE_TYPE (op0
), 1);
9556 max
= fold_build2 (MINUS_EXPR
, TREE_TYPE (op0
), max
, one
);
9557 /* Signal to compare_values_warnv this expr doesn't overflow. */
9559 TREE_NO_WARNING (max
) = 1;
9562 else if (cond_code
== GE_EXPR
|| cond_code
== GT_EXPR
)
9564 max
= TYPE_MAX_VALUE (TREE_TYPE (op0
));
9567 if (cond_code
== GT_EXPR
)
9569 tree one
= build_int_cst (TREE_TYPE (op0
), 1);
9570 min
= fold_build2 (PLUS_EXPR
, TREE_TYPE (op0
), min
, one
);
9571 /* Signal to compare_values_warnv this expr doesn't overflow. */
9573 TREE_NO_WARNING (min
) = 1;
9577 /* Now refine the minimum and maximum values using any
9578 value range information we have for op0. */
9581 if (compare_values (vr
->min
, min
) == 1)
9583 if (compare_values (vr
->max
, max
) == -1)
9586 /* If the new min/max values have converged to a single value,
9587 then there is only one value which can satisfy the condition,
9588 return that value. */
9589 if (operand_equal_p (min
, max
, 0) && is_gimple_min_invariant (min
))
9595 /* Return whether the value range *VR fits in an integer type specified
9596 by PRECISION and UNSIGNED_P. */
9599 range_fits_type_p (value_range
*vr
, unsigned dest_precision
, signop dest_sgn
)
9602 unsigned src_precision
;
9606 /* We can only handle integral and pointer types. */
9607 src_type
= TREE_TYPE (vr
->min
);
9608 if (!INTEGRAL_TYPE_P (src_type
)
9609 && !POINTER_TYPE_P (src_type
))
9612 /* An extension is fine unless VR is SIGNED and dest_sgn is UNSIGNED,
9613 and so is an identity transform. */
9614 src_precision
= TYPE_PRECISION (TREE_TYPE (vr
->min
));
9615 src_sgn
= TYPE_SIGN (src_type
);
9616 if ((src_precision
< dest_precision
9617 && !(dest_sgn
== UNSIGNED
&& src_sgn
== SIGNED
))
9618 || (src_precision
== dest_precision
&& src_sgn
== dest_sgn
))
9621 /* Now we can only handle ranges with constant bounds. */
9622 if (vr
->type
!= VR_RANGE
9623 || TREE_CODE (vr
->min
) != INTEGER_CST
9624 || TREE_CODE (vr
->max
) != INTEGER_CST
)
9627 /* For sign changes, the MSB of the wide_int has to be clear.
9628 An unsigned value with its MSB set cannot be represented by
9629 a signed wide_int, while a negative value cannot be represented
9630 by an unsigned wide_int. */
9631 if (src_sgn
!= dest_sgn
9632 && (wi::lts_p (vr
->min
, 0) || wi::lts_p (vr
->max
, 0)))
9635 /* Then we can perform the conversion on both ends and compare
9636 the result for equality. */
9637 tem
= wi::ext (wi::to_widest (vr
->min
), dest_precision
, dest_sgn
);
9638 if (tem
!= wi::to_widest (vr
->min
))
9640 tem
= wi::ext (wi::to_widest (vr
->max
), dest_precision
, dest_sgn
);
9641 if (tem
!= wi::to_widest (vr
->max
))
9647 /* Simplify a conditional using a relational operator to an equality
9648 test if the range information indicates only one value can satisfy
9649 the original conditional. */
9652 simplify_cond_using_ranges_1 (gcond
*stmt
)
9654 tree op0
= gimple_cond_lhs (stmt
);
9655 tree op1
= gimple_cond_rhs (stmt
);
9656 enum tree_code cond_code
= gimple_cond_code (stmt
);
9658 if (cond_code
!= NE_EXPR
9659 && cond_code
!= EQ_EXPR
9660 && TREE_CODE (op0
) == SSA_NAME
9661 && INTEGRAL_TYPE_P (TREE_TYPE (op0
))
9662 && is_gimple_min_invariant (op1
))
9664 value_range
*vr
= get_value_range (op0
);
9666 /* If we have range information for OP0, then we might be
9667 able to simplify this conditional. */
9668 if (vr
->type
== VR_RANGE
)
9670 tree new_tree
= test_for_singularity (cond_code
, op0
, op1
, vr
);
9675 fprintf (dump_file
, "Simplified relational ");
9676 print_gimple_stmt (dump_file
, stmt
, 0);
9677 fprintf (dump_file
, " into ");
9680 gimple_cond_set_code (stmt
, EQ_EXPR
);
9681 gimple_cond_set_lhs (stmt
, op0
);
9682 gimple_cond_set_rhs (stmt
, new_tree
);
9688 print_gimple_stmt (dump_file
, stmt
, 0);
9689 fprintf (dump_file
, "\n");
9695 /* Try again after inverting the condition. We only deal
9696 with integral types here, so no need to worry about
9697 issues with inverting FP comparisons. */
9698 new_tree
= test_for_singularity
9699 (invert_tree_comparison (cond_code
, false),
9705 fprintf (dump_file
, "Simplified relational ");
9706 print_gimple_stmt (dump_file
, stmt
, 0);
9707 fprintf (dump_file
, " into ");
9710 gimple_cond_set_code (stmt
, NE_EXPR
);
9711 gimple_cond_set_lhs (stmt
, op0
);
9712 gimple_cond_set_rhs (stmt
, new_tree
);
9718 print_gimple_stmt (dump_file
, stmt
, 0);
9719 fprintf (dump_file
, "\n");
9729 /* STMT is a conditional at the end of a basic block.
9731 If the conditional is of the form SSA_NAME op constant and the SSA_NAME
9732 was set via a type conversion, try to replace the SSA_NAME with the RHS
9733 of the type conversion. Doing so makes the conversion dead which helps
9734 subsequent passes. */
9737 simplify_cond_using_ranges_2 (gcond
*stmt
)
9739 tree op0
= gimple_cond_lhs (stmt
);
9740 tree op1
= gimple_cond_rhs (stmt
);
9742 /* If we have a comparison of an SSA_NAME (OP0) against a constant,
9743 see if OP0 was set by a type conversion where the source of
9744 the conversion is another SSA_NAME with a range that fits
9745 into the range of OP0's type.
9747 If so, the conversion is redundant as the earlier SSA_NAME can be
9748 used for the comparison directly if we just massage the constant in the
9750 if (TREE_CODE (op0
) == SSA_NAME
9751 && TREE_CODE (op1
) == INTEGER_CST
)
9753 gimple
*def_stmt
= SSA_NAME_DEF_STMT (op0
);
9756 if (!is_gimple_assign (def_stmt
)
9757 || !CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def_stmt
)))
9760 innerop
= gimple_assign_rhs1 (def_stmt
);
9762 if (TREE_CODE (innerop
) == SSA_NAME
9763 && !POINTER_TYPE_P (TREE_TYPE (innerop
))
9764 && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (innerop
)
9765 && desired_pro_or_demotion_p (TREE_TYPE (innerop
), TREE_TYPE (op0
)))
9767 value_range
*vr
= get_value_range (innerop
);
9769 if (range_int_cst_p (vr
)
9770 && range_fits_type_p (vr
,
9771 TYPE_PRECISION (TREE_TYPE (op0
)),
9772 TYPE_SIGN (TREE_TYPE (op0
)))
9773 && int_fits_type_p (op1
, TREE_TYPE (innerop
)))
9775 tree newconst
= fold_convert (TREE_TYPE (innerop
), op1
);
9776 gimple_cond_set_lhs (stmt
, innerop
);
9777 gimple_cond_set_rhs (stmt
, newconst
);
9779 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
9781 fprintf (dump_file
, "Folded into: ");
9782 print_gimple_stmt (dump_file
, stmt
, 0, TDF_SLIM
);
9783 fprintf (dump_file
, "\n");
9790 /* Simplify a switch statement using the value range of the switch
9794 simplify_switch_using_ranges (gswitch
*stmt
)
9796 tree op
= gimple_switch_index (stmt
);
9797 value_range
*vr
= NULL
;
9801 size_t i
= 0, j
= 0, n
, n2
;
9804 size_t k
= 1, l
= 0;
9806 if (TREE_CODE (op
) == SSA_NAME
)
9808 vr
= get_value_range (op
);
9810 /* We can only handle integer ranges. */
9811 if ((vr
->type
!= VR_RANGE
9812 && vr
->type
!= VR_ANTI_RANGE
)
9813 || symbolic_range_p (vr
))
9816 /* Find case label for min/max of the value range. */
9817 take_default
= !find_case_label_ranges (stmt
, vr
, &i
, &j
, &k
, &l
);
9819 else if (TREE_CODE (op
) == INTEGER_CST
)
9821 take_default
= !find_case_label_index (stmt
, 1, op
, &i
);
9835 n
= gimple_switch_num_labels (stmt
);
9837 /* We can truncate the case label ranges that partially overlap with OP's
9839 size_t min_idx
= 1, max_idx
= 0;
9841 find_case_label_range (stmt
, vr
->min
, vr
->max
, &min_idx
, &max_idx
);
9842 if (min_idx
<= max_idx
)
9844 tree min_label
= gimple_switch_label (stmt
, min_idx
);
9845 tree max_label
= gimple_switch_label (stmt
, max_idx
);
9847 /* Avoid changing the type of the case labels when truncating. */
9848 tree case_label_type
= TREE_TYPE (CASE_LOW (min_label
));
9849 tree vr_min
= fold_convert (case_label_type
, vr
->min
);
9850 tree vr_max
= fold_convert (case_label_type
, vr
->max
);
9852 if (vr
->type
== VR_RANGE
)
9854 /* If OP's value range is [2,8] and the low label range is
9855 0 ... 3, truncate the label's range to 2 .. 3. */
9856 if (tree_int_cst_compare (CASE_LOW (min_label
), vr_min
) < 0
9857 && CASE_HIGH (min_label
) != NULL_TREE
9858 && tree_int_cst_compare (CASE_HIGH (min_label
), vr_min
) >= 0)
9859 CASE_LOW (min_label
) = vr_min
;
9861 /* If OP's value range is [2,8] and the high label range is
9862 7 ... 10, truncate the label's range to 7 .. 8. */
9863 if (tree_int_cst_compare (CASE_LOW (max_label
), vr_max
) <= 0
9864 && CASE_HIGH (max_label
) != NULL_TREE
9865 && tree_int_cst_compare (CASE_HIGH (max_label
), vr_max
) > 0)
9866 CASE_HIGH (max_label
) = vr_max
;
9868 else if (vr
->type
== VR_ANTI_RANGE
)
9870 tree one_cst
= build_one_cst (case_label_type
);
9872 if (min_label
== max_label
)
9874 /* If OP's value range is ~[7,8] and the label's range is
9875 7 ... 10, truncate the label's range to 9 ... 10. */
9876 if (tree_int_cst_compare (CASE_LOW (min_label
), vr_min
) == 0
9877 && CASE_HIGH (min_label
) != NULL_TREE
9878 && tree_int_cst_compare (CASE_HIGH (min_label
), vr_max
) > 0)
9879 CASE_LOW (min_label
)
9880 = int_const_binop (PLUS_EXPR
, vr_max
, one_cst
);
9882 /* If OP's value range is ~[7,8] and the label's range is
9883 5 ... 8, truncate the label's range to 5 ... 6. */
9884 if (tree_int_cst_compare (CASE_LOW (min_label
), vr_min
) < 0
9885 && CASE_HIGH (min_label
) != NULL_TREE
9886 && tree_int_cst_compare (CASE_HIGH (min_label
), vr_max
) == 0)
9887 CASE_HIGH (min_label
)
9888 = int_const_binop (MINUS_EXPR
, vr_min
, one_cst
);
9892 /* If OP's value range is ~[2,8] and the low label range is
9893 0 ... 3, truncate the label's range to 0 ... 1. */
9894 if (tree_int_cst_compare (CASE_LOW (min_label
), vr_min
) < 0
9895 && CASE_HIGH (min_label
) != NULL_TREE
9896 && tree_int_cst_compare (CASE_HIGH (min_label
), vr_min
) >= 0)
9897 CASE_HIGH (min_label
)
9898 = int_const_binop (MINUS_EXPR
, vr_min
, one_cst
);
9900 /* If OP's value range is ~[2,8] and the high label range is
9901 7 ... 10, truncate the label's range to 9 ... 10. */
9902 if (tree_int_cst_compare (CASE_LOW (max_label
), vr_max
) <= 0
9903 && CASE_HIGH (max_label
) != NULL_TREE
9904 && tree_int_cst_compare (CASE_HIGH (max_label
), vr_max
) > 0)
9905 CASE_LOW (max_label
)
9906 = int_const_binop (PLUS_EXPR
, vr_max
, one_cst
);
9910 /* Canonicalize singleton case ranges. */
9911 if (tree_int_cst_equal (CASE_LOW (min_label
), CASE_HIGH (min_label
)))
9912 CASE_HIGH (min_label
) = NULL_TREE
;
9913 if (tree_int_cst_equal (CASE_LOW (max_label
), CASE_HIGH (max_label
)))
9914 CASE_HIGH (max_label
) = NULL_TREE
;
9917 /* We can also eliminate case labels that lie completely outside OP's value
9920 /* Bail out if this is just all edges taken. */
9926 /* Build a new vector of taken case labels. */
9927 vec2
= make_tree_vec (j
- i
+ 1 + l
- k
+ 1 + (int)take_default
);
9930 /* Add the default edge, if necessary. */
9932 TREE_VEC_ELT (vec2
, n2
++) = gimple_switch_default_label (stmt
);
9934 for (; i
<= j
; ++i
, ++n2
)
9935 TREE_VEC_ELT (vec2
, n2
) = gimple_switch_label (stmt
, i
);
9937 for (; k
<= l
; ++k
, ++n2
)
9938 TREE_VEC_ELT (vec2
, n2
) = gimple_switch_label (stmt
, k
);
9940 /* Mark needed edges. */
9941 for (i
= 0; i
< n2
; ++i
)
9943 e
= find_edge (gimple_bb (stmt
),
9944 label_to_block (CASE_LABEL (TREE_VEC_ELT (vec2
, i
))));
9945 e
->aux
= (void *)-1;
9948 /* Queue not needed edges for later removal. */
9949 FOR_EACH_EDGE (e
, ei
, gimple_bb (stmt
)->succs
)
9951 if (e
->aux
== (void *)-1)
9957 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
9959 fprintf (dump_file
, "removing unreachable case label\n");
9961 to_remove_edges
.safe_push (e
);
9962 e
->flags
&= ~EDGE_EXECUTABLE
;
9965 /* And queue an update for the stmt. */
9968 to_update_switch_stmts
.safe_push (su
);
9972 /* Simplify an integral conversion from an SSA name in STMT. */
9975 simplify_conversion_using_ranges (gimple_stmt_iterator
*gsi
, gimple
*stmt
)
9977 tree innerop
, middleop
, finaltype
;
9979 signop inner_sgn
, middle_sgn
, final_sgn
;
9980 unsigned inner_prec
, middle_prec
, final_prec
;
9981 widest_int innermin
, innermed
, innermax
, middlemin
, middlemed
, middlemax
;
9983 finaltype
= TREE_TYPE (gimple_assign_lhs (stmt
));
9984 if (!INTEGRAL_TYPE_P (finaltype
))
9986 middleop
= gimple_assign_rhs1 (stmt
);
9987 def_stmt
= SSA_NAME_DEF_STMT (middleop
);
9988 if (!is_gimple_assign (def_stmt
)
9989 || !CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def_stmt
)))
9991 innerop
= gimple_assign_rhs1 (def_stmt
);
9992 if (TREE_CODE (innerop
) != SSA_NAME
9993 || SSA_NAME_OCCURS_IN_ABNORMAL_PHI (innerop
))
9996 /* Get the value-range of the inner operand. Use get_range_info in
9997 case innerop was created during substitute-and-fold. */
9998 wide_int imin
, imax
;
9999 if (!INTEGRAL_TYPE_P (TREE_TYPE (innerop
))
10000 || get_range_info (innerop
, &imin
, &imax
) != VR_RANGE
)
10002 innermin
= widest_int::from (imin
, TYPE_SIGN (TREE_TYPE (innerop
)));
10003 innermax
= widest_int::from (imax
, TYPE_SIGN (TREE_TYPE (innerop
)));
10005 /* Simulate the conversion chain to check if the result is equal if
10006 the middle conversion is removed. */
10007 inner_prec
= TYPE_PRECISION (TREE_TYPE (innerop
));
10008 middle_prec
= TYPE_PRECISION (TREE_TYPE (middleop
));
10009 final_prec
= TYPE_PRECISION (finaltype
);
10011 /* If the first conversion is not injective, the second must not
10013 if (wi::gtu_p (innermax
- innermin
,
10014 wi::mask
<widest_int
> (middle_prec
, false))
10015 && middle_prec
< final_prec
)
10017 /* We also want a medium value so that we can track the effect that
10018 narrowing conversions with sign change have. */
10019 inner_sgn
= TYPE_SIGN (TREE_TYPE (innerop
));
10020 if (inner_sgn
== UNSIGNED
)
10021 innermed
= wi::shifted_mask
<widest_int
> (1, inner_prec
- 1, false);
10024 if (wi::cmp (innermin
, innermed
, inner_sgn
) >= 0
10025 || wi::cmp (innermed
, innermax
, inner_sgn
) >= 0)
10026 innermed
= innermin
;
10028 middle_sgn
= TYPE_SIGN (TREE_TYPE (middleop
));
10029 middlemin
= wi::ext (innermin
, middle_prec
, middle_sgn
);
10030 middlemed
= wi::ext (innermed
, middle_prec
, middle_sgn
);
10031 middlemax
= wi::ext (innermax
, middle_prec
, middle_sgn
);
10033 /* Require that the final conversion applied to both the original
10034 and the intermediate range produces the same result. */
10035 final_sgn
= TYPE_SIGN (finaltype
);
10036 if (wi::ext (middlemin
, final_prec
, final_sgn
)
10037 != wi::ext (innermin
, final_prec
, final_sgn
)
10038 || wi::ext (middlemed
, final_prec
, final_sgn
)
10039 != wi::ext (innermed
, final_prec
, final_sgn
)
10040 || wi::ext (middlemax
, final_prec
, final_sgn
)
10041 != wi::ext (innermax
, final_prec
, final_sgn
))
10044 gimple_assign_set_rhs1 (stmt
, innerop
);
10045 fold_stmt (gsi
, follow_single_use_edges
);
10049 /* Simplify a conversion from integral SSA name to float in STMT. */
10052 simplify_float_conversion_using_ranges (gimple_stmt_iterator
*gsi
,
10055 tree rhs1
= gimple_assign_rhs1 (stmt
);
10056 value_range
*vr
= get_value_range (rhs1
);
10057 machine_mode fltmode
= TYPE_MODE (TREE_TYPE (gimple_assign_lhs (stmt
)));
10062 /* We can only handle constant ranges. */
10063 if (vr
->type
!= VR_RANGE
10064 || TREE_CODE (vr
->min
) != INTEGER_CST
10065 || TREE_CODE (vr
->max
) != INTEGER_CST
)
10068 /* First check if we can use a signed type in place of an unsigned. */
10069 if (TYPE_UNSIGNED (TREE_TYPE (rhs1
))
10070 && (can_float_p (fltmode
, TYPE_MODE (TREE_TYPE (rhs1
)), 0)
10071 != CODE_FOR_nothing
)
10072 && range_fits_type_p (vr
, TYPE_PRECISION (TREE_TYPE (rhs1
)), SIGNED
))
10073 mode
= TYPE_MODE (TREE_TYPE (rhs1
));
10074 /* If we can do the conversion in the current input mode do nothing. */
10075 else if (can_float_p (fltmode
, TYPE_MODE (TREE_TYPE (rhs1
)),
10076 TYPE_UNSIGNED (TREE_TYPE (rhs1
))) != CODE_FOR_nothing
)
10078 /* Otherwise search for a mode we can use, starting from the narrowest
10079 integer mode available. */
10082 mode
= GET_CLASS_NARROWEST_MODE (MODE_INT
);
10085 /* If we cannot do a signed conversion to float from mode
10086 or if the value-range does not fit in the signed type
10087 try with a wider mode. */
10088 if (can_float_p (fltmode
, mode
, 0) != CODE_FOR_nothing
10089 && range_fits_type_p (vr
, GET_MODE_PRECISION (mode
), SIGNED
))
10092 mode
= GET_MODE_WIDER_MODE (mode
);
10093 /* But do not widen the input. Instead leave that to the
10094 optabs expansion code. */
10095 if (GET_MODE_PRECISION (mode
) > TYPE_PRECISION (TREE_TYPE (rhs1
)))
10098 while (mode
!= VOIDmode
);
10099 if (mode
== VOIDmode
)
10103 /* It works, insert a truncation or sign-change before the
10104 float conversion. */
10105 tem
= make_ssa_name (build_nonstandard_integer_type
10106 (GET_MODE_PRECISION (mode
), 0));
10107 conv
= gimple_build_assign (tem
, NOP_EXPR
, rhs1
);
10108 gsi_insert_before (gsi
, conv
, GSI_SAME_STMT
);
10109 gimple_assign_set_rhs1 (stmt
, tem
);
10110 fold_stmt (gsi
, follow_single_use_edges
);
10115 /* Simplify an internal fn call using ranges if possible. */
10118 simplify_internal_call_using_ranges (gimple_stmt_iterator
*gsi
, gimple
*stmt
)
10120 enum tree_code subcode
;
10121 bool is_ubsan
= false;
10123 switch (gimple_call_internal_fn (stmt
))
10125 case IFN_UBSAN_CHECK_ADD
:
10126 subcode
= PLUS_EXPR
;
10129 case IFN_UBSAN_CHECK_SUB
:
10130 subcode
= MINUS_EXPR
;
10133 case IFN_UBSAN_CHECK_MUL
:
10134 subcode
= MULT_EXPR
;
10137 case IFN_ADD_OVERFLOW
:
10138 subcode
= PLUS_EXPR
;
10140 case IFN_SUB_OVERFLOW
:
10141 subcode
= MINUS_EXPR
;
10143 case IFN_MUL_OVERFLOW
:
10144 subcode
= MULT_EXPR
;
10150 tree op0
= gimple_call_arg (stmt
, 0);
10151 tree op1
= gimple_call_arg (stmt
, 1);
10155 type
= TREE_TYPE (op0
);
10156 if (VECTOR_TYPE_P (type
))
10159 else if (gimple_call_lhs (stmt
) == NULL_TREE
)
10162 type
= TREE_TYPE (TREE_TYPE (gimple_call_lhs (stmt
)));
10163 if (!check_for_binary_op_overflow (subcode
, type
, op0
, op1
, &ovf
)
10164 || (is_ubsan
&& ovf
))
10168 location_t loc
= gimple_location (stmt
);
10170 g
= gimple_build_assign (gimple_call_lhs (stmt
), subcode
, op0
, op1
);
10173 int prec
= TYPE_PRECISION (type
);
10176 || !useless_type_conversion_p (type
, TREE_TYPE (op0
))
10177 || !useless_type_conversion_p (type
, TREE_TYPE (op1
)))
10178 utype
= build_nonstandard_integer_type (prec
, 1);
10179 if (TREE_CODE (op0
) == INTEGER_CST
)
10180 op0
= fold_convert (utype
, op0
);
10181 else if (!useless_type_conversion_p (utype
, TREE_TYPE (op0
)))
10183 g
= gimple_build_assign (make_ssa_name (utype
), NOP_EXPR
, op0
);
10184 gimple_set_location (g
, loc
);
10185 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
10186 op0
= gimple_assign_lhs (g
);
10188 if (TREE_CODE (op1
) == INTEGER_CST
)
10189 op1
= fold_convert (utype
, op1
);
10190 else if (!useless_type_conversion_p (utype
, TREE_TYPE (op1
)))
10192 g
= gimple_build_assign (make_ssa_name (utype
), NOP_EXPR
, op1
);
10193 gimple_set_location (g
, loc
);
10194 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
10195 op1
= gimple_assign_lhs (g
);
10197 g
= gimple_build_assign (make_ssa_name (utype
), subcode
, op0
, op1
);
10198 gimple_set_location (g
, loc
);
10199 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
10202 g
= gimple_build_assign (make_ssa_name (type
), NOP_EXPR
,
10203 gimple_assign_lhs (g
));
10204 gimple_set_location (g
, loc
);
10205 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
10207 g
= gimple_build_assign (gimple_call_lhs (stmt
), COMPLEX_EXPR
,
10208 gimple_assign_lhs (g
),
10209 build_int_cst (type
, ovf
));
10211 gimple_set_location (g
, loc
);
10212 gsi_replace (gsi
, g
, false);
10216 /* Return true if VAR is a two-valued variable. Set a and b with the
10217 two-values when it is true. Return false otherwise. */
10220 two_valued_val_range_p (tree var
, tree
*a
, tree
*b
)
10222 value_range
*vr
= get_value_range (var
);
10223 if ((vr
->type
!= VR_RANGE
10224 && vr
->type
!= VR_ANTI_RANGE
)
10225 || TREE_CODE (vr
->min
) != INTEGER_CST
10226 || TREE_CODE (vr
->max
) != INTEGER_CST
)
10229 if (vr
->type
== VR_RANGE
10230 && wi::sub (vr
->max
, vr
->min
) == 1)
10237 /* ~[TYPE_MIN + 1, TYPE_MAX - 1] */
10238 if (vr
->type
== VR_ANTI_RANGE
10239 && wi::sub (vr
->min
, vrp_val_min (TREE_TYPE (var
))) == 1
10240 && wi::sub (vrp_val_max (TREE_TYPE (var
)), vr
->max
) == 1)
10242 *a
= vrp_val_min (TREE_TYPE (var
));
10243 *b
= vrp_val_max (TREE_TYPE (var
));
10250 /* Simplify STMT using ranges if possible. */
10253 simplify_stmt_using_ranges (gimple_stmt_iterator
*gsi
)
10255 gimple
*stmt
= gsi_stmt (*gsi
);
10256 if (is_gimple_assign (stmt
))
10258 enum tree_code rhs_code
= gimple_assign_rhs_code (stmt
);
10259 tree rhs1
= gimple_assign_rhs1 (stmt
);
10260 tree rhs2
= gimple_assign_rhs2 (stmt
);
10261 tree lhs
= gimple_assign_lhs (stmt
);
10262 tree val1
= NULL_TREE
, val2
= NULL_TREE
;
10263 use_operand_p use_p
;
10267 LHS = CST BINOP VAR
10268 Where VAR is two-valued and LHS is used in GIMPLE_COND only
10270 LHS = VAR == VAL1 ? (CST BINOP VAL1) : (CST BINOP VAL2)
10273 LHS = VAR BINOP CST
10274 Where VAR is two-valued and LHS is used in GIMPLE_COND only
10276 LHS = VAR == VAL1 ? (VAL1 BINOP CST) : (VAL2 BINOP CST) */
10278 if (TREE_CODE_CLASS (rhs_code
) == tcc_binary
10279 && INTEGRAL_TYPE_P (TREE_TYPE (lhs
))
10280 && ((TREE_CODE (rhs1
) == INTEGER_CST
10281 && TREE_CODE (rhs2
) == SSA_NAME
)
10282 || (TREE_CODE (rhs2
) == INTEGER_CST
10283 && TREE_CODE (rhs1
) == SSA_NAME
))
10284 && single_imm_use (lhs
, &use_p
, &use_stmt
)
10285 && gimple_code (use_stmt
) == GIMPLE_COND
)
10288 tree new_rhs1
= NULL_TREE
;
10289 tree new_rhs2
= NULL_TREE
;
10290 tree cmp_var
= NULL_TREE
;
10292 if (TREE_CODE (rhs2
) == SSA_NAME
10293 && two_valued_val_range_p (rhs2
, &val1
, &val2
))
10295 /* Optimize RHS1 OP [VAL1, VAL2]. */
10296 new_rhs1
= int_const_binop (rhs_code
, rhs1
, val1
);
10297 new_rhs2
= int_const_binop (rhs_code
, rhs1
, val2
);
10300 else if (TREE_CODE (rhs1
) == SSA_NAME
10301 && two_valued_val_range_p (rhs1
, &val1
, &val2
))
10303 /* Optimize [VAL1, VAL2] OP RHS2. */
10304 new_rhs1
= int_const_binop (rhs_code
, val1
, rhs2
);
10305 new_rhs2
= int_const_binop (rhs_code
, val2
, rhs2
);
10309 /* If we could not find two-vals or the optimzation is invalid as
10310 in divide by zero, new_rhs1 / new_rhs will be NULL_TREE. */
10311 if (new_rhs1
&& new_rhs2
)
10313 tree cond
= build2 (EQ_EXPR
, boolean_type_node
, cmp_var
, val1
);
10314 gimple_assign_set_rhs_with_ops (gsi
,
10318 update_stmt (gsi_stmt (*gsi
));
10319 fold_stmt (gsi
, follow_single_use_edges
);
10328 /* Transform EQ_EXPR, NE_EXPR into BIT_XOR_EXPR or identity
10329 if the RHS is zero or one, and the LHS are known to be boolean
10331 if (INTEGRAL_TYPE_P (TREE_TYPE (rhs1
)))
10332 return simplify_truth_ops_using_ranges (gsi
, stmt
);
10335 /* Transform TRUNC_DIV_EXPR and TRUNC_MOD_EXPR into RSHIFT_EXPR
10336 and BIT_AND_EXPR respectively if the first operand is greater
10337 than zero and the second operand is an exact power of two.
10338 Also optimize TRUNC_MOD_EXPR away if the second operand is
10339 constant and the first operand already has the right value
10341 case TRUNC_DIV_EXPR
:
10342 case TRUNC_MOD_EXPR
:
10343 if ((TREE_CODE (rhs1
) == SSA_NAME
10344 || TREE_CODE (rhs1
) == INTEGER_CST
)
10345 && INTEGRAL_TYPE_P (TREE_TYPE (rhs1
)))
10346 return simplify_div_or_mod_using_ranges (gsi
, stmt
);
10349 /* Transform ABS (X) into X or -X as appropriate. */
10351 if (TREE_CODE (rhs1
) == SSA_NAME
10352 && INTEGRAL_TYPE_P (TREE_TYPE (rhs1
)))
10353 return simplify_abs_using_ranges (gsi
, stmt
);
10358 /* Optimize away BIT_AND_EXPR and BIT_IOR_EXPR
10359 if all the bits being cleared are already cleared or
10360 all the bits being set are already set. */
10361 if (INTEGRAL_TYPE_P (TREE_TYPE (rhs1
)))
10362 return simplify_bit_ops_using_ranges (gsi
, stmt
);
10366 if (TREE_CODE (rhs1
) == SSA_NAME
10367 && INTEGRAL_TYPE_P (TREE_TYPE (rhs1
)))
10368 return simplify_conversion_using_ranges (gsi
, stmt
);
10372 if (TREE_CODE (rhs1
) == SSA_NAME
10373 && INTEGRAL_TYPE_P (TREE_TYPE (rhs1
)))
10374 return simplify_float_conversion_using_ranges (gsi
, stmt
);
10379 return simplify_min_or_max_using_ranges (gsi
, stmt
);
10385 else if (gimple_code (stmt
) == GIMPLE_COND
)
10386 return simplify_cond_using_ranges_1 (as_a
<gcond
*> (stmt
));
10387 else if (gimple_code (stmt
) == GIMPLE_SWITCH
)
10388 return simplify_switch_using_ranges (as_a
<gswitch
*> (stmt
));
10389 else if (is_gimple_call (stmt
)
10390 && gimple_call_internal_p (stmt
))
10391 return simplify_internal_call_using_ranges (gsi
, stmt
);
10396 /* If the statement pointed by SI has a predicate whose value can be
10397 computed using the value range information computed by VRP, compute
10398 its value and return true. Otherwise, return false. */
10401 fold_predicate_in (gimple_stmt_iterator
*si
)
10403 bool assignment_p
= false;
10405 gimple
*stmt
= gsi_stmt (*si
);
10407 if (is_gimple_assign (stmt
)
10408 && TREE_CODE_CLASS (gimple_assign_rhs_code (stmt
)) == tcc_comparison
)
10410 assignment_p
= true;
10411 val
= vrp_evaluate_conditional (gimple_assign_rhs_code (stmt
),
10412 gimple_assign_rhs1 (stmt
),
10413 gimple_assign_rhs2 (stmt
),
10416 else if (gcond
*cond_stmt
= dyn_cast
<gcond
*> (stmt
))
10417 val
= vrp_evaluate_conditional (gimple_cond_code (cond_stmt
),
10418 gimple_cond_lhs (cond_stmt
),
10419 gimple_cond_rhs (cond_stmt
),
10427 val
= fold_convert (gimple_expr_type (stmt
), val
);
10431 fprintf (dump_file
, "Folding predicate ");
10432 print_gimple_expr (dump_file
, stmt
, 0);
10433 fprintf (dump_file
, " to ");
10434 print_generic_expr (dump_file
, val
);
10435 fprintf (dump_file
, "\n");
10438 if (is_gimple_assign (stmt
))
10439 gimple_assign_set_rhs_from_tree (si
, val
);
10442 gcc_assert (gimple_code (stmt
) == GIMPLE_COND
);
10443 gcond
*cond_stmt
= as_a
<gcond
*> (stmt
);
10444 if (integer_zerop (val
))
10445 gimple_cond_make_false (cond_stmt
);
10446 else if (integer_onep (val
))
10447 gimple_cond_make_true (cond_stmt
);
10449 gcc_unreachable ();
10458 /* Callback for substitute_and_fold folding the stmt at *SI. */
10461 vrp_fold_stmt (gimple_stmt_iterator
*si
)
10463 if (fold_predicate_in (si
))
10466 return simplify_stmt_using_ranges (si
);
10469 /* Return the LHS of any ASSERT_EXPR where OP appears as the first
10470 argument to the ASSERT_EXPR and in which the ASSERT_EXPR dominates
10471 BB. If no such ASSERT_EXPR is found, return OP. */
10474 lhs_of_dominating_assert (tree op
, basic_block bb
, gimple
*stmt
)
10476 imm_use_iterator imm_iter
;
10478 use_operand_p use_p
;
10480 if (TREE_CODE (op
) == SSA_NAME
)
10482 FOR_EACH_IMM_USE_FAST (use_p
, imm_iter
, op
)
10484 use_stmt
= USE_STMT (use_p
);
10485 if (use_stmt
!= stmt
10486 && gimple_assign_single_p (use_stmt
)
10487 && TREE_CODE (gimple_assign_rhs1 (use_stmt
)) == ASSERT_EXPR
10488 && TREE_OPERAND (gimple_assign_rhs1 (use_stmt
), 0) == op
10489 && dominated_by_p (CDI_DOMINATORS
, bb
, gimple_bb (use_stmt
)))
10490 return gimple_assign_lhs (use_stmt
);
10496 /* A trivial wrapper so that we can present the generic jump threading
10497 code with a simple API for simplifying statements. STMT is the
10498 statement we want to simplify, WITHIN_STMT provides the location
10499 for any overflow warnings. */
10502 simplify_stmt_for_jump_threading (gimple
*stmt
, gimple
*within_stmt
,
10503 class avail_exprs_stack
*avail_exprs_stack ATTRIBUTE_UNUSED
,
10506 /* First see if the conditional is in the hash table. */
10507 tree cached_lhs
= avail_exprs_stack
->lookup_avail_expr (stmt
, false, true);
10508 if (cached_lhs
&& is_gimple_min_invariant (cached_lhs
))
10511 if (gcond
*cond_stmt
= dyn_cast
<gcond
*> (stmt
))
10513 tree op0
= gimple_cond_lhs (cond_stmt
);
10514 op0
= lhs_of_dominating_assert (op0
, bb
, stmt
);
10516 tree op1
= gimple_cond_rhs (cond_stmt
);
10517 op1
= lhs_of_dominating_assert (op1
, bb
, stmt
);
10519 return vrp_evaluate_conditional (gimple_cond_code (cond_stmt
),
10520 op0
, op1
, within_stmt
);
10523 /* We simplify a switch statement by trying to determine which case label
10524 will be taken. If we are successful then we return the corresponding
10525 CASE_LABEL_EXPR. */
10526 if (gswitch
*switch_stmt
= dyn_cast
<gswitch
*> (stmt
))
10528 tree op
= gimple_switch_index (switch_stmt
);
10529 if (TREE_CODE (op
) != SSA_NAME
)
10532 op
= lhs_of_dominating_assert (op
, bb
, stmt
);
10534 value_range
*vr
= get_value_range (op
);
10535 if ((vr
->type
!= VR_RANGE
&& vr
->type
!= VR_ANTI_RANGE
)
10536 || symbolic_range_p (vr
))
10539 if (vr
->type
== VR_RANGE
)
10542 /* Get the range of labels that contain a part of the operand's
10544 find_case_label_range (switch_stmt
, vr
->min
, vr
->max
, &i
, &j
);
10546 /* Is there only one such label? */
10549 tree label
= gimple_switch_label (switch_stmt
, i
);
10551 /* The i'th label will be taken only if the value range of the
10552 operand is entirely within the bounds of this label. */
10553 if (CASE_HIGH (label
) != NULL_TREE
10554 ? (tree_int_cst_compare (CASE_LOW (label
), vr
->min
) <= 0
10555 && tree_int_cst_compare (CASE_HIGH (label
), vr
->max
) >= 0)
10556 : (tree_int_cst_equal (CASE_LOW (label
), vr
->min
)
10557 && tree_int_cst_equal (vr
->min
, vr
->max
)))
10561 /* If there are no such labels then the default label will be
10564 return gimple_switch_label (switch_stmt
, 0);
10567 if (vr
->type
== VR_ANTI_RANGE
)
10569 unsigned n
= gimple_switch_num_labels (switch_stmt
);
10570 tree min_label
= gimple_switch_label (switch_stmt
, 1);
10571 tree max_label
= gimple_switch_label (switch_stmt
, n
- 1);
10573 /* The default label will be taken only if the anti-range of the
10574 operand is entirely outside the bounds of all the (non-default)
10576 if (tree_int_cst_compare (vr
->min
, CASE_LOW (min_label
)) <= 0
10577 && (CASE_HIGH (max_label
) != NULL_TREE
10578 ? tree_int_cst_compare (vr
->max
, CASE_HIGH (max_label
)) >= 0
10579 : tree_int_cst_compare (vr
->max
, CASE_LOW (max_label
)) >= 0))
10580 return gimple_switch_label (switch_stmt
, 0);
10586 if (gassign
*assign_stmt
= dyn_cast
<gassign
*> (stmt
))
10588 value_range new_vr
= VR_INITIALIZER
;
10589 tree lhs
= gimple_assign_lhs (assign_stmt
);
10591 if (TREE_CODE (lhs
) == SSA_NAME
10592 && (INTEGRAL_TYPE_P (TREE_TYPE (lhs
))
10593 || POINTER_TYPE_P (TREE_TYPE (lhs
))))
10595 extract_range_from_assignment (&new_vr
, assign_stmt
);
10596 if (range_int_cst_singleton_p (&new_vr
))
10604 class vrp_dom_walker
: public dom_walker
10607 vrp_dom_walker (cdi_direction direction
,
10608 class const_and_copies
*const_and_copies
,
10609 class avail_exprs_stack
*avail_exprs_stack
)
10610 : dom_walker (direction
, true),
10611 m_const_and_copies (const_and_copies
),
10612 m_avail_exprs_stack (avail_exprs_stack
),
10613 m_dummy_cond (NULL
) {}
10615 virtual edge
before_dom_children (basic_block
);
10616 virtual void after_dom_children (basic_block
);
10619 class const_and_copies
*m_const_and_copies
;
10620 class avail_exprs_stack
*m_avail_exprs_stack
;
10622 gcond
*m_dummy_cond
;
10625 /* Called before processing dominator children of BB. We want to look
10626 at ASSERT_EXPRs and record information from them in the appropriate
10629 We could look at other statements here. It's not seen as likely
10630 to significantly increase the jump threads we discover. */
10633 vrp_dom_walker::before_dom_children (basic_block bb
)
10635 gimple_stmt_iterator gsi
;
10637 m_avail_exprs_stack
->push_marker ();
10638 m_const_and_copies
->push_marker ();
10639 for (gsi
= gsi_start_nondebug_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
10641 gimple
*stmt
= gsi_stmt (gsi
);
10642 if (gimple_assign_single_p (stmt
)
10643 && TREE_CODE (gimple_assign_rhs1 (stmt
)) == ASSERT_EXPR
)
10645 tree rhs1
= gimple_assign_rhs1 (stmt
);
10646 tree cond
= TREE_OPERAND (rhs1
, 1);
10647 tree inverted
= invert_truthvalue (cond
);
10648 vec
<cond_equivalence
> p
;
10650 record_conditions (&p
, cond
, inverted
);
10651 for (unsigned int i
= 0; i
< p
.length (); i
++)
10652 m_avail_exprs_stack
->record_cond (&p
[i
]);
10654 tree lhs
= gimple_assign_lhs (stmt
);
10655 m_const_and_copies
->record_const_or_copy (lhs
,
10656 TREE_OPERAND (rhs1
, 0));
10665 /* Called after processing dominator children of BB. This is where we
10666 actually call into the threader. */
10668 vrp_dom_walker::after_dom_children (basic_block bb
)
10671 m_dummy_cond
= gimple_build_cond (NE_EXPR
,
10672 integer_zero_node
, integer_zero_node
,
10675 thread_outgoing_edges (bb
, m_dummy_cond
, m_const_and_copies
,
10676 m_avail_exprs_stack
,
10677 simplify_stmt_for_jump_threading
);
10679 m_avail_exprs_stack
->pop_to_marker ();
10680 m_const_and_copies
->pop_to_marker ();
10683 /* Blocks which have more than one predecessor and more than
10684 one successor present jump threading opportunities, i.e.,
10685 when the block is reached from a specific predecessor, we
10686 may be able to determine which of the outgoing edges will
10687 be traversed. When this optimization applies, we are able
10688 to avoid conditionals at runtime and we may expose secondary
10689 optimization opportunities.
10691 This routine is effectively a driver for the generic jump
10692 threading code. It basically just presents the generic code
10693 with edges that may be suitable for jump threading.
10695 Unlike DOM, we do not iterate VRP if jump threading was successful.
10696 While iterating may expose new opportunities for VRP, it is expected
10697 those opportunities would be very limited and the compile time cost
10698 to expose those opportunities would be significant.
10700 As jump threading opportunities are discovered, they are registered
10701 for later realization. */
10704 identify_jump_threads (void)
10709 /* Ugh. When substituting values earlier in this pass we can
10710 wipe the dominance information. So rebuild the dominator
10711 information as we need it within the jump threading code. */
10712 calculate_dominance_info (CDI_DOMINATORS
);
10714 /* We do not allow VRP information to be used for jump threading
10715 across a back edge in the CFG. Otherwise it becomes too
10716 difficult to avoid eliminating loop exit tests. Of course
10717 EDGE_DFS_BACK is not accurate at this time so we have to
10719 mark_dfs_back_edges ();
10721 /* Do not thread across edges we are about to remove. Just marking
10722 them as EDGE_IGNORE will do. */
10723 FOR_EACH_VEC_ELT (to_remove_edges
, i
, e
)
10724 e
->flags
|= EDGE_IGNORE
;
10726 /* Allocate our unwinder stack to unwind any temporary equivalences
10727 that might be recorded. */
10728 const_and_copies
*equiv_stack
= new const_and_copies ();
10730 hash_table
<expr_elt_hasher
> *avail_exprs
10731 = new hash_table
<expr_elt_hasher
> (1024);
10732 avail_exprs_stack
*avail_exprs_stack
10733 = new class avail_exprs_stack (avail_exprs
);
10735 vrp_dom_walker
walker (CDI_DOMINATORS
, equiv_stack
, avail_exprs_stack
);
10736 walker
.walk (cfun
->cfg
->x_entry_block_ptr
);
10738 /* Clear EDGE_IGNORE. */
10739 FOR_EACH_VEC_ELT (to_remove_edges
, i
, e
)
10740 e
->flags
&= ~EDGE_IGNORE
;
10742 /* We do not actually update the CFG or SSA graphs at this point as
10743 ASSERT_EXPRs are still in the IL and cfg cleanup code does not yet
10744 handle ASSERT_EXPRs gracefully. */
10745 delete equiv_stack
;
10746 delete avail_exprs
;
10747 delete avail_exprs_stack
;
10750 /* Free VRP lattice. */
10753 vrp_free_lattice ()
10755 /* Free allocated memory. */
10757 free (vr_phi_edge_counts
);
10758 bitmap_obstack_release (&vrp_equiv_obstack
);
10759 vrp_value_range_pool
.release ();
10761 /* So that we can distinguish between VRP data being available
10762 and not available. */
10764 vr_phi_edge_counts
= NULL
;
10767 /* Traverse all the blocks folding conditionals with known ranges. */
10770 vrp_finalize (bool warn_array_bounds_p
)
10774 values_propagated
= true;
10778 fprintf (dump_file
, "\nValue ranges after VRP:\n\n");
10779 dump_all_value_ranges (dump_file
);
10780 fprintf (dump_file
, "\n");
10783 /* Set value range to non pointer SSA_NAMEs. */
10784 for (i
= 0; i
< num_vr_values
; i
++)
10787 tree name
= ssa_name (i
);
10790 || (vr_value
[i
]->type
== VR_VARYING
)
10791 || (vr_value
[i
]->type
== VR_UNDEFINED
)
10792 || (TREE_CODE (vr_value
[i
]->min
) != INTEGER_CST
)
10793 || (TREE_CODE (vr_value
[i
]->max
) != INTEGER_CST
))
10796 if (POINTER_TYPE_P (TREE_TYPE (name
))
10797 && ((vr_value
[i
]->type
== VR_RANGE
10798 && range_includes_zero_p (vr_value
[i
]->min
,
10799 vr_value
[i
]->max
) == 0)
10800 || (vr_value
[i
]->type
== VR_ANTI_RANGE
10801 && range_includes_zero_p (vr_value
[i
]->min
,
10802 vr_value
[i
]->max
) == 1)))
10803 set_ptr_nonnull (name
);
10804 else if (!POINTER_TYPE_P (TREE_TYPE (name
)))
10805 set_range_info (name
, vr_value
[i
]->type
, vr_value
[i
]->min
,
10809 substitute_and_fold (op_with_constant_singleton_value_range
, vrp_fold_stmt
);
10811 if (warn_array_bounds
&& warn_array_bounds_p
)
10812 check_all_array_refs ();
10815 /* evrp_dom_walker visits the basic blocks in the dominance order and set
10816 the Value Ranges (VR) for SSA_NAMEs in the scope. Use this VR to
10817 discover more VRs. */
10819 class evrp_dom_walker
: public dom_walker
10823 : dom_walker (CDI_DOMINATORS
), stack (10)
10825 need_eh_cleanup
= BITMAP_ALLOC (NULL
);
10827 ~evrp_dom_walker ()
10829 BITMAP_FREE (need_eh_cleanup
);
10831 virtual edge
before_dom_children (basic_block
);
10832 virtual void after_dom_children (basic_block
);
10833 void push_value_range (tree var
, value_range
*vr
);
10834 value_range
*pop_value_range (tree var
);
10835 value_range
*try_find_new_range (tree
, tree op
, tree_code code
, tree limit
);
10837 /* Cond_stack holds the old VR. */
10838 auto_vec
<std::pair
<tree
, value_range
*> > stack
;
10839 bitmap need_eh_cleanup
;
10840 auto_vec
<gimple
*> stmts_to_fixup
;
10841 auto_vec
<gimple
*> stmts_to_remove
;
10844 /* Find new range for NAME such that (OP CODE LIMIT) is true. */
10847 evrp_dom_walker::try_find_new_range (tree name
,
10848 tree op
, tree_code code
, tree limit
)
10850 value_range vr
= VR_INITIALIZER
;
10851 value_range
*old_vr
= get_value_range (name
);
10853 /* Discover VR when condition is true. */
10854 extract_range_for_var_from_comparison_expr (name
, code
, op
,
10856 /* If we found any usable VR, set the VR to ssa_name and create a
10857 PUSH old value in the stack with the old VR. */
10858 if (vr
.type
== VR_RANGE
|| vr
.type
== VR_ANTI_RANGE
)
10860 if (old_vr
->type
== vr
.type
10861 && vrp_operand_equal_p (old_vr
->min
, vr
.min
)
10862 && vrp_operand_equal_p (old_vr
->max
, vr
.max
))
10864 value_range
*new_vr
= vrp_value_range_pool
.allocate ();
10871 /* See if there is any new scope is entered with new VR and set that VR to
10872 ssa_name before visiting the statements in the scope. */
10875 evrp_dom_walker::before_dom_children (basic_block bb
)
10877 tree op0
= NULL_TREE
;
10881 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
10882 fprintf (dump_file
, "Visiting BB%d\n", bb
->index
);
10884 stack
.safe_push (std::make_pair (NULL_TREE
, (value_range
*)NULL
));
10886 edge pred_e
= NULL
;
10887 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
10889 /* Ignore simple backedges from this to allow recording conditions
10890 in loop headers. */
10891 if (dominated_by_p (CDI_DOMINATORS
, e
->src
, e
->dest
))
10903 gimple
*stmt
= last_stmt (pred_e
->src
);
10905 && gimple_code (stmt
) == GIMPLE_COND
10906 && (op0
= gimple_cond_lhs (stmt
))
10907 && TREE_CODE (op0
) == SSA_NAME
10908 && (INTEGRAL_TYPE_P (TREE_TYPE (gimple_cond_lhs (stmt
)))
10909 || POINTER_TYPE_P (TREE_TYPE (gimple_cond_lhs (stmt
)))))
10911 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
10913 fprintf (dump_file
, "Visiting controlling predicate ");
10914 print_gimple_stmt (dump_file
, stmt
, 0);
10916 /* Entering a new scope. Try to see if we can find a VR
10918 tree op1
= gimple_cond_rhs (stmt
);
10919 if (TREE_OVERFLOW_P (op1
))
10920 op1
= drop_tree_overflow (op1
);
10921 tree_code code
= gimple_cond_code (stmt
);
10923 auto_vec
<assert_info
, 8> asserts
;
10924 register_edge_assert_for (op0
, pred_e
, code
, op0
, op1
, asserts
);
10925 if (TREE_CODE (op1
) == SSA_NAME
)
10926 register_edge_assert_for (op1
, pred_e
, code
, op0
, op1
, asserts
);
10928 auto_vec
<std::pair
<tree
, value_range
*>, 8> vrs
;
10929 for (unsigned i
= 0; i
< asserts
.length (); ++i
)
10931 value_range
*vr
= try_find_new_range (asserts
[i
].name
,
10933 asserts
[i
].comp_code
,
10936 vrs
.safe_push (std::make_pair (asserts
[i
].name
, vr
));
10938 /* Push updated ranges only after finding all of them to avoid
10939 ordering issues that can lead to worse ranges. */
10940 for (unsigned i
= 0; i
< vrs
.length (); ++i
)
10941 push_value_range (vrs
[i
].first
, vrs
[i
].second
);
10945 /* Visit PHI stmts and discover any new VRs possible. */
10946 bool has_unvisited_preds
= false;
10947 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
10948 if (e
->flags
& EDGE_EXECUTABLE
10949 && !(e
->src
->flags
& BB_VISITED
))
10951 has_unvisited_preds
= true;
10955 for (gphi_iterator gpi
= gsi_start_phis (bb
);
10956 !gsi_end_p (gpi
); gsi_next (&gpi
))
10958 gphi
*phi
= gpi
.phi ();
10959 tree lhs
= PHI_RESULT (phi
);
10960 if (virtual_operand_p (lhs
))
10962 value_range vr_result
= VR_INITIALIZER
;
10963 bool interesting
= stmt_interesting_for_vrp (phi
);
10964 if (interesting
&& dump_file
&& (dump_flags
& TDF_DETAILS
))
10966 fprintf (dump_file
, "Visiting PHI node ");
10967 print_gimple_stmt (dump_file
, phi
, 0);
10969 if (!has_unvisited_preds
10971 extract_range_from_phi_node (phi
, &vr_result
);
10974 set_value_range_to_varying (&vr_result
);
10975 /* When we have an unvisited executable predecessor we can't
10976 use PHI arg ranges which may be still UNDEFINED but have
10977 to use VARYING for them. But we can still resort to
10978 SCEV for loop header PHIs. */
10981 && (l
= loop_containing_stmt (phi
))
10982 && l
->header
== gimple_bb (phi
))
10983 adjust_range_with_scev (&vr_result
, l
, phi
, lhs
);
10985 update_value_range (lhs
, &vr_result
);
10987 /* Mark PHIs whose lhs we fully propagate for removal. */
10988 tree val
= op_with_constant_singleton_value_range (lhs
);
10989 if (val
&& may_propagate_copy (lhs
, val
))
10991 stmts_to_remove
.safe_push (phi
);
10995 /* Set the SSA with the value range. */
10996 if (INTEGRAL_TYPE_P (TREE_TYPE (lhs
)))
10998 if ((vr_result
.type
== VR_RANGE
10999 || vr_result
.type
== VR_ANTI_RANGE
)
11000 && (TREE_CODE (vr_result
.min
) == INTEGER_CST
)
11001 && (TREE_CODE (vr_result
.max
) == INTEGER_CST
))
11002 set_range_info (lhs
,
11003 vr_result
.type
, vr_result
.min
, vr_result
.max
);
11005 else if (POINTER_TYPE_P (TREE_TYPE (lhs
))
11006 && ((vr_result
.type
== VR_RANGE
11007 && range_includes_zero_p (vr_result
.min
,
11008 vr_result
.max
) == 0)
11009 || (vr_result
.type
== VR_ANTI_RANGE
11010 && range_includes_zero_p (vr_result
.min
,
11011 vr_result
.max
) == 1)))
11012 set_ptr_nonnull (lhs
);
11015 edge taken_edge
= NULL
;
11017 /* Visit all other stmts and discover any new VRs possible. */
11018 for (gimple_stmt_iterator gsi
= gsi_start_bb (bb
);
11019 !gsi_end_p (gsi
); gsi_next (&gsi
))
11021 gimple
*stmt
= gsi_stmt (gsi
);
11022 tree output
= NULL_TREE
;
11023 gimple
*old_stmt
= stmt
;
11024 bool was_noreturn
= (is_gimple_call (stmt
)
11025 && gimple_call_noreturn_p (stmt
));
11027 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
11029 fprintf (dump_file
, "Visiting stmt ");
11030 print_gimple_stmt (dump_file
, stmt
, 0);
11033 if (gcond
*cond
= dyn_cast
<gcond
*> (stmt
))
11035 vrp_visit_cond_stmt (cond
, &taken_edge
);
11038 if (taken_edge
->flags
& EDGE_TRUE_VALUE
)
11039 gimple_cond_make_true (cond
);
11040 else if (taken_edge
->flags
& EDGE_FALSE_VALUE
)
11041 gimple_cond_make_false (cond
);
11043 gcc_unreachable ();
11044 update_stmt (stmt
);
11047 else if (stmt_interesting_for_vrp (stmt
))
11050 value_range vr
= VR_INITIALIZER
;
11051 extract_range_from_stmt (stmt
, &taken_edge
, &output
, &vr
);
11053 && (vr
.type
== VR_RANGE
|| vr
.type
== VR_ANTI_RANGE
))
11055 update_value_range (output
, &vr
);
11056 vr
= *get_value_range (output
);
11058 /* Mark stmts whose output we fully propagate for removal. */
11060 if ((val
= op_with_constant_singleton_value_range (output
))
11061 && may_propagate_copy (output
, val
)
11062 && !stmt_could_throw_p (stmt
)
11063 && !gimple_has_side_effects (stmt
))
11065 stmts_to_remove
.safe_push (stmt
);
11069 /* Set the SSA with the value range. */
11070 if (INTEGRAL_TYPE_P (TREE_TYPE (output
)))
11072 if ((vr
.type
== VR_RANGE
11073 || vr
.type
== VR_ANTI_RANGE
)
11074 && (TREE_CODE (vr
.min
) == INTEGER_CST
)
11075 && (TREE_CODE (vr
.max
) == INTEGER_CST
))
11076 set_range_info (output
, vr
.type
, vr
.min
, vr
.max
);
11078 else if (POINTER_TYPE_P (TREE_TYPE (output
))
11079 && ((vr
.type
== VR_RANGE
11080 && range_includes_zero_p (vr
.min
,
11082 || (vr
.type
== VR_ANTI_RANGE
11083 && range_includes_zero_p (vr
.min
,
11085 set_ptr_nonnull (output
);
11088 set_defs_to_varying (stmt
);
11091 set_defs_to_varying (stmt
);
11093 /* See if we can derive a range for any of STMT's operands. */
11096 FOR_EACH_SSA_TREE_OPERAND (op
, stmt
, i
, SSA_OP_USE
)
11099 enum tree_code comp_code
;
11101 /* If OP is used in such a way that we can infer a value
11102 range for it, and we don't find a previous assertion for
11103 it, create a new assertion location node for OP. */
11104 if (infer_value_range (stmt
, op
, &comp_code
, &value
))
11106 /* If we are able to infer a nonzero value range for OP,
11107 then walk backwards through the use-def chain to see if OP
11108 was set via a typecast.
11109 If so, then we can also infer a nonzero value range
11110 for the operand of the NOP_EXPR. */
11111 if (comp_code
== NE_EXPR
&& integer_zerop (value
))
11114 gimple
*def_stmt
= SSA_NAME_DEF_STMT (t
);
11115 while (is_gimple_assign (def_stmt
)
11116 && CONVERT_EXPR_CODE_P
11117 (gimple_assign_rhs_code (def_stmt
))
11119 (gimple_assign_rhs1 (def_stmt
)) == SSA_NAME
11121 (TREE_TYPE (gimple_assign_rhs1 (def_stmt
))))
11123 t
= gimple_assign_rhs1 (def_stmt
);
11124 def_stmt
= SSA_NAME_DEF_STMT (t
);
11126 /* Add VR when (T COMP_CODE value) condition is
11128 value_range
*op_range
11129 = try_find_new_range (t
, t
, comp_code
, value
);
11131 push_value_range (t
, op_range
);
11134 /* Add VR when (OP COMP_CODE value) condition is true. */
11135 value_range
*op_range
= try_find_new_range (op
, op
,
11138 push_value_range (op
, op_range
);
11142 /* Try folding stmts with the VR discovered. */
11144 = replace_uses_in (stmt
, op_with_constant_singleton_value_range
);
11145 if (fold_stmt (&gsi
, follow_single_use_edges
)
11148 stmt
= gsi_stmt (gsi
);
11149 update_stmt (stmt
);
11150 did_replace
= true;
11155 /* If we cleaned up EH information from the statement,
11156 remove EH edges. */
11157 if (maybe_clean_or_replace_eh_stmt (old_stmt
, stmt
))
11158 bitmap_set_bit (need_eh_cleanup
, bb
->index
);
11160 /* If we turned a not noreturn call into a noreturn one
11161 schedule it for fixup. */
11163 && is_gimple_call (stmt
)
11164 && gimple_call_noreturn_p (stmt
))
11165 stmts_to_fixup
.safe_push (stmt
);
11167 if (gimple_assign_single_p (stmt
))
11169 tree rhs
= gimple_assign_rhs1 (stmt
);
11170 if (TREE_CODE (rhs
) == ADDR_EXPR
)
11171 recompute_tree_invariant_for_addr_expr (rhs
);
11176 /* Visit BB successor PHI nodes and replace PHI args. */
11177 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
11179 for (gphi_iterator gpi
= gsi_start_phis (e
->dest
);
11180 !gsi_end_p (gpi
); gsi_next (&gpi
))
11182 gphi
*phi
= gpi
.phi ();
11183 use_operand_p use_p
= PHI_ARG_DEF_PTR_FROM_EDGE (phi
, e
);
11184 tree arg
= USE_FROM_PTR (use_p
);
11185 if (TREE_CODE (arg
) != SSA_NAME
11186 || virtual_operand_p (arg
))
11188 tree val
= op_with_constant_singleton_value_range (arg
);
11189 if (val
&& may_propagate_copy (arg
, val
))
11190 propagate_value (use_p
, val
);
11194 bb
->flags
|= BB_VISITED
;
11199 /* Restore/pop VRs valid only for BB when we leave BB. */
11202 evrp_dom_walker::after_dom_children (basic_block bb ATTRIBUTE_UNUSED
)
11204 gcc_checking_assert (!stack
.is_empty ());
11205 while (stack
.last ().first
!= NULL_TREE
)
11206 pop_value_range (stack
.last ().first
);
11210 /* Push the Value Range of VAR to the stack and update it with new VR. */
11213 evrp_dom_walker::push_value_range (tree var
, value_range
*vr
)
11215 if (SSA_NAME_VERSION (var
) >= num_vr_values
)
11217 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
11219 fprintf (dump_file
, "pushing new range for ");
11220 print_generic_expr (dump_file
, var
);
11221 fprintf (dump_file
, ": ");
11222 dump_value_range (dump_file
, vr
);
11223 fprintf (dump_file
, "\n");
11225 stack
.safe_push (std::make_pair (var
, get_value_range (var
)));
11226 vr_value
[SSA_NAME_VERSION (var
)] = vr
;
11229 /* Pop the Value Range from the vrp_stack and update VAR with it. */
11232 evrp_dom_walker::pop_value_range (tree var
)
11234 value_range
*vr
= stack
.last ().second
;
11235 gcc_checking_assert (var
== stack
.last ().first
);
11236 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
11238 fprintf (dump_file
, "popping range for ");
11239 print_generic_expr (dump_file
, var
);
11240 fprintf (dump_file
, ", restoring ");
11241 dump_value_range (dump_file
, vr
);
11242 fprintf (dump_file
, "\n");
11244 vr_value
[SSA_NAME_VERSION (var
)] = vr
;
11250 /* Main entry point for the early vrp pass which is a simplified non-iterative
11251 version of vrp where basic blocks are visited in dominance order. Value
11252 ranges discovered in early vrp will also be used by ipa-vrp. */
11254 static unsigned int
11255 execute_early_vrp ()
11261 loop_optimizer_init (LOOPS_NORMAL
| LOOPS_HAVE_RECORDED_EXITS
);
11262 rewrite_into_loop_closed_ssa (NULL
, TODO_update_ssa
);
11263 scev_initialize ();
11264 calculate_dominance_info (CDI_DOMINATORS
);
11265 FOR_EACH_BB_FN (bb
, cfun
)
11267 bb
->flags
&= ~BB_VISITED
;
11268 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
11269 e
->flags
|= EDGE_EXECUTABLE
;
11271 vrp_initialize_lattice ();
11273 /* Walk stmts in dominance order and propagate VRP. */
11274 evrp_dom_walker walker
;
11275 walker
.walk (ENTRY_BLOCK_PTR_FOR_FN (cfun
));
11279 fprintf (dump_file
, "\nValue ranges after Early VRP:\n\n");
11280 dump_all_value_ranges (dump_file
);
11281 fprintf (dump_file
, "\n");
11284 /* Remove stmts in reverse order to make debug stmt creation possible. */
11285 while (! walker
.stmts_to_remove
.is_empty ())
11287 gimple
*stmt
= walker
.stmts_to_remove
.pop ();
11288 if (dump_file
&& dump_flags
& TDF_DETAILS
)
11290 fprintf (dump_file
, "Removing dead stmt ");
11291 print_gimple_stmt (dump_file
, stmt
, 0);
11292 fprintf (dump_file
, "\n");
11294 gimple_stmt_iterator gsi
= gsi_for_stmt (stmt
);
11295 if (gimple_code (stmt
) == GIMPLE_PHI
)
11296 remove_phi_node (&gsi
, true);
11299 unlink_stmt_vdef (stmt
);
11300 gsi_remove (&gsi
, true);
11301 release_defs (stmt
);
11305 if (!bitmap_empty_p (walker
.need_eh_cleanup
))
11306 gimple_purge_all_dead_eh_edges (walker
.need_eh_cleanup
);
11308 /* Fixup stmts that became noreturn calls. This may require splitting
11309 blocks and thus isn't possible during the dominator walk. Do this
11310 in reverse order so we don't inadvertedly remove a stmt we want to
11311 fixup by visiting a dominating now noreturn call first. */
11312 while (!walker
.stmts_to_fixup
.is_empty ())
11314 gimple
*stmt
= walker
.stmts_to_fixup
.pop ();
11315 fixup_noreturn_call (stmt
);
11318 vrp_free_lattice ();
11320 loop_optimizer_finalize ();
11325 /* Main entry point to VRP (Value Range Propagation). This pass is
11326 loosely based on J. R. C. Patterson, ``Accurate Static Branch
11327 Prediction by Value Range Propagation,'' in SIGPLAN Conference on
11328 Programming Language Design and Implementation, pp. 67-78, 1995.
11329 Also available at http://citeseer.ist.psu.edu/patterson95accurate.html
11331 This is essentially an SSA-CCP pass modified to deal with ranges
11332 instead of constants.
11334 While propagating ranges, we may find that two or more SSA name
11335 have equivalent, though distinct ranges. For instance,
11338 2 p_4 = ASSERT_EXPR <p_3, p_3 != 0>
11340 4 p_5 = ASSERT_EXPR <p_4, p_4 == q_2>;
11344 In the code above, pointer p_5 has range [q_2, q_2], but from the
11345 code we can also determine that p_5 cannot be NULL and, if q_2 had
11346 a non-varying range, p_5's range should also be compatible with it.
11348 These equivalences are created by two expressions: ASSERT_EXPR and
11349 copy operations. Since p_5 is an assertion on p_4, and p_4 was the
11350 result of another assertion, then we can use the fact that p_5 and
11351 p_4 are equivalent when evaluating p_5's range.
11353 Together with value ranges, we also propagate these equivalences
11354 between names so that we can take advantage of information from
11355 multiple ranges when doing final replacement. Note that this
11356 equivalency relation is transitive but not symmetric.
11358 In the example above, p_5 is equivalent to p_4, q_2 and p_3, but we
11359 cannot assert that q_2 is equivalent to p_5 because q_2 may be used
11360 in contexts where that assertion does not hold (e.g., in line 6).
11362 TODO, the main difference between this pass and Patterson's is that
11363 we do not propagate edge probabilities. We only compute whether
11364 edges can be taken or not. That is, instead of having a spectrum
11365 of jump probabilities between 0 and 1, we only deal with 0, 1 and
11366 DON'T KNOW. In the future, it may be worthwhile to propagate
11367 probabilities to aid branch prediction. */
11369 static unsigned int
11370 execute_vrp (bool warn_array_bounds_p
)
11376 loop_optimizer_init (LOOPS_NORMAL
| LOOPS_HAVE_RECORDED_EXITS
);
11377 rewrite_into_loop_closed_ssa (NULL
, TODO_update_ssa
);
11378 scev_initialize ();
11380 /* ??? This ends up using stale EDGE_DFS_BACK for liveness computation.
11381 Inserting assertions may split edges which will invalidate
11383 insert_range_assertions ();
11385 to_remove_edges
.create (10);
11386 to_update_switch_stmts
.create (5);
11387 threadedge_initialize_values ();
11389 /* For visiting PHI nodes we need EDGE_DFS_BACK computed. */
11390 mark_dfs_back_edges ();
11392 vrp_initialize_lattice ();
11394 ssa_propagate (vrp_visit_stmt
, vrp_visit_phi_node
);
11395 vrp_finalize (warn_array_bounds_p
);
11397 /* We must identify jump threading opportunities before we release
11398 the datastructures built by VRP. */
11399 identify_jump_threads ();
11401 /* A comparison of an SSA_NAME against a constant where the SSA_NAME
11402 was set by a type conversion can often be rewritten to use the
11403 RHS of the type conversion.
11405 However, doing so inhibits jump threading through the comparison.
11406 So that transformation is not performed until after jump threading
11409 FOR_EACH_BB_FN (bb
, cfun
)
11411 gimple
*last
= last_stmt (bb
);
11412 if (last
&& gimple_code (last
) == GIMPLE_COND
)
11413 simplify_cond_using_ranges_2 (as_a
<gcond
*> (last
));
11416 vrp_free_lattice ();
11418 free_numbers_of_iterations_estimates (cfun
);
11420 /* ASSERT_EXPRs must be removed before finalizing jump threads
11421 as finalizing jump threads calls the CFG cleanup code which
11422 does not properly handle ASSERT_EXPRs. */
11423 remove_range_assertions ();
11425 /* If we exposed any new variables, go ahead and put them into
11426 SSA form now, before we handle jump threading. This simplifies
11427 interactions between rewriting of _DECL nodes into SSA form
11428 and rewriting SSA_NAME nodes into SSA form after block
11429 duplication and CFG manipulation. */
11430 update_ssa (TODO_update_ssa
);
11432 /* We identified all the jump threading opportunities earlier, but could
11433 not transform the CFG at that time. This routine transforms the
11434 CFG and arranges for the dominator tree to be rebuilt if necessary.
11436 Note the SSA graph update will occur during the normal TODO
11437 processing by the pass manager. */
11438 thread_through_all_blocks (false);
11440 /* Remove dead edges from SWITCH_EXPR optimization. This leaves the
11441 CFG in a broken state and requires a cfg_cleanup run. */
11442 FOR_EACH_VEC_ELT (to_remove_edges
, i
, e
)
11444 /* Update SWITCH_EXPR case label vector. */
11445 FOR_EACH_VEC_ELT (to_update_switch_stmts
, i
, su
)
11448 size_t n
= TREE_VEC_LENGTH (su
->vec
);
11450 gimple_switch_set_num_labels (su
->stmt
, n
);
11451 for (j
= 0; j
< n
; j
++)
11452 gimple_switch_set_label (su
->stmt
, j
, TREE_VEC_ELT (su
->vec
, j
));
11453 /* As we may have replaced the default label with a regular one
11454 make sure to make it a real default label again. This ensures
11455 optimal expansion. */
11456 label
= gimple_switch_label (su
->stmt
, 0);
11457 CASE_LOW (label
) = NULL_TREE
;
11458 CASE_HIGH (label
) = NULL_TREE
;
11461 if (to_remove_edges
.length () > 0)
11463 free_dominance_info (CDI_DOMINATORS
);
11464 loops_state_set (LOOPS_NEED_FIXUP
);
11467 to_remove_edges
.release ();
11468 to_update_switch_stmts
.release ();
11469 threadedge_finalize_values ();
11472 loop_optimizer_finalize ();
11478 const pass_data pass_data_vrp
=
11480 GIMPLE_PASS
, /* type */
11482 OPTGROUP_NONE
, /* optinfo_flags */
11483 TV_TREE_VRP
, /* tv_id */
11484 PROP_ssa
, /* properties_required */
11485 0, /* properties_provided */
11486 0, /* properties_destroyed */
11487 0, /* todo_flags_start */
11488 ( TODO_cleanup_cfg
| TODO_update_ssa
), /* todo_flags_finish */
11491 class pass_vrp
: public gimple_opt_pass
11494 pass_vrp (gcc::context
*ctxt
)
11495 : gimple_opt_pass (pass_data_vrp
, ctxt
), warn_array_bounds_p (false)
11498 /* opt_pass methods: */
11499 opt_pass
* clone () { return new pass_vrp (m_ctxt
); }
11500 void set_pass_param (unsigned int n
, bool param
)
11502 gcc_assert (n
== 0);
11503 warn_array_bounds_p
= param
;
11505 virtual bool gate (function
*) { return flag_tree_vrp
!= 0; }
11506 virtual unsigned int execute (function
*)
11507 { return execute_vrp (warn_array_bounds_p
); }
11510 bool warn_array_bounds_p
;
11511 }; // class pass_vrp
11513 } // anon namespace
11516 make_pass_vrp (gcc::context
*ctxt
)
11518 return new pass_vrp (ctxt
);
11523 const pass_data pass_data_early_vrp
=
11525 GIMPLE_PASS
, /* type */
11527 OPTGROUP_NONE
, /* optinfo_flags */
11528 TV_TREE_EARLY_VRP
, /* tv_id */
11529 PROP_ssa
, /* properties_required */
11530 0, /* properties_provided */
11531 0, /* properties_destroyed */
11532 0, /* todo_flags_start */
11533 ( TODO_cleanup_cfg
| TODO_update_ssa
| TODO_verify_all
),
11536 class pass_early_vrp
: public gimple_opt_pass
11539 pass_early_vrp (gcc::context
*ctxt
)
11540 : gimple_opt_pass (pass_data_early_vrp
, ctxt
)
11543 /* opt_pass methods: */
11544 opt_pass
* clone () { return new pass_early_vrp (m_ctxt
); }
11545 virtual bool gate (function
*)
11547 return flag_tree_vrp
!= 0;
11549 virtual unsigned int execute (function
*)
11550 { return execute_early_vrp (); }
11552 }; // class pass_vrp
11553 } // anon namespace
11556 make_pass_early_vrp (gcc::context
*ctxt
)
11558 return new pass_early_vrp (ctxt
);