]>
Commit | Line | Data |
---|---|---|
0bca51f0 | 1 | /* Support routines for Value Range Propagation (VRP). |
eeef0e45 | 2 | Copyright (C) 2005, 2006, 2007 Free Software Foundation, Inc. |
0bca51f0 DN |
3 | Contributed by Diego Novillo <dnovillo@redhat.com>. |
4 | ||
5 | This file is part of GCC. | |
6 | ||
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 | |
9dcd6f09 | 9 | the Free Software Foundation; either version 3, or (at your option) |
0bca51f0 DN |
10 | any later version. |
11 | ||
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. | |
16 | ||
17 | You should have received a copy of the GNU General Public License | |
9dcd6f09 NC |
18 | along with GCC; see the file COPYING3. If not see |
19 | <http://www.gnu.org/licenses/>. */ | |
0bca51f0 DN |
20 | |
21 | #include "config.h" | |
22 | #include "system.h" | |
23 | #include "coretypes.h" | |
24 | #include "tm.h" | |
25 | #include "ggc.h" | |
26 | #include "flags.h" | |
27 | #include "tree.h" | |
28 | #include "basic-block.h" | |
29 | #include "tree-flow.h" | |
30 | #include "tree-pass.h" | |
31 | #include "tree-dump.h" | |
32 | #include "timevar.h" | |
33 | #include "diagnostic.h" | |
590b1f2d | 34 | #include "toplev.h" |
0c948c27 | 35 | #include "intl.h" |
0bca51f0 DN |
36 | #include "cfgloop.h" |
37 | #include "tree-scalar-evolution.h" | |
38 | #include "tree-ssa-propagate.h" | |
39 | #include "tree-chrec.h" | |
40 | ||
41 | /* Set of SSA names found during the dominator traversal of a | |
227858d1 DN |
42 | sub-graph in find_assert_locations. */ |
43 | static sbitmap found_in_subgraph; | |
0bca51f0 | 44 | |
0bca51f0 DN |
45 | /* Local functions. */ |
46 | static int compare_values (tree val1, tree val2); | |
12df8a7e | 47 | static int compare_values_warnv (tree val1, tree val2, bool *); |
f255541f | 48 | static void vrp_meet (value_range_t *, value_range_t *); |
0c948c27 | 49 | static tree vrp_evaluate_conditional_warnv (tree, bool, bool *); |
0bca51f0 | 50 | |
227858d1 DN |
51 | /* Location information for ASSERT_EXPRs. Each instance of this |
52 | structure describes an ASSERT_EXPR for an SSA name. Since a single | |
53 | SSA name may have more than one assertion associated with it, these | |
54 | locations are kept in a linked list attached to the corresponding | |
55 | SSA name. */ | |
56 | struct assert_locus_d | |
0bca51f0 | 57 | { |
227858d1 DN |
58 | /* Basic block where the assertion would be inserted. */ |
59 | basic_block bb; | |
60 | ||
61 | /* Some assertions need to be inserted on an edge (e.g., assertions | |
62 | generated by COND_EXPRs). In those cases, BB will be NULL. */ | |
63 | edge e; | |
64 | ||
65 | /* Pointer to the statement that generated this assertion. */ | |
66 | block_stmt_iterator si; | |
67 | ||
68 | /* Predicate code for the ASSERT_EXPR. Must be COMPARISON_CLASS_P. */ | |
69 | enum tree_code comp_code; | |
70 | ||
71 | /* Value being compared against. */ | |
72 | tree val; | |
73 | ||
74 | /* Next node in the linked list. */ | |
75 | struct assert_locus_d *next; | |
76 | }; | |
77 | ||
78 | typedef struct assert_locus_d *assert_locus_t; | |
79 | ||
80 | /* If bit I is present, it means that SSA name N_i has a list of | |
81 | assertions that should be inserted in the IL. */ | |
82 | static bitmap need_assert_for; | |
83 | ||
84 | /* Array of locations lists where to insert assertions. ASSERTS_FOR[I] | |
85 | holds a list of ASSERT_LOCUS_T nodes that describe where | |
86 | ASSERT_EXPRs for SSA name N_I should be inserted. */ | |
87 | static assert_locus_t *asserts_for; | |
88 | ||
89 | /* Set of blocks visited in find_assert_locations. Used to avoid | |
90 | visiting the same block more than once. */ | |
91 | static sbitmap blocks_visited; | |
0bca51f0 | 92 | |
227858d1 DN |
93 | /* Value range array. After propagation, VR_VALUE[I] holds the range |
94 | of values that SSA name N_I may take. */ | |
95 | static value_range_t **vr_value; | |
0bca51f0 | 96 | |
fc6827fe ILT |
97 | /* For a PHI node which sets SSA name N_I, VR_COUNTS[I] holds the |
98 | number of executable edges we saw the last time we visited the | |
99 | node. */ | |
100 | static int *vr_phi_edge_counts; | |
101 | ||
0bca51f0 | 102 | |
12df8a7e ILT |
103 | /* Return whether TYPE should use an overflow infinity distinct from |
104 | TYPE_{MIN,MAX}_VALUE. We use an overflow infinity value to | |
105 | represent a signed overflow during VRP computations. An infinity | |
106 | is distinct from a half-range, which will go from some number to | |
107 | TYPE_{MIN,MAX}_VALUE. */ | |
108 | ||
109 | static inline bool | |
58f9752a | 110 | needs_overflow_infinity (const_tree type) |
12df8a7e ILT |
111 | { |
112 | return INTEGRAL_TYPE_P (type) && !TYPE_OVERFLOW_WRAPS (type); | |
113 | } | |
114 | ||
115 | /* Return whether TYPE can support our overflow infinity | |
116 | representation: we use the TREE_OVERFLOW flag, which only exists | |
117 | for constants. If TYPE doesn't support this, we don't optimize | |
118 | cases which would require signed overflow--we drop them to | |
119 | VARYING. */ | |
120 | ||
121 | static inline bool | |
58f9752a | 122 | supports_overflow_infinity (const_tree type) |
12df8a7e ILT |
123 | { |
124 | #ifdef ENABLE_CHECKING | |
125 | gcc_assert (needs_overflow_infinity (type)); | |
126 | #endif | |
127 | return (TYPE_MIN_VALUE (type) != NULL_TREE | |
128 | && CONSTANT_CLASS_P (TYPE_MIN_VALUE (type)) | |
129 | && TYPE_MAX_VALUE (type) != NULL_TREE | |
130 | && CONSTANT_CLASS_P (TYPE_MAX_VALUE (type))); | |
131 | } | |
132 | ||
133 | /* VAL is the maximum or minimum value of a type. Return a | |
134 | corresponding overflow infinity. */ | |
135 | ||
136 | static inline tree | |
137 | make_overflow_infinity (tree val) | |
138 | { | |
139 | #ifdef ENABLE_CHECKING | |
140 | gcc_assert (val != NULL_TREE && CONSTANT_CLASS_P (val)); | |
141 | #endif | |
142 | val = copy_node (val); | |
143 | TREE_OVERFLOW (val) = 1; | |
144 | return val; | |
145 | } | |
146 | ||
147 | /* Return a negative overflow infinity for TYPE. */ | |
148 | ||
149 | static inline tree | |
150 | negative_overflow_infinity (tree type) | |
151 | { | |
152 | #ifdef ENABLE_CHECKING | |
153 | gcc_assert (supports_overflow_infinity (type)); | |
154 | #endif | |
155 | return make_overflow_infinity (TYPE_MIN_VALUE (type)); | |
156 | } | |
157 | ||
158 | /* Return a positive overflow infinity for TYPE. */ | |
159 | ||
160 | static inline tree | |
161 | positive_overflow_infinity (tree type) | |
162 | { | |
163 | #ifdef ENABLE_CHECKING | |
164 | gcc_assert (supports_overflow_infinity (type)); | |
165 | #endif | |
166 | return make_overflow_infinity (TYPE_MAX_VALUE (type)); | |
167 | } | |
168 | ||
169 | /* Return whether VAL is a negative overflow infinity. */ | |
170 | ||
171 | static inline bool | |
58f9752a | 172 | is_negative_overflow_infinity (const_tree val) |
12df8a7e ILT |
173 | { |
174 | return (needs_overflow_infinity (TREE_TYPE (val)) | |
175 | && CONSTANT_CLASS_P (val) | |
176 | && TREE_OVERFLOW (val) | |
177 | && operand_equal_p (val, TYPE_MIN_VALUE (TREE_TYPE (val)), 0)); | |
178 | } | |
179 | ||
180 | /* Return whether VAL is a positive overflow infinity. */ | |
181 | ||
182 | static inline bool | |
58f9752a | 183 | is_positive_overflow_infinity (const_tree val) |
12df8a7e ILT |
184 | { |
185 | return (needs_overflow_infinity (TREE_TYPE (val)) | |
186 | && CONSTANT_CLASS_P (val) | |
187 | && TREE_OVERFLOW (val) | |
188 | && operand_equal_p (val, TYPE_MAX_VALUE (TREE_TYPE (val)), 0)); | |
189 | } | |
190 | ||
191 | /* Return whether VAL is a positive or negative overflow infinity. */ | |
192 | ||
193 | static inline bool | |
58f9752a | 194 | is_overflow_infinity (const_tree val) |
12df8a7e ILT |
195 | { |
196 | return (needs_overflow_infinity (TREE_TYPE (val)) | |
197 | && CONSTANT_CLASS_P (val) | |
198 | && TREE_OVERFLOW (val) | |
199 | && (operand_equal_p (val, TYPE_MAX_VALUE (TREE_TYPE (val)), 0) | |
200 | || operand_equal_p (val, TYPE_MIN_VALUE (TREE_TYPE (val)), 0))); | |
201 | } | |
202 | ||
b80cca7b ILT |
203 | /* If VAL is now an overflow infinity, return VAL. Otherwise, return |
204 | the same value with TREE_OVERFLOW clear. This can be used to avoid | |
205 | confusing a regular value with an overflow value. */ | |
206 | ||
207 | static inline tree | |
208 | avoid_overflow_infinity (tree val) | |
209 | { | |
210 | if (!is_overflow_infinity (val)) | |
211 | return val; | |
212 | ||
213 | if (operand_equal_p (val, TYPE_MAX_VALUE (TREE_TYPE (val)), 0)) | |
214 | return TYPE_MAX_VALUE (TREE_TYPE (val)); | |
215 | else | |
216 | { | |
217 | #ifdef ENABLE_CHECKING | |
218 | gcc_assert (operand_equal_p (val, TYPE_MIN_VALUE (TREE_TYPE (val)), 0)); | |
219 | #endif | |
220 | return TYPE_MIN_VALUE (TREE_TYPE (val)); | |
221 | } | |
222 | } | |
223 | ||
12df8a7e | 224 | |
e1f28918 ILT |
225 | /* Return whether VAL is equal to the maximum value of its type. This |
226 | will be true for a positive overflow infinity. We can't do a | |
227 | simple equality comparison with TYPE_MAX_VALUE because C typedefs | |
228 | and Ada subtypes can produce types whose TYPE_MAX_VALUE is not == | |
229 | to the integer constant with the same value in the type. */ | |
230 | ||
231 | static inline bool | |
58f9752a | 232 | vrp_val_is_max (const_tree val) |
e1f28918 ILT |
233 | { |
234 | tree type_max = TYPE_MAX_VALUE (TREE_TYPE (val)); | |
235 | ||
236 | return (val == type_max | |
237 | || (type_max != NULL_TREE | |
238 | && operand_equal_p (val, type_max, 0))); | |
239 | } | |
240 | ||
241 | /* Return whether VAL is equal to the minimum value of its type. This | |
242 | will be true for a negative overflow infinity. */ | |
243 | ||
244 | static inline bool | |
58f9752a | 245 | vrp_val_is_min (const_tree val) |
e1f28918 ILT |
246 | { |
247 | tree type_min = TYPE_MIN_VALUE (TREE_TYPE (val)); | |
248 | ||
249 | return (val == type_min | |
250 | || (type_min != NULL_TREE | |
251 | && operand_equal_p (val, type_min, 0))); | |
252 | } | |
253 | ||
254 | ||
462508dd DN |
255 | /* Return true if ARG is marked with the nonnull attribute in the |
256 | current function signature. */ | |
257 | ||
258 | static bool | |
58f9752a | 259 | nonnull_arg_p (const_tree arg) |
462508dd DN |
260 | { |
261 | tree t, attrs, fntype; | |
262 | unsigned HOST_WIDE_INT arg_num; | |
263 | ||
264 | gcc_assert (TREE_CODE (arg) == PARM_DECL && POINTER_TYPE_P (TREE_TYPE (arg))); | |
265 | ||
7954dc21 AP |
266 | /* The static chain decl is always non null. */ |
267 | if (arg == cfun->static_chain_decl) | |
268 | return true; | |
269 | ||
462508dd DN |
270 | fntype = TREE_TYPE (current_function_decl); |
271 | attrs = lookup_attribute ("nonnull", TYPE_ATTRIBUTES (fntype)); | |
272 | ||
273 | /* If "nonnull" wasn't specified, we know nothing about the argument. */ | |
274 | if (attrs == NULL_TREE) | |
275 | return false; | |
276 | ||
277 | /* If "nonnull" applies to all the arguments, then ARG is non-null. */ | |
278 | if (TREE_VALUE (attrs) == NULL_TREE) | |
279 | return true; | |
280 | ||
281 | /* Get the position number for ARG in the function signature. */ | |
282 | for (arg_num = 1, t = DECL_ARGUMENTS (current_function_decl); | |
283 | t; | |
284 | t = TREE_CHAIN (t), arg_num++) | |
285 | { | |
286 | if (t == arg) | |
287 | break; | |
288 | } | |
289 | ||
290 | gcc_assert (t == arg); | |
291 | ||
292 | /* Now see if ARG_NUM is mentioned in the nonnull list. */ | |
293 | for (t = TREE_VALUE (attrs); t; t = TREE_CHAIN (t)) | |
294 | { | |
295 | if (compare_tree_int (TREE_VALUE (t), arg_num) == 0) | |
296 | return true; | |
297 | } | |
298 | ||
299 | return false; | |
300 | } | |
301 | ||
302 | ||
227858d1 DN |
303 | /* Set value range VR to {T, MIN, MAX, EQUIV}. */ |
304 | ||
305 | static void | |
306 | set_value_range (value_range_t *vr, enum value_range_type t, tree min, | |
307 | tree max, bitmap equiv) | |
0bca51f0 DN |
308 | { |
309 | #if defined ENABLE_CHECKING | |
227858d1 | 310 | /* Check the validity of the range. */ |
0bca51f0 DN |
311 | if (t == VR_RANGE || t == VR_ANTI_RANGE) |
312 | { | |
313 | int cmp; | |
314 | ||
315 | gcc_assert (min && max); | |
316 | ||
317 | if (INTEGRAL_TYPE_P (TREE_TYPE (min)) && t == VR_ANTI_RANGE) | |
e1f28918 | 318 | gcc_assert (!vrp_val_is_min (min) || !vrp_val_is_max (max)); |
0bca51f0 DN |
319 | |
320 | cmp = compare_values (min, max); | |
321 | gcc_assert (cmp == 0 || cmp == -1 || cmp == -2); | |
8cf781f0 ILT |
322 | |
323 | if (needs_overflow_infinity (TREE_TYPE (min))) | |
324 | gcc_assert (!is_overflow_infinity (min) | |
325 | || !is_overflow_infinity (max)); | |
0bca51f0 | 326 | } |
0bca51f0 | 327 | |
227858d1 DN |
328 | if (t == VR_UNDEFINED || t == VR_VARYING) |
329 | gcc_assert (min == NULL_TREE && max == NULL_TREE); | |
330 | ||
331 | if (t == VR_UNDEFINED || t == VR_VARYING) | |
332 | gcc_assert (equiv == NULL || bitmap_empty_p (equiv)); | |
333 | #endif | |
0bca51f0 DN |
334 | |
335 | vr->type = t; | |
336 | vr->min = min; | |
337 | vr->max = max; | |
227858d1 DN |
338 | |
339 | /* Since updating the equivalence set involves deep copying the | |
340 | bitmaps, only do it if absolutely necessary. */ | |
f5052e29 RG |
341 | if (vr->equiv == NULL |
342 | && equiv != NULL) | |
227858d1 DN |
343 | vr->equiv = BITMAP_ALLOC (NULL); |
344 | ||
345 | if (equiv != vr->equiv) | |
346 | { | |
347 | if (equiv && !bitmap_empty_p (equiv)) | |
348 | bitmap_copy (vr->equiv, equiv); | |
349 | else | |
350 | bitmap_clear (vr->equiv); | |
351 | } | |
0bca51f0 DN |
352 | } |
353 | ||
354 | ||
227858d1 | 355 | /* Copy value range FROM into value range TO. */ |
0bca51f0 | 356 | |
227858d1 DN |
357 | static inline void |
358 | copy_value_range (value_range_t *to, value_range_t *from) | |
0bca51f0 | 359 | { |
227858d1 DN |
360 | set_value_range (to, from->type, from->min, from->max, from->equiv); |
361 | } | |
0bca51f0 | 362 | |
12df8a7e ILT |
363 | |
364 | /* Set value range VR to VR_VARYING. */ | |
b16caf72 JL |
365 | |
366 | static inline void | |
12df8a7e | 367 | set_value_range_to_varying (value_range_t *vr) |
b16caf72 | 368 | { |
12df8a7e ILT |
369 | vr->type = VR_VARYING; |
370 | vr->min = vr->max = NULL_TREE; | |
371 | if (vr->equiv) | |
372 | bitmap_clear (vr->equiv); | |
373 | } | |
374 | ||
8cf781f0 ILT |
375 | /* Set value range VR to a single value. This function is only called |
376 | with values we get from statements, and exists to clear the | |
377 | TREE_OVERFLOW flag so that we don't think we have an overflow | |
378 | infinity when we shouldn't. */ | |
379 | ||
380 | static inline void | |
b60b4711 | 381 | set_value_range_to_value (value_range_t *vr, tree val, bitmap equiv) |
8cf781f0 ILT |
382 | { |
383 | gcc_assert (is_gimple_min_invariant (val)); | |
b80cca7b | 384 | val = avoid_overflow_infinity (val); |
b60b4711 | 385 | set_value_range (vr, VR_RANGE, val, val, equiv); |
8cf781f0 ILT |
386 | } |
387 | ||
12df8a7e | 388 | /* Set value range VR to a non-negative range of type TYPE. |
110abdbc | 389 | OVERFLOW_INFINITY indicates whether to use an overflow infinity |
12df8a7e ILT |
390 | rather than TYPE_MAX_VALUE; this should be true if we determine |
391 | that the range is nonnegative based on the assumption that signed | |
392 | overflow does not occur. */ | |
393 | ||
394 | static inline void | |
395 | set_value_range_to_nonnegative (value_range_t *vr, tree type, | |
396 | bool overflow_infinity) | |
397 | { | |
398 | tree zero; | |
399 | ||
400 | if (overflow_infinity && !supports_overflow_infinity (type)) | |
401 | { | |
402 | set_value_range_to_varying (vr); | |
403 | return; | |
404 | } | |
405 | ||
406 | zero = build_int_cst (type, 0); | |
407 | set_value_range (vr, VR_RANGE, zero, | |
408 | (overflow_infinity | |
409 | ? positive_overflow_infinity (type) | |
410 | : TYPE_MAX_VALUE (type)), | |
411 | vr->equiv); | |
b16caf72 | 412 | } |
227858d1 DN |
413 | |
414 | /* Set value range VR to a non-NULL range of type TYPE. */ | |
415 | ||
416 | static inline void | |
417 | set_value_range_to_nonnull (value_range_t *vr, tree type) | |
418 | { | |
419 | tree zero = build_int_cst (type, 0); | |
420 | set_value_range (vr, VR_ANTI_RANGE, zero, zero, vr->equiv); | |
421 | } | |
422 | ||
423 | ||
424 | /* Set value range VR to a NULL range of type TYPE. */ | |
425 | ||
426 | static inline void | |
427 | set_value_range_to_null (value_range_t *vr, tree type) | |
428 | { | |
b60b4711 | 429 | set_value_range_to_value (vr, build_int_cst (type, 0), vr->equiv); |
227858d1 DN |
430 | } |
431 | ||
432 | ||
31ab1cc9 RG |
433 | /* Set value range VR to a range of a truthvalue of type TYPE. */ |
434 | ||
435 | static inline void | |
436 | set_value_range_to_truthvalue (value_range_t *vr, tree type) | |
437 | { | |
438 | if (TYPE_PRECISION (type) == 1) | |
439 | set_value_range_to_varying (vr); | |
440 | else | |
441 | set_value_range (vr, VR_RANGE, | |
442 | build_int_cst (type, 0), build_int_cst (type, 1), | |
443 | vr->equiv); | |
444 | } | |
445 | ||
446 | ||
227858d1 DN |
447 | /* Set value range VR to VR_UNDEFINED. */ |
448 | ||
449 | static inline void | |
450 | set_value_range_to_undefined (value_range_t *vr) | |
451 | { | |
452 | vr->type = VR_UNDEFINED; | |
453 | vr->min = vr->max = NULL_TREE; | |
454 | if (vr->equiv) | |
455 | bitmap_clear (vr->equiv); | |
0bca51f0 DN |
456 | } |
457 | ||
458 | ||
b16caf72 JL |
459 | /* Return value range information for VAR. |
460 | ||
461 | If we have no values ranges recorded (ie, VRP is not running), then | |
462 | return NULL. Otherwise create an empty range if none existed for VAR. */ | |
0bca51f0 | 463 | |
227858d1 | 464 | static value_range_t * |
58f9752a | 465 | get_value_range (const_tree var) |
0bca51f0 | 466 | { |
227858d1 | 467 | value_range_t *vr; |
0bca51f0 | 468 | tree sym; |
227858d1 | 469 | unsigned ver = SSA_NAME_VERSION (var); |
0bca51f0 | 470 | |
b16caf72 JL |
471 | /* If we have no recorded ranges, then return NULL. */ |
472 | if (! vr_value) | |
473 | return NULL; | |
474 | ||
227858d1 | 475 | vr = vr_value[ver]; |
0bca51f0 DN |
476 | if (vr) |
477 | return vr; | |
478 | ||
479 | /* Create a default value range. */ | |
b9eae1a9 | 480 | vr_value[ver] = vr = XCNEW (value_range_t); |
0bca51f0 | 481 | |
f5052e29 RG |
482 | /* Defer allocating the equivalence set. */ |
483 | vr->equiv = NULL; | |
227858d1 DN |
484 | |
485 | /* If VAR is a default definition, the variable can take any value | |
486 | in VAR's type. */ | |
0bca51f0 | 487 | sym = SSA_NAME_VAR (var); |
cfaab3a9 | 488 | if (SSA_NAME_IS_DEFAULT_DEF (var)) |
462508dd DN |
489 | { |
490 | /* Try to use the "nonnull" attribute to create ~[0, 0] | |
491 | anti-ranges for pointers. Note that this is only valid with | |
492 | default definitions of PARM_DECLs. */ | |
493 | if (TREE_CODE (sym) == PARM_DECL | |
494 | && POINTER_TYPE_P (TREE_TYPE (sym)) | |
495 | && nonnull_arg_p (sym)) | |
496 | set_value_range_to_nonnull (vr, TREE_TYPE (sym)); | |
497 | else | |
498 | set_value_range_to_varying (vr); | |
499 | } | |
0bca51f0 DN |
500 | |
501 | return vr; | |
502 | } | |
503 | ||
1ce35d26 RG |
504 | /* Return true, if VAL1 and VAL2 are equal values for VRP purposes. */ |
505 | ||
506 | static inline bool | |
58f9752a | 507 | vrp_operand_equal_p (const_tree val1, const_tree val2) |
1ce35d26 | 508 | { |
12df8a7e ILT |
509 | if (val1 == val2) |
510 | return true; | |
511 | if (!val1 || !val2 || !operand_equal_p (val1, val2, 0)) | |
512 | return false; | |
513 | if (is_overflow_infinity (val1)) | |
514 | return is_overflow_infinity (val2); | |
515 | return true; | |
1ce35d26 RG |
516 | } |
517 | ||
518 | /* Return true, if the bitmaps B1 and B2 are equal. */ | |
519 | ||
520 | static inline bool | |
22ea9ec0 | 521 | vrp_bitmap_equal_p (const_bitmap b1, const_bitmap b2) |
1ce35d26 RG |
522 | { |
523 | return (b1 == b2 | |
524 | || (b1 && b2 | |
525 | && bitmap_equal_p (b1, b2))); | |
526 | } | |
0bca51f0 | 527 | |
227858d1 DN |
528 | /* Update the value range and equivalence set for variable VAR to |
529 | NEW_VR. Return true if NEW_VR is different from VAR's previous | |
530 | value. | |
531 | ||
532 | NOTE: This function assumes that NEW_VR is a temporary value range | |
533 | object created for the sole purpose of updating VAR's range. The | |
534 | storage used by the equivalence set from NEW_VR will be freed by | |
535 | this function. Do not call update_value_range when NEW_VR | |
536 | is the range object associated with another SSA name. */ | |
0bca51f0 DN |
537 | |
538 | static inline bool | |
58f9752a | 539 | update_value_range (const_tree var, value_range_t *new_vr) |
0bca51f0 | 540 | { |
227858d1 DN |
541 | value_range_t *old_vr; |
542 | bool is_new; | |
543 | ||
544 | /* Update the value range, if necessary. */ | |
545 | old_vr = get_value_range (var); | |
546 | is_new = old_vr->type != new_vr->type | |
1ce35d26 RG |
547 | || !vrp_operand_equal_p (old_vr->min, new_vr->min) |
548 | || !vrp_operand_equal_p (old_vr->max, new_vr->max) | |
549 | || !vrp_bitmap_equal_p (old_vr->equiv, new_vr->equiv); | |
0bca51f0 | 550 | |
227858d1 DN |
551 | if (is_new) |
552 | set_value_range (old_vr, new_vr->type, new_vr->min, new_vr->max, | |
553 | new_vr->equiv); | |
0bca51f0 | 554 | |
227858d1 | 555 | BITMAP_FREE (new_vr->equiv); |
0bca51f0 | 556 | |
227858d1 DN |
557 | return is_new; |
558 | } | |
0bca51f0 | 559 | |
0bca51f0 | 560 | |
f5052e29 RG |
561 | /* Add VAR and VAR's equivalence set to EQUIV. This is the central |
562 | point where equivalence processing can be turned on/off. */ | |
0bca51f0 | 563 | |
227858d1 | 564 | static void |
58f9752a | 565 | add_equivalence (bitmap *equiv, const_tree var) |
227858d1 DN |
566 | { |
567 | unsigned ver = SSA_NAME_VERSION (var); | |
568 | value_range_t *vr = vr_value[ver]; | |
0bca51f0 | 569 | |
f5052e29 RG |
570 | if (*equiv == NULL) |
571 | *equiv = BITMAP_ALLOC (NULL); | |
572 | bitmap_set_bit (*equiv, ver); | |
227858d1 | 573 | if (vr && vr->equiv) |
f5052e29 | 574 | bitmap_ior_into (*equiv, vr->equiv); |
0bca51f0 DN |
575 | } |
576 | ||
577 | ||
578 | /* Return true if VR is ~[0, 0]. */ | |
579 | ||
580 | static inline bool | |
227858d1 | 581 | range_is_nonnull (value_range_t *vr) |
0bca51f0 DN |
582 | { |
583 | return vr->type == VR_ANTI_RANGE | |
584 | && integer_zerop (vr->min) | |
585 | && integer_zerop (vr->max); | |
586 | } | |
587 | ||
588 | ||
589 | /* Return true if VR is [0, 0]. */ | |
590 | ||
591 | static inline bool | |
227858d1 | 592 | range_is_null (value_range_t *vr) |
0bca51f0 DN |
593 | { |
594 | return vr->type == VR_RANGE | |
595 | && integer_zerop (vr->min) | |
596 | && integer_zerop (vr->max); | |
597 | } | |
598 | ||
599 | ||
227858d1 | 600 | /* Return true if value range VR involves at least one symbol. */ |
0bca51f0 | 601 | |
227858d1 DN |
602 | static inline bool |
603 | symbolic_range_p (value_range_t *vr) | |
0bca51f0 | 604 | { |
227858d1 DN |
605 | return (!is_gimple_min_invariant (vr->min) |
606 | || !is_gimple_min_invariant (vr->max)); | |
0bca51f0 DN |
607 | } |
608 | ||
110abdbc | 609 | /* Return true if value range VR uses an overflow infinity. */ |
b16caf72 | 610 | |
12df8a7e ILT |
611 | static inline bool |
612 | overflow_infinity_range_p (value_range_t *vr) | |
b16caf72 | 613 | { |
12df8a7e ILT |
614 | return (vr->type == VR_RANGE |
615 | && (is_overflow_infinity (vr->min) | |
616 | || is_overflow_infinity (vr->max))); | |
617 | } | |
6ac01510 | 618 | |
0c948c27 ILT |
619 | /* Return false if we can not make a valid comparison based on VR; |
620 | this will be the case if it uses an overflow infinity and overflow | |
621 | is not undefined (i.e., -fno-strict-overflow is in effect). | |
622 | Otherwise return true, and set *STRICT_OVERFLOW_P to true if VR | |
623 | uses an overflow infinity. */ | |
624 | ||
625 | static bool | |
626 | usable_range_p (value_range_t *vr, bool *strict_overflow_p) | |
627 | { | |
628 | gcc_assert (vr->type == VR_RANGE); | |
629 | if (is_overflow_infinity (vr->min)) | |
630 | { | |
631 | *strict_overflow_p = true; | |
632 | if (!TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (vr->min))) | |
633 | return false; | |
634 | } | |
635 | if (is_overflow_infinity (vr->max)) | |
636 | { | |
637 | *strict_overflow_p = true; | |
638 | if (!TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (vr->max))) | |
639 | return false; | |
640 | } | |
641 | return true; | |
642 | } | |
643 | ||
644 | ||
12df8a7e ILT |
645 | /* Like tree_expr_nonnegative_warnv_p, but this function uses value |
646 | ranges obtained so far. */ | |
647 | ||
648 | static bool | |
649 | vrp_expr_computes_nonnegative (tree expr, bool *strict_overflow_p) | |
650 | { | |
651 | return tree_expr_nonnegative_warnv_p (expr, strict_overflow_p); | |
b16caf72 | 652 | } |
0bca51f0 | 653 | |
12df8a7e | 654 | /* Like tree_expr_nonzero_warnv_p, but this function uses value ranges |
227858d1 | 655 | obtained so far. */ |
0bca51f0 | 656 | |
227858d1 | 657 | static bool |
12df8a7e | 658 | vrp_expr_computes_nonzero (tree expr, bool *strict_overflow_p) |
0bca51f0 | 659 | { |
12df8a7e | 660 | if (tree_expr_nonzero_warnv_p (expr, strict_overflow_p)) |
227858d1 | 661 | return true; |
0bca51f0 | 662 | |
227858d1 DN |
663 | /* If we have an expression of the form &X->a, then the expression |
664 | is nonnull if X is nonnull. */ | |
665 | if (TREE_CODE (expr) == ADDR_EXPR) | |
666 | { | |
667 | tree base = get_base_address (TREE_OPERAND (expr, 0)); | |
0bca51f0 | 668 | |
227858d1 DN |
669 | if (base != NULL_TREE |
670 | && TREE_CODE (base) == INDIRECT_REF | |
671 | && TREE_CODE (TREE_OPERAND (base, 0)) == SSA_NAME) | |
672 | { | |
673 | value_range_t *vr = get_value_range (TREE_OPERAND (base, 0)); | |
674 | if (range_is_nonnull (vr)) | |
675 | return true; | |
676 | } | |
677 | } | |
b565d777 | 678 | |
227858d1 | 679 | return false; |
b565d777 DN |
680 | } |
681 | ||
04dce5a4 ZD |
682 | /* Returns true if EXPR is a valid value (as expected by compare_values) -- |
683 | a gimple invariant, or SSA_NAME +- CST. */ | |
684 | ||
685 | static bool | |
686 | valid_value_p (tree expr) | |
687 | { | |
688 | if (TREE_CODE (expr) == SSA_NAME) | |
689 | return true; | |
690 | ||
691 | if (TREE_CODE (expr) == PLUS_EXPR | |
692 | || TREE_CODE (expr) == MINUS_EXPR) | |
693 | return (TREE_CODE (TREE_OPERAND (expr, 0)) == SSA_NAME | |
694 | && TREE_CODE (TREE_OPERAND (expr, 1)) == INTEGER_CST); | |
695 | ||
696 | return is_gimple_min_invariant (expr); | |
697 | } | |
b565d777 | 698 | |
6b3c76a9 JH |
699 | /* Return |
700 | 1 if VAL < VAL2 | |
701 | 0 if !(VAL < VAL2) | |
702 | -2 if those are incomparable. */ | |
703 | static inline int | |
704 | operand_less_p (tree val, tree val2) | |
705 | { | |
6b3c76a9 JH |
706 | /* LT is folded faster than GE and others. Inline the common case. */ |
707 | if (TREE_CODE (val) == INTEGER_CST && TREE_CODE (val2) == INTEGER_CST) | |
708 | { | |
709 | if (TYPE_UNSIGNED (TREE_TYPE (val))) | |
710 | return INT_CST_LT_UNSIGNED (val, val2); | |
711 | else | |
12df8a7e ILT |
712 | { |
713 | if (INT_CST_LT (val, val2)) | |
714 | return 1; | |
715 | } | |
6b3c76a9 JH |
716 | } |
717 | else | |
12df8a7e ILT |
718 | { |
719 | tree tcmp; | |
720 | ||
c8539275 ILT |
721 | fold_defer_overflow_warnings (); |
722 | ||
12df8a7e | 723 | tcmp = fold_binary_to_constant (LT_EXPR, boolean_type_node, val, val2); |
c8539275 ILT |
724 | |
725 | fold_undefer_and_ignore_overflow_warnings (); | |
726 | ||
12df8a7e ILT |
727 | if (!tcmp) |
728 | return -2; | |
729 | ||
730 | if (!integer_zerop (tcmp)) | |
731 | return 1; | |
732 | } | |
733 | ||
734 | /* val >= val2, not considering overflow infinity. */ | |
735 | if (is_negative_overflow_infinity (val)) | |
736 | return is_negative_overflow_infinity (val2) ? 0 : 1; | |
737 | else if (is_positive_overflow_infinity (val2)) | |
738 | return is_positive_overflow_infinity (val) ? 0 : 1; | |
739 | ||
740 | return 0; | |
6b3c76a9 JH |
741 | } |
742 | ||
0bca51f0 DN |
743 | /* Compare two values VAL1 and VAL2. Return |
744 | ||
745 | -2 if VAL1 and VAL2 cannot be compared at compile-time, | |
746 | -1 if VAL1 < VAL2, | |
747 | 0 if VAL1 == VAL2, | |
748 | +1 if VAL1 > VAL2, and | |
749 | +2 if VAL1 != VAL2 | |
750 | ||
751 | This is similar to tree_int_cst_compare but supports pointer values | |
12df8a7e ILT |
752 | and values that cannot be compared at compile time. |
753 | ||
754 | If STRICT_OVERFLOW_P is not NULL, then set *STRICT_OVERFLOW_P to | |
755 | true if the return value is only valid if we assume that signed | |
756 | overflow is undefined. */ | |
0bca51f0 DN |
757 | |
758 | static int | |
12df8a7e | 759 | compare_values_warnv (tree val1, tree val2, bool *strict_overflow_p) |
0bca51f0 DN |
760 | { |
761 | if (val1 == val2) | |
762 | return 0; | |
763 | ||
30abf793 KH |
764 | /* Below we rely on the fact that VAL1 and VAL2 are both pointers or |
765 | both integers. */ | |
766 | gcc_assert (POINTER_TYPE_P (TREE_TYPE (val1)) | |
767 | == POINTER_TYPE_P (TREE_TYPE (val2))); | |
5be014d5 AP |
768 | /* Convert the two values into the same type. This is needed because |
769 | sizetype causes sign extension even for unsigned types. */ | |
770 | val2 = fold_convert (TREE_TYPE (val1), val2); | |
771 | STRIP_USELESS_TYPE_CONVERSION (val2); | |
30abf793 | 772 | |
0bca51f0 DN |
773 | if ((TREE_CODE (val1) == SSA_NAME |
774 | || TREE_CODE (val1) == PLUS_EXPR | |
775 | || TREE_CODE (val1) == MINUS_EXPR) | |
776 | && (TREE_CODE (val2) == SSA_NAME | |
777 | || TREE_CODE (val2) == PLUS_EXPR | |
778 | || TREE_CODE (val2) == MINUS_EXPR)) | |
779 | { | |
780 | tree n1, c1, n2, c2; | |
67ac6e63 | 781 | enum tree_code code1, code2; |
0bca51f0 DN |
782 | |
783 | /* If VAL1 and VAL2 are of the form 'NAME [+-] CST' or 'NAME', | |
784 | return -1 or +1 accordingly. If VAL1 and VAL2 don't use the | |
785 | same name, return -2. */ | |
786 | if (TREE_CODE (val1) == SSA_NAME) | |
787 | { | |
67ac6e63 | 788 | code1 = SSA_NAME; |
0bca51f0 DN |
789 | n1 = val1; |
790 | c1 = NULL_TREE; | |
791 | } | |
792 | else | |
793 | { | |
67ac6e63 | 794 | code1 = TREE_CODE (val1); |
0bca51f0 DN |
795 | n1 = TREE_OPERAND (val1, 0); |
796 | c1 = TREE_OPERAND (val1, 1); | |
67ac6e63 RG |
797 | if (tree_int_cst_sgn (c1) == -1) |
798 | { | |
12df8a7e ILT |
799 | if (is_negative_overflow_infinity (c1)) |
800 | return -2; | |
67ac6e63 RG |
801 | c1 = fold_unary_to_constant (NEGATE_EXPR, TREE_TYPE (c1), c1); |
802 | if (!c1) | |
803 | return -2; | |
804 | code1 = code1 == MINUS_EXPR ? PLUS_EXPR : MINUS_EXPR; | |
805 | } | |
0bca51f0 DN |
806 | } |
807 | ||
808 | if (TREE_CODE (val2) == SSA_NAME) | |
809 | { | |
67ac6e63 | 810 | code2 = SSA_NAME; |
0bca51f0 DN |
811 | n2 = val2; |
812 | c2 = NULL_TREE; | |
813 | } | |
814 | else | |
815 | { | |
67ac6e63 | 816 | code2 = TREE_CODE (val2); |
0bca51f0 DN |
817 | n2 = TREE_OPERAND (val2, 0); |
818 | c2 = TREE_OPERAND (val2, 1); | |
67ac6e63 RG |
819 | if (tree_int_cst_sgn (c2) == -1) |
820 | { | |
12df8a7e ILT |
821 | if (is_negative_overflow_infinity (c2)) |
822 | return -2; | |
67ac6e63 RG |
823 | c2 = fold_unary_to_constant (NEGATE_EXPR, TREE_TYPE (c2), c2); |
824 | if (!c2) | |
825 | return -2; | |
826 | code2 = code2 == MINUS_EXPR ? PLUS_EXPR : MINUS_EXPR; | |
827 | } | |
0bca51f0 DN |
828 | } |
829 | ||
830 | /* Both values must use the same name. */ | |
831 | if (n1 != n2) | |
832 | return -2; | |
833 | ||
67ac6e63 RG |
834 | if (code1 == SSA_NAME |
835 | && code2 == SSA_NAME) | |
836 | /* NAME == NAME */ | |
837 | return 0; | |
838 | ||
839 | /* If overflow is defined we cannot simplify more. */ | |
eeef0e45 | 840 | if (!TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (val1))) |
67ac6e63 RG |
841 | return -2; |
842 | ||
3fe5bcaf ILT |
843 | if (strict_overflow_p != NULL |
844 | && (code1 == SSA_NAME || !TREE_NO_WARNING (val1)) | |
845 | && (code2 == SSA_NAME || !TREE_NO_WARNING (val2))) | |
12df8a7e ILT |
846 | *strict_overflow_p = true; |
847 | ||
67ac6e63 | 848 | if (code1 == SSA_NAME) |
0bca51f0 | 849 | { |
67ac6e63 | 850 | if (code2 == PLUS_EXPR) |
0bca51f0 DN |
851 | /* NAME < NAME + CST */ |
852 | return -1; | |
67ac6e63 | 853 | else if (code2 == MINUS_EXPR) |
0bca51f0 DN |
854 | /* NAME > NAME - CST */ |
855 | return 1; | |
856 | } | |
67ac6e63 | 857 | else if (code1 == PLUS_EXPR) |
0bca51f0 | 858 | { |
67ac6e63 | 859 | if (code2 == SSA_NAME) |
0bca51f0 DN |
860 | /* NAME + CST > NAME */ |
861 | return 1; | |
67ac6e63 | 862 | else if (code2 == PLUS_EXPR) |
0bca51f0 | 863 | /* NAME + CST1 > NAME + CST2, if CST1 > CST2 */ |
12df8a7e | 864 | return compare_values_warnv (c1, c2, strict_overflow_p); |
67ac6e63 | 865 | else if (code2 == MINUS_EXPR) |
0bca51f0 DN |
866 | /* NAME + CST1 > NAME - CST2 */ |
867 | return 1; | |
868 | } | |
67ac6e63 | 869 | else if (code1 == MINUS_EXPR) |
0bca51f0 | 870 | { |
67ac6e63 | 871 | if (code2 == SSA_NAME) |
0bca51f0 DN |
872 | /* NAME - CST < NAME */ |
873 | return -1; | |
67ac6e63 | 874 | else if (code2 == PLUS_EXPR) |
0bca51f0 DN |
875 | /* NAME - CST1 < NAME + CST2 */ |
876 | return -1; | |
67ac6e63 | 877 | else if (code2 == MINUS_EXPR) |
0bca51f0 DN |
878 | /* NAME - CST1 > NAME - CST2, if CST1 < CST2. Notice that |
879 | C1 and C2 are swapped in the call to compare_values. */ | |
12df8a7e | 880 | return compare_values_warnv (c2, c1, strict_overflow_p); |
0bca51f0 DN |
881 | } |
882 | ||
883 | gcc_unreachable (); | |
884 | } | |
885 | ||
886 | /* We cannot compare non-constants. */ | |
887 | if (!is_gimple_min_invariant (val1) || !is_gimple_min_invariant (val2)) | |
888 | return -2; | |
889 | ||
30abf793 | 890 | if (!POINTER_TYPE_P (TREE_TYPE (val1))) |
87f2a9f5 | 891 | { |
12df8a7e ILT |
892 | /* We cannot compare overflowed values, except for overflow |
893 | infinities. */ | |
87f2a9f5 | 894 | if (TREE_OVERFLOW (val1) || TREE_OVERFLOW (val2)) |
12df8a7e | 895 | { |
0c948c27 ILT |
896 | if (strict_overflow_p != NULL) |
897 | *strict_overflow_p = true; | |
12df8a7e ILT |
898 | if (is_negative_overflow_infinity (val1)) |
899 | return is_negative_overflow_infinity (val2) ? 0 : -1; | |
900 | else if (is_negative_overflow_infinity (val2)) | |
901 | return 1; | |
902 | else if (is_positive_overflow_infinity (val1)) | |
903 | return is_positive_overflow_infinity (val2) ? 0 : 1; | |
904 | else if (is_positive_overflow_infinity (val2)) | |
905 | return -1; | |
906 | return -2; | |
907 | } | |
87f2a9f5 RS |
908 | |
909 | return tree_int_cst_compare (val1, val2); | |
910 | } | |
0bca51f0 DN |
911 | else |
912 | { | |
913 | tree t; | |
914 | ||
915 | /* First see if VAL1 and VAL2 are not the same. */ | |
916 | if (val1 == val2 || operand_equal_p (val1, val2, 0)) | |
917 | return 0; | |
918 | ||
919 | /* If VAL1 is a lower address than VAL2, return -1. */ | |
6b3c76a9 | 920 | if (operand_less_p (val1, val2) == 1) |
0bca51f0 DN |
921 | return -1; |
922 | ||
923 | /* If VAL1 is a higher address than VAL2, return +1. */ | |
6b3c76a9 | 924 | if (operand_less_p (val2, val1) == 1) |
0bca51f0 DN |
925 | return 1; |
926 | ||
5daffcc7 JH |
927 | /* If VAL1 is different than VAL2, return +2. |
928 | For integer constants we either have already returned -1 or 1 | |
2e226e66 KH |
929 | or they are equivalent. We still might succeed in proving |
930 | something about non-trivial operands. */ | |
5daffcc7 JH |
931 | if (TREE_CODE (val1) != INTEGER_CST |
932 | || TREE_CODE (val2) != INTEGER_CST) | |
933 | { | |
934 | t = fold_binary_to_constant (NE_EXPR, boolean_type_node, val1, val2); | |
935 | if (t && tree_expr_nonzero_p (t)) | |
936 | return 2; | |
937 | } | |
0bca51f0 DN |
938 | |
939 | return -2; | |
940 | } | |
941 | } | |
942 | ||
0c948c27 ILT |
943 | /* Compare values like compare_values_warnv, but treat comparisons of |
944 | nonconstants which rely on undefined overflow as incomparable. */ | |
12df8a7e ILT |
945 | |
946 | static int | |
947 | compare_values (tree val1, tree val2) | |
948 | { | |
949 | bool sop; | |
950 | int ret; | |
951 | ||
952 | sop = false; | |
953 | ret = compare_values_warnv (val1, val2, &sop); | |
0c948c27 ILT |
954 | if (sop |
955 | && (!is_gimple_min_invariant (val1) || !is_gimple_min_invariant (val2))) | |
12df8a7e ILT |
956 | ret = -2; |
957 | return ret; | |
958 | } | |
959 | ||
0bca51f0 DN |
960 | |
961 | /* Return 1 if VAL is inside value range VR (VR->MIN <= VAL <= VR->MAX), | |
962 | 0 if VAL is not inside VR, | |
c83033e7 DN |
963 | -2 if we cannot tell either way. |
964 | ||
965 | FIXME, the current semantics of this functions are a bit quirky | |
966 | when taken in the context of VRP. In here we do not care | |
967 | about VR's type. If VR is the anti-range ~[3, 5] the call | |
968 | value_inside_range (4, VR) will return 1. | |
969 | ||
970 | This is counter-intuitive in a strict sense, but the callers | |
971 | currently expect this. They are calling the function | |
972 | merely to determine whether VR->MIN <= VAL <= VR->MAX. The | |
973 | callers are applying the VR_RANGE/VR_ANTI_RANGE semantics | |
974 | themselves. | |
975 | ||
976 | This also applies to value_ranges_intersect_p and | |
977 | range_includes_zero_p. The semantics of VR_RANGE and | |
978 | VR_ANTI_RANGE should be encoded here, but that also means | |
6b3c76a9 JH |
979 | adapting the users of these functions to the new semantics. |
980 | ||
981 | Benchmark compile/20001226-1.c compilation time after changing this | |
982 | function. */ | |
0bca51f0 DN |
983 | |
984 | static inline int | |
6b3c76a9 | 985 | value_inside_range (tree val, value_range_t * vr) |
0bca51f0 | 986 | { |
6b3c76a9 | 987 | int cmp1, cmp2; |
0bca51f0 | 988 | |
6b3c76a9 JH |
989 | cmp1 = operand_less_p (val, vr->min); |
990 | if (cmp1 == -2) | |
0bca51f0 | 991 | return -2; |
6b3c76a9 JH |
992 | if (cmp1 == 1) |
993 | return 0; | |
0bca51f0 | 994 | |
6b3c76a9 JH |
995 | cmp2 = operand_less_p (vr->max, val); |
996 | if (cmp2 == -2) | |
0bca51f0 DN |
997 | return -2; |
998 | ||
6b3c76a9 | 999 | return !cmp2; |
0bca51f0 DN |
1000 | } |
1001 | ||
1002 | ||
1003 | /* Return true if value ranges VR0 and VR1 have a non-empty | |
6b3c76a9 JH |
1004 | intersection. |
1005 | ||
1006 | Benchmark compile/20001226-1.c compilation time after changing this | |
1007 | function. | |
1008 | */ | |
0bca51f0 DN |
1009 | |
1010 | static inline bool | |
227858d1 | 1011 | value_ranges_intersect_p (value_range_t *vr0, value_range_t *vr1) |
0bca51f0 | 1012 | { |
5daffcc7 JH |
1013 | /* The value ranges do not intersect if the maximum of the first range is |
1014 | less than the minimum of the second range or vice versa. | |
1015 | When those relations are unknown, we can't do any better. */ | |
1016 | if (operand_less_p (vr0->max, vr1->min) != 0) | |
1017 | return false; | |
1018 | if (operand_less_p (vr1->max, vr0->min) != 0) | |
1019 | return false; | |
1020 | return true; | |
0bca51f0 DN |
1021 | } |
1022 | ||
1023 | ||
c83033e7 DN |
1024 | /* Return true if VR includes the value zero, false otherwise. FIXME, |
1025 | currently this will return false for an anti-range like ~[-4, 3]. | |
1026 | This will be wrong when the semantics of value_inside_range are | |
1027 | modified (currently the users of this function expect these | |
1028 | semantics). */ | |
227858d1 DN |
1029 | |
1030 | static inline bool | |
1031 | range_includes_zero_p (value_range_t *vr) | |
1032 | { | |
1033 | tree zero; | |
1034 | ||
1035 | gcc_assert (vr->type != VR_UNDEFINED | |
1036 | && vr->type != VR_VARYING | |
1037 | && !symbolic_range_p (vr)); | |
1038 | ||
1039 | zero = build_int_cst (TREE_TYPE (vr->min), 0); | |
1040 | return (value_inside_range (zero, vr) == 1); | |
1041 | } | |
1042 | ||
b16caf72 JL |
1043 | /* Return true if T, an SSA_NAME, is known to be nonnegative. Return |
1044 | false otherwise or if no value range information is available. */ | |
1045 | ||
1046 | bool | |
58f9752a | 1047 | ssa_name_nonnegative_p (const_tree t) |
b16caf72 JL |
1048 | { |
1049 | value_range_t *vr = get_value_range (t); | |
1050 | ||
1051 | if (!vr) | |
1052 | return false; | |
1053 | ||
1054 | /* Testing for VR_ANTI_RANGE is not useful here as any anti-range | |
1055 | which would return a useful value should be encoded as a VR_RANGE. */ | |
1056 | if (vr->type == VR_RANGE) | |
1057 | { | |
1058 | int result = compare_values (vr->min, integer_zero_node); | |
1059 | ||
1060 | return (result == 0 || result == 1); | |
1061 | } | |
1062 | return false; | |
1063 | } | |
1064 | ||
1065 | /* Return true if T, an SSA_NAME, is known to be nonzero. Return | |
1066 | false otherwise or if no value range information is available. */ | |
1067 | ||
1068 | bool | |
58f9752a | 1069 | ssa_name_nonzero_p (const_tree t) |
b16caf72 JL |
1070 | { |
1071 | value_range_t *vr = get_value_range (t); | |
1072 | ||
1073 | if (!vr) | |
1074 | return false; | |
1075 | ||
1076 | /* A VR_RANGE which does not include zero is a nonzero value. */ | |
1077 | if (vr->type == VR_RANGE && !symbolic_range_p (vr)) | |
1078 | return ! range_includes_zero_p (vr); | |
1079 | ||
1080 | /* A VR_ANTI_RANGE which does include zero is a nonzero value. */ | |
1081 | if (vr->type == VR_ANTI_RANGE && !symbolic_range_p (vr)) | |
1082 | return range_includes_zero_p (vr); | |
1083 | ||
1084 | return false; | |
1085 | } | |
1086 | ||
227858d1 | 1087 | |
0bca51f0 DN |
1088 | /* Extract value range information from an ASSERT_EXPR EXPR and store |
1089 | it in *VR_P. */ | |
1090 | ||
1091 | static void | |
227858d1 | 1092 | extract_range_from_assert (value_range_t *vr_p, tree expr) |
0bca51f0 | 1093 | { |
227858d1 DN |
1094 | tree var, cond, limit, min, max, type; |
1095 | value_range_t *var_vr, *limit_vr; | |
b565d777 | 1096 | enum tree_code cond_code; |
0bca51f0 DN |
1097 | |
1098 | var = ASSERT_EXPR_VAR (expr); | |
1099 | cond = ASSERT_EXPR_COND (expr); | |
1100 | ||
7da4bf7d | 1101 | gcc_assert (COMPARISON_CLASS_P (cond)); |
0bca51f0 DN |
1102 | |
1103 | /* Find VAR in the ASSERT_EXPR conditional. */ | |
227858d1 DN |
1104 | if (var == TREE_OPERAND (cond, 0)) |
1105 | { | |
1106 | /* If the predicate is of the form VAR COMP LIMIT, then we just | |
1107 | take LIMIT from the RHS and use the same comparison code. */ | |
1108 | limit = TREE_OPERAND (cond, 1); | |
1109 | cond_code = TREE_CODE (cond); | |
1110 | } | |
1111 | else | |
1112 | { | |
1113 | /* If the predicate is of the form LIMIT COMP VAR, then we need | |
1114 | to flip around the comparison code to create the proper range | |
1115 | for VAR. */ | |
1116 | limit = TREE_OPERAND (cond, 0); | |
09b2f9e8 | 1117 | cond_code = swap_tree_comparison (TREE_CODE (cond)); |
227858d1 | 1118 | } |
0bca51f0 | 1119 | |
b80cca7b ILT |
1120 | limit = avoid_overflow_infinity (limit); |
1121 | ||
227858d1 | 1122 | type = TREE_TYPE (limit); |
0bca51f0 DN |
1123 | gcc_assert (limit != var); |
1124 | ||
227858d1 DN |
1125 | /* For pointer arithmetic, we only keep track of pointer equality |
1126 | and inequality. */ | |
1127 | if (POINTER_TYPE_P (type) && cond_code != NE_EXPR && cond_code != EQ_EXPR) | |
0bca51f0 | 1128 | { |
b565d777 | 1129 | set_value_range_to_varying (vr_p); |
0bca51f0 DN |
1130 | return; |
1131 | } | |
1132 | ||
227858d1 DN |
1133 | /* If LIMIT is another SSA name and LIMIT has a range of its own, |
1134 | try to use LIMIT's range to avoid creating symbolic ranges | |
1135 | unnecessarily. */ | |
1136 | limit_vr = (TREE_CODE (limit) == SSA_NAME) ? get_value_range (limit) : NULL; | |
1137 | ||
1138 | /* LIMIT's range is only interesting if it has any useful information. */ | |
1139 | if (limit_vr | |
1140 | && (limit_vr->type == VR_UNDEFINED | |
1141 | || limit_vr->type == VR_VARYING | |
1142 | || symbolic_range_p (limit_vr))) | |
1143 | limit_vr = NULL; | |
1144 | ||
db3d5328 DN |
1145 | /* Initially, the new range has the same set of equivalences of |
1146 | VAR's range. This will be revised before returning the final | |
1147 | value. Since assertions may be chained via mutually exclusive | |
1148 | predicates, we will need to trim the set of equivalences before | |
1149 | we are done. */ | |
227858d1 | 1150 | gcc_assert (vr_p->equiv == NULL); |
f5052e29 | 1151 | add_equivalence (&vr_p->equiv, var); |
227858d1 DN |
1152 | |
1153 | /* Extract a new range based on the asserted comparison for VAR and | |
1154 | LIMIT's value range. Notice that if LIMIT has an anti-range, we | |
1155 | will only use it for equality comparisons (EQ_EXPR). For any | |
1156 | other kind of assertion, we cannot derive a range from LIMIT's | |
1157 | anti-range that can be used to describe the new range. For | |
1158 | instance, ASSERT_EXPR <x_2, x_2 <= b_4>. If b_4 is ~[2, 10], | |
1159 | then b_4 takes on the ranges [-INF, 1] and [11, +INF]. There is | |
1160 | no single range for x_2 that could describe LE_EXPR, so we might | |
1161 | as well build the range [b_4, +INF] for it. */ | |
1162 | if (cond_code == EQ_EXPR) | |
1163 | { | |
1164 | enum value_range_type range_type; | |
1165 | ||
1166 | if (limit_vr) | |
1167 | { | |
1168 | range_type = limit_vr->type; | |
1169 | min = limit_vr->min; | |
1170 | max = limit_vr->max; | |
1171 | } | |
1172 | else | |
1173 | { | |
1174 | range_type = VR_RANGE; | |
1175 | min = limit; | |
1176 | max = limit; | |
1177 | } | |
1178 | ||
1179 | set_value_range (vr_p, range_type, min, max, vr_p->equiv); | |
1180 | ||
1181 | /* When asserting the equality VAR == LIMIT and LIMIT is another | |
1182 | SSA name, the new range will also inherit the equivalence set | |
1183 | from LIMIT. */ | |
1184 | if (TREE_CODE (limit) == SSA_NAME) | |
f5052e29 | 1185 | add_equivalence (&vr_p->equiv, limit); |
227858d1 DN |
1186 | } |
1187 | else if (cond_code == NE_EXPR) | |
1188 | { | |
1189 | /* As described above, when LIMIT's range is an anti-range and | |
1190 | this assertion is an inequality (NE_EXPR), then we cannot | |
1191 | derive anything from the anti-range. For instance, if | |
1192 | LIMIT's range was ~[0, 0], the assertion 'VAR != LIMIT' does | |
1193 | not imply that VAR's range is [0, 0]. So, in the case of | |
1194 | anti-ranges, we just assert the inequality using LIMIT and | |
fde5c44c JM |
1195 | not its anti-range. |
1196 | ||
1197 | If LIMIT_VR is a range, we can only use it to build a new | |
1198 | anti-range if LIMIT_VR is a single-valued range. For | |
1199 | instance, if LIMIT_VR is [0, 1], the predicate | |
1200 | VAR != [0, 1] does not mean that VAR's range is ~[0, 1]. | |
1201 | Rather, it means that for value 0 VAR should be ~[0, 0] | |
1202 | and for value 1, VAR should be ~[1, 1]. We cannot | |
1203 | represent these ranges. | |
1204 | ||
1205 | The only situation in which we can build a valid | |
1206 | anti-range is when LIMIT_VR is a single-valued range | |
1207 | (i.e., LIMIT_VR->MIN == LIMIT_VR->MAX). In that case, | |
1208 | build the anti-range ~[LIMIT_VR->MIN, LIMIT_VR->MAX]. */ | |
1209 | if (limit_vr | |
1210 | && limit_vr->type == VR_RANGE | |
1211 | && compare_values (limit_vr->min, limit_vr->max) == 0) | |
227858d1 | 1212 | { |
fde5c44c JM |
1213 | min = limit_vr->min; |
1214 | max = limit_vr->max; | |
227858d1 DN |
1215 | } |
1216 | else | |
1217 | { | |
fde5c44c JM |
1218 | /* In any other case, we cannot use LIMIT's range to build a |
1219 | valid anti-range. */ | |
1220 | min = max = limit; | |
227858d1 DN |
1221 | } |
1222 | ||
1223 | /* If MIN and MAX cover the whole range for their type, then | |
1224 | just use the original LIMIT. */ | |
1225 | if (INTEGRAL_TYPE_P (type) | |
e1f28918 ILT |
1226 | && vrp_val_is_min (min) |
1227 | && vrp_val_is_max (max)) | |
227858d1 DN |
1228 | min = max = limit; |
1229 | ||
1230 | set_value_range (vr_p, VR_ANTI_RANGE, min, max, vr_p->equiv); | |
1231 | } | |
1232 | else if (cond_code == LE_EXPR || cond_code == LT_EXPR) | |
0bca51f0 | 1233 | { |
227858d1 DN |
1234 | min = TYPE_MIN_VALUE (type); |
1235 | ||
1236 | if (limit_vr == NULL || limit_vr->type == VR_ANTI_RANGE) | |
1237 | max = limit; | |
1238 | else | |
1239 | { | |
1240 | /* If LIMIT_VR is of the form [N1, N2], we need to build the | |
1241 | range [MIN, N2] for LE_EXPR and [MIN, N2 - 1] for | |
1242 | LT_EXPR. */ | |
1243 | max = limit_vr->max; | |
1244 | } | |
1245 | ||
9d6eefd5 EB |
1246 | /* If the maximum value forces us to be out of bounds, simply punt. |
1247 | It would be pointless to try and do anything more since this | |
1248 | all should be optimized away above us. */ | |
7343ff45 ILT |
1249 | if ((cond_code == LT_EXPR |
1250 | && compare_values (max, min) == 0) | |
1251 | || is_overflow_infinity (max)) | |
9d6eefd5 EB |
1252 | set_value_range_to_varying (vr_p); |
1253 | else | |
227858d1 | 1254 | { |
9d6eefd5 | 1255 | /* For LT_EXPR, we create the range [MIN, MAX - 1]. */ |
7343ff45 | 1256 | if (cond_code == LT_EXPR) |
9d6eefd5 EB |
1257 | { |
1258 | tree one = build_int_cst (type, 1); | |
1259 | max = fold_build2 (MINUS_EXPR, type, max, one); | |
3fe5bcaf ILT |
1260 | if (EXPR_P (max)) |
1261 | TREE_NO_WARNING (max) = 1; | |
9d6eefd5 | 1262 | } |
227858d1 | 1263 | |
9d6eefd5 EB |
1264 | set_value_range (vr_p, VR_RANGE, min, max, vr_p->equiv); |
1265 | } | |
0bca51f0 | 1266 | } |
227858d1 | 1267 | else if (cond_code == GE_EXPR || cond_code == GT_EXPR) |
0bca51f0 | 1268 | { |
227858d1 DN |
1269 | max = TYPE_MAX_VALUE (type); |
1270 | ||
1271 | if (limit_vr == NULL || limit_vr->type == VR_ANTI_RANGE) | |
1272 | min = limit; | |
1273 | else | |
1274 | { | |
1275 | /* If LIMIT_VR is of the form [N1, N2], we need to build the | |
1276 | range [N1, MAX] for GE_EXPR and [N1 + 1, MAX] for | |
1277 | GT_EXPR. */ | |
1278 | min = limit_vr->min; | |
1279 | } | |
1280 | ||
9d6eefd5 EB |
1281 | /* If the minimum value forces us to be out of bounds, simply punt. |
1282 | It would be pointless to try and do anything more since this | |
1283 | all should be optimized away above us. */ | |
7343ff45 ILT |
1284 | if ((cond_code == GT_EXPR |
1285 | && compare_values (min, max) == 0) | |
1286 | || is_overflow_infinity (min)) | |
9d6eefd5 EB |
1287 | set_value_range_to_varying (vr_p); |
1288 | else | |
227858d1 | 1289 | { |
9d6eefd5 | 1290 | /* For GT_EXPR, we create the range [MIN + 1, MAX]. */ |
7343ff45 | 1291 | if (cond_code == GT_EXPR) |
9d6eefd5 EB |
1292 | { |
1293 | tree one = build_int_cst (type, 1); | |
1294 | min = fold_build2 (PLUS_EXPR, type, min, one); | |
3fe5bcaf ILT |
1295 | if (EXPR_P (min)) |
1296 | TREE_NO_WARNING (min) = 1; | |
9d6eefd5 | 1297 | } |
227858d1 | 1298 | |
9d6eefd5 EB |
1299 | set_value_range (vr_p, VR_RANGE, min, max, vr_p->equiv); |
1300 | } | |
0bca51f0 DN |
1301 | } |
1302 | else | |
1303 | gcc_unreachable (); | |
1304 | ||
012a7a78 DN |
1305 | /* If VAR already had a known range, it may happen that the new |
1306 | range we have computed and VAR's range are not compatible. For | |
1307 | instance, | |
1308 | ||
1309 | if (p_5 == NULL) | |
1310 | p_6 = ASSERT_EXPR <p_5, p_5 == NULL>; | |
1311 | x_7 = p_6->fld; | |
1312 | p_8 = ASSERT_EXPR <p_6, p_6 != NULL>; | |
1313 | ||
1314 | While the above comes from a faulty program, it will cause an ICE | |
1315 | later because p_8 and p_6 will have incompatible ranges and at | |
1316 | the same time will be considered equivalent. A similar situation | |
1317 | would arise from | |
1318 | ||
1319 | if (i_5 > 10) | |
1320 | i_6 = ASSERT_EXPR <i_5, i_5 > 10>; | |
1321 | if (i_5 < 5) | |
1322 | i_7 = ASSERT_EXPR <i_6, i_6 < 5>; | |
1323 | ||
1324 | Again i_6 and i_7 will have incompatible ranges. It would be | |
1325 | pointless to try and do anything with i_7's range because | |
1326 | anything dominated by 'if (i_5 < 5)' will be optimized away. | |
1327 | Note, due to the wa in which simulation proceeds, the statement | |
1328 | i_7 = ASSERT_EXPR <...> we would never be visited because the | |
c83eecad | 1329 | conditional 'if (i_5 < 5)' always evaluates to false. However, |
012a7a78 DN |
1330 | this extra check does not hurt and may protect against future |
1331 | changes to VRP that may get into a situation similar to the | |
1332 | NULL pointer dereference example. | |
1333 | ||
1334 | Note that these compatibility tests are only needed when dealing | |
1335 | with ranges or a mix of range and anti-range. If VAR_VR and VR_P | |
1336 | are both anti-ranges, they will always be compatible, because two | |
1337 | anti-ranges will always have a non-empty intersection. */ | |
1338 | ||
0bca51f0 | 1339 | var_vr = get_value_range (var); |
0bca51f0 | 1340 | |
012a7a78 DN |
1341 | /* We may need to make adjustments when VR_P and VAR_VR are numeric |
1342 | ranges or anti-ranges. */ | |
1343 | if (vr_p->type == VR_VARYING | |
1344 | || vr_p->type == VR_UNDEFINED | |
1345 | || var_vr->type == VR_VARYING | |
1346 | || var_vr->type == VR_UNDEFINED | |
1347 | || symbolic_range_p (vr_p) | |
1348 | || symbolic_range_p (var_vr)) | |
96644aba | 1349 | return; |
012a7a78 DN |
1350 | |
1351 | if (var_vr->type == VR_RANGE && vr_p->type == VR_RANGE) | |
1352 | { | |
1353 | /* If the two ranges have a non-empty intersection, we can | |
1354 | refine the resulting range. Since the assert expression | |
1355 | creates an equivalency and at the same time it asserts a | |
1356 | predicate, we can take the intersection of the two ranges to | |
1357 | get better precision. */ | |
1358 | if (value_ranges_intersect_p (var_vr, vr_p)) | |
1359 | { | |
1360 | /* Use the larger of the two minimums. */ | |
1361 | if (compare_values (vr_p->min, var_vr->min) == -1) | |
1362 | min = var_vr->min; | |
1363 | else | |
1364 | min = vr_p->min; | |
1365 | ||
1366 | /* Use the smaller of the two maximums. */ | |
1367 | if (compare_values (vr_p->max, var_vr->max) == 1) | |
1368 | max = var_vr->max; | |
1369 | else | |
1370 | max = vr_p->max; | |
1371 | ||
1372 | set_value_range (vr_p, vr_p->type, min, max, vr_p->equiv); | |
1373 | } | |
0bca51f0 | 1374 | else |
012a7a78 DN |
1375 | { |
1376 | /* The two ranges do not intersect, set the new range to | |
1377 | VARYING, because we will not be able to do anything | |
1378 | meaningful with it. */ | |
1379 | set_value_range_to_varying (vr_p); | |
1380 | } | |
1381 | } | |
1382 | else if ((var_vr->type == VR_RANGE && vr_p->type == VR_ANTI_RANGE) | |
1383 | || (var_vr->type == VR_ANTI_RANGE && vr_p->type == VR_RANGE)) | |
1384 | { | |
1385 | /* A range and an anti-range will cancel each other only if | |
1386 | their ends are the same. For instance, in the example above, | |
1387 | p_8's range ~[0, 0] and p_6's range [0, 0] are incompatible, | |
1388 | so VR_P should be set to VR_VARYING. */ | |
1389 | if (compare_values (var_vr->min, vr_p->min) == 0 | |
1390 | && compare_values (var_vr->max, vr_p->max) == 0) | |
1391 | set_value_range_to_varying (vr_p); | |
307d19fe JL |
1392 | else |
1393 | { | |
1394 | tree min, max, anti_min, anti_max, real_min, real_max; | |
b881887e | 1395 | int cmp; |
307d19fe JL |
1396 | |
1397 | /* We want to compute the logical AND of the two ranges; | |
1398 | there are three cases to consider. | |
1399 | ||
1400 | ||
c0220ea4 | 1401 | 1. The VR_ANTI_RANGE range is completely within the |
307d19fe JL |
1402 | VR_RANGE and the endpoints of the ranges are |
1403 | different. In that case the resulting range | |
4f67dfcf JL |
1404 | should be whichever range is more precise. |
1405 | Typically that will be the VR_RANGE. | |
307d19fe JL |
1406 | |
1407 | 2. The VR_ANTI_RANGE is completely disjoint from | |
1408 | the VR_RANGE. In this case the resulting range | |
1409 | should be the VR_RANGE. | |
1410 | ||
1411 | 3. There is some overlap between the VR_ANTI_RANGE | |
1412 | and the VR_RANGE. | |
1413 | ||
1414 | 3a. If the high limit of the VR_ANTI_RANGE resides | |
1415 | within the VR_RANGE, then the result is a new | |
1416 | VR_RANGE starting at the high limit of the | |
1417 | the VR_ANTI_RANGE + 1 and extending to the | |
1418 | high limit of the original VR_RANGE. | |
1419 | ||
1420 | 3b. If the low limit of the VR_ANTI_RANGE resides | |
1421 | within the VR_RANGE, then the result is a new | |
1422 | VR_RANGE starting at the low limit of the original | |
1423 | VR_RANGE and extending to the low limit of the | |
1424 | VR_ANTI_RANGE - 1. */ | |
1425 | if (vr_p->type == VR_ANTI_RANGE) | |
1426 | { | |
1427 | anti_min = vr_p->min; | |
1428 | anti_max = vr_p->max; | |
1429 | real_min = var_vr->min; | |
1430 | real_max = var_vr->max; | |
1431 | } | |
1432 | else | |
1433 | { | |
1434 | anti_min = var_vr->min; | |
1435 | anti_max = var_vr->max; | |
1436 | real_min = vr_p->min; | |
1437 | real_max = vr_p->max; | |
1438 | } | |
1439 | ||
1440 | ||
1441 | /* Case 1, VR_ANTI_RANGE completely within VR_RANGE, | |
1442 | not including any endpoints. */ | |
1443 | if (compare_values (anti_max, real_max) == -1 | |
1444 | && compare_values (anti_min, real_min) == 1) | |
1445 | { | |
4f67dfcf JL |
1446 | set_value_range (vr_p, VR_RANGE, real_min, |
1447 | real_max, vr_p->equiv); | |
307d19fe JL |
1448 | } |
1449 | /* Case 2, VR_ANTI_RANGE completely disjoint from | |
1450 | VR_RANGE. */ | |
1451 | else if (compare_values (anti_min, real_max) == 1 | |
1452 | || compare_values (anti_max, real_min) == -1) | |
1453 | { | |
1454 | set_value_range (vr_p, VR_RANGE, real_min, | |
1455 | real_max, vr_p->equiv); | |
1456 | } | |
1457 | /* Case 3a, the anti-range extends into the low | |
1458 | part of the real range. Thus creating a new | |
917f1b7e | 1459 | low for the real range. */ |
b881887e RG |
1460 | else if (((cmp = compare_values (anti_max, real_min)) == 1 |
1461 | || cmp == 0) | |
307d19fe JL |
1462 | && compare_values (anti_max, real_max) == -1) |
1463 | { | |
12df8a7e ILT |
1464 | gcc_assert (!is_positive_overflow_infinity (anti_max)); |
1465 | if (needs_overflow_infinity (TREE_TYPE (anti_max)) | |
e1f28918 | 1466 | && vrp_val_is_max (anti_max)) |
12df8a7e ILT |
1467 | { |
1468 | if (!supports_overflow_infinity (TREE_TYPE (var_vr->min))) | |
1469 | { | |
1470 | set_value_range_to_varying (vr_p); | |
1471 | return; | |
1472 | } | |
1473 | min = positive_overflow_infinity (TREE_TYPE (var_vr->min)); | |
1474 | } | |
42289977 | 1475 | else if (!POINTER_TYPE_P (TREE_TYPE (var_vr->min))) |
12df8a7e ILT |
1476 | min = fold_build2 (PLUS_EXPR, TREE_TYPE (var_vr->min), |
1477 | anti_max, | |
1478 | build_int_cst (TREE_TYPE (var_vr->min), 1)); | |
42289977 RG |
1479 | else |
1480 | min = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (var_vr->min), | |
1481 | anti_max, size_int (1)); | |
307d19fe JL |
1482 | max = real_max; |
1483 | set_value_range (vr_p, VR_RANGE, min, max, vr_p->equiv); | |
1484 | } | |
1485 | /* Case 3b, the anti-range extends into the high | |
1486 | part of the real range. Thus creating a new | |
917f1b7e | 1487 | higher for the real range. */ |
307d19fe | 1488 | else if (compare_values (anti_min, real_min) == 1 |
b881887e RG |
1489 | && ((cmp = compare_values (anti_min, real_max)) == -1 |
1490 | || cmp == 0)) | |
307d19fe | 1491 | { |
12df8a7e ILT |
1492 | gcc_assert (!is_negative_overflow_infinity (anti_min)); |
1493 | if (needs_overflow_infinity (TREE_TYPE (anti_min)) | |
e1f28918 | 1494 | && vrp_val_is_min (anti_min)) |
12df8a7e ILT |
1495 | { |
1496 | if (!supports_overflow_infinity (TREE_TYPE (var_vr->min))) | |
1497 | { | |
1498 | set_value_range_to_varying (vr_p); | |
1499 | return; | |
1500 | } | |
1501 | max = negative_overflow_infinity (TREE_TYPE (var_vr->min)); | |
1502 | } | |
5be014d5 | 1503 | else if (!POINTER_TYPE_P (TREE_TYPE (var_vr->min))) |
12df8a7e ILT |
1504 | max = fold_build2 (MINUS_EXPR, TREE_TYPE (var_vr->min), |
1505 | anti_min, | |
1506 | build_int_cst (TREE_TYPE (var_vr->min), 1)); | |
5be014d5 AP |
1507 | else |
1508 | max = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (var_vr->min), | |
1509 | anti_min, | |
1510 | size_int (-1)); | |
307d19fe JL |
1511 | min = real_min; |
1512 | set_value_range (vr_p, VR_RANGE, min, max, vr_p->equiv); | |
1513 | } | |
1514 | } | |
0bca51f0 DN |
1515 | } |
1516 | } | |
1517 | ||
1518 | ||
1519 | /* Extract range information from SSA name VAR and store it in VR. If | |
1520 | VAR has an interesting range, use it. Otherwise, create the | |
1521 | range [VAR, VAR] and return it. This is useful in situations where | |
1522 | we may have conditionals testing values of VARYING names. For | |
1523 | instance, | |
1524 | ||
1525 | x_3 = y_5; | |
1526 | if (x_3 > y_5) | |
1527 | ... | |
1528 | ||
1529 | Even if y_5 is deemed VARYING, we can determine that x_3 > y_5 is | |
1530 | always false. */ | |
1531 | ||
1532 | static void | |
227858d1 | 1533 | extract_range_from_ssa_name (value_range_t *vr, tree var) |
0bca51f0 | 1534 | { |
227858d1 | 1535 | value_range_t *var_vr = get_value_range (var); |
0bca51f0 DN |
1536 | |
1537 | if (var_vr->type != VR_UNDEFINED && var_vr->type != VR_VARYING) | |
227858d1 | 1538 | copy_value_range (vr, var_vr); |
0bca51f0 | 1539 | else |
227858d1 DN |
1540 | set_value_range (vr, VR_RANGE, var, var, NULL); |
1541 | ||
f5052e29 | 1542 | add_equivalence (&vr->equiv, var); |
0bca51f0 DN |
1543 | } |
1544 | ||
1545 | ||
9983270b DN |
1546 | /* Wrapper around int_const_binop. If the operation overflows and we |
1547 | are not using wrapping arithmetic, then adjust the result to be | |
12df8a7e ILT |
1548 | -INF or +INF depending on CODE, VAL1 and VAL2. This can return |
1549 | NULL_TREE if we need to use an overflow infinity representation but | |
1550 | the type does not support it. */ | |
9983270b | 1551 | |
12df8a7e | 1552 | static tree |
9983270b DN |
1553 | vrp_int_const_binop (enum tree_code code, tree val1, tree val2) |
1554 | { | |
1555 | tree res; | |
1556 | ||
377d569b | 1557 | res = int_const_binop (code, val1, val2, 0); |
9983270b DN |
1558 | |
1559 | /* If we are not using wrapping arithmetic, operate symbolically | |
1560 | on -INF and +INF. */ | |
eeef0e45 | 1561 | if (TYPE_OVERFLOW_WRAPS (TREE_TYPE (val1))) |
b17775ab JM |
1562 | { |
1563 | int checkz = compare_values (res, val1); | |
26ef4301 | 1564 | bool overflow = false; |
b17775ab | 1565 | |
7dc32197 | 1566 | /* Ensure that res = val1 [+*] val2 >= val1 |
b17775ab | 1567 | or that res = val1 - val2 <= val1. */ |
26ef4301 | 1568 | if ((code == PLUS_EXPR |
7dc32197 DN |
1569 | && !(checkz == 1 || checkz == 0)) |
1570 | || (code == MINUS_EXPR | |
1571 | && !(checkz == 0 || checkz == -1))) | |
26ef4301 JL |
1572 | { |
1573 | overflow = true; | |
1574 | } | |
1575 | /* Checking for multiplication overflow is done by dividing the | |
1576 | output of the multiplication by the first input of the | |
1577 | multiplication. If the result of that division operation is | |
1578 | not equal to the second input of the multiplication, then the | |
1579 | multiplication overflowed. */ | |
1580 | else if (code == MULT_EXPR && !integer_zerop (val1)) | |
1581 | { | |
1582 | tree tmp = int_const_binop (TRUNC_DIV_EXPR, | |
3ea0e1e4 | 1583 | res, |
26ef4301 JL |
1584 | val1, 0); |
1585 | int check = compare_values (tmp, val2); | |
1586 | ||
1587 | if (check != 0) | |
1588 | overflow = true; | |
1589 | } | |
1590 | ||
1591 | if (overflow) | |
b17775ab JM |
1592 | { |
1593 | res = copy_node (res); | |
1594 | TREE_OVERFLOW (res) = 1; | |
1595 | } | |
26ef4301 | 1596 | |
b17775ab | 1597 | } |
12df8a7e ILT |
1598 | else if ((TREE_OVERFLOW (res) |
1599 | && !TREE_OVERFLOW (val1) | |
1600 | && !TREE_OVERFLOW (val2)) | |
1601 | || is_overflow_infinity (val1) | |
1602 | || is_overflow_infinity (val2)) | |
9983270b | 1603 | { |
7dc32197 DN |
1604 | /* If the operation overflowed but neither VAL1 nor VAL2 are |
1605 | overflown, return -INF or +INF depending on the operation | |
1606 | and the combination of signs of the operands. */ | |
9983270b DN |
1607 | int sgn1 = tree_int_cst_sgn (val1); |
1608 | int sgn2 = tree_int_cst_sgn (val2); | |
1609 | ||
12df8a7e ILT |
1610 | if (needs_overflow_infinity (TREE_TYPE (res)) |
1611 | && !supports_overflow_infinity (TREE_TYPE (res))) | |
1612 | return NULL_TREE; | |
1613 | ||
d7419dec ILT |
1614 | /* We have to punt on adding infinities of different signs, |
1615 | since we can't tell what the sign of the result should be. | |
1616 | Likewise for subtracting infinities of the same sign. */ | |
1617 | if (((code == PLUS_EXPR && sgn1 != sgn2) | |
1618 | || (code == MINUS_EXPR && sgn1 == sgn2)) | |
12df8a7e ILT |
1619 | && is_overflow_infinity (val1) |
1620 | && is_overflow_infinity (val2)) | |
1621 | return NULL_TREE; | |
1622 | ||
d7419dec ILT |
1623 | /* Don't try to handle division or shifting of infinities. */ |
1624 | if ((code == TRUNC_DIV_EXPR | |
1625 | || code == FLOOR_DIV_EXPR | |
1626 | || code == CEIL_DIV_EXPR | |
1627 | || code == EXACT_DIV_EXPR | |
1628 | || code == ROUND_DIV_EXPR | |
1629 | || code == RSHIFT_EXPR) | |
1630 | && (is_overflow_infinity (val1) | |
1631 | || is_overflow_infinity (val2))) | |
1632 | return NULL_TREE; | |
1633 | ||
0d22e81f EB |
1634 | /* Notice that we only need to handle the restricted set of |
1635 | operations handled by extract_range_from_binary_expr. | |
1636 | Among them, only multiplication, addition and subtraction | |
1637 | can yield overflow without overflown operands because we | |
1638 | are working with integral types only... except in the | |
1639 | case VAL1 = -INF and VAL2 = -1 which overflows to +INF | |
1640 | for division too. */ | |
1641 | ||
1642 | /* For multiplication, the sign of the overflow is given | |
1643 | by the comparison of the signs of the operands. */ | |
1644 | if ((code == MULT_EXPR && sgn1 == sgn2) | |
1645 | /* For addition, the operands must be of the same sign | |
1646 | to yield an overflow. Its sign is therefore that | |
d7419dec ILT |
1647 | of one of the operands, for example the first. For |
1648 | infinite operands X + -INF is negative, not positive. */ | |
1649 | || (code == PLUS_EXPR | |
1650 | && (sgn1 >= 0 | |
1651 | ? !is_negative_overflow_infinity (val2) | |
1652 | : is_positive_overflow_infinity (val2))) | |
12df8a7e ILT |
1653 | /* For subtraction, non-infinite operands must be of |
1654 | different signs to yield an overflow. Its sign is | |
1655 | therefore that of the first operand or the opposite of | |
1656 | that of the second operand. A first operand of 0 counts | |
1657 | as positive here, for the corner case 0 - (-INF), which | |
1658 | overflows, but must yield +INF. For infinite operands 0 | |
1659 | - INF is negative, not positive. */ | |
1660 | || (code == MINUS_EXPR | |
1661 | && (sgn1 >= 0 | |
1662 | ? !is_positive_overflow_infinity (val2) | |
1663 | : is_negative_overflow_infinity (val2))) | |
13338552 RG |
1664 | /* We only get in here with positive shift count, so the |
1665 | overflow direction is the same as the sign of val1. | |
1666 | Actually rshift does not overflow at all, but we only | |
1667 | handle the case of shifting overflowed -INF and +INF. */ | |
1668 | || (code == RSHIFT_EXPR | |
1669 | && sgn1 >= 0) | |
0d22e81f EB |
1670 | /* For division, the only case is -INF / -1 = +INF. */ |
1671 | || code == TRUNC_DIV_EXPR | |
1672 | || code == FLOOR_DIV_EXPR | |
1673 | || code == CEIL_DIV_EXPR | |
1674 | || code == EXACT_DIV_EXPR | |
1675 | || code == ROUND_DIV_EXPR) | |
12df8a7e ILT |
1676 | return (needs_overflow_infinity (TREE_TYPE (res)) |
1677 | ? positive_overflow_infinity (TREE_TYPE (res)) | |
1678 | : TYPE_MAX_VALUE (TREE_TYPE (res))); | |
9983270b | 1679 | else |
12df8a7e ILT |
1680 | return (needs_overflow_infinity (TREE_TYPE (res)) |
1681 | ? negative_overflow_infinity (TREE_TYPE (res)) | |
1682 | : TYPE_MIN_VALUE (TREE_TYPE (res))); | |
9983270b DN |
1683 | } |
1684 | ||
1685 | return res; | |
1686 | } | |
1687 | ||
1688 | ||
0bca51f0 DN |
1689 | /* Extract range information from a binary expression EXPR based on |
1690 | the ranges of each of its operands and the expression code. */ | |
1691 | ||
1692 | static void | |
227858d1 | 1693 | extract_range_from_binary_expr (value_range_t *vr, tree expr) |
0bca51f0 DN |
1694 | { |
1695 | enum tree_code code = TREE_CODE (expr); | |
4e2d94a9 | 1696 | enum value_range_type type; |
0bca51f0 | 1697 | tree op0, op1, min, max; |
0bca51f0 | 1698 | int cmp; |
227858d1 DN |
1699 | value_range_t vr0 = { VR_UNDEFINED, NULL_TREE, NULL_TREE, NULL }; |
1700 | value_range_t vr1 = { VR_UNDEFINED, NULL_TREE, NULL_TREE, NULL }; | |
0bca51f0 DN |
1701 | |
1702 | /* Not all binary expressions can be applied to ranges in a | |
1703 | meaningful way. Handle only arithmetic operations. */ | |
1704 | if (code != PLUS_EXPR | |
1705 | && code != MINUS_EXPR | |
5be014d5 | 1706 | && code != POINTER_PLUS_EXPR |
0bca51f0 DN |
1707 | && code != MULT_EXPR |
1708 | && code != TRUNC_DIV_EXPR | |
1709 | && code != FLOOR_DIV_EXPR | |
1710 | && code != CEIL_DIV_EXPR | |
1711 | && code != EXACT_DIV_EXPR | |
1712 | && code != ROUND_DIV_EXPR | |
6569e716 | 1713 | && code != RSHIFT_EXPR |
0bca51f0 | 1714 | && code != MIN_EXPR |
227858d1 | 1715 | && code != MAX_EXPR |
29c8f8c2 | 1716 | && code != BIT_AND_EXPR |
227858d1 DN |
1717 | && code != TRUTH_ANDIF_EXPR |
1718 | && code != TRUTH_ORIF_EXPR | |
1719 | && code != TRUTH_AND_EXPR | |
74290e83 | 1720 | && code != TRUTH_OR_EXPR) |
0bca51f0 | 1721 | { |
b565d777 | 1722 | set_value_range_to_varying (vr); |
0bca51f0 DN |
1723 | return; |
1724 | } | |
1725 | ||
1726 | /* Get value ranges for each operand. For constant operands, create | |
1727 | a new value range with the operand to simplify processing. */ | |
1728 | op0 = TREE_OPERAND (expr, 0); | |
1729 | if (TREE_CODE (op0) == SSA_NAME) | |
1730 | vr0 = *(get_value_range (op0)); | |
227858d1 | 1731 | else if (is_gimple_min_invariant (op0)) |
b60b4711 | 1732 | set_value_range_to_value (&vr0, op0, NULL); |
0bca51f0 | 1733 | else |
227858d1 | 1734 | set_value_range_to_varying (&vr0); |
0bca51f0 DN |
1735 | |
1736 | op1 = TREE_OPERAND (expr, 1); | |
1737 | if (TREE_CODE (op1) == SSA_NAME) | |
1738 | vr1 = *(get_value_range (op1)); | |
227858d1 | 1739 | else if (is_gimple_min_invariant (op1)) |
b60b4711 | 1740 | set_value_range_to_value (&vr1, op1, NULL); |
0bca51f0 | 1741 | else |
227858d1 | 1742 | set_value_range_to_varying (&vr1); |
0bca51f0 DN |
1743 | |
1744 | /* If either range is UNDEFINED, so is the result. */ | |
1745 | if (vr0.type == VR_UNDEFINED || vr1.type == VR_UNDEFINED) | |
1746 | { | |
227858d1 | 1747 | set_value_range_to_undefined (vr); |
0bca51f0 DN |
1748 | return; |
1749 | } | |
1750 | ||
4e2d94a9 KH |
1751 | /* The type of the resulting value range defaults to VR0.TYPE. */ |
1752 | type = vr0.type; | |
1753 | ||
227858d1 | 1754 | /* Refuse to operate on VARYING ranges, ranges of different kinds |
29c8f8c2 KH |
1755 | and symbolic ranges. As an exception, we allow BIT_AND_EXPR |
1756 | because we may be able to derive a useful range even if one of | |
1757 | the operands is VR_VARYING or symbolic range. TODO, we may be | |
1758 | able to derive anti-ranges in some cases. */ | |
1759 | if (code != BIT_AND_EXPR | |
9b61327b KH |
1760 | && code != TRUTH_AND_EXPR |
1761 | && code != TRUTH_OR_EXPR | |
29c8f8c2 KH |
1762 | && (vr0.type == VR_VARYING |
1763 | || vr1.type == VR_VARYING | |
1764 | || vr0.type != vr1.type | |
1765 | || symbolic_range_p (&vr0) | |
1766 | || symbolic_range_p (&vr1))) | |
0bca51f0 | 1767 | { |
b565d777 | 1768 | set_value_range_to_varying (vr); |
0bca51f0 DN |
1769 | return; |
1770 | } | |
1771 | ||
1772 | /* Now evaluate the expression to determine the new range. */ | |
1773 | if (POINTER_TYPE_P (TREE_TYPE (expr)) | |
1774 | || POINTER_TYPE_P (TREE_TYPE (op0)) | |
1775 | || POINTER_TYPE_P (TREE_TYPE (op1))) | |
1776 | { | |
5be014d5 | 1777 | if (code == MIN_EXPR || code == MAX_EXPR) |
e57f2b41 | 1778 | { |
5be014d5 AP |
1779 | /* For MIN/MAX expressions with pointers, we only care about |
1780 | nullness, if both are non null, then the result is nonnull. | |
1781 | If both are null, then the result is null. Otherwise they | |
1782 | are varying. */ | |
1783 | if (range_is_nonnull (&vr0) && range_is_nonnull (&vr1)) | |
e57f2b41 KH |
1784 | set_value_range_to_nonnull (vr, TREE_TYPE (expr)); |
1785 | else if (range_is_null (&vr0) && range_is_null (&vr1)) | |
1786 | set_value_range_to_null (vr, TREE_TYPE (expr)); | |
1787 | else | |
1788 | set_value_range_to_varying (vr); | |
5be014d5 AP |
1789 | |
1790 | return; | |
e57f2b41 | 1791 | } |
5be014d5 AP |
1792 | gcc_assert (code == POINTER_PLUS_EXPR); |
1793 | /* For pointer types, we are really only interested in asserting | |
1794 | whether the expression evaluates to non-NULL. */ | |
1795 | if (range_is_nonnull (&vr0) || range_is_nonnull (&vr1)) | |
1796 | set_value_range_to_nonnull (vr, TREE_TYPE (expr)); | |
1797 | else if (range_is_null (&vr0) && range_is_null (&vr1)) | |
1798 | set_value_range_to_null (vr, TREE_TYPE (expr)); | |
0bca51f0 | 1799 | else |
5be014d5 | 1800 | set_value_range_to_varying (vr); |
0bca51f0 DN |
1801 | |
1802 | return; | |
1803 | } | |
1804 | ||
1805 | /* For integer ranges, apply the operation to each end of the | |
1806 | range and see what we end up with. */ | |
227858d1 DN |
1807 | if (code == TRUTH_ANDIF_EXPR |
1808 | || code == TRUTH_ORIF_EXPR | |
1809 | || code == TRUTH_AND_EXPR | |
74290e83 | 1810 | || code == TRUTH_OR_EXPR) |
227858d1 | 1811 | { |
9b61327b KH |
1812 | /* If one of the operands is zero, we know that the whole |
1813 | expression evaluates zero. */ | |
1814 | if (code == TRUTH_AND_EXPR | |
1815 | && ((vr0.type == VR_RANGE | |
1816 | && integer_zerop (vr0.min) | |
1817 | && integer_zerop (vr0.max)) | |
1818 | || (vr1.type == VR_RANGE | |
1819 | && integer_zerop (vr1.min) | |
1820 | && integer_zerop (vr1.max)))) | |
1821 | { | |
1822 | type = VR_RANGE; | |
1823 | min = max = build_int_cst (TREE_TYPE (expr), 0); | |
1824 | } | |
1825 | /* If one of the operands is one, we know that the whole | |
1826 | expression evaluates one. */ | |
1827 | else if (code == TRUTH_OR_EXPR | |
1828 | && ((vr0.type == VR_RANGE | |
1829 | && integer_onep (vr0.min) | |
1830 | && integer_onep (vr0.max)) | |
1831 | || (vr1.type == VR_RANGE | |
1832 | && integer_onep (vr1.min) | |
1833 | && integer_onep (vr1.max)))) | |
1834 | { | |
1835 | type = VR_RANGE; | |
1836 | min = max = build_int_cst (TREE_TYPE (expr), 1); | |
1837 | } | |
1838 | else if (vr0.type != VR_VARYING | |
1839 | && vr1.type != VR_VARYING | |
1840 | && vr0.type == vr1.type | |
1841 | && !symbolic_range_p (&vr0) | |
12df8a7e ILT |
1842 | && !overflow_infinity_range_p (&vr0) |
1843 | && !symbolic_range_p (&vr1) | |
1844 | && !overflow_infinity_range_p (&vr1)) | |
9b61327b KH |
1845 | { |
1846 | /* Boolean expressions cannot be folded with int_const_binop. */ | |
1847 | min = fold_binary (code, TREE_TYPE (expr), vr0.min, vr1.min); | |
1848 | max = fold_binary (code, TREE_TYPE (expr), vr0.max, vr1.max); | |
1849 | } | |
1850 | else | |
1851 | { | |
31ab1cc9 RG |
1852 | /* The result of a TRUTH_*_EXPR is always true or false. */ |
1853 | set_value_range_to_truthvalue (vr, TREE_TYPE (expr)); | |
9b61327b KH |
1854 | return; |
1855 | } | |
227858d1 DN |
1856 | } |
1857 | else if (code == PLUS_EXPR | |
227858d1 DN |
1858 | || code == MIN_EXPR |
1859 | || code == MAX_EXPR) | |
0bca51f0 | 1860 | { |
567fb660 KH |
1861 | /* If we have a PLUS_EXPR with two VR_ANTI_RANGEs, drop to |
1862 | VR_VARYING. It would take more effort to compute a precise | |
1863 | range for such a case. For example, if we have op0 == 1 and | |
1864 | op1 == -1 with their ranges both being ~[0,0], we would have | |
1865 | op0 + op1 == 0, so we cannot claim that the sum is in ~[0,0]. | |
1866 | Note that we are guaranteed to have vr0.type == vr1.type at | |
1867 | this point. */ | |
1868 | if (code == PLUS_EXPR && vr0.type == VR_ANTI_RANGE) | |
1869 | { | |
1870 | set_value_range_to_varying (vr); | |
1871 | return; | |
1872 | } | |
1873 | ||
0bca51f0 DN |
1874 | /* For operations that make the resulting range directly |
1875 | proportional to the original ranges, apply the operation to | |
1876 | the same end of each range. */ | |
9983270b DN |
1877 | min = vrp_int_const_binop (code, vr0.min, vr1.min); |
1878 | max = vrp_int_const_binop (code, vr0.max, vr1.max); | |
0bca51f0 | 1879 | } |
9983270b DN |
1880 | else if (code == MULT_EXPR |
1881 | || code == TRUNC_DIV_EXPR | |
227858d1 DN |
1882 | || code == FLOOR_DIV_EXPR |
1883 | || code == CEIL_DIV_EXPR | |
1884 | || code == EXACT_DIV_EXPR | |
6569e716 RG |
1885 | || code == ROUND_DIV_EXPR |
1886 | || code == RSHIFT_EXPR) | |
0bca51f0 | 1887 | { |
9983270b DN |
1888 | tree val[4]; |
1889 | size_t i; | |
12df8a7e | 1890 | bool sop; |
9983270b | 1891 | |
567fb660 KH |
1892 | /* If we have an unsigned MULT_EXPR with two VR_ANTI_RANGEs, |
1893 | drop to VR_VARYING. It would take more effort to compute a | |
1894 | precise range for such a case. For example, if we have | |
1895 | op0 == 65536 and op1 == 65536 with their ranges both being | |
1896 | ~[0,0] on a 32-bit machine, we would have op0 * op1 == 0, so | |
1897 | we cannot claim that the product is in ~[0,0]. Note that we | |
1898 | are guaranteed to have vr0.type == vr1.type at this | |
1899 | point. */ | |
1900 | if (code == MULT_EXPR | |
1901 | && vr0.type == VR_ANTI_RANGE | |
eeef0e45 | 1902 | && !TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (op0))) |
567fb660 KH |
1903 | { |
1904 | set_value_range_to_varying (vr); | |
1905 | return; | |
1906 | } | |
1907 | ||
af33044f RH |
1908 | /* If we have a RSHIFT_EXPR with any shift values outside [0..prec-1], |
1909 | then drop to VR_VARYING. Outside of this range we get undefined | |
7fa7289d | 1910 | behavior from the shift operation. We cannot even trust |
af33044f RH |
1911 | SHIFT_COUNT_TRUNCATED at this stage, because that applies to rtl |
1912 | shifts, and the operation at the tree level may be widened. */ | |
1913 | if (code == RSHIFT_EXPR) | |
13338552 | 1914 | { |
af33044f RH |
1915 | if (vr1.type == VR_ANTI_RANGE |
1916 | || !vrp_expr_computes_nonnegative (op1, &sop) | |
1917 | || (operand_less_p | |
1918 | (build_int_cst (TREE_TYPE (vr1.max), | |
1919 | TYPE_PRECISION (TREE_TYPE (expr)) - 1), | |
1920 | vr1.max) != 0)) | |
1921 | { | |
1922 | set_value_range_to_varying (vr); | |
1923 | return; | |
1924 | } | |
13338552 RG |
1925 | } |
1926 | ||
9983270b DN |
1927 | /* Multiplications and divisions are a bit tricky to handle, |
1928 | depending on the mix of signs we have in the two ranges, we | |
1929 | need to operate on different values to get the minimum and | |
1930 | maximum values for the new range. One approach is to figure | |
1931 | out all the variations of range combinations and do the | |
1932 | operations. | |
1933 | ||
1934 | However, this involves several calls to compare_values and it | |
1935 | is pretty convoluted. It's simpler to do the 4 operations | |
1936 | (MIN0 OP MIN1, MIN0 OP MAX1, MAX0 OP MIN1 and MAX0 OP MAX0 OP | |
1937 | MAX1) and then figure the smallest and largest values to form | |
1938 | the new range. */ | |
1939 | ||
1940 | /* Divisions by zero result in a VARYING value. */ | |
af33044f RH |
1941 | else if (code != MULT_EXPR |
1942 | && (vr0.type == VR_ANTI_RANGE || range_includes_zero_p (&vr1))) | |
227858d1 DN |
1943 | { |
1944 | set_value_range_to_varying (vr); | |
1945 | return; | |
1946 | } | |
fda05890 | 1947 | |
9983270b | 1948 | /* Compute the 4 cross operations. */ |
12df8a7e | 1949 | sop = false; |
9983270b | 1950 | val[0] = vrp_int_const_binop (code, vr0.min, vr1.min); |
12df8a7e ILT |
1951 | if (val[0] == NULL_TREE) |
1952 | sop = true; | |
1953 | ||
1954 | if (vr1.max == vr1.min) | |
1955 | val[1] = NULL_TREE; | |
1956 | else | |
1957 | { | |
1958 | val[1] = vrp_int_const_binop (code, vr0.min, vr1.max); | |
1959 | if (val[1] == NULL_TREE) | |
1960 | sop = true; | |
1961 | } | |
9983270b | 1962 | |
12df8a7e ILT |
1963 | if (vr0.max == vr0.min) |
1964 | val[2] = NULL_TREE; | |
1965 | else | |
1966 | { | |
1967 | val[2] = vrp_int_const_binop (code, vr0.max, vr1.min); | |
1968 | if (val[2] == NULL_TREE) | |
1969 | sop = true; | |
1970 | } | |
9983270b | 1971 | |
12df8a7e ILT |
1972 | if (vr0.min == vr0.max || vr1.min == vr1.max) |
1973 | val[3] = NULL_TREE; | |
1974 | else | |
1975 | { | |
1976 | val[3] = vrp_int_const_binop (code, vr0.max, vr1.max); | |
1977 | if (val[3] == NULL_TREE) | |
1978 | sop = true; | |
1979 | } | |
9983270b | 1980 | |
12df8a7e ILT |
1981 | if (sop) |
1982 | { | |
1983 | set_value_range_to_varying (vr); | |
1984 | return; | |
1985 | } | |
9983270b DN |
1986 | |
1987 | /* Set MIN to the minimum of VAL[i] and MAX to the maximum | |
1988 | of VAL[i]. */ | |
1989 | min = val[0]; | |
1990 | max = val[0]; | |
1991 | for (i = 1; i < 4; i++) | |
227858d1 | 1992 | { |
12df8a7e ILT |
1993 | if (!is_gimple_min_invariant (min) |
1994 | || (TREE_OVERFLOW (min) && !is_overflow_infinity (min)) | |
1995 | || !is_gimple_min_invariant (max) | |
1996 | || (TREE_OVERFLOW (max) && !is_overflow_infinity (max))) | |
9983270b DN |
1997 | break; |
1998 | ||
1999 | if (val[i]) | |
227858d1 | 2000 | { |
12df8a7e ILT |
2001 | if (!is_gimple_min_invariant (val[i]) |
2002 | || (TREE_OVERFLOW (val[i]) | |
2003 | && !is_overflow_infinity (val[i]))) | |
9983270b DN |
2004 | { |
2005 | /* If we found an overflowed value, set MIN and MAX | |
2006 | to it so that we set the resulting range to | |
2007 | VARYING. */ | |
2008 | min = max = val[i]; | |
2009 | break; | |
2010 | } | |
2011 | ||
2012 | if (compare_values (val[i], min) == -1) | |
2013 | min = val[i]; | |
2014 | ||
2015 | if (compare_values (val[i], max) == 1) | |
2016 | max = val[i]; | |
227858d1 DN |
2017 | } |
2018 | } | |
2019 | } | |
2020 | else if (code == MINUS_EXPR) | |
2021 | { | |
567fb660 KH |
2022 | /* If we have a MINUS_EXPR with two VR_ANTI_RANGEs, drop to |
2023 | VR_VARYING. It would take more effort to compute a precise | |
2024 | range for such a case. For example, if we have op0 == 1 and | |
2025 | op1 == 1 with their ranges both being ~[0,0], we would have | |
2026 | op0 - op1 == 0, so we cannot claim that the difference is in | |
2027 | ~[0,0]. Note that we are guaranteed to have | |
2028 | vr0.type == vr1.type at this point. */ | |
2029 | if (vr0.type == VR_ANTI_RANGE) | |
2030 | { | |
2031 | set_value_range_to_varying (vr); | |
2032 | return; | |
2033 | } | |
2034 | ||
227858d1 DN |
2035 | /* For MINUS_EXPR, apply the operation to the opposite ends of |
2036 | each range. */ | |
9983270b DN |
2037 | min = vrp_int_const_binop (code, vr0.min, vr1.max); |
2038 | max = vrp_int_const_binop (code, vr0.max, vr1.min); | |
227858d1 | 2039 | } |
29c8f8c2 KH |
2040 | else if (code == BIT_AND_EXPR) |
2041 | { | |
2042 | if (vr0.type == VR_RANGE | |
2043 | && vr0.min == vr0.max | |
12df8a7e ILT |
2044 | && TREE_CODE (vr0.max) == INTEGER_CST |
2045 | && !TREE_OVERFLOW (vr0.max) | |
2046 | && tree_int_cst_sgn (vr0.max) >= 0) | |
29c8f8c2 | 2047 | { |
dec2f881 | 2048 | min = build_int_cst (TREE_TYPE (expr), 0); |
29c8f8c2 KH |
2049 | max = vr0.max; |
2050 | } | |
2051 | else if (vr1.type == VR_RANGE | |
12df8a7e ILT |
2052 | && vr1.min == vr1.max |
2053 | && TREE_CODE (vr1.max) == INTEGER_CST | |
2054 | && !TREE_OVERFLOW (vr1.max) | |
2055 | && tree_int_cst_sgn (vr1.max) >= 0) | |
29c8f8c2 | 2056 | { |
4e2d94a9 | 2057 | type = VR_RANGE; |
dec2f881 | 2058 | min = build_int_cst (TREE_TYPE (expr), 0); |
29c8f8c2 KH |
2059 | max = vr1.max; |
2060 | } | |
2061 | else | |
2062 | { | |
2063 | set_value_range_to_varying (vr); | |
2064 | return; | |
2065 | } | |
2066 | } | |
227858d1 DN |
2067 | else |
2068 | gcc_unreachable (); | |
fda05890 | 2069 | |
9983270b | 2070 | /* If either MIN or MAX overflowed, then set the resulting range to |
12df8a7e ILT |
2071 | VARYING. But we do accept an overflow infinity |
2072 | representation. */ | |
2073 | if (min == NULL_TREE | |
2074 | || !is_gimple_min_invariant (min) | |
2075 | || (TREE_OVERFLOW (min) && !is_overflow_infinity (min)) | |
2076 | || max == NULL_TREE | |
2077 | || !is_gimple_min_invariant (max) | |
2078 | || (TREE_OVERFLOW (max) && !is_overflow_infinity (max))) | |
2079 | { | |
2080 | set_value_range_to_varying (vr); | |
2081 | return; | |
2082 | } | |
2083 | ||
fa633851 ILT |
2084 | /* We punt if: |
2085 | 1) [-INF, +INF] | |
2086 | 2) [-INF, +-INF(OVF)] | |
2087 | 3) [+-INF(OVF), +INF] | |
2088 | 4) [+-INF(OVF), +-INF(OVF)] | |
2089 | We learn nothing when we have INF and INF(OVF) on both sides. | |
2090 | Note that we do accept [-INF, -INF] and [+INF, +INF] without | |
2091 | overflow. */ | |
e1f28918 ILT |
2092 | if ((vrp_val_is_min (min) || is_overflow_infinity (min)) |
2093 | && (vrp_val_is_max (max) || is_overflow_infinity (max))) | |
227858d1 | 2094 | { |
9983270b DN |
2095 | set_value_range_to_varying (vr); |
2096 | return; | |
fda05890 KH |
2097 | } |
2098 | ||
227858d1 DN |
2099 | cmp = compare_values (min, max); |
2100 | if (cmp == -2 || cmp == 1) | |
2101 | { | |
2102 | /* If the new range has its limits swapped around (MIN > MAX), | |
2103 | then the operation caused one of them to wrap around, mark | |
2104 | the new range VARYING. */ | |
2105 | set_value_range_to_varying (vr); | |
2106 | } | |
2107 | else | |
4e2d94a9 | 2108 | set_value_range (vr, type, min, max, NULL); |
fda05890 KH |
2109 | } |
2110 | ||
2111 | ||
0bca51f0 DN |
2112 | /* Extract range information from a unary expression EXPR based on |
2113 | the range of its operand and the expression code. */ | |
2114 | ||
2115 | static void | |
227858d1 | 2116 | extract_range_from_unary_expr (value_range_t *vr, tree expr) |
0bca51f0 DN |
2117 | { |
2118 | enum tree_code code = TREE_CODE (expr); | |
2119 | tree min, max, op0; | |
0bca51f0 | 2120 | int cmp; |
227858d1 DN |
2121 | value_range_t vr0 = { VR_UNDEFINED, NULL_TREE, NULL_TREE, NULL }; |
2122 | ||
2123 | /* Refuse to operate on certain unary expressions for which we | |
2124 | cannot easily determine a resulting range. */ | |
2125 | if (code == FIX_TRUNC_EXPR | |
227858d1 DN |
2126 | || code == FLOAT_EXPR |
2127 | || code == BIT_NOT_EXPR | |
2128 | || code == NON_LVALUE_EXPR | |
2129 | || code == CONJ_EXPR) | |
2130 | { | |
2131 | set_value_range_to_varying (vr); | |
2132 | return; | |
2133 | } | |
0bca51f0 DN |
2134 | |
2135 | /* Get value ranges for the operand. For constant operands, create | |
2136 | a new value range with the operand to simplify processing. */ | |
2137 | op0 = TREE_OPERAND (expr, 0); | |
2138 | if (TREE_CODE (op0) == SSA_NAME) | |
2139 | vr0 = *(get_value_range (op0)); | |
227858d1 | 2140 | else if (is_gimple_min_invariant (op0)) |
b60b4711 | 2141 | set_value_range_to_value (&vr0, op0, NULL); |
0bca51f0 | 2142 | else |
227858d1 | 2143 | set_value_range_to_varying (&vr0); |
0bca51f0 DN |
2144 | |
2145 | /* If VR0 is UNDEFINED, so is the result. */ | |
2146 | if (vr0.type == VR_UNDEFINED) | |
2147 | { | |
227858d1 | 2148 | set_value_range_to_undefined (vr); |
0bca51f0 DN |
2149 | return; |
2150 | } | |
2151 | ||
a3b196e3 JL |
2152 | /* Refuse to operate on symbolic ranges, or if neither operand is |
2153 | a pointer or integral type. */ | |
2154 | if ((!INTEGRAL_TYPE_P (TREE_TYPE (op0)) | |
2155 | && !POINTER_TYPE_P (TREE_TYPE (op0))) | |
2156 | || (vr0.type != VR_VARYING | |
2157 | && symbolic_range_p (&vr0))) | |
0bca51f0 | 2158 | { |
b565d777 | 2159 | set_value_range_to_varying (vr); |
0bca51f0 DN |
2160 | return; |
2161 | } | |
2162 | ||
2163 | /* If the expression involves pointers, we are only interested in | |
2164 | determining if it evaluates to NULL [0, 0] or non-NULL (~[0, 0]). */ | |
2165 | if (POINTER_TYPE_P (TREE_TYPE (expr)) || POINTER_TYPE_P (TREE_TYPE (op0))) | |
2166 | { | |
12df8a7e | 2167 | bool sop; |
6ac01510 | 2168 | |
12df8a7e ILT |
2169 | sop = false; |
2170 | if (range_is_nonnull (&vr0) | |
2171 | || (tree_expr_nonzero_warnv_p (expr, &sop) | |
2172 | && !sop)) | |
0bca51f0 DN |
2173 | set_value_range_to_nonnull (vr, TREE_TYPE (expr)); |
2174 | else if (range_is_null (&vr0)) | |
2175 | set_value_range_to_null (vr, TREE_TYPE (expr)); | |
2176 | else | |
b565d777 | 2177 | set_value_range_to_varying (vr); |
0bca51f0 DN |
2178 | |
2179 | return; | |
2180 | } | |
2181 | ||
2182 | /* Handle unary expressions on integer ranges. */ | |
441e96b5 | 2183 | if (code == NOP_EXPR || code == CONVERT_EXPR) |
0bca51f0 | 2184 | { |
441e96b5 DN |
2185 | tree inner_type = TREE_TYPE (op0); |
2186 | tree outer_type = TREE_TYPE (expr); | |
2187 | ||
2735e93e JL |
2188 | /* If VR0 represents a simple range, then try to convert |
2189 | the min and max values for the range to the same type | |
2190 | as OUTER_TYPE. If the results compare equal to VR0's | |
2191 | min and max values and the new min is still less than | |
2192 | or equal to the new max, then we can safely use the newly | |
2193 | computed range for EXPR. This allows us to compute | |
2194 | accurate ranges through many casts. */ | |
12df8a7e ILT |
2195 | if ((vr0.type == VR_RANGE |
2196 | && !overflow_infinity_range_p (&vr0)) | |
a3b196e3 JL |
2197 | || (vr0.type == VR_VARYING |
2198 | && TYPE_PRECISION (outer_type) > TYPE_PRECISION (inner_type))) | |
2735e93e | 2199 | { |
a3b196e3 JL |
2200 | tree new_min, new_max, orig_min, orig_max; |
2201 | ||
2202 | /* Convert the input operand min/max to OUTER_TYPE. If | |
2203 | the input has no range information, then use the min/max | |
2204 | for the input's type. */ | |
2205 | if (vr0.type == VR_RANGE) | |
2206 | { | |
2207 | orig_min = vr0.min; | |
2208 | orig_max = vr0.max; | |
2209 | } | |
2210 | else | |
2211 | { | |
2212 | orig_min = TYPE_MIN_VALUE (inner_type); | |
2213 | orig_max = TYPE_MAX_VALUE (inner_type); | |
2214 | } | |
2735e93e | 2215 | |
a3b196e3 JL |
2216 | new_min = fold_convert (outer_type, orig_min); |
2217 | new_max = fold_convert (outer_type, orig_max); | |
2735e93e JL |
2218 | |
2219 | /* Verify the new min/max values are gimple values and | |
75c40d56 | 2220 | that they compare equal to the original input's |
a3b196e3 | 2221 | min/max values. */ |
2735e93e JL |
2222 | if (is_gimple_val (new_min) |
2223 | && is_gimple_val (new_max) | |
a3b196e3 JL |
2224 | && tree_int_cst_equal (new_min, orig_min) |
2225 | && tree_int_cst_equal (new_max, orig_max) | |
9c4ed267 ILT |
2226 | && (!is_overflow_infinity (new_min) |
2227 | || !is_overflow_infinity (new_max)) | |
b881887e RG |
2228 | && (cmp = compare_values (new_min, new_max)) <= 0 |
2229 | && cmp >= -1) | |
2735e93e JL |
2230 | { |
2231 | set_value_range (vr, VR_RANGE, new_min, new_max, vr->equiv); | |
2232 | return; | |
2233 | } | |
2234 | } | |
2235 | ||
0bca51f0 DN |
2236 | /* When converting types of different sizes, set the result to |
2237 | VARYING. Things like sign extensions and precision loss may | |
2238 | change the range. For instance, if x_3 is of type 'long long | |
2239 | int' and 'y_5 = (unsigned short) x_3', if x_3 is ~[0, 0], it | |
2240 | is impossible to know at compile time whether y_5 will be | |
2241 | ~[0, 0]. */ | |
441e96b5 DN |
2242 | if (TYPE_SIZE (inner_type) != TYPE_SIZE (outer_type) |
2243 | || TYPE_PRECISION (inner_type) != TYPE_PRECISION (outer_type)) | |
2244 | { | |
2245 | set_value_range_to_varying (vr); | |
2246 | return; | |
2247 | } | |
0bca51f0 DN |
2248 | } |
2249 | ||
a3b196e3 JL |
2250 | /* Conversion of a VR_VARYING value to a wider type can result |
2251 | in a usable range. So wait until after we've handled conversions | |
2252 | before dropping the result to VR_VARYING if we had a source | |
2253 | operand that is VR_VARYING. */ | |
2254 | if (vr0.type == VR_VARYING) | |
2255 | { | |
2256 | set_value_range_to_varying (vr); | |
2257 | return; | |
2258 | } | |
2259 | ||
0bca51f0 DN |
2260 | /* Apply the operation to each end of the range and see what we end |
2261 | up with. */ | |
227858d1 DN |
2262 | if (code == NEGATE_EXPR |
2263 | && !TYPE_UNSIGNED (TREE_TYPE (expr))) | |
2264 | { | |
96b2034b | 2265 | /* NEGATE_EXPR flips the range around. We need to treat |
12df8a7e ILT |
2266 | TYPE_MIN_VALUE specially. */ |
2267 | if (is_positive_overflow_infinity (vr0.max)) | |
2268 | min = negative_overflow_infinity (TREE_TYPE (expr)); | |
2269 | else if (is_negative_overflow_infinity (vr0.max)) | |
2270 | min = positive_overflow_infinity (TREE_TYPE (expr)); | |
e1f28918 | 2271 | else if (!vrp_val_is_min (vr0.max)) |
12df8a7e ILT |
2272 | min = fold_unary_to_constant (code, TREE_TYPE (expr), vr0.max); |
2273 | else if (needs_overflow_infinity (TREE_TYPE (expr))) | |
2274 | { | |
8cf781f0 ILT |
2275 | if (supports_overflow_infinity (TREE_TYPE (expr)) |
2276 | && !is_overflow_infinity (vr0.min) | |
e1f28918 | 2277 | && !vrp_val_is_min (vr0.min)) |
12df8a7e ILT |
2278 | min = positive_overflow_infinity (TREE_TYPE (expr)); |
2279 | else | |
2280 | { | |
2281 | set_value_range_to_varying (vr); | |
2282 | return; | |
2283 | } | |
2284 | } | |
2285 | else | |
2286 | min = TYPE_MIN_VALUE (TREE_TYPE (expr)); | |
2287 | ||
2288 | if (is_positive_overflow_infinity (vr0.min)) | |
2289 | max = negative_overflow_infinity (TREE_TYPE (expr)); | |
2290 | else if (is_negative_overflow_infinity (vr0.min)) | |
2291 | max = positive_overflow_infinity (TREE_TYPE (expr)); | |
e1f28918 | 2292 | else if (!vrp_val_is_min (vr0.min)) |
12df8a7e ILT |
2293 | max = fold_unary_to_constant (code, TREE_TYPE (expr), vr0.min); |
2294 | else if (needs_overflow_infinity (TREE_TYPE (expr))) | |
2295 | { | |
2296 | if (supports_overflow_infinity (TREE_TYPE (expr))) | |
2297 | max = positive_overflow_infinity (TREE_TYPE (expr)); | |
2298 | else | |
2299 | { | |
2300 | set_value_range_to_varying (vr); | |
2301 | return; | |
2302 | } | |
2303 | } | |
2304 | else | |
2305 | max = TYPE_MIN_VALUE (TREE_TYPE (expr)); | |
c1a70a3c RS |
2306 | } |
2307 | else if (code == NEGATE_EXPR | |
2308 | && TYPE_UNSIGNED (TREE_TYPE (expr))) | |
2309 | { | |
2310 | if (!range_includes_zero_p (&vr0)) | |
2311 | { | |
2312 | max = fold_unary_to_constant (code, TREE_TYPE (expr), vr0.min); | |
2313 | min = fold_unary_to_constant (code, TREE_TYPE (expr), vr0.max); | |
2314 | } | |
2315 | else | |
2316 | { | |
2317 | if (range_is_null (&vr0)) | |
2318 | set_value_range_to_null (vr, TREE_TYPE (expr)); | |
2319 | else | |
2320 | set_value_range_to_varying (vr); | |
2321 | return; | |
2322 | } | |
227858d1 DN |
2323 | } |
2324 | else if (code == ABS_EXPR | |
2325 | && !TYPE_UNSIGNED (TREE_TYPE (expr))) | |
2326 | { | |
ff08cbee JM |
2327 | /* -TYPE_MIN_VALUE = TYPE_MIN_VALUE with flag_wrapv so we can't get a |
2328 | useful range. */ | |
eeef0e45 | 2329 | if (!TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (expr)) |
ff08cbee | 2330 | && ((vr0.type == VR_RANGE |
e1f28918 | 2331 | && vrp_val_is_min (vr0.min)) |
ff08cbee | 2332 | || (vr0.type == VR_ANTI_RANGE |
e1f28918 | 2333 | && !vrp_val_is_min (vr0.min) |
ff08cbee JM |
2334 | && !range_includes_zero_p (&vr0)))) |
2335 | { | |
2336 | set_value_range_to_varying (vr); | |
2337 | return; | |
2338 | } | |
2339 | ||
227858d1 DN |
2340 | /* ABS_EXPR may flip the range around, if the original range |
2341 | included negative values. */ | |
12df8a7e ILT |
2342 | if (is_overflow_infinity (vr0.min)) |
2343 | min = positive_overflow_infinity (TREE_TYPE (expr)); | |
e1f28918 | 2344 | else if (!vrp_val_is_min (vr0.min)) |
12df8a7e ILT |
2345 | min = fold_unary_to_constant (code, TREE_TYPE (expr), vr0.min); |
2346 | else if (!needs_overflow_infinity (TREE_TYPE (expr))) | |
2347 | min = TYPE_MAX_VALUE (TREE_TYPE (expr)); | |
2348 | else if (supports_overflow_infinity (TREE_TYPE (expr))) | |
2349 | min = positive_overflow_infinity (TREE_TYPE (expr)); | |
2350 | else | |
2351 | { | |
2352 | set_value_range_to_varying (vr); | |
2353 | return; | |
2354 | } | |
227858d1 | 2355 | |
12df8a7e ILT |
2356 | if (is_overflow_infinity (vr0.max)) |
2357 | max = positive_overflow_infinity (TREE_TYPE (expr)); | |
e1f28918 | 2358 | else if (!vrp_val_is_min (vr0.max)) |
12df8a7e ILT |
2359 | max = fold_unary_to_constant (code, TREE_TYPE (expr), vr0.max); |
2360 | else if (!needs_overflow_infinity (TREE_TYPE (expr))) | |
2361 | max = TYPE_MAX_VALUE (TREE_TYPE (expr)); | |
2362 | else if (supports_overflow_infinity (TREE_TYPE (expr))) | |
2363 | max = positive_overflow_infinity (TREE_TYPE (expr)); | |
2364 | else | |
2365 | { | |
2366 | set_value_range_to_varying (vr); | |
2367 | return; | |
2368 | } | |
227858d1 | 2369 | |
ff08cbee JM |
2370 | cmp = compare_values (min, max); |
2371 | ||
2372 | /* If a VR_ANTI_RANGEs contains zero, then we have | |
2373 | ~[-INF, min(MIN, MAX)]. */ | |
2374 | if (vr0.type == VR_ANTI_RANGE) | |
2375 | { | |
2376 | if (range_includes_zero_p (&vr0)) | |
2377 | { | |
ff08cbee JM |
2378 | /* Take the lower of the two values. */ |
2379 | if (cmp != 1) | |
2380 | max = min; | |
2381 | ||
2382 | /* Create ~[-INF, min (abs(MIN), abs(MAX))] | |
2383 | or ~[-INF + 1, min (abs(MIN), abs(MAX))] when | |
2384 | flag_wrapv is set and the original anti-range doesn't include | |
2385 | TYPE_MIN_VALUE, remember -TYPE_MIN_VALUE = TYPE_MIN_VALUE. */ | |
12df8a7e ILT |
2386 | if (TYPE_OVERFLOW_WRAPS (TREE_TYPE (expr))) |
2387 | { | |
2388 | tree type_min_value = TYPE_MIN_VALUE (TREE_TYPE (expr)); | |
2389 | ||
2390 | min = (vr0.min != type_min_value | |
2391 | ? int_const_binop (PLUS_EXPR, type_min_value, | |
2392 | integer_one_node, 0) | |
2393 | : type_min_value); | |
2394 | } | |
2395 | else | |
2396 | { | |
2397 | if (overflow_infinity_range_p (&vr0)) | |
2398 | min = negative_overflow_infinity (TREE_TYPE (expr)); | |
2399 | else | |
2400 | min = TYPE_MIN_VALUE (TREE_TYPE (expr)); | |
2401 | } | |
ff08cbee JM |
2402 | } |
2403 | else | |
2404 | { | |
2405 | /* All else has failed, so create the range [0, INF], even for | |
2406 | flag_wrapv since TYPE_MIN_VALUE is in the original | |
2407 | anti-range. */ | |
2408 | vr0.type = VR_RANGE; | |
2409 | min = build_int_cst (TREE_TYPE (expr), 0); | |
12df8a7e ILT |
2410 | if (needs_overflow_infinity (TREE_TYPE (expr))) |
2411 | { | |
2412 | if (supports_overflow_infinity (TREE_TYPE (expr))) | |
2413 | max = positive_overflow_infinity (TREE_TYPE (expr)); | |
2414 | else | |
2415 | { | |
2416 | set_value_range_to_varying (vr); | |
2417 | return; | |
2418 | } | |
2419 | } | |
2420 | else | |
2421 | max = TYPE_MAX_VALUE (TREE_TYPE (expr)); | |
ff08cbee JM |
2422 | } |
2423 | } | |
2424 | ||
2425 | /* If the range contains zero then we know that the minimum value in the | |
2426 | range will be zero. */ | |
2427 | else if (range_includes_zero_p (&vr0)) | |
2428 | { | |
2429 | if (cmp == 1) | |
2430 | max = min; | |
2431 | min = build_int_cst (TREE_TYPE (expr), 0); | |
2432 | } | |
2433 | else | |
227858d1 | 2434 | { |
ff08cbee JM |
2435 | /* If the range was reversed, swap MIN and MAX. */ |
2436 | if (cmp == 1) | |
2437 | { | |
2438 | tree t = min; | |
2439 | min = max; | |
2440 | max = t; | |
2441 | } | |
227858d1 DN |
2442 | } |
2443 | } | |
2444 | else | |
2445 | { | |
2446 | /* Otherwise, operate on each end of the range. */ | |
2447 | min = fold_unary_to_constant (code, TREE_TYPE (expr), vr0.min); | |
2448 | max = fold_unary_to_constant (code, TREE_TYPE (expr), vr0.max); | |
12df8a7e ILT |
2449 | |
2450 | if (needs_overflow_infinity (TREE_TYPE (expr))) | |
2451 | { | |
2452 | gcc_assert (code != NEGATE_EXPR && code != ABS_EXPR); | |
8cf781f0 ILT |
2453 | |
2454 | /* If both sides have overflowed, we don't know | |
2455 | anything. */ | |
2456 | if ((is_overflow_infinity (vr0.min) | |
2457 | || TREE_OVERFLOW (min)) | |
2458 | && (is_overflow_infinity (vr0.max) | |
2459 | || TREE_OVERFLOW (max))) | |
2460 | { | |
2461 | set_value_range_to_varying (vr); | |
2462 | return; | |
2463 | } | |
2464 | ||
12df8a7e ILT |
2465 | if (is_overflow_infinity (vr0.min)) |
2466 | min = vr0.min; | |
2467 | else if (TREE_OVERFLOW (min)) | |
2468 | { | |
2469 | if (supports_overflow_infinity (TREE_TYPE (expr))) | |
2470 | min = (tree_int_cst_sgn (min) >= 0 | |
2471 | ? positive_overflow_infinity (TREE_TYPE (min)) | |
2472 | : negative_overflow_infinity (TREE_TYPE (min))); | |
2473 | else | |
2474 | { | |
2475 | set_value_range_to_varying (vr); | |
2476 | return; | |
2477 | } | |
2478 | } | |
2479 | ||
2480 | if (is_overflow_infinity (vr0.max)) | |
2481 | max = vr0.max; | |
2482 | else if (TREE_OVERFLOW (max)) | |
2483 | { | |
2484 | if (supports_overflow_infinity (TREE_TYPE (expr))) | |
2485 | max = (tree_int_cst_sgn (max) >= 0 | |
2486 | ? positive_overflow_infinity (TREE_TYPE (max)) | |
2487 | : negative_overflow_infinity (TREE_TYPE (max))); | |
2488 | else | |
2489 | { | |
2490 | set_value_range_to_varying (vr); | |
2491 | return; | |
2492 | } | |
2493 | } | |
2494 | } | |
227858d1 | 2495 | } |
0bca51f0 DN |
2496 | |
2497 | cmp = compare_values (min, max); | |
2498 | if (cmp == -2 || cmp == 1) | |
2499 | { | |
2500 | /* If the new range has its limits swapped around (MIN > MAX), | |
2501 | then the operation caused one of them to wrap around, mark | |
2502 | the new range VARYING. */ | |
b565d777 | 2503 | set_value_range_to_varying (vr); |
0bca51f0 DN |
2504 | } |
2505 | else | |
227858d1 DN |
2506 | set_value_range (vr, vr0.type, min, max, NULL); |
2507 | } | |
2508 | ||
2509 | ||
f255541f RC |
2510 | /* Extract range information from a conditional expression EXPR based on |
2511 | the ranges of each of its operands and the expression code. */ | |
2512 | ||
2513 | static void | |
2514 | extract_range_from_cond_expr (value_range_t *vr, tree expr) | |
2515 | { | |
2516 | tree op0, op1; | |
2517 | value_range_t vr0 = { VR_UNDEFINED, NULL_TREE, NULL_TREE, NULL }; | |
2518 | value_range_t vr1 = { VR_UNDEFINED, NULL_TREE, NULL_TREE, NULL }; | |
2519 | ||
2520 | /* Get value ranges for each operand. For constant operands, create | |
2521 | a new value range with the operand to simplify processing. */ | |
2522 | op0 = COND_EXPR_THEN (expr); | |
2523 | if (TREE_CODE (op0) == SSA_NAME) | |
2524 | vr0 = *(get_value_range (op0)); | |
2525 | else if (is_gimple_min_invariant (op0)) | |
b60b4711 | 2526 | set_value_range_to_value (&vr0, op0, NULL); |
f255541f RC |
2527 | else |
2528 | set_value_range_to_varying (&vr0); | |
2529 | ||
2530 | op1 = COND_EXPR_ELSE (expr); | |
2531 | if (TREE_CODE (op1) == SSA_NAME) | |
2532 | vr1 = *(get_value_range (op1)); | |
2533 | else if (is_gimple_min_invariant (op1)) | |
b60b4711 | 2534 | set_value_range_to_value (&vr1, op1, NULL); |
f255541f RC |
2535 | else |
2536 | set_value_range_to_varying (&vr1); | |
2537 | ||
2538 | /* The resulting value range is the union of the operand ranges */ | |
2539 | vrp_meet (&vr0, &vr1); | |
2540 | copy_value_range (vr, &vr0); | |
2541 | } | |
2542 | ||
2543 | ||
227858d1 DN |
2544 | /* Extract range information from a comparison expression EXPR based |
2545 | on the range of its operand and the expression code. */ | |
2546 | ||
2547 | static void | |
2548 | extract_range_from_comparison (value_range_t *vr, tree expr) | |
2549 | { | |
12df8a7e | 2550 | bool sop = false; |
0c948c27 | 2551 | tree val = vrp_evaluate_conditional_warnv (expr, false, &sop); |
12df8a7e ILT |
2552 | |
2553 | /* A disadvantage of using a special infinity as an overflow | |
2554 | representation is that we lose the ability to record overflow | |
2555 | when we don't have an infinity. So we have to ignore a result | |
2556 | which relies on overflow. */ | |
2557 | ||
2558 | if (val && !is_overflow_infinity (val) && !sop) | |
227858d1 DN |
2559 | { |
2560 | /* Since this expression was found on the RHS of an assignment, | |
2561 | its type may be different from _Bool. Convert VAL to EXPR's | |
2562 | type. */ | |
2563 | val = fold_convert (TREE_TYPE (expr), val); | |
b60b4711 ILT |
2564 | if (is_gimple_min_invariant (val)) |
2565 | set_value_range_to_value (vr, val, vr->equiv); | |
2566 | else | |
2567 | set_value_range (vr, VR_RANGE, val, val, vr->equiv); | |
227858d1 DN |
2568 | } |
2569 | else | |
31ab1cc9 RG |
2570 | /* The result of a comparison is always true or false. */ |
2571 | set_value_range_to_truthvalue (vr, TREE_TYPE (expr)); | |
0bca51f0 DN |
2572 | } |
2573 | ||
2574 | ||
2575 | /* Try to compute a useful range out of expression EXPR and store it | |
227858d1 | 2576 | in *VR. */ |
0bca51f0 DN |
2577 | |
2578 | static void | |
227858d1 | 2579 | extract_range_from_expr (value_range_t *vr, tree expr) |
0bca51f0 DN |
2580 | { |
2581 | enum tree_code code = TREE_CODE (expr); | |
2582 | ||
2583 | if (code == ASSERT_EXPR) | |
2584 | extract_range_from_assert (vr, expr); | |
2585 | else if (code == SSA_NAME) | |
2586 | extract_range_from_ssa_name (vr, expr); | |
227858d1 DN |
2587 | else if (TREE_CODE_CLASS (code) == tcc_binary |
2588 | || code == TRUTH_ANDIF_EXPR | |
2589 | || code == TRUTH_ORIF_EXPR | |
2590 | || code == TRUTH_AND_EXPR | |
2591 | || code == TRUTH_OR_EXPR | |
2592 | || code == TRUTH_XOR_EXPR) | |
0bca51f0 DN |
2593 | extract_range_from_binary_expr (vr, expr); |
2594 | else if (TREE_CODE_CLASS (code) == tcc_unary) | |
2595 | extract_range_from_unary_expr (vr, expr); | |
f255541f RC |
2596 | else if (code == COND_EXPR) |
2597 | extract_range_from_cond_expr (vr, expr); | |
227858d1 DN |
2598 | else if (TREE_CODE_CLASS (code) == tcc_comparison) |
2599 | extract_range_from_comparison (vr, expr); | |
227858d1 | 2600 | else if (is_gimple_min_invariant (expr)) |
b60b4711 | 2601 | set_value_range_to_value (vr, expr, NULL); |
0bca51f0 | 2602 | else |
b565d777 | 2603 | set_value_range_to_varying (vr); |
b16caf72 JL |
2604 | |
2605 | /* If we got a varying range from the tests above, try a final | |
2606 | time to derive a nonnegative or nonzero range. This time | |
2607 | relying primarily on generic routines in fold in conjunction | |
2608 | with range data. */ | |
2609 | if (vr->type == VR_VARYING) | |
2610 | { | |
12df8a7e ILT |
2611 | bool sop = false; |
2612 | ||
b16caf72 | 2613 | if (INTEGRAL_TYPE_P (TREE_TYPE (expr)) |
12df8a7e ILT |
2614 | && vrp_expr_computes_nonnegative (expr, &sop)) |
2615 | set_value_range_to_nonnegative (vr, TREE_TYPE (expr), | |
2616 | sop || is_overflow_infinity (expr)); | |
2617 | else if (vrp_expr_computes_nonzero (expr, &sop) | |
2618 | && !sop) | |
b16caf72 JL |
2619 | set_value_range_to_nonnull (vr, TREE_TYPE (expr)); |
2620 | } | |
0bca51f0 DN |
2621 | } |
2622 | ||
1e8552eb | 2623 | /* Given a range VR, a LOOP and a variable VAR, determine whether it |
0bca51f0 DN |
2624 | would be profitable to adjust VR using scalar evolution information |
2625 | for VAR. If so, update VR with the new limits. */ | |
2626 | ||
2627 | static void | |
1e8552eb SP |
2628 | adjust_range_with_scev (value_range_t *vr, struct loop *loop, tree stmt, |
2629 | tree var) | |
0bca51f0 | 2630 | { |
20527215 | 2631 | tree init, step, chrec, tmin, tmax, min, max, type; |
d7f5de76 | 2632 | enum ev_direction dir; |
0bca51f0 DN |
2633 | |
2634 | /* TODO. Don't adjust anti-ranges. An anti-range may provide | |
2635 | better opportunities than a regular range, but I'm not sure. */ | |
2636 | if (vr->type == VR_ANTI_RANGE) | |
2637 | return; | |
2638 | ||
13285d51 ZD |
2639 | /* Ensure that there are not values in the scev cache based on assumptions |
2640 | on ranges of ssa names that were changed | |
2641 | (in set_value_range/set_value_range_to_varying). Preserve cached numbers | |
2642 | of iterations, that were computed before the start of VRP (we do not | |
2643 | recompute these each time to save the compile time). */ | |
2644 | scev_reset_except_niters (); | |
2645 | ||
d7770457 | 2646 | chrec = instantiate_parameters (loop, analyze_scalar_evolution (loop, var)); |
6f1c9cd0 SP |
2647 | |
2648 | /* Like in PR19590, scev can return a constant function. */ | |
2649 | if (is_gimple_min_invariant (chrec)) | |
2650 | { | |
cdc64612 | 2651 | set_value_range_to_value (vr, chrec, vr->equiv); |
6f1c9cd0 SP |
2652 | return; |
2653 | } | |
2654 | ||
0bca51f0 DN |
2655 | if (TREE_CODE (chrec) != POLYNOMIAL_CHREC) |
2656 | return; | |
2657 | ||
d7770457 SP |
2658 | init = initial_condition_in_loop_num (chrec, loop->num); |
2659 | step = evolution_part_in_loop_num (chrec, loop->num); | |
0bca51f0 DN |
2660 | |
2661 | /* If STEP is symbolic, we can't know whether INIT will be the | |
04dce5a4 ZD |
2662 | minimum or maximum value in the range. Also, unless INIT is |
2663 | a simple expression, compare_values and possibly other functions | |
2664 | in tree-vrp won't be able to handle it. */ | |
d7770457 | 2665 | if (step == NULL_TREE |
04dce5a4 ZD |
2666 | || !is_gimple_min_invariant (step) |
2667 | || !valid_value_p (init)) | |
0bca51f0 DN |
2668 | return; |
2669 | ||
d7f5de76 ZD |
2670 | dir = scev_direction (chrec); |
2671 | if (/* Do not adjust ranges if we do not know whether the iv increases | |
2672 | or decreases, ... */ | |
2673 | dir == EV_DIR_UNKNOWN | |
2674 | /* ... or if it may wrap. */ | |
42fd6772 | 2675 | || scev_probably_wraps_p (init, step, stmt, get_chrec_loop (chrec), |
d7f5de76 | 2676 | true)) |
227858d1 DN |
2677 | return; |
2678 | ||
12df8a7e ILT |
2679 | /* We use TYPE_MIN_VALUE and TYPE_MAX_VALUE here instead of |
2680 | negative_overflow_infinity and positive_overflow_infinity, | |
2681 | because we have concluded that the loop probably does not | |
2682 | wrap. */ | |
2683 | ||
20527215 ZD |
2684 | type = TREE_TYPE (var); |
2685 | if (POINTER_TYPE_P (type) || !TYPE_MIN_VALUE (type)) | |
2686 | tmin = lower_bound_in_type (type, type); | |
2687 | else | |
2688 | tmin = TYPE_MIN_VALUE (type); | |
2689 | if (POINTER_TYPE_P (type) || !TYPE_MAX_VALUE (type)) | |
2690 | tmax = upper_bound_in_type (type, type); | |
2691 | else | |
2692 | tmax = TYPE_MAX_VALUE (type); | |
2693 | ||
2694 | if (vr->type == VR_VARYING || vr->type == VR_UNDEFINED) | |
0bca51f0 | 2695 | { |
20527215 ZD |
2696 | min = tmin; |
2697 | max = tmax; | |
2698 | ||
0bca51f0 DN |
2699 | /* For VARYING or UNDEFINED ranges, just about anything we get |
2700 | from scalar evolutions should be better. */ | |
4f67dfcf | 2701 | |
d7f5de76 | 2702 | if (dir == EV_DIR_DECREASES) |
4f67dfcf | 2703 | max = init; |
0bca51f0 | 2704 | else |
4f67dfcf JL |
2705 | min = init; |
2706 | ||
2707 | /* If we would create an invalid range, then just assume we | |
2708 | know absolutely nothing. This may be over-conservative, | |
20527215 ZD |
2709 | but it's clearly safe, and should happen only in unreachable |
2710 | parts of code, or for invalid programs. */ | |
4f67dfcf JL |
2711 | if (compare_values (min, max) == 1) |
2712 | return; | |
2713 | ||
2714 | set_value_range (vr, VR_RANGE, min, max, vr->equiv); | |
0bca51f0 DN |
2715 | } |
2716 | else if (vr->type == VR_RANGE) | |
2717 | { | |
20527215 ZD |
2718 | min = vr->min; |
2719 | max = vr->max; | |
d5448566 | 2720 | |
d7f5de76 | 2721 | if (dir == EV_DIR_DECREASES) |
0bca51f0 | 2722 | { |
d5448566 KH |
2723 | /* INIT is the maximum value. If INIT is lower than VR->MAX |
2724 | but no smaller than VR->MIN, set VR->MAX to INIT. */ | |
2725 | if (compare_values (init, max) == -1) | |
2726 | { | |
2727 | max = init; | |
2728 | ||
2729 | /* If we just created an invalid range with the minimum | |
20527215 ZD |
2730 | greater than the maximum, we fail conservatively. |
2731 | This should happen only in unreachable | |
2732 | parts of code, or for invalid programs. */ | |
d5448566 | 2733 | if (compare_values (min, max) == 1) |
20527215 | 2734 | return; |
d5448566 | 2735 | } |
9a46cc16 ILT |
2736 | |
2737 | /* According to the loop information, the variable does not | |
2738 | overflow. If we think it does, probably because of an | |
2739 | overflow due to arithmetic on a different INF value, | |
2740 | reset now. */ | |
2741 | if (is_negative_overflow_infinity (min)) | |
2742 | min = tmin; | |
0bca51f0 DN |
2743 | } |
2744 | else | |
2745 | { | |
2746 | /* If INIT is bigger than VR->MIN, set VR->MIN to INIT. */ | |
d5448566 KH |
2747 | if (compare_values (init, min) == 1) |
2748 | { | |
2749 | min = init; | |
2750 | ||
20527215 | 2751 | /* Again, avoid creating invalid range by failing. */ |
d5448566 | 2752 | if (compare_values (min, max) == 1) |
20527215 | 2753 | return; |
d5448566 | 2754 | } |
9a46cc16 ILT |
2755 | |
2756 | if (is_positive_overflow_infinity (max)) | |
2757 | max = tmax; | |
0bca51f0 | 2758 | } |
d5448566 | 2759 | |
227858d1 | 2760 | set_value_range (vr, VR_RANGE, min, max, vr->equiv); |
0bca51f0 DN |
2761 | } |
2762 | } | |
2763 | ||
9a46cc16 ILT |
2764 | /* Return true if VAR may overflow at STMT. This checks any available |
2765 | loop information to see if we can determine that VAR does not | |
2766 | overflow. */ | |
2767 | ||
2768 | static bool | |
2769 | vrp_var_may_overflow (tree var, tree stmt) | |
2770 | { | |
2771 | struct loop *l; | |
2772 | tree chrec, init, step; | |
2773 | ||
2774 | if (current_loops == NULL) | |
2775 | return true; | |
2776 | ||
2777 | l = loop_containing_stmt (stmt); | |
2778 | if (l == NULL) | |
2779 | return true; | |
2780 | ||
2781 | chrec = instantiate_parameters (l, analyze_scalar_evolution (l, var)); | |
2782 | if (TREE_CODE (chrec) != POLYNOMIAL_CHREC) | |
2783 | return true; | |
2784 | ||
2785 | init = initial_condition_in_loop_num (chrec, l->num); | |
2786 | step = evolution_part_in_loop_num (chrec, l->num); | |
2787 | ||
2788 | if (step == NULL_TREE | |
2789 | || !is_gimple_min_invariant (step) | |
2790 | || !valid_value_p (init)) | |
2791 | return true; | |
2792 | ||
2793 | /* If we get here, we know something useful about VAR based on the | |
2794 | loop information. If it wraps, it may overflow. */ | |
2795 | ||
2796 | if (scev_probably_wraps_p (init, step, stmt, get_chrec_loop (chrec), | |
2797 | true)) | |
2798 | return true; | |
2799 | ||
2800 | if (dump_file && (dump_flags & TDF_DETAILS) != 0) | |
2801 | { | |
2802 | print_generic_expr (dump_file, var, 0); | |
2803 | fprintf (dump_file, ": loop information indicates does not overflow\n"); | |
2804 | } | |
2805 | ||
2806 | return false; | |
2807 | } | |
2808 | ||
0bca51f0 DN |
2809 | |
2810 | /* Given two numeric value ranges VR0, VR1 and a comparison code COMP: | |
2811 | ||
227858d1 DN |
2812 | - Return BOOLEAN_TRUE_NODE if VR0 COMP VR1 always returns true for |
2813 | all the values in the ranges. | |
0bca51f0 DN |
2814 | |
2815 | - Return BOOLEAN_FALSE_NODE if the comparison always returns false. | |
2816 | ||
227858d1 | 2817 | - Return NULL_TREE if it is not always possible to determine the |
12df8a7e ILT |
2818 | value of the comparison. |
2819 | ||
2820 | Also set *STRICT_OVERFLOW_P to indicate whether a range with an | |
2821 | overflow infinity was used in the test. */ | |
227858d1 | 2822 | |
0bca51f0 DN |
2823 | |
2824 | static tree | |
12df8a7e ILT |
2825 | compare_ranges (enum tree_code comp, value_range_t *vr0, value_range_t *vr1, |
2826 | bool *strict_overflow_p) | |
0bca51f0 DN |
2827 | { |
2828 | /* VARYING or UNDEFINED ranges cannot be compared. */ | |
2829 | if (vr0->type == VR_VARYING | |
2830 | || vr0->type == VR_UNDEFINED | |
2831 | || vr1->type == VR_VARYING | |
2832 | || vr1->type == VR_UNDEFINED) | |
2833 | return NULL_TREE; | |
2834 | ||
2835 | /* Anti-ranges need to be handled separately. */ | |
2836 | if (vr0->type == VR_ANTI_RANGE || vr1->type == VR_ANTI_RANGE) | |
2837 | { | |
2838 | /* If both are anti-ranges, then we cannot compute any | |
2839 | comparison. */ | |
2840 | if (vr0->type == VR_ANTI_RANGE && vr1->type == VR_ANTI_RANGE) | |
2841 | return NULL_TREE; | |
2842 | ||
2843 | /* These comparisons are never statically computable. */ | |
2844 | if (comp == GT_EXPR | |
2845 | || comp == GE_EXPR | |
2846 | || comp == LT_EXPR | |
2847 | || comp == LE_EXPR) | |
2848 | return NULL_TREE; | |
2849 | ||
2850 | /* Equality can be computed only between a range and an | |
2851 | anti-range. ~[VAL1, VAL2] == [VAL1, VAL2] is always false. */ | |
2852 | if (vr0->type == VR_RANGE) | |
2853 | { | |
2854 | /* To simplify processing, make VR0 the anti-range. */ | |
227858d1 | 2855 | value_range_t *tmp = vr0; |
0bca51f0 DN |
2856 | vr0 = vr1; |
2857 | vr1 = tmp; | |
2858 | } | |
2859 | ||
2860 | gcc_assert (comp == NE_EXPR || comp == EQ_EXPR); | |
2861 | ||
12df8a7e ILT |
2862 | if (compare_values_warnv (vr0->min, vr1->min, strict_overflow_p) == 0 |
2863 | && compare_values_warnv (vr0->max, vr1->max, strict_overflow_p) == 0) | |
0bca51f0 DN |
2864 | return (comp == NE_EXPR) ? boolean_true_node : boolean_false_node; |
2865 | ||
2866 | return NULL_TREE; | |
2867 | } | |
2868 | ||
0c948c27 ILT |
2869 | if (!usable_range_p (vr0, strict_overflow_p) |
2870 | || !usable_range_p (vr1, strict_overflow_p)) | |
2871 | return NULL_TREE; | |
2872 | ||
0bca51f0 DN |
2873 | /* Simplify processing. If COMP is GT_EXPR or GE_EXPR, switch the |
2874 | operands around and change the comparison code. */ | |
2875 | if (comp == GT_EXPR || comp == GE_EXPR) | |
2876 | { | |
227858d1 | 2877 | value_range_t *tmp; |
0bca51f0 DN |
2878 | comp = (comp == GT_EXPR) ? LT_EXPR : LE_EXPR; |
2879 | tmp = vr0; | |
2880 | vr0 = vr1; | |
2881 | vr1 = tmp; | |
2882 | } | |
2883 | ||
2884 | if (comp == EQ_EXPR) | |
2885 | { | |
2886 | /* Equality may only be computed if both ranges represent | |
2887 | exactly one value. */ | |
12df8a7e ILT |
2888 | if (compare_values_warnv (vr0->min, vr0->max, strict_overflow_p) == 0 |
2889 | && compare_values_warnv (vr1->min, vr1->max, strict_overflow_p) == 0) | |
0bca51f0 | 2890 | { |
12df8a7e ILT |
2891 | int cmp_min = compare_values_warnv (vr0->min, vr1->min, |
2892 | strict_overflow_p); | |
2893 | int cmp_max = compare_values_warnv (vr0->max, vr1->max, | |
2894 | strict_overflow_p); | |
0bca51f0 DN |
2895 | if (cmp_min == 0 && cmp_max == 0) |
2896 | return boolean_true_node; | |
2897 | else if (cmp_min != -2 && cmp_max != -2) | |
2898 | return boolean_false_node; | |
2899 | } | |
7ab1122a | 2900 | /* If [V0_MIN, V1_MAX] < [V1_MIN, V1_MAX] then V0 != V1. */ |
12df8a7e ILT |
2901 | else if (compare_values_warnv (vr0->min, vr1->max, |
2902 | strict_overflow_p) == 1 | |
2903 | || compare_values_warnv (vr1->min, vr0->max, | |
2904 | strict_overflow_p) == 1) | |
7ab1122a | 2905 | return boolean_false_node; |
0bca51f0 DN |
2906 | |
2907 | return NULL_TREE; | |
2908 | } | |
2909 | else if (comp == NE_EXPR) | |
2910 | { | |
2911 | int cmp1, cmp2; | |
2912 | ||
2913 | /* If VR0 is completely to the left or completely to the right | |
2914 | of VR1, they are always different. Notice that we need to | |
2915 | make sure that both comparisons yield similar results to | |
2916 | avoid comparing values that cannot be compared at | |
2917 | compile-time. */ | |
12df8a7e ILT |
2918 | cmp1 = compare_values_warnv (vr0->max, vr1->min, strict_overflow_p); |
2919 | cmp2 = compare_values_warnv (vr0->min, vr1->max, strict_overflow_p); | |
0bca51f0 DN |
2920 | if ((cmp1 == -1 && cmp2 == -1) || (cmp1 == 1 && cmp2 == 1)) |
2921 | return boolean_true_node; | |
2922 | ||
2923 | /* If VR0 and VR1 represent a single value and are identical, | |
2924 | return false. */ | |
12df8a7e ILT |
2925 | else if (compare_values_warnv (vr0->min, vr0->max, |
2926 | strict_overflow_p) == 0 | |
2927 | && compare_values_warnv (vr1->min, vr1->max, | |
2928 | strict_overflow_p) == 0 | |
2929 | && compare_values_warnv (vr0->min, vr1->min, | |
2930 | strict_overflow_p) == 0 | |
2931 | && compare_values_warnv (vr0->max, vr1->max, | |
2932 | strict_overflow_p) == 0) | |
0bca51f0 DN |
2933 | return boolean_false_node; |
2934 | ||
2935 | /* Otherwise, they may or may not be different. */ | |
2936 | else | |
2937 | return NULL_TREE; | |
2938 | } | |
2939 | else if (comp == LT_EXPR || comp == LE_EXPR) | |
2940 | { | |
2941 | int tst; | |
2942 | ||
2943 | /* If VR0 is to the left of VR1, return true. */ | |
12df8a7e | 2944 | tst = compare_values_warnv (vr0->max, vr1->min, strict_overflow_p); |
0bca51f0 DN |
2945 | if ((comp == LT_EXPR && tst == -1) |
2946 | || (comp == LE_EXPR && (tst == -1 || tst == 0))) | |
12df8a7e ILT |
2947 | { |
2948 | if (overflow_infinity_range_p (vr0) | |
2949 | || overflow_infinity_range_p (vr1)) | |
2950 | *strict_overflow_p = true; | |
2951 | return boolean_true_node; | |
2952 | } | |
0bca51f0 DN |
2953 | |
2954 | /* If VR0 is to the right of VR1, return false. */ | |
12df8a7e | 2955 | tst = compare_values_warnv (vr0->min, vr1->max, strict_overflow_p); |
0bca51f0 DN |
2956 | if ((comp == LT_EXPR && (tst == 0 || tst == 1)) |
2957 | || (comp == LE_EXPR && tst == 1)) | |
12df8a7e ILT |
2958 | { |
2959 | if (overflow_infinity_range_p (vr0) | |
2960 | || overflow_infinity_range_p (vr1)) | |
2961 | *strict_overflow_p = true; | |
2962 | return boolean_false_node; | |
2963 | } | |
0bca51f0 DN |
2964 | |
2965 | /* Otherwise, we don't know. */ | |
2966 | return NULL_TREE; | |
2967 | } | |
2968 | ||
2969 | gcc_unreachable (); | |
2970 | } | |
2971 | ||
2972 | ||
2973 | /* Given a value range VR, a value VAL and a comparison code COMP, return | |
227858d1 | 2974 | BOOLEAN_TRUE_NODE if VR COMP VAL always returns true for all the |
0bca51f0 DN |
2975 | values in VR. Return BOOLEAN_FALSE_NODE if the comparison |
2976 | always returns false. Return NULL_TREE if it is not always | |
12df8a7e ILT |
2977 | possible to determine the value of the comparison. Also set |
2978 | *STRICT_OVERFLOW_P to indicate whether a range with an overflow | |
2979 | infinity was used in the test. */ | |
0bca51f0 DN |
2980 | |
2981 | static tree | |
12df8a7e ILT |
2982 | compare_range_with_value (enum tree_code comp, value_range_t *vr, tree val, |
2983 | bool *strict_overflow_p) | |
0bca51f0 DN |
2984 | { |
2985 | if (vr->type == VR_VARYING || vr->type == VR_UNDEFINED) | |
2986 | return NULL_TREE; | |
2987 | ||
2988 | /* Anti-ranges need to be handled separately. */ | |
2989 | if (vr->type == VR_ANTI_RANGE) | |
2990 | { | |
2991 | /* For anti-ranges, the only predicates that we can compute at | |
2992 | compile time are equality and inequality. */ | |
2993 | if (comp == GT_EXPR | |
2994 | || comp == GE_EXPR | |
2995 | || comp == LT_EXPR | |
2996 | || comp == LE_EXPR) | |
2997 | return NULL_TREE; | |
2998 | ||
d2f3ffba JM |
2999 | /* ~[VAL_1, VAL_2] OP VAL is known if VAL_1 <= VAL <= VAL_2. */ |
3000 | if (value_inside_range (val, vr) == 1) | |
0bca51f0 DN |
3001 | return (comp == NE_EXPR) ? boolean_true_node : boolean_false_node; |
3002 | ||
3003 | return NULL_TREE; | |
3004 | } | |
3005 | ||
0c948c27 ILT |
3006 | if (!usable_range_p (vr, strict_overflow_p)) |
3007 | return NULL_TREE; | |
3008 | ||
0bca51f0 DN |
3009 | if (comp == EQ_EXPR) |
3010 | { | |
3011 | /* EQ_EXPR may only be computed if VR represents exactly | |
3012 | one value. */ | |
12df8a7e | 3013 | if (compare_values_warnv (vr->min, vr->max, strict_overflow_p) == 0) |
0bca51f0 | 3014 | { |
12df8a7e | 3015 | int cmp = compare_values_warnv (vr->min, val, strict_overflow_p); |
0bca51f0 DN |
3016 | if (cmp == 0) |
3017 | return boolean_true_node; | |
3018 | else if (cmp == -1 || cmp == 1 || cmp == 2) | |
3019 | return boolean_false_node; | |
3020 | } | |
12df8a7e ILT |
3021 | else if (compare_values_warnv (val, vr->min, strict_overflow_p) == -1 |
3022 | || compare_values_warnv (vr->max, val, strict_overflow_p) == -1) | |
5de2df7b | 3023 | return boolean_false_node; |
0bca51f0 DN |
3024 | |
3025 | return NULL_TREE; | |
3026 | } | |
3027 | else if (comp == NE_EXPR) | |
3028 | { | |
3029 | /* If VAL is not inside VR, then they are always different. */ | |
12df8a7e ILT |
3030 | if (compare_values_warnv (vr->max, val, strict_overflow_p) == -1 |
3031 | || compare_values_warnv (vr->min, val, strict_overflow_p) == 1) | |
0bca51f0 DN |
3032 | return boolean_true_node; |
3033 | ||
3034 | /* If VR represents exactly one value equal to VAL, then return | |
3035 | false. */ | |
12df8a7e ILT |
3036 | if (compare_values_warnv (vr->min, vr->max, strict_overflow_p) == 0 |
3037 | && compare_values_warnv (vr->min, val, strict_overflow_p) == 0) | |
0bca51f0 DN |
3038 | return boolean_false_node; |
3039 | ||
3040 | /* Otherwise, they may or may not be different. */ | |
3041 | return NULL_TREE; | |
3042 | } | |
3043 | else if (comp == LT_EXPR || comp == LE_EXPR) | |
3044 | { | |
3045 | int tst; | |
3046 | ||
3047 | /* If VR is to the left of VAL, return true. */ | |
12df8a7e | 3048 | tst = compare_values_warnv (vr->max, val, strict_overflow_p); |
0bca51f0 DN |
3049 | if ((comp == LT_EXPR && tst == -1) |
3050 | || (comp == LE_EXPR && (tst == -1 || tst == 0))) | |
12df8a7e ILT |
3051 | { |
3052 | if (overflow_infinity_range_p (vr)) | |
3053 | *strict_overflow_p = true; | |
3054 | return boolean_true_node; | |
3055 | } | |
0bca51f0 DN |
3056 | |
3057 | /* If VR is to the right of VAL, return false. */ | |
12df8a7e | 3058 | tst = compare_values_warnv (vr->min, val, strict_overflow_p); |
0bca51f0 DN |
3059 | if ((comp == LT_EXPR && (tst == 0 || tst == 1)) |
3060 | || (comp == LE_EXPR && tst == 1)) | |
12df8a7e ILT |
3061 | { |
3062 | if (overflow_infinity_range_p (vr)) | |
3063 | *strict_overflow_p = true; | |
3064 | return boolean_false_node; | |
3065 | } | |
0bca51f0 DN |
3066 | |
3067 | /* Otherwise, we don't know. */ | |
3068 | return NULL_TREE; | |
3069 | } | |
3070 | else if (comp == GT_EXPR || comp == GE_EXPR) | |
3071 | { | |
3072 | int tst; | |
3073 | ||
3074 | /* If VR is to the right of VAL, return true. */ | |
12df8a7e | 3075 | tst = compare_values_warnv (vr->min, val, strict_overflow_p); |
0bca51f0 DN |
3076 | if ((comp == GT_EXPR && tst == 1) |
3077 | || (comp == GE_EXPR && (tst == 0 || tst == 1))) | |
12df8a7e ILT |
3078 | { |
3079 | if (overflow_infinity_range_p (vr)) | |
3080 | *strict_overflow_p = true; | |
3081 | return boolean_true_node; | |
3082 | } | |
0bca51f0 DN |
3083 | |
3084 | /* If VR is to the left of VAL, return false. */ | |
12df8a7e | 3085 | tst = compare_values_warnv (vr->max, val, strict_overflow_p); |
0bca51f0 DN |
3086 | if ((comp == GT_EXPR && (tst == -1 || tst == 0)) |
3087 | || (comp == GE_EXPR && tst == -1)) | |
12df8a7e ILT |
3088 | { |
3089 | if (overflow_infinity_range_p (vr)) | |
3090 | *strict_overflow_p = true; | |
3091 | return boolean_false_node; | |
3092 | } | |
0bca51f0 DN |
3093 | |
3094 | /* Otherwise, we don't know. */ | |
3095 | return NULL_TREE; | |
3096 | } | |
3097 | ||
3098 | gcc_unreachable (); | |
3099 | } | |
3100 | ||
3101 | ||
3102 | /* Debugging dumps. */ | |
3103 | ||
227858d1 DN |
3104 | void dump_value_range (FILE *, value_range_t *); |
3105 | void debug_value_range (value_range_t *); | |
3106 | void dump_all_value_ranges (FILE *); | |
3107 | void debug_all_value_ranges (void); | |
3108 | void dump_vr_equiv (FILE *, bitmap); | |
3109 | void debug_vr_equiv (bitmap); | |
3110 | ||
3111 | ||
3112 | /* Dump value range VR to FILE. */ | |
3113 | ||
0bca51f0 | 3114 | void |
227858d1 | 3115 | dump_value_range (FILE *file, value_range_t *vr) |
0bca51f0 DN |
3116 | { |
3117 | if (vr == NULL) | |
3118 | fprintf (file, "[]"); | |
3119 | else if (vr->type == VR_UNDEFINED) | |
3120 | fprintf (file, "UNDEFINED"); | |
3121 | else if (vr->type == VR_RANGE || vr->type == VR_ANTI_RANGE) | |
3122 | { | |
227858d1 DN |
3123 | tree type = TREE_TYPE (vr->min); |
3124 | ||
0bca51f0 | 3125 | fprintf (file, "%s[", (vr->type == VR_ANTI_RANGE) ? "~" : ""); |
227858d1 | 3126 | |
e1f28918 | 3127 | if (is_negative_overflow_infinity (vr->min)) |
12df8a7e | 3128 | fprintf (file, "-INF(OVF)"); |
e1f28918 ILT |
3129 | else if (INTEGRAL_TYPE_P (type) |
3130 | && !TYPE_UNSIGNED (type) | |
3131 | && vrp_val_is_min (vr->min)) | |
3132 | fprintf (file, "-INF"); | |
227858d1 DN |
3133 | else |
3134 | print_generic_expr (file, vr->min, 0); | |
3135 | ||
0bca51f0 | 3136 | fprintf (file, ", "); |
227858d1 | 3137 | |
e1f28918 | 3138 | if (is_positive_overflow_infinity (vr->max)) |
12df8a7e | 3139 | fprintf (file, "+INF(OVF)"); |
e1f28918 ILT |
3140 | else if (INTEGRAL_TYPE_P (type) |
3141 | && vrp_val_is_max (vr->max)) | |
3142 | fprintf (file, "+INF"); | |
227858d1 DN |
3143 | else |
3144 | print_generic_expr (file, vr->max, 0); | |
3145 | ||
0bca51f0 | 3146 | fprintf (file, "]"); |
227858d1 DN |
3147 | |
3148 | if (vr->equiv) | |
3149 | { | |
3150 | bitmap_iterator bi; | |
3151 | unsigned i, c = 0; | |
3152 | ||
3153 | fprintf (file, " EQUIVALENCES: { "); | |
3154 | ||
3155 | EXECUTE_IF_SET_IN_BITMAP (vr->equiv, 0, i, bi) | |
3156 | { | |
3157 | print_generic_expr (file, ssa_name (i), 0); | |
3158 | fprintf (file, " "); | |
3159 | c++; | |
3160 | } | |
3161 | ||
3162 | fprintf (file, "} (%u elements)", c); | |
3163 | } | |
0bca51f0 DN |
3164 | } |
3165 | else if (vr->type == VR_VARYING) | |
3166 | fprintf (file, "VARYING"); | |
3167 | else | |
3168 | fprintf (file, "INVALID RANGE"); | |
3169 | } | |
3170 | ||
3171 | ||
3172 | /* Dump value range VR to stderr. */ | |
3173 | ||
3174 | void | |
227858d1 | 3175 | debug_value_range (value_range_t *vr) |
0bca51f0 DN |
3176 | { |
3177 | dump_value_range (stderr, vr); | |
96644aba | 3178 | fprintf (stderr, "\n"); |
0bca51f0 DN |
3179 | } |
3180 | ||
3181 | ||
3182 | /* Dump value ranges of all SSA_NAMEs to FILE. */ | |
3183 | ||
3184 | void | |
3185 | dump_all_value_ranges (FILE *file) | |
3186 | { | |
3187 | size_t i; | |
3188 | ||
3189 | for (i = 0; i < num_ssa_names; i++) | |
3190 | { | |
227858d1 | 3191 | if (vr_value[i]) |
0bca51f0 | 3192 | { |
227858d1 | 3193 | print_generic_expr (file, ssa_name (i), 0); |
0bca51f0 | 3194 | fprintf (file, ": "); |
227858d1 | 3195 | dump_value_range (file, vr_value[i]); |
0bca51f0 DN |
3196 | fprintf (file, "\n"); |
3197 | } | |
3198 | } | |
3199 | ||
3200 | fprintf (file, "\n"); | |
3201 | } | |
3202 | ||
3203 | ||
3204 | /* Dump all value ranges to stderr. */ | |
3205 | ||
3206 | void | |
3207 | debug_all_value_ranges (void) | |
3208 | { | |
3209 | dump_all_value_ranges (stderr); | |
3210 | } | |
3211 | ||
3212 | ||
0bca51f0 DN |
3213 | /* Given a COND_EXPR COND of the form 'V OP W', and an SSA name V, |
3214 | create a new SSA name N and return the assertion assignment | |
3215 | 'V = ASSERT_EXPR <V, V OP W>'. */ | |
3216 | ||
3217 | static tree | |
3218 | build_assert_expr_for (tree cond, tree v) | |
3219 | { | |
3220 | tree n, assertion; | |
3221 | ||
3222 | gcc_assert (TREE_CODE (v) == SSA_NAME); | |
3223 | n = duplicate_ssa_name (v, NULL_TREE); | |
3224 | ||
7da4bf7d | 3225 | if (COMPARISON_CLASS_P (cond)) |
0bca51f0 | 3226 | { |
0d451405 | 3227 | tree a = build2 (ASSERT_EXPR, TREE_TYPE (v), v, cond); |
ebb07520 | 3228 | assertion = build_gimple_modify_stmt (n, a); |
0bca51f0 DN |
3229 | } |
3230 | else if (TREE_CODE (cond) == TRUTH_NOT_EXPR) | |
3231 | { | |
3232 | /* Given !V, build the assignment N = false. */ | |
3233 | tree op0 = TREE_OPERAND (cond, 0); | |
3234 | gcc_assert (op0 == v); | |
ebb07520 | 3235 | assertion = build_gimple_modify_stmt (n, boolean_false_node); |
0bca51f0 DN |
3236 | } |
3237 | else if (TREE_CODE (cond) == SSA_NAME) | |
3238 | { | |
3239 | /* Given V, build the assignment N = true. */ | |
3240 | gcc_assert (v == cond); | |
ebb07520 | 3241 | assertion = build_gimple_modify_stmt (n, boolean_true_node); |
0bca51f0 DN |
3242 | } |
3243 | else | |
3244 | gcc_unreachable (); | |
3245 | ||
3246 | SSA_NAME_DEF_STMT (n) = assertion; | |
3247 | ||
3248 | /* The new ASSERT_EXPR, creates a new SSA name that replaces the | |
3249 | operand of the ASSERT_EXPR. Register the new name and the old one | |
3250 | in the replacement table so that we can fix the SSA web after | |
3251 | adding all the ASSERT_EXPRs. */ | |
3252 | register_new_name_mapping (n, v); | |
3253 | ||
3254 | return assertion; | |
3255 | } | |
3256 | ||
3257 | ||
3258 | /* Return false if EXPR is a predicate expression involving floating | |
3259 | point values. */ | |
3260 | ||
3261 | static inline bool | |
58f9752a | 3262 | fp_predicate (const_tree expr) |
0bca51f0 | 3263 | { |
7da4bf7d KH |
3264 | return (COMPARISON_CLASS_P (expr) |
3265 | && FLOAT_TYPE_P (TREE_TYPE (TREE_OPERAND (expr, 0)))); | |
0bca51f0 DN |
3266 | } |
3267 | ||
3268 | ||
227858d1 DN |
3269 | /* If the range of values taken by OP can be inferred after STMT executes, |
3270 | return the comparison code (COMP_CODE_P) and value (VAL_P) that | |
3271 | describes the inferred range. Return true if a range could be | |
3272 | inferred. */ | |
0bca51f0 | 3273 | |
227858d1 DN |
3274 | static bool |
3275 | infer_value_range (tree stmt, tree op, enum tree_code *comp_code_p, tree *val_p) | |
0bca51f0 | 3276 | { |
227858d1 DN |
3277 | *val_p = NULL_TREE; |
3278 | *comp_code_p = ERROR_MARK; | |
3279 | ||
9fabf0d4 DN |
3280 | /* Do not attempt to infer anything in names that flow through |
3281 | abnormal edges. */ | |
3282 | if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (op)) | |
227858d1 DN |
3283 | return false; |
3284 | ||
3285 | /* Similarly, don't infer anything from statements that may throw | |
3286 | exceptions. */ | |
3287 | if (tree_could_throw_p (stmt)) | |
3288 | return false; | |
9fabf0d4 | 3289 | |
8c5285e1 DN |
3290 | /* If STMT is the last statement of a basic block with no |
3291 | successors, there is no point inferring anything about any of its | |
3292 | operands. We would not be able to find a proper insertion point | |
3293 | for the assertion, anyway. */ | |
3294 | if (stmt_ends_bb_p (stmt) && EDGE_COUNT (bb_for_stmt (stmt)->succs) == 0) | |
3295 | return false; | |
3296 | ||
60c9ad46 JL |
3297 | /* We can only assume that a pointer dereference will yield |
3298 | non-NULL if -fdelete-null-pointer-checks is enabled. */ | |
3299 | if (flag_delete_null_pointer_checks && POINTER_TYPE_P (TREE_TYPE (op))) | |
0bca51f0 | 3300 | { |
e9e0aa2c | 3301 | unsigned num_uses, num_loads, num_stores; |
0bca51f0 | 3302 | |
e9e0aa2c DN |
3303 | count_uses_and_derefs (op, stmt, &num_uses, &num_loads, &num_stores); |
3304 | if (num_loads + num_stores > 0) | |
0bca51f0 | 3305 | { |
227858d1 DN |
3306 | *val_p = build_int_cst (TREE_TYPE (op), 0); |
3307 | *comp_code_p = NE_EXPR; | |
3308 | return true; | |
0bca51f0 DN |
3309 | } |
3310 | } | |
3311 | ||
227858d1 | 3312 | return false; |
0bca51f0 DN |
3313 | } |
3314 | ||
3315 | ||
227858d1 DN |
3316 | void dump_asserts_for (FILE *, tree); |
3317 | void debug_asserts_for (tree); | |
3318 | void dump_all_asserts (FILE *); | |
3319 | void debug_all_asserts (void); | |
3320 | ||
3321 | /* Dump all the registered assertions for NAME to FILE. */ | |
3322 | ||
3323 | void | |
3324 | dump_asserts_for (FILE *file, tree name) | |
3325 | { | |
3326 | assert_locus_t loc; | |
3327 | ||
3328 | fprintf (file, "Assertions to be inserted for "); | |
3329 | print_generic_expr (file, name, 0); | |
3330 | fprintf (file, "\n"); | |
3331 | ||
3332 | loc = asserts_for[SSA_NAME_VERSION (name)]; | |
3333 | while (loc) | |
3334 | { | |
3335 | fprintf (file, "\t"); | |
3336 | print_generic_expr (file, bsi_stmt (loc->si), 0); | |
3337 | fprintf (file, "\n\tBB #%d", loc->bb->index); | |
3338 | if (loc->e) | |
3339 | { | |
3340 | fprintf (file, "\n\tEDGE %d->%d", loc->e->src->index, | |
3341 | loc->e->dest->index); | |
3342 | dump_edge_info (file, loc->e, 0); | |
3343 | } | |
3344 | fprintf (file, "\n\tPREDICATE: "); | |
3345 | print_generic_expr (file, name, 0); | |
3346 | fprintf (file, " %s ", tree_code_name[(int)loc->comp_code]); | |
3347 | print_generic_expr (file, loc->val, 0); | |
3348 | fprintf (file, "\n\n"); | |
3349 | loc = loc->next; | |
3350 | } | |
3351 | ||
3352 | fprintf (file, "\n"); | |
3353 | } | |
3354 | ||
3355 | ||
3356 | /* Dump all the registered assertions for NAME to stderr. */ | |
3357 | ||
3358 | void | |
3359 | debug_asserts_for (tree name) | |
3360 | { | |
3361 | dump_asserts_for (stderr, name); | |
3362 | } | |
3363 | ||
3364 | ||
3365 | /* Dump all the registered assertions for all the names to FILE. */ | |
3366 | ||
3367 | void | |
3368 | dump_all_asserts (FILE *file) | |
3369 | { | |
3370 | unsigned i; | |
3371 | bitmap_iterator bi; | |
3372 | ||
3373 | fprintf (file, "\nASSERT_EXPRs to be inserted\n\n"); | |
3374 | EXECUTE_IF_SET_IN_BITMAP (need_assert_for, 0, i, bi) | |
3375 | dump_asserts_for (file, ssa_name (i)); | |
3376 | fprintf (file, "\n"); | |
3377 | } | |
3378 | ||
3379 | ||
3380 | /* Dump all the registered assertions for all the names to stderr. */ | |
3381 | ||
3382 | void | |
3383 | debug_all_asserts (void) | |
3384 | { | |
3385 | dump_all_asserts (stderr); | |
3386 | } | |
3387 | ||
3388 | ||
3389 | /* If NAME doesn't have an ASSERT_EXPR registered for asserting | |
3390 | 'NAME COMP_CODE VAL' at a location that dominates block BB or | |
3391 | E->DEST, then register this location as a possible insertion point | |
3392 | for ASSERT_EXPR <NAME, NAME COMP_CODE VAL>. | |
3393 | ||
3394 | BB, E and SI provide the exact insertion point for the new | |
3395 | ASSERT_EXPR. If BB is NULL, then the ASSERT_EXPR is to be inserted | |
3396 | on edge E. Otherwise, if E is NULL, the ASSERT_EXPR is inserted on | |
3397 | BB. If SI points to a COND_EXPR or a SWITCH_EXPR statement, then E | |
3398 | must not be NULL. */ | |
3399 | ||
3400 | static void | |
3401 | register_new_assert_for (tree name, | |
3402 | enum tree_code comp_code, | |
3403 | tree val, | |
3404 | basic_block bb, | |
3405 | edge e, | |
3406 | block_stmt_iterator si) | |
3407 | { | |
3408 | assert_locus_t n, loc, last_loc; | |
3409 | bool found; | |
3410 | basic_block dest_bb; | |
3411 | ||
3412 | #if defined ENABLE_CHECKING | |
3413 | gcc_assert (bb == NULL || e == NULL); | |
3414 | ||
3415 | if (e == NULL) | |
3416 | gcc_assert (TREE_CODE (bsi_stmt (si)) != COND_EXPR | |
3417 | && TREE_CODE (bsi_stmt (si)) != SWITCH_EXPR); | |
3418 | #endif | |
3419 | ||
3420 | /* The new assertion A will be inserted at BB or E. We need to | |
3421 | determine if the new location is dominated by a previously | |
3422 | registered location for A. If we are doing an edge insertion, | |
3423 | assume that A will be inserted at E->DEST. Note that this is not | |
3424 | necessarily true. | |
3425 | ||
3426 | If E is a critical edge, it will be split. But even if E is | |
3427 | split, the new block will dominate the same set of blocks that | |
3428 | E->DEST dominates. | |
3429 | ||
3430 | The reverse, however, is not true, blocks dominated by E->DEST | |
3431 | will not be dominated by the new block created to split E. So, | |
3432 | if the insertion location is on a critical edge, we will not use | |
3433 | the new location to move another assertion previously registered | |
3434 | at a block dominated by E->DEST. */ | |
3435 | dest_bb = (bb) ? bb : e->dest; | |
3436 | ||
3437 | /* If NAME already has an ASSERT_EXPR registered for COMP_CODE and | |
3438 | VAL at a block dominating DEST_BB, then we don't need to insert a new | |
3439 | one. Similarly, if the same assertion already exists at a block | |
3440 | dominated by DEST_BB and the new location is not on a critical | |
3441 | edge, then update the existing location for the assertion (i.e., | |
3442 | move the assertion up in the dominance tree). | |
3443 | ||
3444 | Note, this is implemented as a simple linked list because there | |
3445 | should not be more than a handful of assertions registered per | |
3446 | name. If this becomes a performance problem, a table hashed by | |
3447 | COMP_CODE and VAL could be implemented. */ | |
3448 | loc = asserts_for[SSA_NAME_VERSION (name)]; | |
3449 | last_loc = loc; | |
3450 | found = false; | |
3451 | while (loc) | |
3452 | { | |
3453 | if (loc->comp_code == comp_code | |
3454 | && (loc->val == val | |
3455 | || operand_equal_p (loc->val, val, 0))) | |
3456 | { | |
3457 | /* If the assertion NAME COMP_CODE VAL has already been | |
3458 | registered at a basic block that dominates DEST_BB, then | |
3459 | we don't need to insert the same assertion again. Note | |
3460 | that we don't check strict dominance here to avoid | |
3461 | replicating the same assertion inside the same basic | |
3462 | block more than once (e.g., when a pointer is | |
3463 | dereferenced several times inside a block). | |
3464 | ||
3465 | An exception to this rule are edge insertions. If the | |
3466 | new assertion is to be inserted on edge E, then it will | |
3467 | dominate all the other insertions that we may want to | |
3468 | insert in DEST_BB. So, if we are doing an edge | |
3469 | insertion, don't do this dominance check. */ | |
3470 | if (e == NULL | |
3471 | && dominated_by_p (CDI_DOMINATORS, dest_bb, loc->bb)) | |
3472 | return; | |
3473 | ||
3474 | /* Otherwise, if E is not a critical edge and DEST_BB | |
3475 | dominates the existing location for the assertion, move | |
3476 | the assertion up in the dominance tree by updating its | |
3477 | location information. */ | |
3478 | if ((e == NULL || !EDGE_CRITICAL_P (e)) | |
3479 | && dominated_by_p (CDI_DOMINATORS, loc->bb, dest_bb)) | |
3480 | { | |
3481 | loc->bb = dest_bb; | |
3482 | loc->e = e; | |
3483 | loc->si = si; | |
3484 | return; | |
3485 | } | |
3486 | } | |
3487 | ||
3488 | /* Update the last node of the list and move to the next one. */ | |
3489 | last_loc = loc; | |
3490 | loc = loc->next; | |
3491 | } | |
3492 | ||
3493 | /* If we didn't find an assertion already registered for | |
3494 | NAME COMP_CODE VAL, add a new one at the end of the list of | |
3495 | assertions associated with NAME. */ | |
5ed6ace5 | 3496 | n = XNEW (struct assert_locus_d); |
227858d1 DN |
3497 | n->bb = dest_bb; |
3498 | n->e = e; | |
3499 | n->si = si; | |
3500 | n->comp_code = comp_code; | |
3501 | n->val = val; | |
3502 | n->next = NULL; | |
3503 | ||
3504 | if (last_loc) | |
3505 | last_loc->next = n; | |
3506 | else | |
3507 | asserts_for[SSA_NAME_VERSION (name)] = n; | |
3508 | ||
3509 | bitmap_set_bit (need_assert_for, SSA_NAME_VERSION (name)); | |
3510 | } | |
3511 | ||
279f3eb5 JL |
3512 | /* COND is a predicate which uses NAME. Extract a suitable test code |
3513 | and value and store them into *CODE_P and *VAL_P so the predicate | |
3514 | is normalized to NAME *CODE_P *VAL_P. | |
227858d1 | 3515 | |
279f3eb5 JL |
3516 | If no extraction was possible, return FALSE, otherwise return TRUE. |
3517 | ||
3518 | If INVERT is true, then we invert the result stored into *CODE_P. */ | |
227858d1 DN |
3519 | |
3520 | static bool | |
279f3eb5 JL |
3521 | extract_code_and_val_from_cond (tree name, tree cond, bool invert, |
3522 | enum tree_code *code_p, tree *val_p) | |
227858d1 | 3523 | { |
227858d1 | 3524 | enum tree_code comp_code; |
279f3eb5 JL |
3525 | tree val; |
3526 | ||
3527 | /* Predicates may be a single SSA name or NAME OP VAL. */ | |
3528 | if (cond == name) | |
3529 | { | |
3530 | /* If the predicate is a name, it must be NAME, in which | |
3531 | case we create the predicate NAME == true or | |
3532 | NAME == false accordingly. */ | |
3533 | comp_code = EQ_EXPR; | |
3534 | val = invert ? boolean_false_node : boolean_true_node; | |
3535 | } | |
3536 | else | |
3537 | { | |
3538 | /* Otherwise, we have a comparison of the form NAME COMP VAL | |
3539 | or VAL COMP NAME. */ | |
3540 | if (name == TREE_OPERAND (cond, 1)) | |
3541 | { | |
3542 | /* If the predicate is of the form VAL COMP NAME, flip | |
3543 | COMP around because we need to register NAME as the | |
3544 | first operand in the predicate. */ | |
3545 | comp_code = swap_tree_comparison (TREE_CODE (cond)); | |
3546 | val = TREE_OPERAND (cond, 0); | |
3547 | } | |
3548 | else | |
3549 | { | |
3550 | /* The comparison is of the form NAME COMP VAL, so the | |
3551 | comparison code remains unchanged. */ | |
3552 | comp_code = TREE_CODE (cond); | |
3553 | val = TREE_OPERAND (cond, 1); | |
3554 | } | |
227858d1 | 3555 | |
279f3eb5 JL |
3556 | /* Invert the comparison code as necessary. */ |
3557 | if (invert) | |
3558 | comp_code = invert_tree_comparison (comp_code, 0); | |
227858d1 | 3559 | |
279f3eb5 JL |
3560 | /* VRP does not handle float types. */ |
3561 | if (SCALAR_FLOAT_TYPE_P (TREE_TYPE (val))) | |
3562 | return false; | |
3563 | ||
3564 | /* Do not register always-false predicates. | |
3565 | FIXME: this works around a limitation in fold() when dealing with | |
3566 | enumerations. Given 'enum { N1, N2 } x;', fold will not | |
3567 | fold 'if (x > N2)' to 'if (0)'. */ | |
3568 | if ((comp_code == GT_EXPR || comp_code == LT_EXPR) | |
3569 | && INTEGRAL_TYPE_P (TREE_TYPE (val))) | |
3570 | { | |
3571 | tree min = TYPE_MIN_VALUE (TREE_TYPE (val)); | |
3572 | tree max = TYPE_MAX_VALUE (TREE_TYPE (val)); | |
3573 | ||
3574 | if (comp_code == GT_EXPR | |
3575 | && (!max | |
3576 | || compare_values (val, max) == 0)) | |
3577 | return false; | |
3578 | ||
3579 | if (comp_code == LT_EXPR | |
3580 | && (!min | |
3581 | || compare_values (val, min) == 0)) | |
3582 | return false; | |
3583 | } | |
3584 | } | |
3585 | *code_p = comp_code; | |
3586 | *val_p = val; | |
3587 | return true; | |
3588 | } | |
3589 | ||
3590 | /* OP is an operand of a truth value expression which is known to have | |
3591 | a particular value. Register any asserts for OP and for any | |
3592 | operands in OP's defining statement. | |
3593 | ||
3594 | If CODE is EQ_EXPR, then we want to register OP is zero (false), | |
3595 | if CODE is NE_EXPR, then we want to register OP is nonzero (true). */ | |
3596 | ||
3597 | static bool | |
3598 | register_edge_assert_for_1 (tree op, enum tree_code code, | |
3599 | edge e, block_stmt_iterator bsi) | |
3600 | { | |
34fc5065 | 3601 | bool retval = false; |
279f3eb5 | 3602 | tree op_def, rhs, val; |
227858d1 | 3603 | |
279f3eb5 JL |
3604 | /* We only care about SSA_NAMEs. */ |
3605 | if (TREE_CODE (op) != SSA_NAME) | |
227858d1 DN |
3606 | return false; |
3607 | ||
279f3eb5 JL |
3608 | /* We know that OP will have a zero or nonzero value. If OP is used |
3609 | more than once go ahead and register an assert for OP. | |
3610 | ||
3611 | The FOUND_IN_SUBGRAPH support is not helpful in this situation as | |
3612 | it will always be set for OP (because OP is used in a COND_EXPR in | |
3613 | the subgraph). */ | |
3614 | if (!has_single_use (op)) | |
3615 | { | |
3616 | val = build_int_cst (TREE_TYPE (op), 0); | |
3617 | register_new_assert_for (op, code, val, NULL, e, bsi); | |
3618 | retval = true; | |
3619 | } | |
3620 | ||
3621 | /* Now look at how OP is set. If it's set from a comparison, | |
3622 | a truth operation or some bit operations, then we may be able | |
3623 | to register information about the operands of that assignment. */ | |
3624 | op_def = SSA_NAME_DEF_STMT (op); | |
07beea0d | 3625 | if (TREE_CODE (op_def) != GIMPLE_MODIFY_STMT) |
279f3eb5 JL |
3626 | return retval; |
3627 | ||
07beea0d | 3628 | rhs = GIMPLE_STMT_OPERAND (op_def, 1); |
279f3eb5 JL |
3629 | |
3630 | if (COMPARISON_CLASS_P (rhs)) | |
227858d1 | 3631 | { |
34fc5065 | 3632 | bool invert = (code == EQ_EXPR ? true : false); |
279f3eb5 JL |
3633 | tree op0 = TREE_OPERAND (rhs, 0); |
3634 | tree op1 = TREE_OPERAND (rhs, 1); | |
227858d1 | 3635 | |
279f3eb5 JL |
3636 | /* Conditionally register an assert for each SSA_NAME in the |
3637 | comparison. */ | |
3638 | if (TREE_CODE (op0) == SSA_NAME | |
3639 | && !has_single_use (op0) | |
3640 | && extract_code_and_val_from_cond (op0, rhs, | |
3641 | invert, &code, &val)) | |
227858d1 | 3642 | { |
279f3eb5 JL |
3643 | register_new_assert_for (op0, code, val, NULL, e, bsi); |
3644 | retval = true; | |
227858d1 | 3645 | } |
279f3eb5 JL |
3646 | |
3647 | /* Similarly for the second operand of the comparison. */ | |
3648 | if (TREE_CODE (op1) == SSA_NAME | |
3649 | && !has_single_use (op1) | |
3650 | && extract_code_and_val_from_cond (op1, rhs, | |
3651 | invert, &code, &val)) | |
227858d1 | 3652 | { |
279f3eb5 JL |
3653 | register_new_assert_for (op1, code, val, NULL, e, bsi); |
3654 | retval = true; | |
3655 | } | |
3656 | } | |
3657 | else if ((code == NE_EXPR | |
3658 | && (TREE_CODE (rhs) == TRUTH_AND_EXPR | |
3659 | || TREE_CODE (rhs) == BIT_AND_EXPR)) | |
3660 | || (code == EQ_EXPR | |
3661 | && (TREE_CODE (rhs) == TRUTH_OR_EXPR | |
3662 | || TREE_CODE (rhs) == BIT_IOR_EXPR))) | |
3663 | { | |
3664 | /* Recurse on each operand. */ | |
3665 | retval |= register_edge_assert_for_1 (TREE_OPERAND (rhs, 0), | |
3666 | code, e, bsi); | |
3667 | retval |= register_edge_assert_for_1 (TREE_OPERAND (rhs, 1), | |
3668 | code, e, bsi); | |
3669 | } | |
3670 | else if (TREE_CODE (rhs) == TRUTH_NOT_EXPR) | |
3671 | { | |
34fc5065 RG |
3672 | /* Recurse, flipping CODE. */ |
3673 | code = invert_tree_comparison (code, false); | |
279f3eb5 | 3674 | retval |= register_edge_assert_for_1 (TREE_OPERAND (rhs, 0), |
34fc5065 | 3675 | code, e, bsi); |
279f3eb5 JL |
3676 | } |
3677 | else if (TREE_CODE (rhs) == SSA_NAME) | |
3678 | { | |
34fc5065 | 3679 | /* Recurse through the copy. */ |
279f3eb5 JL |
3680 | retval |= register_edge_assert_for_1 (rhs, code, e, bsi); |
3681 | } | |
3682 | else if (TREE_CODE (rhs) == NOP_EXPR | |
3683 | || TREE_CODE (rhs) == CONVERT_EXPR | |
279f3eb5 JL |
3684 | || TREE_CODE (rhs) == NON_LVALUE_EXPR) |
3685 | { | |
34fc5065 | 3686 | /* Recurse through the type conversion. */ |
279f3eb5 JL |
3687 | retval |= register_edge_assert_for_1 (TREE_OPERAND (rhs, 0), |
3688 | code, e, bsi); | |
3689 | } | |
227858d1 | 3690 | |
279f3eb5 JL |
3691 | return retval; |
3692 | } | |
da11c5d2 | 3693 | |
279f3eb5 JL |
3694 | /* Try to register an edge assertion for SSA name NAME on edge E for |
3695 | the condition COND contributing to the conditional jump pointed to by SI. | |
3696 | Return true if an assertion for NAME could be registered. */ | |
da11c5d2 | 3697 | |
279f3eb5 JL |
3698 | static bool |
3699 | register_edge_assert_for (tree name, edge e, block_stmt_iterator si, tree cond) | |
3700 | { | |
3701 | tree val; | |
3702 | enum tree_code comp_code; | |
3703 | bool retval = false; | |
3704 | bool is_else_edge = (e->flags & EDGE_FALSE_VALUE) != 0; | |
3705 | ||
3706 | /* Do not attempt to infer anything in names that flow through | |
3707 | abnormal edges. */ | |
3708 | if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name)) | |
3709 | return false; | |
3710 | ||
3711 | if (!extract_code_and_val_from_cond (name, cond, is_else_edge, | |
3712 | &comp_code, &val)) | |
3713 | return false; | |
3714 | ||
3715 | /* Only register an ASSERT_EXPR if NAME was found in the sub-graph | |
3716 | reachable from E. */ | |
3717 | if (TEST_BIT (found_in_subgraph, SSA_NAME_VERSION (name))) | |
3718 | { | |
3719 | register_new_assert_for (name, comp_code, val, NULL, e, si); | |
3720 | retval = true; | |
3721 | } | |
3722 | ||
3723 | /* If COND is effectively an equality test of an SSA_NAME against | |
3724 | the value zero or one, then we may be able to assert values | |
3725 | for SSA_NAMEs which flow into COND. */ | |
3726 | ||
3727 | /* In the case of NAME == 1 or NAME != 0, for TRUTH_AND_EXPR defining | |
3728 | statement of NAME we can assert both operands of the TRUTH_AND_EXPR | |
2f8e468b | 3729 | have nonzero value. */ |
279f3eb5 JL |
3730 | if (((comp_code == EQ_EXPR && integer_onep (val)) |
3731 | || (comp_code == NE_EXPR && integer_zerop (val)))) | |
3732 | { | |
3733 | tree def_stmt = SSA_NAME_DEF_STMT (name); | |
3734 | ||
07beea0d AH |
3735 | if (TREE_CODE (def_stmt) == GIMPLE_MODIFY_STMT |
3736 | && (TREE_CODE (GIMPLE_STMT_OPERAND (def_stmt, 1)) == TRUTH_AND_EXPR | |
3737 | || TREE_CODE (GIMPLE_STMT_OPERAND (def_stmt, 1)) == BIT_AND_EXPR)) | |
279f3eb5 | 3738 | { |
07beea0d AH |
3739 | tree op0 = TREE_OPERAND (GIMPLE_STMT_OPERAND (def_stmt, 1), 0); |
3740 | tree op1 = TREE_OPERAND (GIMPLE_STMT_OPERAND (def_stmt, 1), 1); | |
279f3eb5 JL |
3741 | retval |= register_edge_assert_for_1 (op0, NE_EXPR, e, si); |
3742 | retval |= register_edge_assert_for_1 (op1, NE_EXPR, e, si); | |
227858d1 DN |
3743 | } |
3744 | } | |
279f3eb5 JL |
3745 | |
3746 | /* In the case of NAME == 0 or NAME != 1, for TRUTH_OR_EXPR defining | |
3747 | statement of NAME we can assert both operands of the TRUTH_OR_EXPR | |
3748 | have zero value. */ | |
3749 | if (((comp_code == EQ_EXPR && integer_zerop (val)) | |
3750 | || (comp_code == NE_EXPR && integer_onep (val)))) | |
227858d1 | 3751 | { |
279f3eb5 JL |
3752 | tree def_stmt = SSA_NAME_DEF_STMT (name); |
3753 | ||
07beea0d AH |
3754 | if (TREE_CODE (def_stmt) == GIMPLE_MODIFY_STMT |
3755 | && (TREE_CODE (GIMPLE_STMT_OPERAND (def_stmt, 1)) == TRUTH_OR_EXPR | |
e09deb14 RG |
3756 | /* For BIT_IOR_EXPR only if NAME == 0 both operands have |
3757 | necessarily zero value. */ | |
3758 | || (comp_code == EQ_EXPR | |
3759 | && (TREE_CODE (GIMPLE_STMT_OPERAND (def_stmt, 1)) | |
3760 | == BIT_IOR_EXPR)))) | |
279f3eb5 | 3761 | { |
07beea0d AH |
3762 | tree op0 = TREE_OPERAND (GIMPLE_STMT_OPERAND (def_stmt, 1), 0); |
3763 | tree op1 = TREE_OPERAND (GIMPLE_STMT_OPERAND (def_stmt, 1), 1); | |
279f3eb5 JL |
3764 | retval |= register_edge_assert_for_1 (op0, EQ_EXPR, e, si); |
3765 | retval |= register_edge_assert_for_1 (op1, EQ_EXPR, e, si); | |
3766 | } | |
227858d1 DN |
3767 | } |
3768 | ||
279f3eb5 | 3769 | return retval; |
227858d1 DN |
3770 | } |
3771 | ||
3772 | ||
3773 | static bool find_assert_locations (basic_block bb); | |
3774 | ||
3775 | /* Determine whether the outgoing edges of BB should receive an | |
279f3eb5 | 3776 | ASSERT_EXPR for each of the operands of BB's LAST statement. |
9bb6aa43 | 3777 | The last statement of BB must be a COND_EXPR. |
227858d1 DN |
3778 | |
3779 | If any of the sub-graphs rooted at BB have an interesting use of | |
3780 | the predicate operands, an assert location node is added to the | |
3781 | list of assertions for the corresponding operands. */ | |
3782 | ||
3783 | static bool | |
279f3eb5 | 3784 | find_conditional_asserts (basic_block bb, tree last) |
227858d1 DN |
3785 | { |
3786 | bool need_assert; | |
279f3eb5 JL |
3787 | block_stmt_iterator bsi; |
3788 | tree op; | |
227858d1 DN |
3789 | edge_iterator ei; |
3790 | edge e; | |
3791 | ssa_op_iter iter; | |
3792 | ||
3793 | need_assert = false; | |
279f3eb5 | 3794 | bsi = bsi_for_stmt (last); |
227858d1 DN |
3795 | |
3796 | /* Look for uses of the operands in each of the sub-graphs | |
3797 | rooted at BB. We need to check each of the outgoing edges | |
3798 | separately, so that we know what kind of ASSERT_EXPR to | |
3799 | insert. */ | |
3800 | FOR_EACH_EDGE (e, ei, bb->succs) | |
3801 | { | |
3802 | if (e->dest == bb) | |
3803 | continue; | |
3804 | ||
3805 | /* Remove the COND_EXPR operands from the FOUND_IN_SUBGRAPH bitmap. | |
3806 | Otherwise, when we finish traversing each of the sub-graphs, we | |
3807 | won't know whether the variables were found in the sub-graphs or | |
2090d6a0 JL |
3808 | if they had been found in a block upstream from BB. |
3809 | ||
3810 | This is actually a bad idea is some cases, particularly jump | |
3811 | threading. Consider a CFG like the following: | |
3812 | ||
3813 | 0 | |
3814 | /| | |
3815 | 1 | | |
3816 | \| | |
3817 | 2 | |
3818 | / \ | |
3819 | 3 4 | |
3820 | ||
3821 | Assume that one or more operands in the conditional at the | |
3822 | end of block 0 are used in a conditional in block 2, but not | |
3823 | anywhere in block 1. In this case we will not insert any | |
3824 | assert statements in block 1, which may cause us to miss | |
3825 | opportunities to optimize, particularly for jump threading. */ | |
227858d1 DN |
3826 | FOR_EACH_SSA_TREE_OPERAND (op, last, iter, SSA_OP_USE) |
3827 | RESET_BIT (found_in_subgraph, SSA_NAME_VERSION (op)); | |
3828 | ||
3829 | /* Traverse the strictly dominated sub-graph rooted at E->DEST | |
3830 | to determine if any of the operands in the conditional | |
3831 | predicate are used. */ | |
12a6309e | 3832 | need_assert |= find_assert_locations (e->dest); |
227858d1 DN |
3833 | |
3834 | /* Register the necessary assertions for each operand in the | |
3835 | conditional predicate. */ | |
3836 | FOR_EACH_SSA_TREE_OPERAND (op, last, iter, SSA_OP_USE) | |
279f3eb5 JL |
3837 | need_assert |= register_edge_assert_for (op, e, bsi, |
3838 | COND_EXPR_COND (last)); | |
227858d1 DN |
3839 | } |
3840 | ||
3841 | /* Finally, indicate that we have found the operands in the | |
3842 | conditional. */ | |
3843 | FOR_EACH_SSA_TREE_OPERAND (op, last, iter, SSA_OP_USE) | |
3844 | SET_BIT (found_in_subgraph, SSA_NAME_VERSION (op)); | |
3845 | ||
3846 | return need_assert; | |
3847 | } | |
3848 | ||
9bb6aa43 RG |
3849 | /* Compare two case labels sorting first by the destination label uid |
3850 | and then by the case value. */ | |
3851 | ||
3852 | static int | |
3853 | compare_case_labels (const void *p1, const void *p2) | |
3854 | { | |
741ac903 KG |
3855 | const_tree const case1 = *(const_tree const*)p1; |
3856 | const_tree const case2 = *(const_tree const*)p2; | |
9bb6aa43 RG |
3857 | unsigned int uid1 = DECL_UID (CASE_LABEL (case1)); |
3858 | unsigned int uid2 = DECL_UID (CASE_LABEL (case2)); | |
3859 | ||
3860 | if (uid1 < uid2) | |
3861 | return -1; | |
3862 | else if (uid1 == uid2) | |
3863 | { | |
3864 | /* Make sure the default label is first in a group. */ | |
3865 | if (!CASE_LOW (case1)) | |
3866 | return -1; | |
3867 | else if (!CASE_LOW (case2)) | |
3868 | return 1; | |
3869 | else | |
3870 | return tree_int_cst_compare (CASE_LOW (case1), CASE_LOW (case2)); | |
3871 | } | |
3872 | else | |
3873 | return 1; | |
3874 | } | |
3875 | ||
3876 | /* Determine whether the outgoing edges of BB should receive an | |
3877 | ASSERT_EXPR for each of the operands of BB's LAST statement. | |
3878 | The last statement of BB must be a SWITCH_EXPR. | |
3879 | ||
3880 | If any of the sub-graphs rooted at BB have an interesting use of | |
3881 | the predicate operands, an assert location node is added to the | |
3882 | list of assertions for the corresponding operands. */ | |
3883 | ||
3884 | static bool | |
3885 | find_switch_asserts (basic_block bb, tree last) | |
3886 | { | |
3887 | bool need_assert; | |
3888 | block_stmt_iterator bsi; | |
3889 | tree op, cond; | |
3890 | edge e; | |
3891 | tree vec = SWITCH_LABELS (last), vec2; | |
3892 | size_t n = TREE_VEC_LENGTH (vec); | |
3893 | unsigned int idx; | |
3894 | ||
3895 | need_assert = false; | |
3896 | bsi = bsi_for_stmt (last); | |
3897 | op = TREE_OPERAND (last, 0); | |
3898 | if (TREE_CODE (op) != SSA_NAME) | |
3899 | return false; | |
3900 | ||
3901 | /* Build a vector of case labels sorted by destination label. */ | |
3902 | vec2 = make_tree_vec (n); | |
3903 | for (idx = 0; idx < n; ++idx) | |
3904 | TREE_VEC_ELT (vec2, idx) = TREE_VEC_ELT (vec, idx); | |
3905 | qsort (&TREE_VEC_ELT (vec2, 0), n, sizeof (tree), compare_case_labels); | |
3906 | ||
3907 | for (idx = 0; idx < n; ++idx) | |
3908 | { | |
3909 | tree min, max; | |
3910 | tree cl = TREE_VEC_ELT (vec2, idx); | |
3911 | ||
3912 | min = CASE_LOW (cl); | |
3913 | max = CASE_HIGH (cl); | |
3914 | ||
3915 | /* If there are multiple case labels with the same destination | |
3916 | we need to combine them to a single value range for the edge. */ | |
3917 | if (idx + 1 < n | |
3918 | && CASE_LABEL (cl) == CASE_LABEL (TREE_VEC_ELT (vec2, idx + 1))) | |
3919 | { | |
3920 | /* Skip labels until the last of the group. */ | |
3921 | do { | |
3922 | ++idx; | |
3923 | } while (idx < n | |
3924 | && CASE_LABEL (cl) == CASE_LABEL (TREE_VEC_ELT (vec2, idx))); | |
3925 | --idx; | |
3926 | ||
3927 | /* Pick up the maximum of the case label range. */ | |
3928 | if (CASE_HIGH (TREE_VEC_ELT (vec2, idx))) | |
3929 | max = CASE_HIGH (TREE_VEC_ELT (vec2, idx)); | |
3930 | else | |
3931 | max = CASE_LOW (TREE_VEC_ELT (vec2, idx)); | |
3932 | } | |
3933 | ||
3934 | /* Nothing to do if the range includes the default label until we | |
3935 | can register anti-ranges. */ | |
3936 | if (min == NULL_TREE) | |
3937 | continue; | |
3938 | ||
3939 | /* Find the edge to register the assert expr on. */ | |
3940 | e = find_edge (bb, label_to_block (CASE_LABEL (cl))); | |
3941 | ||
3942 | /* Remove the SWITCH_EXPR operand from the FOUND_IN_SUBGRAPH bitmap. | |
3943 | Otherwise, when we finish traversing each of the sub-graphs, we | |
3944 | won't know whether the variables were found in the sub-graphs or | |
3945 | if they had been found in a block upstream from BB. */ | |
3946 | RESET_BIT (found_in_subgraph, SSA_NAME_VERSION (op)); | |
3947 | ||
3948 | /* Traverse the strictly dominated sub-graph rooted at E->DEST | |
3949 | to determine if any of the operands in the conditional | |
3950 | predicate are used. */ | |
3951 | if (e->dest != bb) | |
3952 | need_assert |= find_assert_locations (e->dest); | |
3953 | ||
3954 | /* Register the necessary assertions for the operand in the | |
3955 | SWITCH_EXPR. */ | |
3956 | cond = build2 (max ? GE_EXPR : EQ_EXPR, boolean_type_node, | |
3957 | op, fold_convert (TREE_TYPE (op), min)); | |
3958 | need_assert |= register_edge_assert_for (op, e, bsi, cond); | |
3959 | if (max) | |
3960 | { | |
3961 | cond = build2 (LE_EXPR, boolean_type_node, | |
3962 | op, fold_convert (TREE_TYPE (op), max)); | |
3963 | need_assert |= register_edge_assert_for (op, e, bsi, cond); | |
3964 | } | |
3965 | } | |
3966 | ||
3967 | /* Finally, indicate that we have found the operand in the | |
3968 | SWITCH_EXPR. */ | |
3969 | SET_BIT (found_in_subgraph, SSA_NAME_VERSION (op)); | |
3970 | ||
3971 | return need_assert; | |
3972 | } | |
3973 | ||
227858d1 DN |
3974 | |
3975 | /* Traverse all the statements in block BB looking for statements that | |
3976 | may generate useful assertions for the SSA names in their operand. | |
3977 | If a statement produces a useful assertion A for name N_i, then the | |
3978 | list of assertions already generated for N_i is scanned to | |
3979 | determine if A is actually needed. | |
3980 | ||
3981 | If N_i already had the assertion A at a location dominating the | |
3982 | current location, then nothing needs to be done. Otherwise, the | |
3983 | new location for A is recorded instead. | |
3984 | ||
3985 | 1- For every statement S in BB, all the variables used by S are | |
3986 | added to bitmap FOUND_IN_SUBGRAPH. | |
3987 | ||
3988 | 2- If statement S uses an operand N in a way that exposes a known | |
3989 | value range for N, then if N was not already generated by an | |
3990 | ASSERT_EXPR, create a new assert location for N. For instance, | |
3991 | if N is a pointer and the statement dereferences it, we can | |
3992 | assume that N is not NULL. | |
3993 | ||
3994 | 3- COND_EXPRs are a special case of #2. We can derive range | |
3995 | information from the predicate but need to insert different | |
3996 | ASSERT_EXPRs for each of the sub-graphs rooted at the | |
3997 | conditional block. If the last statement of BB is a conditional | |
3998 | expression of the form 'X op Y', then | |
3999 | ||
4000 | a) Remove X and Y from the set FOUND_IN_SUBGRAPH. | |
4001 | ||
4002 | b) If the conditional is the only entry point to the sub-graph | |
4003 | corresponding to the THEN_CLAUSE, recurse into it. On | |
4004 | return, if X and/or Y are marked in FOUND_IN_SUBGRAPH, then | |
4005 | an ASSERT_EXPR is added for the corresponding variable. | |
4006 | ||
4007 | c) Repeat step (b) on the ELSE_CLAUSE. | |
4008 | ||
4009 | d) Mark X and Y in FOUND_IN_SUBGRAPH. | |
4010 | ||
4011 | For instance, | |
4012 | ||
4013 | if (a == 9) | |
4014 | b = a; | |
4015 | else | |
4016 | b = c + 1; | |
4017 | ||
4018 | In this case, an assertion on the THEN clause is useful to | |
4019 | determine that 'a' is always 9 on that edge. However, an assertion | |
4020 | on the ELSE clause would be unnecessary. | |
4021 | ||
4022 | 4- If BB does not end in a conditional expression, then we recurse | |
4023 | into BB's dominator children. | |
4024 | ||
4025 | At the end of the recursive traversal, every SSA name will have a | |
4026 | list of locations where ASSERT_EXPRs should be added. When a new | |
4027 | location for name N is found, it is registered by calling | |
4028 | register_new_assert_for. That function keeps track of all the | |
4029 | registered assertions to prevent adding unnecessary assertions. | |
4030 | For instance, if a pointer P_4 is dereferenced more than once in a | |
4031 | dominator tree, only the location dominating all the dereference of | |
4032 | P_4 will receive an ASSERT_EXPR. | |
4033 | ||
4034 | If this function returns true, then it means that there are names | |
4035 | for which we need to generate ASSERT_EXPRs. Those assertions are | |
9bb6aa43 | 4036 | inserted by process_assert_insertions. */ |
227858d1 DN |
4037 | |
4038 | static bool | |
4039 | find_assert_locations (basic_block bb) | |
4040 | { | |
4041 | block_stmt_iterator si; | |
4042 | tree last, phi; | |
4043 | bool need_assert; | |
4044 | basic_block son; | |
4045 | ||
4046 | if (TEST_BIT (blocks_visited, bb->index)) | |
4047 | return false; | |
4048 | ||
4049 | SET_BIT (blocks_visited, bb->index); | |
4050 | ||
4051 | need_assert = false; | |
4052 | ||
4053 | /* Traverse all PHI nodes in BB marking used operands. */ | |
4054 | for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi)) | |
4055 | { | |
4056 | use_operand_p arg_p; | |
4057 | ssa_op_iter i; | |
4058 | ||
4059 | FOR_EACH_PHI_ARG (arg_p, phi, i, SSA_OP_USE) | |
4060 | { | |
4061 | tree arg = USE_FROM_PTR (arg_p); | |
4062 | if (TREE_CODE (arg) == SSA_NAME) | |
4063 | { | |
4064 | gcc_assert (is_gimple_reg (PHI_RESULT (phi))); | |
4065 | SET_BIT (found_in_subgraph, SSA_NAME_VERSION (arg)); | |
4066 | } | |
4067 | } | |
4068 | } | |
4069 | ||
4070 | /* Traverse all the statements in BB marking used names and looking | |
4071 | for statements that may infer assertions for their used operands. */ | |
4072 | last = NULL_TREE; | |
4073 | for (si = bsi_start (bb); !bsi_end_p (si); bsi_next (&si)) | |
4074 | { | |
4075 | tree stmt, op; | |
4076 | ssa_op_iter i; | |
4077 | ||
4078 | stmt = bsi_stmt (si); | |
4079 | ||
4080 | /* See if we can derive an assertion for any of STMT's operands. */ | |
4081 | FOR_EACH_SSA_TREE_OPERAND (op, stmt, i, SSA_OP_USE) | |
4082 | { | |
4083 | tree value; | |
4084 | enum tree_code comp_code; | |
4085 | ||
4086 | /* Mark OP in bitmap FOUND_IN_SUBGRAPH. If STMT is inside | |
4087 | the sub-graph of a conditional block, when we return from | |
4088 | this recursive walk, our parent will use the | |
4089 | FOUND_IN_SUBGRAPH bitset to determine if one of the | |
4090 | operands it was looking for was present in the sub-graph. */ | |
4091 | SET_BIT (found_in_subgraph, SSA_NAME_VERSION (op)); | |
4092 | ||
227858d1 DN |
4093 | /* If OP is used in such a way that we can infer a value |
4094 | range for it, and we don't find a previous assertion for | |
4095 | it, create a new assertion location node for OP. */ | |
4096 | if (infer_value_range (stmt, op, &comp_code, &value)) | |
4097 | { | |
917f1b7e | 4098 | /* If we are able to infer a nonzero value range for OP, |
60c9ad46 JL |
4099 | then walk backwards through the use-def chain to see if OP |
4100 | was set via a typecast. | |
4101 | ||
4102 | If so, then we can also infer a nonzero value range | |
4103 | for the operand of the NOP_EXPR. */ | |
4104 | if (comp_code == NE_EXPR && integer_zerop (value)) | |
4105 | { | |
4106 | tree t = op; | |
4107 | tree def_stmt = SSA_NAME_DEF_STMT (t); | |
4108 | ||
07beea0d AH |
4109 | while (TREE_CODE (def_stmt) == GIMPLE_MODIFY_STMT |
4110 | && TREE_CODE | |
4111 | (GIMPLE_STMT_OPERAND (def_stmt, 1)) == NOP_EXPR | |
4112 | && TREE_CODE | |
4113 | (TREE_OPERAND (GIMPLE_STMT_OPERAND (def_stmt, 1), | |
4114 | 0)) == SSA_NAME | |
4115 | && POINTER_TYPE_P | |
4116 | (TREE_TYPE (TREE_OPERAND | |
4117 | (GIMPLE_STMT_OPERAND (def_stmt, | |
4118 | 1), 0)))) | |
60c9ad46 | 4119 | { |
07beea0d | 4120 | t = TREE_OPERAND (GIMPLE_STMT_OPERAND (def_stmt, 1), 0); |
60c9ad46 JL |
4121 | def_stmt = SSA_NAME_DEF_STMT (t); |
4122 | ||
4123 | /* Note we want to register the assert for the | |
4124 | operand of the NOP_EXPR after SI, not after the | |
4125 | conversion. */ | |
4126 | if (! has_single_use (t)) | |
4127 | { | |
4128 | register_new_assert_for (t, comp_code, value, | |
4129 | bb, NULL, si); | |
4130 | need_assert = true; | |
4131 | } | |
4132 | } | |
4133 | } | |
4134 | ||
4135 | /* If OP is used only once, namely in this STMT, don't | |
4136 | bother creating an ASSERT_EXPR for it. Such an | |
4137 | ASSERT_EXPR would do nothing but increase compile time. */ | |
4138 | if (!has_single_use (op)) | |
4139 | { | |
4140 | register_new_assert_for (op, comp_code, value, bb, NULL, si); | |
4141 | need_assert = true; | |
4142 | } | |
0bca51f0 DN |
4143 | } |
4144 | } | |
4145 | ||
4146 | /* Remember the last statement of the block. */ | |
4147 | last = stmt; | |
4148 | } | |
4149 | ||
227858d1 | 4150 | /* If BB's last statement is a conditional expression |
0bca51f0 | 4151 | involving integer operands, recurse into each of the sub-graphs |
227858d1 | 4152 | rooted at BB to determine if we need to add ASSERT_EXPRs. */ |
0bca51f0 DN |
4153 | if (last |
4154 | && TREE_CODE (last) == COND_EXPR | |
4155 | && !fp_predicate (COND_EXPR_COND (last)) | |
f47c96aa | 4156 | && !ZERO_SSA_OPERANDS (last, SSA_OP_USE)) |
279f3eb5 | 4157 | need_assert |= find_conditional_asserts (bb, last); |
227858d1 | 4158 | |
9bb6aa43 RG |
4159 | if (last |
4160 | && TREE_CODE (last) == SWITCH_EXPR | |
4161 | && !ZERO_SSA_OPERANDS (last, SSA_OP_USE)) | |
4162 | need_assert |= find_switch_asserts (bb, last); | |
4163 | ||
227858d1 DN |
4164 | /* Recurse into the dominator children of BB. */ |
4165 | for (son = first_dom_son (CDI_DOMINATORS, bb); | |
4166 | son; | |
4167 | son = next_dom_son (CDI_DOMINATORS, son)) | |
4168 | need_assert |= find_assert_locations (son); | |
4169 | ||
4170 | return need_assert; | |
4171 | } | |
4172 | ||
4173 | ||
4174 | /* Create an ASSERT_EXPR for NAME and insert it in the location | |
4175 | indicated by LOC. Return true if we made any edge insertions. */ | |
4176 | ||
4177 | static bool | |
4178 | process_assert_insertions_for (tree name, assert_locus_t loc) | |
4179 | { | |
4180 | /* Build the comparison expression NAME_i COMP_CODE VAL. */ | |
4181 | tree stmt, cond, assert_expr; | |
4182 | edge_iterator ei; | |
4183 | edge e; | |
4184 | ||
0d451405 | 4185 | cond = build2 (loc->comp_code, boolean_type_node, name, loc->val); |
227858d1 DN |
4186 | assert_expr = build_assert_expr_for (cond, name); |
4187 | ||
4188 | if (loc->e) | |
0bca51f0 | 4189 | { |
227858d1 DN |
4190 | /* We have been asked to insert the assertion on an edge. This |
4191 | is used only by COND_EXPR and SWITCH_EXPR assertions. */ | |
4192 | #if defined ENABLE_CHECKING | |
4193 | gcc_assert (TREE_CODE (bsi_stmt (loc->si)) == COND_EXPR | |
4194 | || TREE_CODE (bsi_stmt (loc->si)) == SWITCH_EXPR); | |
4195 | #endif | |
0bca51f0 | 4196 | |
227858d1 DN |
4197 | bsi_insert_on_edge (loc->e, assert_expr); |
4198 | return true; | |
4199 | } | |
9fabf0d4 | 4200 | |
227858d1 DN |
4201 | /* Otherwise, we can insert right after LOC->SI iff the |
4202 | statement must not be the last statement in the block. */ | |
4203 | stmt = bsi_stmt (loc->si); | |
4204 | if (!stmt_ends_bb_p (stmt)) | |
4205 | { | |
4206 | bsi_insert_after (&loc->si, assert_expr, BSI_SAME_STMT); | |
4207 | return false; | |
4208 | } | |
9fabf0d4 | 4209 | |
227858d1 DN |
4210 | /* If STMT must be the last statement in BB, we can only insert new |
4211 | assertions on the non-abnormal edge out of BB. Note that since | |
4212 | STMT is not control flow, there may only be one non-abnormal edge | |
4213 | out of BB. */ | |
4214 | FOR_EACH_EDGE (e, ei, loc->bb->succs) | |
4215 | if (!(e->flags & EDGE_ABNORMAL)) | |
4216 | { | |
4217 | bsi_insert_on_edge (e, assert_expr); | |
4218 | return true; | |
4219 | } | |
0bca51f0 | 4220 | |
227858d1 DN |
4221 | gcc_unreachable (); |
4222 | } | |
0bca51f0 | 4223 | |
0bca51f0 | 4224 | |
227858d1 DN |
4225 | /* Process all the insertions registered for every name N_i registered |
4226 | in NEED_ASSERT_FOR. The list of assertions to be inserted are | |
4227 | found in ASSERTS_FOR[i]. */ | |
0bca51f0 | 4228 | |
227858d1 DN |
4229 | static void |
4230 | process_assert_insertions (void) | |
4231 | { | |
4232 | unsigned i; | |
4233 | bitmap_iterator bi; | |
4234 | bool update_edges_p = false; | |
4235 | int num_asserts = 0; | |
0bca51f0 | 4236 | |
227858d1 DN |
4237 | if (dump_file && (dump_flags & TDF_DETAILS)) |
4238 | dump_all_asserts (dump_file); | |
60b4ccde | 4239 | |
227858d1 DN |
4240 | EXECUTE_IF_SET_IN_BITMAP (need_assert_for, 0, i, bi) |
4241 | { | |
4242 | assert_locus_t loc = asserts_for[i]; | |
4243 | gcc_assert (loc); | |
4244 | ||
4245 | while (loc) | |
60b4ccde | 4246 | { |
227858d1 DN |
4247 | assert_locus_t next = loc->next; |
4248 | update_edges_p |= process_assert_insertions_for (ssa_name (i), loc); | |
4249 | free (loc); | |
4250 | loc = next; | |
4251 | num_asserts++; | |
60b4ccde | 4252 | } |
0bca51f0 | 4253 | } |
0bca51f0 | 4254 | |
227858d1 DN |
4255 | if (update_edges_p) |
4256 | bsi_commit_edge_inserts (); | |
0bca51f0 | 4257 | |
227858d1 DN |
4258 | if (dump_file && (dump_flags & TDF_STATS)) |
4259 | fprintf (dump_file, "\nNumber of ASSERT_EXPR expressions inserted: %d\n\n", | |
4260 | num_asserts); | |
0bca51f0 DN |
4261 | } |
4262 | ||
4263 | ||
4264 | /* Traverse the flowgraph looking for conditional jumps to insert range | |
4265 | expressions. These range expressions are meant to provide information | |
4266 | to optimizations that need to reason in terms of value ranges. They | |
4267 | will not be expanded into RTL. For instance, given: | |
4268 | ||
4269 | x = ... | |
4270 | y = ... | |
4271 | if (x < y) | |
4272 | y = x - 2; | |
4273 | else | |
4274 | x = y + 3; | |
4275 | ||
4276 | this pass will transform the code into: | |
4277 | ||
4278 | x = ... | |
4279 | y = ... | |
4280 | if (x < y) | |
4281 | { | |
4282 | x = ASSERT_EXPR <x, x < y> | |
4283 | y = x - 2 | |
4284 | } | |
4285 | else | |
4286 | { | |
4287 | y = ASSERT_EXPR <y, x <= y> | |
4288 | x = y + 3 | |
4289 | } | |
4290 | ||
4291 | The idea is that once copy and constant propagation have run, other | |
4292 | optimizations will be able to determine what ranges of values can 'x' | |
4293 | take in different paths of the code, simply by checking the reaching | |
4294 | definition of 'x'. */ | |
4295 | ||
4296 | static void | |
4297 | insert_range_assertions (void) | |
4298 | { | |
4299 | edge e; | |
4300 | edge_iterator ei; | |
4301 | bool update_ssa_p; | |
4302 | ||
227858d1 DN |
4303 | found_in_subgraph = sbitmap_alloc (num_ssa_names); |
4304 | sbitmap_zero (found_in_subgraph); | |
4305 | ||
4306 | blocks_visited = sbitmap_alloc (last_basic_block); | |
4307 | sbitmap_zero (blocks_visited); | |
4308 | ||
4309 | need_assert_for = BITMAP_ALLOC (NULL); | |
b9eae1a9 | 4310 | asserts_for = XCNEWVEC (assert_locus_t, num_ssa_names); |
0bca51f0 DN |
4311 | |
4312 | calculate_dominance_info (CDI_DOMINATORS); | |
4313 | ||
4314 | update_ssa_p = false; | |
4315 | FOR_EACH_EDGE (e, ei, ENTRY_BLOCK_PTR->succs) | |
227858d1 | 4316 | if (find_assert_locations (e->dest)) |
0bca51f0 DN |
4317 | update_ssa_p = true; |
4318 | ||
4319 | if (update_ssa_p) | |
4320 | { | |
227858d1 | 4321 | process_assert_insertions (); |
0bca51f0 DN |
4322 | update_ssa (TODO_update_ssa_no_phi); |
4323 | } | |
4324 | ||
4325 | if (dump_file && (dump_flags & TDF_DETAILS)) | |
4326 | { | |
4327 | fprintf (dump_file, "\nSSA form after inserting ASSERT_EXPRs\n"); | |
4328 | dump_function_to_file (current_function_decl, dump_file, dump_flags); | |
4329 | } | |
4330 | ||
227858d1 DN |
4331 | sbitmap_free (found_in_subgraph); |
4332 | free (asserts_for); | |
4333 | BITMAP_FREE (need_assert_for); | |
0bca51f0 DN |
4334 | } |
4335 | ||
590b1f2d DM |
4336 | /* Checks one ARRAY_REF in REF, located at LOCUS. Ignores flexible arrays |
4337 | and "struct" hacks. If VRP can determine that the | |
9f5ed61a | 4338 | array subscript is a constant, check if it is outside valid |
590b1f2d DM |
4339 | range. If the array subscript is a RANGE, warn if it is |
4340 | non-overlapping with valid range. | |
4341 | IGNORE_OFF_BY_ONE is true if the ARRAY_REF is inside a ADDR_EXPR. */ | |
4342 | ||
4343 | static void | |
4344 | check_array_ref (tree ref, location_t* locus, bool ignore_off_by_one) | |
4345 | { | |
4346 | value_range_t* vr = NULL; | |
4347 | tree low_sub, up_sub; | |
4348 | tree low_bound, up_bound = array_ref_up_bound (ref); | |
4349 | ||
4350 | low_sub = up_sub = TREE_OPERAND (ref, 1); | |
4351 | ||
88df9da1 | 4352 | if (!up_bound || TREE_NO_WARNING (ref) |
590b1f2d DM |
4353 | || TREE_CODE (up_bound) != INTEGER_CST |
4354 | /* Can not check flexible arrays. */ | |
4355 | || (TYPE_SIZE (TREE_TYPE (ref)) == NULL_TREE | |
4356 | && TYPE_DOMAIN (TREE_TYPE (ref)) != NULL_TREE | |
4357 | && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (ref))) == NULL_TREE) | |
4358 | /* Accesses after the end of arrays of size 0 (gcc | |
4359 | extension) and 1 are likely intentional ("struct | |
4360 | hack"). */ | |
4361 | || compare_tree_int (up_bound, 1) <= 0) | |
4362 | return; | |
4363 | ||
4364 | low_bound = array_ref_low_bound (ref); | |
4365 | ||
4366 | if (TREE_CODE (low_sub) == SSA_NAME) | |
4367 | { | |
4368 | vr = get_value_range (low_sub); | |
4369 | if (vr->type == VR_RANGE || vr->type == VR_ANTI_RANGE) | |
4370 | { | |
4371 | low_sub = vr->type == VR_RANGE ? vr->max : vr->min; | |
4372 | up_sub = vr->type == VR_RANGE ? vr->min : vr->max; | |
4373 | } | |
4374 | } | |
4375 | ||
4376 | if (vr && vr->type == VR_ANTI_RANGE) | |
4377 | { | |
4378 | if (TREE_CODE (up_sub) == INTEGER_CST | |
4379 | && tree_int_cst_lt (up_bound, up_sub) | |
4380 | && TREE_CODE (low_sub) == INTEGER_CST | |
4381 | && tree_int_cst_lt (low_sub, low_bound)) | |
4382 | { | |
4383 | warning (OPT_Warray_bounds, | |
4384 | "%Harray subscript is outside array bounds", locus); | |
4385 | TREE_NO_WARNING (ref) = 1; | |
4386 | } | |
4387 | } | |
4388 | else if (TREE_CODE (up_sub) == INTEGER_CST | |
4389 | && tree_int_cst_lt (up_bound, up_sub) | |
4390 | && !tree_int_cst_equal (up_bound, up_sub) | |
4391 | && (!ignore_off_by_one | |
4392 | || !tree_int_cst_equal (int_const_binop (PLUS_EXPR, | |
4393 | up_bound, | |
4394 | integer_one_node, | |
4395 | 0), | |
4396 | up_sub))) | |
4397 | { | |
4398 | warning (OPT_Warray_bounds, "%Harray subscript is above array bounds", | |
4399 | locus); | |
4400 | TREE_NO_WARNING (ref) = 1; | |
4401 | } | |
4402 | else if (TREE_CODE (low_sub) == INTEGER_CST | |
4403 | && tree_int_cst_lt (low_sub, low_bound)) | |
4404 | { | |
4405 | warning (OPT_Warray_bounds, "%Harray subscript is below array bounds", | |
4406 | locus); | |
4407 | TREE_NO_WARNING (ref) = 1; | |
4408 | } | |
4409 | } | |
4410 | ||
05fb69e4 DM |
4411 | /* Searches if the expr T, located at LOCATION computes |
4412 | address of an ARRAY_REF, and call check_array_ref on it. */ | |
4413 | ||
4414 | static void | |
4415 | search_for_addr_array(tree t, location_t* location) | |
4416 | { | |
4417 | while (TREE_CODE (t) == SSA_NAME) | |
4418 | { | |
4419 | t = SSA_NAME_DEF_STMT (t); | |
4420 | if (TREE_CODE (t) != GIMPLE_MODIFY_STMT) | |
4421 | return; | |
4422 | t = GIMPLE_STMT_OPERAND (t, 1); | |
4423 | } | |
4424 | ||
4425 | ||
4426 | /* We are only interested in addresses of ARRAY_REF's. */ | |
4427 | if (TREE_CODE (t) != ADDR_EXPR) | |
4428 | return; | |
4429 | ||
4430 | /* Check each ARRAY_REFs in the reference chain. */ | |
4431 | do | |
4432 | { | |
4433 | if (TREE_CODE (t) == ARRAY_REF) | |
4434 | check_array_ref (t, location, true /*ignore_off_by_one*/); | |
4435 | ||
4436 | t = TREE_OPERAND(t,0); | |
4437 | } | |
4438 | while (handled_component_p (t)); | |
4439 | } | |
4440 | ||
590b1f2d DM |
4441 | /* walk_tree() callback that checks if *TP is |
4442 | an ARRAY_REF inside an ADDR_EXPR (in which an array | |
4443 | subscript one outside the valid range is allowed). Call | |
4444 | check_array_ref for each ARRAY_REF found. The location is | |
4445 | passed in DATA. */ | |
4446 | ||
4447 | static tree | |
4448 | check_array_bounds (tree *tp, int *walk_subtree, void *data) | |
4449 | { | |
4450 | tree t = *tp; | |
1eb7b049 DM |
4451 | tree stmt = (tree)data; |
4452 | location_t *location = EXPR_LOCUS (stmt); | |
590b1f2d | 4453 | |
88df9da1 DM |
4454 | if (!EXPR_HAS_LOCATION (stmt)) |
4455 | { | |
4456 | *walk_subtree = FALSE; | |
4457 | return NULL_TREE; | |
4458 | } | |
4459 | ||
590b1f2d DM |
4460 | *walk_subtree = TRUE; |
4461 | ||
4462 | if (TREE_CODE (t) == ARRAY_REF) | |
4463 | check_array_ref (t, location, false /*ignore_off_by_one*/); | |
1eb7b049 | 4464 | |
05fb69e4 DM |
4465 | if (TREE_CODE (t) == INDIRECT_REF |
4466 | || (TREE_CODE (t) == RETURN_EXPR && TREE_OPERAND (t, 0))) | |
4467 | search_for_addr_array (TREE_OPERAND (t, 0), location); | |
4468 | else if (TREE_CODE (t) == CALL_EXPR) | |
4469 | { | |
4470 | tree arg; | |
4471 | call_expr_arg_iterator iter; | |
1eb7b049 | 4472 | |
05fb69e4 DM |
4473 | FOR_EACH_CALL_EXPR_ARG (arg, iter, t) |
4474 | search_for_addr_array (arg, location); | |
590b1f2d DM |
4475 | } |
4476 | ||
05fb69e4 DM |
4477 | if (TREE_CODE (t) == ADDR_EXPR) |
4478 | *walk_subtree = FALSE; | |
4479 | ||
590b1f2d DM |
4480 | return NULL_TREE; |
4481 | } | |
4482 | ||
4483 | /* Walk over all statements of all reachable BBs and call check_array_bounds | |
4484 | on them. */ | |
4485 | ||
4486 | static void | |
4487 | check_all_array_refs (void) | |
4488 | { | |
4489 | basic_block bb; | |
4490 | block_stmt_iterator si; | |
4491 | ||
4492 | FOR_EACH_BB (bb) | |
4493 | { | |
4494 | /* Skip bb's that are clearly unreachable. */ | |
4495 | if (single_pred_p (bb)) | |
4496 | { | |
4497 | basic_block pred_bb = EDGE_PRED (bb, 0)->src; | |
4498 | tree ls = NULL_TREE; | |
4499 | ||
4500 | if (!bsi_end_p (bsi_last (pred_bb))) | |
4501 | ls = bsi_stmt (bsi_last (pred_bb)); | |
4502 | ||
4503 | if (ls && TREE_CODE (ls) == COND_EXPR | |
4504 | && ((COND_EXPR_COND (ls) == boolean_false_node | |
4505 | && (EDGE_PRED (bb, 0)->flags & EDGE_TRUE_VALUE)) | |
4506 | || (COND_EXPR_COND (ls) == boolean_true_node | |
4507 | && (EDGE_PRED (bb, 0)->flags & EDGE_FALSE_VALUE)))) | |
4508 | continue; | |
4509 | } | |
4510 | for (si = bsi_start (bb); !bsi_end_p (si); bsi_next (&si)) | |
4511 | walk_tree (bsi_stmt_ptr (si), check_array_bounds, | |
4512 | bsi_stmt (si), NULL); | |
4513 | } | |
4514 | } | |
0bca51f0 | 4515 | |
94908762 JL |
4516 | /* Convert range assertion expressions into the implied copies and |
4517 | copy propagate away the copies. Doing the trivial copy propagation | |
4518 | here avoids the need to run the full copy propagation pass after | |
4519 | VRP. | |
227858d1 DN |
4520 | |
4521 | FIXME, this will eventually lead to copy propagation removing the | |
4522 | names that had useful range information attached to them. For | |
4523 | instance, if we had the assertion N_i = ASSERT_EXPR <N_j, N_j > 3>, | |
4524 | then N_i will have the range [3, +INF]. | |
4525 | ||
4526 | However, by converting the assertion into the implied copy | |
4527 | operation N_i = N_j, we will then copy-propagate N_j into the uses | |
4528 | of N_i and lose the range information. We may want to hold on to | |
4529 | ASSERT_EXPRs a little while longer as the ranges could be used in | |
4530 | things like jump threading. | |
4531 | ||
4532 | The problem with keeping ASSERT_EXPRs around is that passes after | |
94908762 JL |
4533 | VRP need to handle them appropriately. |
4534 | ||
4535 | Another approach would be to make the range information a first | |
4536 | class property of the SSA_NAME so that it can be queried from | |
4537 | any pass. This is made somewhat more complex by the need for | |
4538 | multiple ranges to be associated with one SSA_NAME. */ | |
0bca51f0 DN |
4539 | |
4540 | static void | |
4541 | remove_range_assertions (void) | |
4542 | { | |
4543 | basic_block bb; | |
4544 | block_stmt_iterator si; | |
4545 | ||
94908762 JL |
4546 | /* Note that the BSI iterator bump happens at the bottom of the |
4547 | loop and no bump is necessary if we're removing the statement | |
4548 | referenced by the current BSI. */ | |
0bca51f0 | 4549 | FOR_EACH_BB (bb) |
94908762 | 4550 | for (si = bsi_start (bb); !bsi_end_p (si);) |
0bca51f0 DN |
4551 | { |
4552 | tree stmt = bsi_stmt (si); | |
6c00f606 | 4553 | tree use_stmt; |
0bca51f0 | 4554 | |
07beea0d AH |
4555 | if (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT |
4556 | && TREE_CODE (GIMPLE_STMT_OPERAND (stmt, 1)) == ASSERT_EXPR) | |
0bca51f0 | 4557 | { |
07beea0d | 4558 | tree rhs = GIMPLE_STMT_OPERAND (stmt, 1), var; |
0bca51f0 | 4559 | tree cond = fold (ASSERT_EXPR_COND (rhs)); |
94908762 JL |
4560 | use_operand_p use_p; |
4561 | imm_use_iterator iter; | |
4562 | ||
0bca51f0 | 4563 | gcc_assert (cond != boolean_false_node); |
94908762 | 4564 | |
701b8964 ZD |
4565 | /* Propagate the RHS into every use of the LHS. */ |
4566 | var = ASSERT_EXPR_VAR (rhs); | |
07beea0d AH |
4567 | FOR_EACH_IMM_USE_STMT (use_stmt, iter, |
4568 | GIMPLE_STMT_OPERAND (stmt, 0)) | |
6c00f606 AM |
4569 | FOR_EACH_IMM_USE_ON_STMT (use_p, iter) |
4570 | { | |
4571 | SET_USE (use_p, var); | |
4572 | gcc_assert (TREE_CODE (var) == SSA_NAME); | |
4573 | } | |
94908762 JL |
4574 | |
4575 | /* And finally, remove the copy, it is not needed. */ | |
736432ee | 4576 | bsi_remove (&si, true); |
ca15e365 | 4577 | release_defs (stmt); |
0bca51f0 | 4578 | } |
94908762 JL |
4579 | else |
4580 | bsi_next (&si); | |
0bca51f0 | 4581 | } |
f7acf1c2 RG |
4582 | |
4583 | sbitmap_free (blocks_visited); | |
0bca51f0 DN |
4584 | } |
4585 | ||
4586 | ||
4587 | /* Return true if STMT is interesting for VRP. */ | |
4588 | ||
4589 | static bool | |
4590 | stmt_interesting_for_vrp (tree stmt) | |
4591 | { | |
4592 | if (TREE_CODE (stmt) == PHI_NODE | |
4593 | && is_gimple_reg (PHI_RESULT (stmt)) | |
4594 | && (INTEGRAL_TYPE_P (TREE_TYPE (PHI_RESULT (stmt))) | |
4595 | || POINTER_TYPE_P (TREE_TYPE (PHI_RESULT (stmt))))) | |
4596 | return true; | |
07beea0d | 4597 | else if (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT) |
0bca51f0 | 4598 | { |
07beea0d AH |
4599 | tree lhs = GIMPLE_STMT_OPERAND (stmt, 0); |
4600 | tree rhs = GIMPLE_STMT_OPERAND (stmt, 1); | |
0bca51f0 | 4601 | |
2bbec6d9 JL |
4602 | /* In general, assignments with virtual operands are not useful |
4603 | for deriving ranges, with the obvious exception of calls to | |
4604 | builtin functions. */ | |
0bca51f0 DN |
4605 | if (TREE_CODE (lhs) == SSA_NAME |
4606 | && (INTEGRAL_TYPE_P (TREE_TYPE (lhs)) | |
4607 | || POINTER_TYPE_P (TREE_TYPE (lhs))) | |
2bbec6d9 | 4608 | && ((TREE_CODE (rhs) == CALL_EXPR |
5039610b SL |
4609 | && TREE_CODE (CALL_EXPR_FN (rhs)) == ADDR_EXPR |
4610 | && DECL_P (TREE_OPERAND (CALL_EXPR_FN (rhs), 0)) | |
4611 | && DECL_IS_BUILTIN (TREE_OPERAND (CALL_EXPR_FN (rhs), 0))) | |
2bbec6d9 | 4612 | || ZERO_SSA_OPERANDS (stmt, SSA_OP_ALL_VIRTUALS))) |
0bca51f0 DN |
4613 | return true; |
4614 | } | |
4615 | else if (TREE_CODE (stmt) == COND_EXPR || TREE_CODE (stmt) == SWITCH_EXPR) | |
4616 | return true; | |
4617 | ||
4618 | return false; | |
4619 | } | |
4620 | ||
4621 | ||
87e71ff4 | 4622 | /* Initialize local data structures for VRP. */ |
0bca51f0 | 4623 | |
227858d1 | 4624 | static void |
0bca51f0 DN |
4625 | vrp_initialize (void) |
4626 | { | |
4627 | basic_block bb; | |
0bca51f0 | 4628 | |
b9eae1a9 | 4629 | vr_value = XCNEWVEC (value_range_t *, num_ssa_names); |
fc6827fe | 4630 | vr_phi_edge_counts = XCNEWVEC (int, num_ssa_names); |
0bca51f0 DN |
4631 | |
4632 | FOR_EACH_BB (bb) | |
4633 | { | |
4634 | block_stmt_iterator si; | |
4635 | tree phi; | |
4636 | ||
4637 | for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi)) | |
4638 | { | |
4639 | if (!stmt_interesting_for_vrp (phi)) | |
4640 | { | |
4641 | tree lhs = PHI_RESULT (phi); | |
b565d777 | 4642 | set_value_range_to_varying (get_value_range (lhs)); |
0bca51f0 DN |
4643 | DONT_SIMULATE_AGAIN (phi) = true; |
4644 | } | |
4645 | else | |
4646 | DONT_SIMULATE_AGAIN (phi) = false; | |
4647 | } | |
4648 | ||
4649 | for (si = bsi_start (bb); !bsi_end_p (si); bsi_next (&si)) | |
4650 | { | |
4651 | tree stmt = bsi_stmt (si); | |
4652 | ||
4653 | if (!stmt_interesting_for_vrp (stmt)) | |
4654 | { | |
4655 | ssa_op_iter i; | |
4656 | tree def; | |
4657 | FOR_EACH_SSA_TREE_OPERAND (def, stmt, i, SSA_OP_DEF) | |
b565d777 | 4658 | set_value_range_to_varying (get_value_range (def)); |
0bca51f0 DN |
4659 | DONT_SIMULATE_AGAIN (stmt) = true; |
4660 | } | |
4661 | else | |
4662 | { | |
0bca51f0 DN |
4663 | DONT_SIMULATE_AGAIN (stmt) = false; |
4664 | } | |
4665 | } | |
4666 | } | |
0bca51f0 DN |
4667 | } |
4668 | ||
4669 | ||
4670 | /* Visit assignment STMT. If it produces an interesting range, record | |
4671 | the SSA name in *OUTPUT_P. */ | |
4672 | ||
4673 | static enum ssa_prop_result | |
4674 | vrp_visit_assignment (tree stmt, tree *output_p) | |
4675 | { | |
4676 | tree lhs, rhs, def; | |
4677 | ssa_op_iter iter; | |
4678 | ||
07beea0d AH |
4679 | lhs = GIMPLE_STMT_OPERAND (stmt, 0); |
4680 | rhs = GIMPLE_STMT_OPERAND (stmt, 1); | |
0bca51f0 DN |
4681 | |
4682 | /* We only keep track of ranges in integral and pointer types. */ | |
4683 | if (TREE_CODE (lhs) == SSA_NAME | |
e260a614 JL |
4684 | && ((INTEGRAL_TYPE_P (TREE_TYPE (lhs)) |
4685 | /* It is valid to have NULL MIN/MAX values on a type. See | |
4686 | build_range_type. */ | |
4687 | && TYPE_MIN_VALUE (TREE_TYPE (lhs)) | |
4688 | && TYPE_MAX_VALUE (TREE_TYPE (lhs))) | |
0bca51f0 DN |
4689 | || POINTER_TYPE_P (TREE_TYPE (lhs)))) |
4690 | { | |
0bca51f0 | 4691 | struct loop *l; |
227858d1 DN |
4692 | value_range_t new_vr = { VR_UNDEFINED, NULL_TREE, NULL_TREE, NULL }; |
4693 | ||
0bca51f0 DN |
4694 | extract_range_from_expr (&new_vr, rhs); |
4695 | ||
4696 | /* If STMT is inside a loop, we may be able to know something | |
4697 | else about the range of LHS by examining scalar evolution | |
4698 | information. */ | |
d78f3f78 | 4699 | if (current_loops && (l = loop_containing_stmt (stmt))) |
1e8552eb | 4700 | adjust_range_with_scev (&new_vr, l, stmt, lhs); |
0bca51f0 | 4701 | |
227858d1 | 4702 | if (update_value_range (lhs, &new_vr)) |
0bca51f0 DN |
4703 | { |
4704 | *output_p = lhs; | |
4705 | ||
4706 | if (dump_file && (dump_flags & TDF_DETAILS)) | |
4707 | { | |
227858d1 | 4708 | fprintf (dump_file, "Found new range for "); |
0bca51f0 | 4709 | print_generic_expr (dump_file, lhs, 0); |
227858d1 DN |
4710 | fprintf (dump_file, ": "); |
4711 | dump_value_range (dump_file, &new_vr); | |
0bca51f0 DN |
4712 | fprintf (dump_file, "\n\n"); |
4713 | } | |
4714 | ||
4715 | if (new_vr.type == VR_VARYING) | |
4716 | return SSA_PROP_VARYING; | |
4717 | ||
4718 | return SSA_PROP_INTERESTING; | |
4719 | } | |
4720 | ||
4721 | return SSA_PROP_NOT_INTERESTING; | |
4722 | } | |
4723 | ||
227858d1 | 4724 | /* Every other statement produces no useful ranges. */ |
0bca51f0 | 4725 | FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_DEF) |
b565d777 | 4726 | set_value_range_to_varying (get_value_range (def)); |
0bca51f0 DN |
4727 | |
4728 | return SSA_PROP_VARYING; | |
4729 | } | |
4730 | ||
f5052e29 | 4731 | /* Helper that gets the value range of the SSA_NAME with version I |
c80b4100 | 4732 | or a symbolic range containing the SSA_NAME only if the value range |
f5052e29 RG |
4733 | is varying or undefined. */ |
4734 | ||
4735 | static inline value_range_t | |
4736 | get_vr_for_comparison (int i) | |
4737 | { | |
4738 | value_range_t vr = *(vr_value[i]); | |
4739 | ||
4740 | /* If name N_i does not have a valid range, use N_i as its own | |
4741 | range. This allows us to compare against names that may | |
4742 | have N_i in their ranges. */ | |
4743 | if (vr.type == VR_VARYING || vr.type == VR_UNDEFINED) | |
4744 | { | |
4745 | vr.type = VR_RANGE; | |
4746 | vr.min = ssa_name (i); | |
4747 | vr.max = ssa_name (i); | |
4748 | } | |
4749 | ||
4750 | return vr; | |
4751 | } | |
0bca51f0 | 4752 | |
227858d1 DN |
4753 | /* Compare all the value ranges for names equivalent to VAR with VAL |
4754 | using comparison code COMP. Return the same value returned by | |
12df8a7e ILT |
4755 | compare_range_with_value, including the setting of |
4756 | *STRICT_OVERFLOW_P. */ | |
227858d1 DN |
4757 | |
4758 | static tree | |
12df8a7e ILT |
4759 | compare_name_with_value (enum tree_code comp, tree var, tree val, |
4760 | bool *strict_overflow_p) | |
227858d1 DN |
4761 | { |
4762 | bitmap_iterator bi; | |
4763 | unsigned i; | |
4764 | bitmap e; | |
4765 | tree retval, t; | |
12df8a7e | 4766 | int used_strict_overflow; |
f5052e29 RG |
4767 | bool sop; |
4768 | value_range_t equiv_vr; | |
227858d1 DN |
4769 | |
4770 | /* Get the set of equivalences for VAR. */ | |
4771 | e = get_value_range (var)->equiv; | |
4772 | ||
12df8a7e ILT |
4773 | /* Start at -1. Set it to 0 if we do a comparison without relying |
4774 | on overflow, or 1 if all comparisons rely on overflow. */ | |
4775 | used_strict_overflow = -1; | |
4776 | ||
f5052e29 RG |
4777 | /* Compare vars' value range with val. */ |
4778 | equiv_vr = get_vr_for_comparison (SSA_NAME_VERSION (var)); | |
4779 | sop = false; | |
4780 | retval = compare_range_with_value (comp, &equiv_vr, val, &sop); | |
e07e405d ILT |
4781 | if (retval) |
4782 | used_strict_overflow = sop ? 1 : 0; | |
227858d1 | 4783 | |
f5052e29 RG |
4784 | /* If the equiv set is empty we have done all work we need to do. */ |
4785 | if (e == NULL) | |
4786 | { | |
4787 | if (retval | |
4788 | && used_strict_overflow > 0) | |
4789 | *strict_overflow_p = true; | |
4790 | return retval; | |
4791 | } | |
227858d1 | 4792 | |
f5052e29 RG |
4793 | EXECUTE_IF_SET_IN_BITMAP (e, 0, i, bi) |
4794 | { | |
4795 | equiv_vr = get_vr_for_comparison (i); | |
12df8a7e ILT |
4796 | sop = false; |
4797 | t = compare_range_with_value (comp, &equiv_vr, val, &sop); | |
227858d1 DN |
4798 | if (t) |
4799 | { | |
96644aba RG |
4800 | /* If we get different answers from different members |
4801 | of the equivalence set this check must be in a dead | |
4802 | code region. Folding it to a trap representation | |
4803 | would be correct here. For now just return don't-know. */ | |
4804 | if (retval != NULL | |
4805 | && t != retval) | |
4806 | { | |
4807 | retval = NULL_TREE; | |
4808 | break; | |
4809 | } | |
227858d1 | 4810 | retval = t; |
12df8a7e ILT |
4811 | |
4812 | if (!sop) | |
4813 | used_strict_overflow = 0; | |
4814 | else if (used_strict_overflow < 0) | |
4815 | used_strict_overflow = 1; | |
227858d1 DN |
4816 | } |
4817 | } | |
4818 | ||
f5052e29 RG |
4819 | if (retval |
4820 | && used_strict_overflow > 0) | |
4821 | *strict_overflow_p = true; | |
227858d1 | 4822 | |
f5052e29 | 4823 | return retval; |
227858d1 DN |
4824 | } |
4825 | ||
4826 | ||
4827 | /* Given a comparison code COMP and names N1 and N2, compare all the | |
8ab5f5c9 | 4828 | ranges equivalent to N1 against all the ranges equivalent to N2 |
227858d1 | 4829 | to determine the value of N1 COMP N2. Return the same value |
12df8a7e ILT |
4830 | returned by compare_ranges. Set *STRICT_OVERFLOW_P to indicate |
4831 | whether we relied on an overflow infinity in the comparison. */ | |
4832 | ||
0bca51f0 DN |
4833 | |
4834 | static tree | |
12df8a7e ILT |
4835 | compare_names (enum tree_code comp, tree n1, tree n2, |
4836 | bool *strict_overflow_p) | |
227858d1 DN |
4837 | { |
4838 | tree t, retval; | |
4839 | bitmap e1, e2; | |
4840 | bitmap_iterator bi1, bi2; | |
4841 | unsigned i1, i2; | |
12df8a7e | 4842 | int used_strict_overflow; |
f5052e29 RG |
4843 | static bitmap_obstack *s_obstack = NULL; |
4844 | static bitmap s_e1 = NULL, s_e2 = NULL; | |
227858d1 DN |
4845 | |
4846 | /* Compare the ranges of every name equivalent to N1 against the | |
4847 | ranges of every name equivalent to N2. */ | |
4848 | e1 = get_value_range (n1)->equiv; | |
4849 | e2 = get_value_range (n2)->equiv; | |
4850 | ||
f5052e29 RG |
4851 | /* Use the fake bitmaps if e1 or e2 are not available. */ |
4852 | if (s_obstack == NULL) | |
4853 | { | |
4854 | s_obstack = XNEW (bitmap_obstack); | |
4855 | bitmap_obstack_initialize (s_obstack); | |
4856 | s_e1 = BITMAP_ALLOC (s_obstack); | |
4857 | s_e2 = BITMAP_ALLOC (s_obstack); | |
4858 | } | |
4859 | if (e1 == NULL) | |
4860 | e1 = s_e1; | |
4861 | if (e2 == NULL) | |
4862 | e2 = s_e2; | |
4863 | ||
227858d1 DN |
4864 | /* Add N1 and N2 to their own set of equivalences to avoid |
4865 | duplicating the body of the loop just to check N1 and N2 | |
4866 | ranges. */ | |
4867 | bitmap_set_bit (e1, SSA_NAME_VERSION (n1)); | |
4868 | bitmap_set_bit (e2, SSA_NAME_VERSION (n2)); | |
4869 | ||
4870 | /* If the equivalence sets have a common intersection, then the two | |
4871 | names can be compared without checking their ranges. */ | |
4872 | if (bitmap_intersect_p (e1, e2)) | |
4873 | { | |
4874 | bitmap_clear_bit (e1, SSA_NAME_VERSION (n1)); | |
4875 | bitmap_clear_bit (e2, SSA_NAME_VERSION (n2)); | |
4876 | ||
4877 | return (comp == EQ_EXPR || comp == GE_EXPR || comp == LE_EXPR) | |
4878 | ? boolean_true_node | |
4879 | : boolean_false_node; | |
4880 | } | |
4881 | ||
12df8a7e ILT |
4882 | /* Start at -1. Set it to 0 if we do a comparison without relying |
4883 | on overflow, or 1 if all comparisons rely on overflow. */ | |
4884 | used_strict_overflow = -1; | |
4885 | ||
227858d1 DN |
4886 | /* Otherwise, compare all the equivalent ranges. First, add N1 and |
4887 | N2 to their own set of equivalences to avoid duplicating the body | |
4888 | of the loop just to check N1 and N2 ranges. */ | |
4889 | EXECUTE_IF_SET_IN_BITMAP (e1, 0, i1, bi1) | |
4890 | { | |
f5052e29 | 4891 | value_range_t vr1 = get_vr_for_comparison (i1); |
227858d1 DN |
4892 | |
4893 | t = retval = NULL_TREE; | |
4894 | EXECUTE_IF_SET_IN_BITMAP (e2, 0, i2, bi2) | |
4895 | { | |
3b7bab4d | 4896 | bool sop = false; |
12df8a7e | 4897 | |
f5052e29 | 4898 | value_range_t vr2 = get_vr_for_comparison (i2); |
227858d1 | 4899 | |
12df8a7e | 4900 | t = compare_ranges (comp, &vr1, &vr2, &sop); |
227858d1 DN |
4901 | if (t) |
4902 | { | |
96644aba RG |
4903 | /* If we get different answers from different members |
4904 | of the equivalence set this check must be in a dead | |
4905 | code region. Folding it to a trap representation | |
4906 | would be correct here. For now just return don't-know. */ | |
4907 | if (retval != NULL | |
4908 | && t != retval) | |
4909 | { | |
4910 | bitmap_clear_bit (e1, SSA_NAME_VERSION (n1)); | |
4911 | bitmap_clear_bit (e2, SSA_NAME_VERSION (n2)); | |
4912 | return NULL_TREE; | |
4913 | } | |
227858d1 | 4914 | retval = t; |
12df8a7e ILT |
4915 | |
4916 | if (!sop) | |
4917 | used_strict_overflow = 0; | |
4918 | else if (used_strict_overflow < 0) | |
4919 | used_strict_overflow = 1; | |
227858d1 DN |
4920 | } |
4921 | } | |
4922 | ||
4923 | if (retval) | |
4924 | { | |
4925 | bitmap_clear_bit (e1, SSA_NAME_VERSION (n1)); | |
4926 | bitmap_clear_bit (e2, SSA_NAME_VERSION (n2)); | |
12df8a7e ILT |
4927 | if (used_strict_overflow > 0) |
4928 | *strict_overflow_p = true; | |
227858d1 DN |
4929 | return retval; |
4930 | } | |
4931 | } | |
4932 | ||
4933 | /* None of the equivalent ranges are useful in computing this | |
4934 | comparison. */ | |
4935 | bitmap_clear_bit (e1, SSA_NAME_VERSION (n1)); | |
4936 | bitmap_clear_bit (e2, SSA_NAME_VERSION (n2)); | |
4937 | return NULL_TREE; | |
4938 | } | |
4939 | ||
4940 | ||
4941 | /* Given a conditional predicate COND, try to determine if COND yields | |
4942 | true or false based on the value ranges of its operands. Return | |
4943 | BOOLEAN_TRUE_NODE if the conditional always evaluates to true, | |
4944 | BOOLEAN_FALSE_NODE if the conditional always evaluates to false, and, | |
4945 | NULL if the conditional cannot be evaluated at compile time. | |
4946 | ||
4947 | If USE_EQUIV_P is true, the ranges of all the names equivalent with | |
4948 | the operands in COND are used when trying to compute its value. | |
4949 | This is only used during final substitution. During propagation, | |
12df8a7e ILT |
4950 | we only check the range of each variable and not its equivalents. |
4951 | ||
4952 | Set *STRICT_OVERFLOW_P to indicate whether we relied on an overflow | |
4953 | infinity to produce the result. */ | |
227858d1 | 4954 | |
0c948c27 ILT |
4955 | static tree |
4956 | vrp_evaluate_conditional_warnv (tree cond, bool use_equiv_p, | |
4957 | bool *strict_overflow_p) | |
0bca51f0 DN |
4958 | { |
4959 | gcc_assert (TREE_CODE (cond) == SSA_NAME | |
4960 | || TREE_CODE_CLASS (TREE_CODE (cond)) == tcc_comparison); | |
4961 | ||
4962 | if (TREE_CODE (cond) == SSA_NAME) | |
4963 | { | |
227858d1 DN |
4964 | value_range_t *vr; |
4965 | tree retval; | |
4966 | ||
4967 | if (use_equiv_p) | |
12df8a7e ILT |
4968 | retval = compare_name_with_value (NE_EXPR, cond, boolean_false_node, |
4969 | strict_overflow_p); | |
227858d1 DN |
4970 | else |
4971 | { | |
4972 | value_range_t *vr = get_value_range (cond); | |
12df8a7e ILT |
4973 | retval = compare_range_with_value (NE_EXPR, vr, boolean_false_node, |
4974 | strict_overflow_p); | |
227858d1 DN |
4975 | } |
4976 | ||
4977 | /* If COND has a known boolean range, return it. */ | |
4978 | if (retval) | |
4979 | return retval; | |
4980 | ||
4981 | /* Otherwise, if COND has a symbolic range of exactly one value, | |
4982 | return it. */ | |
4983 | vr = get_value_range (cond); | |
4984 | if (vr->type == VR_RANGE && vr->min == vr->max) | |
0bca51f0 DN |
4985 | return vr->min; |
4986 | } | |
4987 | else | |
4988 | { | |
227858d1 DN |
4989 | tree op0 = TREE_OPERAND (cond, 0); |
4990 | tree op1 = TREE_OPERAND (cond, 1); | |
0bca51f0 | 4991 | |
227858d1 DN |
4992 | /* We only deal with integral and pointer types. */ |
4993 | if (!INTEGRAL_TYPE_P (TREE_TYPE (op0)) | |
4994 | && !POINTER_TYPE_P (TREE_TYPE (op0))) | |
4995 | return NULL_TREE; | |
0bca51f0 | 4996 | |
227858d1 DN |
4997 | if (use_equiv_p) |
4998 | { | |
4999 | if (TREE_CODE (op0) == SSA_NAME && TREE_CODE (op1) == SSA_NAME) | |
12df8a7e ILT |
5000 | return compare_names (TREE_CODE (cond), op0, op1, |
5001 | strict_overflow_p); | |
227858d1 | 5002 | else if (TREE_CODE (op0) == SSA_NAME) |
12df8a7e ILT |
5003 | return compare_name_with_value (TREE_CODE (cond), op0, op1, |
5004 | strict_overflow_p); | |
227858d1 | 5005 | else if (TREE_CODE (op1) == SSA_NAME) |
12df8a7e ILT |
5006 | return (compare_name_with_value |
5007 | (swap_tree_comparison (TREE_CODE (cond)), op1, op0, | |
5008 | strict_overflow_p)); | |
227858d1 DN |
5009 | } |
5010 | else | |
5011 | { | |
5012 | value_range_t *vr0, *vr1; | |
5013 | ||
5014 | vr0 = (TREE_CODE (op0) == SSA_NAME) ? get_value_range (op0) : NULL; | |
5015 | vr1 = (TREE_CODE (op1) == SSA_NAME) ? get_value_range (op1) : NULL; | |
5016 | ||
5017 | if (vr0 && vr1) | |
12df8a7e ILT |
5018 | return compare_ranges (TREE_CODE (cond), vr0, vr1, |
5019 | strict_overflow_p); | |
227858d1 | 5020 | else if (vr0 && vr1 == NULL) |
12df8a7e ILT |
5021 | return compare_range_with_value (TREE_CODE (cond), vr0, op1, |
5022 | strict_overflow_p); | |
227858d1 | 5023 | else if (vr0 == NULL && vr1) |
12df8a7e ILT |
5024 | return (compare_range_with_value |
5025 | (swap_tree_comparison (TREE_CODE (cond)), vr1, op0, | |
5026 | strict_overflow_p)); | |
227858d1 | 5027 | } |
0bca51f0 DN |
5028 | } |
5029 | ||
5030 | /* Anything else cannot be computed statically. */ | |
5031 | return NULL_TREE; | |
5032 | } | |
5033 | ||
0c948c27 ILT |
5034 | /* Given COND within STMT, try to simplify it based on value range |
5035 | information. Return NULL if the conditional can not be evaluated. | |
5036 | The ranges of all the names equivalent with the operands in COND | |
5037 | will be used when trying to compute the value. If the result is | |
5038 | based on undefined signed overflow, issue a warning if | |
5039 | appropriate. */ | |
5040 | ||
5041 | tree | |
5042 | vrp_evaluate_conditional (tree cond, tree stmt) | |
5043 | { | |
5044 | bool sop; | |
5045 | tree ret; | |
5046 | ||
5047 | sop = false; | |
5048 | ret = vrp_evaluate_conditional_warnv (cond, true, &sop); | |
5049 | ||
5050 | if (ret && sop) | |
5051 | { | |
5052 | enum warn_strict_overflow_code wc; | |
5053 | const char* warnmsg; | |
5054 | ||
5055 | if (is_gimple_min_invariant (ret)) | |
5056 | { | |
5057 | wc = WARN_STRICT_OVERFLOW_CONDITIONAL; | |
5058 | warnmsg = G_("assuming signed overflow does not occur when " | |
5059 | "simplifying conditional to constant"); | |
5060 | } | |
5061 | else | |
5062 | { | |
5063 | wc = WARN_STRICT_OVERFLOW_COMPARISON; | |
5064 | warnmsg = G_("assuming signed overflow does not occur when " | |
5065 | "simplifying conditional"); | |
5066 | } | |
5067 | ||
5068 | if (issue_strict_overflow_warning (wc)) | |
5069 | { | |
5070 | location_t locus; | |
5071 | ||
5072 | if (!EXPR_HAS_LOCATION (stmt)) | |
5073 | locus = input_location; | |
5074 | else | |
5075 | locus = EXPR_LOCATION (stmt); | |
5076 | warning (OPT_Wstrict_overflow, "%H%s", &locus, warnmsg); | |
5077 | } | |
5078 | } | |
5079 | ||
faebccf9 DN |
5080 | if (warn_type_limits |
5081 | && ret | |
5082 | && TREE_CODE_CLASS (TREE_CODE (cond)) == tcc_comparison) | |
5083 | { | |
5084 | /* If the comparison is being folded and the operand on the LHS | |
5085 | is being compared against a constant value that is outside of | |
5086 | the natural range of OP0's type, then the predicate will | |
5087 | always fold regardless of the value of OP0. If -Wtype-limits | |
5088 | was specified, emit a warning. */ | |
5089 | const char *warnmsg = NULL; | |
5090 | tree op0 = TREE_OPERAND (cond, 0); | |
5091 | tree op1 = TREE_OPERAND (cond, 1); | |
5092 | tree type = TREE_TYPE (op0); | |
5093 | value_range_t *vr0 = get_value_range (op0); | |
5094 | ||
5095 | if (vr0->type != VR_VARYING | |
5096 | && INTEGRAL_TYPE_P (type) | |
5097 | && vrp_val_is_min (vr0->min) | |
5098 | && vrp_val_is_max (vr0->max) | |
5099 | && is_gimple_min_invariant (op1)) | |
5100 | { | |
5101 | if (integer_zerop (ret)) | |
5102 | warnmsg = G_("comparison always false due to limited range of " | |
5103 | "data type"); | |
5104 | else | |
5105 | warnmsg = G_("comparison always true due to limited range of " | |
5106 | "data type"); | |
5107 | } | |
5108 | ||
5109 | if (warnmsg) | |
5110 | { | |
5111 | location_t locus; | |
5112 | ||
5113 | if (!EXPR_HAS_LOCATION (stmt)) | |
5114 | locus = input_location; | |
5115 | else | |
5116 | locus = EXPR_LOCATION (stmt); | |
5117 | ||
5118 | warning (OPT_Wtype_limits, "%H%s", &locus, warnmsg); | |
5119 | } | |
5120 | } | |
5121 | ||
0c948c27 ILT |
5122 | return ret; |
5123 | } | |
5124 | ||
0bca51f0 DN |
5125 | |
5126 | /* Visit conditional statement STMT. If we can determine which edge | |
5127 | will be taken out of STMT's basic block, record it in | |
5128 | *TAKEN_EDGE_P and return SSA_PROP_INTERESTING. Otherwise, return | |
5129 | SSA_PROP_VARYING. */ | |
5130 | ||
5131 | static enum ssa_prop_result | |
5132 | vrp_visit_cond_stmt (tree stmt, edge *taken_edge_p) | |
5133 | { | |
5134 | tree cond, val; | |
12df8a7e | 5135 | bool sop; |
0bca51f0 DN |
5136 | |
5137 | *taken_edge_p = NULL; | |
5138 | ||
9bb6aa43 | 5139 | /* FIXME. Handle SWITCH_EXPRs. */ |
0bca51f0 DN |
5140 | if (TREE_CODE (stmt) == SWITCH_EXPR) |
5141 | return SSA_PROP_VARYING; | |
5142 | ||
5143 | cond = COND_EXPR_COND (stmt); | |
5144 | ||
5145 | if (dump_file && (dump_flags & TDF_DETAILS)) | |
5146 | { | |
5147 | tree use; | |
5148 | ssa_op_iter i; | |
5149 | ||
5150 | fprintf (dump_file, "\nVisiting conditional with predicate: "); | |
5151 | print_generic_expr (dump_file, cond, 0); | |
5152 | fprintf (dump_file, "\nWith known ranges\n"); | |
5153 | ||
5154 | FOR_EACH_SSA_TREE_OPERAND (use, stmt, i, SSA_OP_USE) | |
5155 | { | |
5156 | fprintf (dump_file, "\t"); | |
5157 | print_generic_expr (dump_file, use, 0); | |
5158 | fprintf (dump_file, ": "); | |
227858d1 | 5159 | dump_value_range (dump_file, vr_value[SSA_NAME_VERSION (use)]); |
0bca51f0 DN |
5160 | } |
5161 | ||
5162 | fprintf (dump_file, "\n"); | |
5163 | } | |
5164 | ||
5165 | /* Compute the value of the predicate COND by checking the known | |
227858d1 DN |
5166 | ranges of each of its operands. |
5167 | ||
5168 | Note that we cannot evaluate all the equivalent ranges here | |
5169 | because those ranges may not yet be final and with the current | |
5170 | propagation strategy, we cannot determine when the value ranges | |
5171 | of the names in the equivalence set have changed. | |
5172 | ||
5173 | For instance, given the following code fragment | |
5174 | ||
5175 | i_5 = PHI <8, i_13> | |
5176 | ... | |
5177 | i_14 = ASSERT_EXPR <i_5, i_5 != 0> | |
5178 | if (i_14 == 1) | |
5179 | ... | |
5180 | ||
5181 | Assume that on the first visit to i_14, i_5 has the temporary | |
5182 | range [8, 8] because the second argument to the PHI function is | |
5183 | not yet executable. We derive the range ~[0, 0] for i_14 and the | |
5184 | equivalence set { i_5 }. So, when we visit 'if (i_14 == 1)' for | |
5185 | the first time, since i_14 is equivalent to the range [8, 8], we | |
5186 | determine that the predicate is always false. | |
5187 | ||
5188 | On the next round of propagation, i_13 is determined to be | |
5189 | VARYING, which causes i_5 to drop down to VARYING. So, another | |
5190 | visit to i_14 is scheduled. In this second visit, we compute the | |
5191 | exact same range and equivalence set for i_14, namely ~[0, 0] and | |
5192 | { i_5 }. But we did not have the previous range for i_5 | |
5193 | registered, so vrp_visit_assignment thinks that the range for | |
5194 | i_14 has not changed. Therefore, the predicate 'if (i_14 == 1)' | |
5195 | is not visited again, which stops propagation from visiting | |
5196 | statements in the THEN clause of that if(). | |
5197 | ||
5198 | To properly fix this we would need to keep the previous range | |
5199 | value for the names in the equivalence set. This way we would've | |
5200 | discovered that from one visit to the other i_5 changed from | |
5201 | range [8, 8] to VR_VARYING. | |
5202 | ||
5203 | However, fixing this apparent limitation may not be worth the | |
5204 | additional checking. Testing on several code bases (GCC, DLV, | |
5205 | MICO, TRAMP3D and SPEC2000) showed that doing this results in | |
5206 | 4 more predicates folded in SPEC. */ | |
12df8a7e | 5207 | sop = false; |
0c948c27 | 5208 | val = vrp_evaluate_conditional_warnv (cond, false, &sop); |
0bca51f0 | 5209 | if (val) |
12df8a7e ILT |
5210 | { |
5211 | if (!sop) | |
5212 | *taken_edge_p = find_taken_edge (bb_for_stmt (stmt), val); | |
5213 | else | |
5214 | { | |
5215 | if (dump_file && (dump_flags & TDF_DETAILS)) | |
5216 | fprintf (dump_file, | |
5217 | "\nIgnoring predicate evaluation because " | |
5218 | "it assumes that signed overflow is undefined"); | |
5219 | val = NULL_TREE; | |
5220 | } | |
5221 | } | |
0bca51f0 DN |
5222 | |
5223 | if (dump_file && (dump_flags & TDF_DETAILS)) | |
5224 | { | |
5225 | fprintf (dump_file, "\nPredicate evaluates to: "); | |
5226 | if (val == NULL_TREE) | |
5227 | fprintf (dump_file, "DON'T KNOW\n"); | |
5228 | else | |
5229 | print_generic_stmt (dump_file, val, 0); | |
5230 | } | |
5231 | ||
5232 | return (*taken_edge_p) ? SSA_PROP_INTERESTING : SSA_PROP_VARYING; | |
5233 | } | |
5234 | ||
5235 | ||
5236 | /* Evaluate statement STMT. If the statement produces a useful range, | |
5237 | return SSA_PROP_INTERESTING and record the SSA name with the | |
5238 | interesting range into *OUTPUT_P. | |
5239 | ||
5240 | If STMT is a conditional branch and we can determine its truth | |
5241 | value, the taken edge is recorded in *TAKEN_EDGE_P. | |
5242 | ||
5243 | If STMT produces a varying value, return SSA_PROP_VARYING. */ | |
5244 | ||
5245 | static enum ssa_prop_result | |
5246 | vrp_visit_stmt (tree stmt, edge *taken_edge_p, tree *output_p) | |
5247 | { | |
5248 | tree def; | |
5249 | ssa_op_iter iter; | |
5250 | stmt_ann_t ann; | |
5251 | ||
5252 | if (dump_file && (dump_flags & TDF_DETAILS)) | |
5253 | { | |
5254 | fprintf (dump_file, "\nVisiting statement:\n"); | |
5255 | print_generic_stmt (dump_file, stmt, dump_flags); | |
5256 | fprintf (dump_file, "\n"); | |
5257 | } | |
5258 | ||
5259 | ann = stmt_ann (stmt); | |
07beea0d | 5260 | if (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT) |
2bbec6d9 | 5261 | { |
07beea0d | 5262 | tree rhs = GIMPLE_STMT_OPERAND (stmt, 1); |
2bbec6d9 JL |
5263 | |
5264 | /* In general, assignments with virtual operands are not useful | |
5265 | for deriving ranges, with the obvious exception of calls to | |
5266 | builtin functions. */ | |
5267 | if ((TREE_CODE (rhs) == CALL_EXPR | |
5039610b SL |
5268 | && TREE_CODE (CALL_EXPR_FN (rhs)) == ADDR_EXPR |
5269 | && DECL_P (TREE_OPERAND (CALL_EXPR_FN (rhs), 0)) | |
5270 | && DECL_IS_BUILTIN (TREE_OPERAND (CALL_EXPR_FN (rhs), 0))) | |
2bbec6d9 JL |
5271 | || ZERO_SSA_OPERANDS (stmt, SSA_OP_ALL_VIRTUALS)) |
5272 | return vrp_visit_assignment (stmt, output_p); | |
5273 | } | |
0bca51f0 DN |
5274 | else if (TREE_CODE (stmt) == COND_EXPR || TREE_CODE (stmt) == SWITCH_EXPR) |
5275 | return vrp_visit_cond_stmt (stmt, taken_edge_p); | |
5276 | ||
5277 | /* All other statements produce nothing of interest for VRP, so mark | |
5278 | their outputs varying and prevent further simulation. */ | |
5279 | FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_DEF) | |
b565d777 | 5280 | set_value_range_to_varying (get_value_range (def)); |
0bca51f0 DN |
5281 | |
5282 | return SSA_PROP_VARYING; | |
5283 | } | |
5284 | ||
5285 | ||
5286 | /* Meet operation for value ranges. Given two value ranges VR0 and | |
32c8bce7 DS |
5287 | VR1, store in VR0 a range that contains both VR0 and VR1. This |
5288 | may not be the smallest possible such range. */ | |
0bca51f0 DN |
5289 | |
5290 | static void | |
227858d1 | 5291 | vrp_meet (value_range_t *vr0, value_range_t *vr1) |
0bca51f0 DN |
5292 | { |
5293 | if (vr0->type == VR_UNDEFINED) | |
5294 | { | |
227858d1 | 5295 | copy_value_range (vr0, vr1); |
0bca51f0 DN |
5296 | return; |
5297 | } | |
5298 | ||
5299 | if (vr1->type == VR_UNDEFINED) | |
5300 | { | |
5301 | /* Nothing to do. VR0 already has the resulting range. */ | |
5302 | return; | |
5303 | } | |
5304 | ||
5305 | if (vr0->type == VR_VARYING) | |
5306 | { | |
5307 | /* Nothing to do. VR0 already has the resulting range. */ | |
5308 | return; | |
5309 | } | |
5310 | ||
5311 | if (vr1->type == VR_VARYING) | |
0bca51f0 | 5312 | { |
b565d777 | 5313 | set_value_range_to_varying (vr0); |
0bca51f0 DN |
5314 | return; |
5315 | } | |
5316 | ||
5317 | if (vr0->type == VR_RANGE && vr1->type == VR_RANGE) | |
5318 | { | |
32c8bce7 DS |
5319 | int cmp; |
5320 | tree min, max; | |
5321 | ||
5322 | /* Compute the convex hull of the ranges. The lower limit of | |
5323 | the new range is the minimum of the two ranges. If they | |
5324 | cannot be compared, then give up. */ | |
5325 | cmp = compare_values (vr0->min, vr1->min); | |
5326 | if (cmp == 0 || cmp == 1) | |
5327 | min = vr1->min; | |
5328 | else if (cmp == -1) | |
5329 | min = vr0->min; | |
5330 | else | |
5331 | goto give_up; | |
5332 | ||
5333 | /* Similarly, the upper limit of the new range is the maximum | |
5334 | of the two ranges. If they cannot be compared, then | |
5335 | give up. */ | |
5336 | cmp = compare_values (vr0->max, vr1->max); | |
5337 | if (cmp == 0 || cmp == -1) | |
5338 | max = vr1->max; | |
5339 | else if (cmp == 1) | |
5340 | max = vr0->max; | |
5341 | else | |
5342 | goto give_up; | |
0bca51f0 | 5343 | |
8cf781f0 ILT |
5344 | /* Check for useless ranges. */ |
5345 | if (INTEGRAL_TYPE_P (TREE_TYPE (min)) | |
e1f28918 ILT |
5346 | && ((vrp_val_is_min (min) || is_overflow_infinity (min)) |
5347 | && (vrp_val_is_max (max) || is_overflow_infinity (max)))) | |
8cf781f0 ILT |
5348 | goto give_up; |
5349 | ||
32c8bce7 DS |
5350 | /* The resulting set of equivalences is the intersection of |
5351 | the two sets. */ | |
5352 | if (vr0->equiv && vr1->equiv && vr0->equiv != vr1->equiv) | |
5353 | bitmap_and_into (vr0->equiv, vr1->equiv); | |
5354 | else if (vr0->equiv && !vr1->equiv) | |
5355 | bitmap_clear (vr0->equiv); | |
227858d1 | 5356 | |
32c8bce7 | 5357 | set_value_range (vr0, vr0->type, min, max, vr0->equiv); |
0bca51f0 DN |
5358 | } |
5359 | else if (vr0->type == VR_ANTI_RANGE && vr1->type == VR_ANTI_RANGE) | |
5360 | { | |
32c8bce7 DS |
5361 | /* Two anti-ranges meet only if their complements intersect. |
5362 | Only handle the case of identical ranges. */ | |
0bca51f0 DN |
5363 | if (compare_values (vr0->min, vr1->min) == 0 |
5364 | && compare_values (vr0->max, vr1->max) == 0 | |
5365 | && compare_values (vr0->min, vr0->max) == 0) | |
227858d1 | 5366 | { |
8ab5f5c9 | 5367 | /* The resulting set of equivalences is the intersection of |
227858d1 DN |
5368 | the two sets. */ |
5369 | if (vr0->equiv && vr1->equiv && vr0->equiv != vr1->equiv) | |
5370 | bitmap_and_into (vr0->equiv, vr1->equiv); | |
880031e1 JL |
5371 | else if (vr0->equiv && !vr1->equiv) |
5372 | bitmap_clear (vr0->equiv); | |
227858d1 | 5373 | } |
0bca51f0 | 5374 | else |
32c8bce7 | 5375 | goto give_up; |
0bca51f0 DN |
5376 | } |
5377 | else if (vr0->type == VR_ANTI_RANGE || vr1->type == VR_ANTI_RANGE) | |
5378 | { | |
32c8bce7 DS |
5379 | /* For a numeric range [VAL1, VAL2] and an anti-range ~[VAL3, VAL4], |
5380 | only handle the case where the ranges have an empty intersection. | |
5381 | The result of the meet operation is the anti-range. */ | |
227858d1 DN |
5382 | if (!symbolic_range_p (vr0) |
5383 | && !symbolic_range_p (vr1) | |
5384 | && !value_ranges_intersect_p (vr0, vr1)) | |
0bca51f0 | 5385 | { |
2d33a2ef DN |
5386 | /* Copy most of VR1 into VR0. Don't copy VR1's equivalence |
5387 | set. We need to compute the intersection of the two | |
5388 | equivalence sets. */ | |
0bca51f0 | 5389 | if (vr1->type == VR_ANTI_RANGE) |
2d33a2ef | 5390 | set_value_range (vr0, vr1->type, vr1->min, vr1->max, vr0->equiv); |
880031e1 JL |
5391 | |
5392 | /* The resulting set of equivalences is the intersection of | |
5393 | the two sets. */ | |
5394 | if (vr0->equiv && vr1->equiv && vr0->equiv != vr1->equiv) | |
5395 | bitmap_and_into (vr0->equiv, vr1->equiv); | |
5396 | else if (vr0->equiv && !vr1->equiv) | |
5397 | bitmap_clear (vr0->equiv); | |
0bca51f0 DN |
5398 | } |
5399 | else | |
32c8bce7 | 5400 | goto give_up; |
0bca51f0 DN |
5401 | } |
5402 | else | |
5403 | gcc_unreachable (); | |
227858d1 DN |
5404 | |
5405 | return; | |
5406 | ||
32c8bce7 DS |
5407 | give_up: |
5408 | /* Failed to find an efficient meet. Before giving up and setting | |
5409 | the result to VARYING, see if we can at least derive a useful | |
5410 | anti-range. FIXME, all this nonsense about distinguishing | |
b19bb8b0 DN |
5411 | anti-ranges from ranges is necessary because of the odd |
5412 | semantics of range_includes_zero_p and friends. */ | |
227858d1 | 5413 | if (!symbolic_range_p (vr0) |
b19bb8b0 DN |
5414 | && ((vr0->type == VR_RANGE && !range_includes_zero_p (vr0)) |
5415 | || (vr0->type == VR_ANTI_RANGE && range_includes_zero_p (vr0))) | |
227858d1 | 5416 | && !symbolic_range_p (vr1) |
b19bb8b0 DN |
5417 | && ((vr1->type == VR_RANGE && !range_includes_zero_p (vr1)) |
5418 | || (vr1->type == VR_ANTI_RANGE && range_includes_zero_p (vr1)))) | |
e82d7e60 DN |
5419 | { |
5420 | set_value_range_to_nonnull (vr0, TREE_TYPE (vr0->min)); | |
5421 | ||
5422 | /* Since this meet operation did not result from the meeting of | |
5423 | two equivalent names, VR0 cannot have any equivalences. */ | |
5424 | if (vr0->equiv) | |
5425 | bitmap_clear (vr0->equiv); | |
5426 | } | |
227858d1 DN |
5427 | else |
5428 | set_value_range_to_varying (vr0); | |
0bca51f0 DN |
5429 | } |
5430 | ||
227858d1 | 5431 | |
0bca51f0 DN |
5432 | /* Visit all arguments for PHI node PHI that flow through executable |
5433 | edges. If a valid value range can be derived from all the incoming | |
5434 | value ranges, set a new range for the LHS of PHI. */ | |
5435 | ||
5436 | static enum ssa_prop_result | |
5437 | vrp_visit_phi_node (tree phi) | |
5438 | { | |
5439 | int i; | |
5440 | tree lhs = PHI_RESULT (phi); | |
227858d1 DN |
5441 | value_range_t *lhs_vr = get_value_range (lhs); |
5442 | value_range_t vr_result = { VR_UNDEFINED, NULL_TREE, NULL_TREE, NULL }; | |
fc6827fe | 5443 | int edges, old_edges; |
227858d1 DN |
5444 | |
5445 | copy_value_range (&vr_result, lhs_vr); | |
0bca51f0 DN |
5446 | |
5447 | if (dump_file && (dump_flags & TDF_DETAILS)) | |
5448 | { | |
5449 | fprintf (dump_file, "\nVisiting PHI node: "); | |
5450 | print_generic_expr (dump_file, phi, dump_flags); | |
5451 | } | |
5452 | ||
fc6827fe | 5453 | edges = 0; |
0bca51f0 DN |
5454 | for (i = 0; i < PHI_NUM_ARGS (phi); i++) |
5455 | { | |
5456 | edge e = PHI_ARG_EDGE (phi, i); | |
5457 | ||
5458 | if (dump_file && (dump_flags & TDF_DETAILS)) | |
5459 | { | |
5460 | fprintf (dump_file, | |
5461 | "\n Argument #%d (%d -> %d %sexecutable)\n", | |
5462 | i, e->src->index, e->dest->index, | |
5463 | (e->flags & EDGE_EXECUTABLE) ? "" : "not "); | |
5464 | } | |
5465 | ||
5466 | if (e->flags & EDGE_EXECUTABLE) | |
5467 | { | |
5468 | tree arg = PHI_ARG_DEF (phi, i); | |
227858d1 | 5469 | value_range_t vr_arg; |
0bca51f0 | 5470 | |
fc6827fe ILT |
5471 | ++edges; |
5472 | ||
0bca51f0 | 5473 | if (TREE_CODE (arg) == SSA_NAME) |
31ab1cc9 RG |
5474 | { |
5475 | vr_arg = *(get_value_range (arg)); | |
31ab1cc9 | 5476 | } |
0bca51f0 DN |
5477 | else |
5478 | { | |
8cf781f0 ILT |
5479 | if (is_overflow_infinity (arg)) |
5480 | { | |
5481 | arg = copy_node (arg); | |
5482 | TREE_OVERFLOW (arg) = 0; | |
5483 | } | |
5484 | ||
0bca51f0 DN |
5485 | vr_arg.type = VR_RANGE; |
5486 | vr_arg.min = arg; | |
5487 | vr_arg.max = arg; | |
227858d1 | 5488 | vr_arg.equiv = NULL; |
0bca51f0 DN |
5489 | } |
5490 | ||
5491 | if (dump_file && (dump_flags & TDF_DETAILS)) | |
5492 | { | |
5493 | fprintf (dump_file, "\t"); | |
5494 | print_generic_expr (dump_file, arg, dump_flags); | |
5495 | fprintf (dump_file, "\n\tValue: "); | |
5496 | dump_value_range (dump_file, &vr_arg); | |
5497 | fprintf (dump_file, "\n"); | |
5498 | } | |
5499 | ||
5500 | vrp_meet (&vr_result, &vr_arg); | |
5501 | ||
5502 | if (vr_result.type == VR_VARYING) | |
5503 | break; | |
5504 | } | |
5505 | } | |
5506 | ||
5507 | if (vr_result.type == VR_VARYING) | |
227858d1 | 5508 | goto varying; |
0bca51f0 | 5509 | |
fc6827fe ILT |
5510 | old_edges = vr_phi_edge_counts[SSA_NAME_VERSION (lhs)]; |
5511 | vr_phi_edge_counts[SSA_NAME_VERSION (lhs)] = edges; | |
5512 | ||
0bca51f0 DN |
5513 | /* To prevent infinite iterations in the algorithm, derive ranges |
5514 | when the new value is slightly bigger or smaller than the | |
fc6827fe ILT |
5515 | previous one. We don't do this if we have seen a new executable |
5516 | edge; this helps us avoid an overflow infinity for conditionals | |
5517 | which are not in a loop. */ | |
31ab1cc9 | 5518 | if (lhs_vr->type == VR_RANGE && vr_result.type == VR_RANGE |
fc6827fe | 5519 | && edges <= old_edges) |
0bca51f0 DN |
5520 | { |
5521 | if (!POINTER_TYPE_P (TREE_TYPE (lhs))) | |
5522 | { | |
5523 | int cmp_min = compare_values (lhs_vr->min, vr_result.min); | |
5524 | int cmp_max = compare_values (lhs_vr->max, vr_result.max); | |
5525 | ||
5526 | /* If the new minimum is smaller or larger than the previous | |
5527 | one, go all the way to -INF. In the first case, to avoid | |
5528 | iterating millions of times to reach -INF, and in the | |
5529 | other case to avoid infinite bouncing between different | |
5530 | minimums. */ | |
5531 | if (cmp_min > 0 || cmp_min < 0) | |
12df8a7e ILT |
5532 | { |
5533 | /* If we will end up with a (-INF, +INF) range, set it | |
5534 | to VARYING. */ | |
e1f28918 | 5535 | if (vrp_val_is_max (vr_result.max)) |
12df8a7e ILT |
5536 | goto varying; |
5537 | ||
9a46cc16 ILT |
5538 | if (!needs_overflow_infinity (TREE_TYPE (vr_result.min)) |
5539 | || !vrp_var_may_overflow (lhs, phi)) | |
12df8a7e ILT |
5540 | vr_result.min = TYPE_MIN_VALUE (TREE_TYPE (vr_result.min)); |
5541 | else if (supports_overflow_infinity (TREE_TYPE (vr_result.min))) | |
5542 | vr_result.min = | |
5543 | negative_overflow_infinity (TREE_TYPE (vr_result.min)); | |
5544 | else | |
5545 | goto varying; | |
5546 | } | |
0bca51f0 DN |
5547 | |
5548 | /* Similarly, if the new maximum is smaller or larger than | |
5549 | the previous one, go all the way to +INF. */ | |
5550 | if (cmp_max < 0 || cmp_max > 0) | |
12df8a7e ILT |
5551 | { |
5552 | /* If we will end up with a (-INF, +INF) range, set it | |
5553 | to VARYING. */ | |
e1f28918 | 5554 | if (vrp_val_is_min (vr_result.min)) |
12df8a7e ILT |
5555 | goto varying; |
5556 | ||
9a46cc16 ILT |
5557 | if (!needs_overflow_infinity (TREE_TYPE (vr_result.max)) |
5558 | || !vrp_var_may_overflow (lhs, phi)) | |
12df8a7e ILT |
5559 | vr_result.max = TYPE_MAX_VALUE (TREE_TYPE (vr_result.max)); |
5560 | else if (supports_overflow_infinity (TREE_TYPE (vr_result.max))) | |
5561 | vr_result.max = | |
5562 | positive_overflow_infinity (TREE_TYPE (vr_result.max)); | |
5563 | else | |
5564 | goto varying; | |
5565 | } | |
0bca51f0 DN |
5566 | } |
5567 | } | |
5568 | ||
5569 | /* If the new range is different than the previous value, keep | |
5570 | iterating. */ | |
227858d1 | 5571 | if (update_value_range (lhs, &vr_result)) |
0bca51f0 DN |
5572 | return SSA_PROP_INTERESTING; |
5573 | ||
5574 | /* Nothing changed, don't add outgoing edges. */ | |
5575 | return SSA_PROP_NOT_INTERESTING; | |
227858d1 DN |
5576 | |
5577 | /* No match found. Set the LHS to VARYING. */ | |
5578 | varying: | |
5579 | set_value_range_to_varying (lhs_vr); | |
5580 | return SSA_PROP_VARYING; | |
0bca51f0 DN |
5581 | } |
5582 | ||
1a557723 JL |
5583 | /* Simplify a division or modulo operator to a right shift or |
5584 | bitwise and if the first operand is unsigned or is greater | |
5585 | than zero and the second operand is an exact power of two. */ | |
a513fe88 JL |
5586 | |
5587 | static void | |
1a557723 | 5588 | simplify_div_or_mod_using_ranges (tree stmt, tree rhs, enum tree_code rhs_code) |
a513fe88 | 5589 | { |
1a557723 JL |
5590 | tree val = NULL; |
5591 | tree op = TREE_OPERAND (rhs, 0); | |
5592 | value_range_t *vr = get_value_range (TREE_OPERAND (rhs, 0)); | |
a513fe88 | 5593 | |
1a557723 JL |
5594 | if (TYPE_UNSIGNED (TREE_TYPE (op))) |
5595 | { | |
5596 | val = integer_one_node; | |
5597 | } | |
5598 | else | |
5599 | { | |
12df8a7e ILT |
5600 | bool sop = false; |
5601 | ||
737b0891 | 5602 | val = compare_range_with_value (GE_EXPR, vr, integer_zero_node, &sop); |
0c948c27 ILT |
5603 | |
5604 | if (val | |
5605 | && sop | |
5606 | && integer_onep (val) | |
5607 | && issue_strict_overflow_warning (WARN_STRICT_OVERFLOW_MISC)) | |
5608 | { | |
5609 | location_t locus; | |
5610 | ||
5611 | if (!EXPR_HAS_LOCATION (stmt)) | |
5612 | locus = input_location; | |
5613 | else | |
5614 | locus = EXPR_LOCATION (stmt); | |
5615 | warning (OPT_Wstrict_overflow, | |
5616 | ("%Hassuming signed overflow does not occur when " | |
5617 | "simplifying / or %% to >> or &"), | |
5618 | &locus); | |
5619 | } | |
1a557723 JL |
5620 | } |
5621 | ||
5622 | if (val && integer_onep (val)) | |
a513fe88 | 5623 | { |
1a557723 JL |
5624 | tree t; |
5625 | tree op0 = TREE_OPERAND (rhs, 0); | |
5626 | tree op1 = TREE_OPERAND (rhs, 1); | |
a513fe88 | 5627 | |
1a557723 JL |
5628 | if (rhs_code == TRUNC_DIV_EXPR) |
5629 | { | |
5630 | t = build_int_cst (NULL_TREE, tree_log2 (op1)); | |
a5ad7269 | 5631 | t = build2 (RSHIFT_EXPR, TREE_TYPE (op0), op0, t); |
1a557723 JL |
5632 | } |
5633 | else | |
a513fe88 | 5634 | { |
1a557723 JL |
5635 | t = build_int_cst (TREE_TYPE (op1), 1); |
5636 | t = int_const_binop (MINUS_EXPR, op1, t, 0); | |
5637 | t = fold_convert (TREE_TYPE (op0), t); | |
5638 | t = build2 (BIT_AND_EXPR, TREE_TYPE (op0), op0, t); | |
5639 | } | |
5640 | ||
07beea0d | 5641 | GIMPLE_STMT_OPERAND (stmt, 1) = t; |
1a557723 JL |
5642 | update_stmt (stmt); |
5643 | } | |
5644 | } | |
a513fe88 | 5645 | |
1a557723 JL |
5646 | /* If the operand to an ABS_EXPR is >= 0, then eliminate the |
5647 | ABS_EXPR. If the operand is <= 0, then simplify the | |
5648 | ABS_EXPR into a NEGATE_EXPR. */ | |
5649 | ||
5650 | static void | |
5651 | simplify_abs_using_ranges (tree stmt, tree rhs) | |
5652 | { | |
5653 | tree val = NULL; | |
5654 | tree op = TREE_OPERAND (rhs, 0); | |
5655 | tree type = TREE_TYPE (op); | |
5656 | value_range_t *vr = get_value_range (TREE_OPERAND (rhs, 0)); | |
5657 | ||
5658 | if (TYPE_UNSIGNED (type)) | |
5659 | { | |
5660 | val = integer_zero_node; | |
5661 | } | |
5662 | else if (vr) | |
5663 | { | |
12df8a7e ILT |
5664 | bool sop = false; |
5665 | ||
5666 | val = compare_range_with_value (LE_EXPR, vr, integer_zero_node, &sop); | |
1a557723 JL |
5667 | if (!val) |
5668 | { | |
12df8a7e ILT |
5669 | sop = false; |
5670 | val = compare_range_with_value (GE_EXPR, vr, integer_zero_node, | |
5671 | &sop); | |
1a557723 JL |
5672 | |
5673 | if (val) | |
a513fe88 | 5674 | { |
1a557723 JL |
5675 | if (integer_zerop (val)) |
5676 | val = integer_one_node; | |
5677 | else if (integer_onep (val)) | |
5678 | val = integer_zero_node; | |
5679 | } | |
5680 | } | |
a513fe88 | 5681 | |
1a557723 JL |
5682 | if (val |
5683 | && (integer_onep (val) || integer_zerop (val))) | |
5684 | { | |
5685 | tree t; | |
5686 | ||
0c948c27 ILT |
5687 | if (sop && issue_strict_overflow_warning (WARN_STRICT_OVERFLOW_MISC)) |
5688 | { | |
5689 | location_t locus; | |
5690 | ||
5691 | if (!EXPR_HAS_LOCATION (stmt)) | |
5692 | locus = input_location; | |
5693 | else | |
5694 | locus = EXPR_LOCATION (stmt); | |
5695 | warning (OPT_Wstrict_overflow, | |
5696 | ("%Hassuming signed overflow does not occur when " | |
5697 | "simplifying abs (X) to X or -X"), | |
5698 | &locus); | |
5699 | } | |
5700 | ||
1a557723 JL |
5701 | if (integer_onep (val)) |
5702 | t = build1 (NEGATE_EXPR, TREE_TYPE (op), op); | |
5703 | else | |
5704 | t = op; | |
5705 | ||
07beea0d | 5706 | GIMPLE_STMT_OPERAND (stmt, 1) = t; |
1a557723 JL |
5707 | update_stmt (stmt); |
5708 | } | |
5709 | } | |
5710 | } | |
5711 | ||
d579f20b JL |
5712 | /* We are comparing trees OP0 and OP1 using COND_CODE. OP0 has |
5713 | a known value range VR. | |
5714 | ||
5715 | If there is one and only one value which will satisfy the | |
5716 | conditional, then return that value. Else return NULL. */ | |
5717 | ||
5718 | static tree | |
5719 | test_for_singularity (enum tree_code cond_code, tree op0, | |
5720 | tree op1, value_range_t *vr) | |
5721 | { | |
5722 | tree min = NULL; | |
5723 | tree max = NULL; | |
5724 | ||
5725 | /* Extract minimum/maximum values which satisfy the | |
5726 | the conditional as it was written. */ | |
5727 | if (cond_code == LE_EXPR || cond_code == LT_EXPR) | |
5728 | { | |
12df8a7e ILT |
5729 | /* This should not be negative infinity; there is no overflow |
5730 | here. */ | |
d579f20b JL |
5731 | min = TYPE_MIN_VALUE (TREE_TYPE (op0)); |
5732 | ||
5733 | max = op1; | |
12df8a7e | 5734 | if (cond_code == LT_EXPR && !is_overflow_infinity (max)) |
d579f20b JL |
5735 | { |
5736 | tree one = build_int_cst (TREE_TYPE (op0), 1); | |
a5ad7269 | 5737 | max = fold_build2 (MINUS_EXPR, TREE_TYPE (op0), max, one); |
3fe5bcaf ILT |
5738 | if (EXPR_P (max)) |
5739 | TREE_NO_WARNING (max) = 1; | |
d579f20b JL |
5740 | } |
5741 | } | |
5742 | else if (cond_code == GE_EXPR || cond_code == GT_EXPR) | |
5743 | { | |
12df8a7e ILT |
5744 | /* This should not be positive infinity; there is no overflow |
5745 | here. */ | |
d579f20b JL |
5746 | max = TYPE_MAX_VALUE (TREE_TYPE (op0)); |
5747 | ||
5748 | min = op1; | |
12df8a7e | 5749 | if (cond_code == GT_EXPR && !is_overflow_infinity (min)) |
d579f20b JL |
5750 | { |
5751 | tree one = build_int_cst (TREE_TYPE (op0), 1); | |
f9fe7aed | 5752 | min = fold_build2 (PLUS_EXPR, TREE_TYPE (op0), min, one); |
3fe5bcaf ILT |
5753 | if (EXPR_P (min)) |
5754 | TREE_NO_WARNING (min) = 1; | |
d579f20b JL |
5755 | } |
5756 | } | |
5757 | ||
5758 | /* Now refine the minimum and maximum values using any | |
5759 | value range information we have for op0. */ | |
5760 | if (min && max) | |
5761 | { | |
5762 | if (compare_values (vr->min, min) == -1) | |
5763 | min = min; | |
5764 | else | |
5765 | min = vr->min; | |
5766 | if (compare_values (vr->max, max) == 1) | |
5767 | max = max; | |
5768 | else | |
5769 | max = vr->max; | |
5770 | ||
f9fe7aed JL |
5771 | /* If the new min/max values have converged to a single value, |
5772 | then there is only one value which can satisfy the condition, | |
5773 | return that value. */ | |
5774 | if (operand_equal_p (min, max, 0) && is_gimple_min_invariant (min)) | |
d579f20b JL |
5775 | return min; |
5776 | } | |
5777 | return NULL; | |
5778 | } | |
5779 | ||
1a557723 JL |
5780 | /* Simplify a conditional using a relational operator to an equality |
5781 | test if the range information indicates only one value can satisfy | |
5782 | the original conditional. */ | |
5783 | ||
5784 | static void | |
5785 | simplify_cond_using_ranges (tree stmt) | |
5786 | { | |
5787 | tree cond = COND_EXPR_COND (stmt); | |
5788 | tree op0 = TREE_OPERAND (cond, 0); | |
5789 | tree op1 = TREE_OPERAND (cond, 1); | |
5790 | enum tree_code cond_code = TREE_CODE (cond); | |
5791 | ||
5792 | if (cond_code != NE_EXPR | |
5793 | && cond_code != EQ_EXPR | |
5794 | && TREE_CODE (op0) == SSA_NAME | |
5795 | && INTEGRAL_TYPE_P (TREE_TYPE (op0)) | |
5796 | && is_gimple_min_invariant (op1)) | |
5797 | { | |
5798 | value_range_t *vr = get_value_range (op0); | |
5799 | ||
5800 | /* If we have range information for OP0, then we might be | |
5801 | able to simplify this conditional. */ | |
5802 | if (vr->type == VR_RANGE) | |
5803 | { | |
d579f20b | 5804 | tree new = test_for_singularity (cond_code, op0, op1, vr); |
1a557723 | 5805 | |
d579f20b | 5806 | if (new) |
1a557723 | 5807 | { |
d579f20b | 5808 | if (dump_file) |
1a557723 | 5809 | { |
d579f20b JL |
5810 | fprintf (dump_file, "Simplified relational "); |
5811 | print_generic_expr (dump_file, cond, 0); | |
5812 | fprintf (dump_file, " into "); | |
a513fe88 JL |
5813 | } |
5814 | ||
d579f20b | 5815 | COND_EXPR_COND (stmt) |
0d451405 | 5816 | = build2 (EQ_EXPR, boolean_type_node, op0, new); |
d579f20b JL |
5817 | update_stmt (stmt); |
5818 | ||
5819 | if (dump_file) | |
a513fe88 | 5820 | { |
d579f20b JL |
5821 | print_generic_expr (dump_file, COND_EXPR_COND (stmt), 0); |
5822 | fprintf (dump_file, "\n"); | |
a513fe88 | 5823 | } |
d579f20b JL |
5824 | return; |
5825 | ||
a513fe88 JL |
5826 | } |
5827 | ||
d579f20b JL |
5828 | /* Try again after inverting the condition. We only deal |
5829 | with integral types here, so no need to worry about | |
5830 | issues with inverting FP comparisons. */ | |
5831 | cond_code = invert_tree_comparison (cond_code, false); | |
5832 | new = test_for_singularity (cond_code, op0, op1, vr); | |
5833 | ||
5834 | if (new) | |
1a557723 | 5835 | { |
d579f20b | 5836 | if (dump_file) |
1a557723 | 5837 | { |
d579f20b JL |
5838 | fprintf (dump_file, "Simplified relational "); |
5839 | print_generic_expr (dump_file, cond, 0); | |
5840 | fprintf (dump_file, " into "); | |
1a557723 | 5841 | } |
d579f20b JL |
5842 | |
5843 | COND_EXPR_COND (stmt) | |
0d451405 | 5844 | = build2 (NE_EXPR, boolean_type_node, op0, new); |
d579f20b JL |
5845 | update_stmt (stmt); |
5846 | ||
5847 | if (dump_file) | |
5848 | { | |
5849 | print_generic_expr (dump_file, COND_EXPR_COND (stmt), 0); | |
5850 | fprintf (dump_file, "\n"); | |
5851 | } | |
5852 | return; | |
5853 | ||
1a557723 | 5854 | } |
a513fe88 JL |
5855 | } |
5856 | } | |
5857 | } | |
5858 | ||
1a557723 JL |
5859 | /* Simplify STMT using ranges if possible. */ |
5860 | ||
5861 | void | |
5862 | simplify_stmt_using_ranges (tree stmt) | |
5863 | { | |
07beea0d | 5864 | if (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT) |
1a557723 | 5865 | { |
07beea0d | 5866 | tree rhs = GIMPLE_STMT_OPERAND (stmt, 1); |
1a557723 JL |
5867 | enum tree_code rhs_code = TREE_CODE (rhs); |
5868 | ||
5869 | /* Transform TRUNC_DIV_EXPR and TRUNC_MOD_EXPR into RSHIFT_EXPR | |
5870 | and BIT_AND_EXPR respectively if the first operand is greater | |
5871 | than zero and the second operand is an exact power of two. */ | |
5872 | if ((rhs_code == TRUNC_DIV_EXPR || rhs_code == TRUNC_MOD_EXPR) | |
5873 | && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (rhs, 0))) | |
5874 | && integer_pow2p (TREE_OPERAND (rhs, 1))) | |
5875 | simplify_div_or_mod_using_ranges (stmt, rhs, rhs_code); | |
5876 | ||
5877 | /* Transform ABS (X) into X or -X as appropriate. */ | |
5878 | if (rhs_code == ABS_EXPR | |
5879 | && TREE_CODE (TREE_OPERAND (rhs, 0)) == SSA_NAME | |
5880 | && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (rhs, 0)))) | |
5881 | simplify_abs_using_ranges (stmt, rhs); | |
5882 | } | |
5883 | else if (TREE_CODE (stmt) == COND_EXPR | |
5884 | && COMPARISON_CLASS_P (COND_EXPR_COND (stmt))) | |
5885 | { | |
5886 | simplify_cond_using_ranges (stmt); | |
5887 | } | |
5888 | } | |
5889 | ||
2090d6a0 JL |
5890 | /* Stack of dest,src equivalency pairs that need to be restored after |
5891 | each attempt to thread a block's incoming edge to an outgoing edge. | |
5892 | ||
5893 | A NULL entry is used to mark the end of pairs which need to be | |
5894 | restored. */ | |
5895 | static VEC(tree,heap) *stack; | |
5896 | ||
0c948c27 ILT |
5897 | /* A trivial wrapper so that we can present the generic jump threading |
5898 | code with a simple API for simplifying statements. STMT is the | |
5899 | statement we want to simplify, WITHIN_STMT provides the location | |
5900 | for any overflow warnings. */ | |
5901 | ||
2090d6a0 | 5902 | static tree |
0c948c27 | 5903 | simplify_stmt_for_jump_threading (tree stmt, tree within_stmt) |
2090d6a0 JL |
5904 | { |
5905 | /* We only use VRP information to simplify conditionals. This is | |
5906 | overly conservative, but it's unclear if doing more would be | |
5907 | worth the compile time cost. */ | |
5908 | if (TREE_CODE (stmt) != COND_EXPR) | |
5909 | return NULL; | |
5910 | ||
0c948c27 | 5911 | return vrp_evaluate_conditional (COND_EXPR_COND (stmt), within_stmt); |
2090d6a0 JL |
5912 | } |
5913 | ||
5914 | /* Blocks which have more than one predecessor and more than | |
5915 | one successor present jump threading opportunities. ie, | |
5916 | when the block is reached from a specific predecessor, we | |
5917 | may be able to determine which of the outgoing edges will | |
5918 | be traversed. When this optimization applies, we are able | |
5919 | to avoid conditionals at runtime and we may expose secondary | |
5920 | optimization opportunities. | |
5921 | ||
5922 | This routine is effectively a driver for the generic jump | |
5923 | threading code. It basically just presents the generic code | |
5924 | with edges that may be suitable for jump threading. | |
5925 | ||
5926 | Unlike DOM, we do not iterate VRP if jump threading was successful. | |
5927 | While iterating may expose new opportunities for VRP, it is expected | |
5928 | those opportunities would be very limited and the compile time cost | |
5929 | to expose those opportunities would be significant. | |
5930 | ||
5931 | As jump threading opportunities are discovered, they are registered | |
5932 | for later realization. */ | |
5933 | ||
5934 | static void | |
5935 | identify_jump_threads (void) | |
5936 | { | |
5937 | basic_block bb; | |
5938 | tree dummy; | |
5939 | ||
5940 | /* Ugh. When substituting values earlier in this pass we can | |
5941 | wipe the dominance information. So rebuild the dominator | |
5942 | information as we need it within the jump threading code. */ | |
5943 | calculate_dominance_info (CDI_DOMINATORS); | |
5944 | ||
5945 | /* We do not allow VRP information to be used for jump threading | |
5946 | across a back edge in the CFG. Otherwise it becomes too | |
5947 | difficult to avoid eliminating loop exit tests. Of course | |
5948 | EDGE_DFS_BACK is not accurate at this time so we have to | |
5949 | recompute it. */ | |
5950 | mark_dfs_back_edges (); | |
5951 | ||
5952 | /* Allocate our unwinder stack to unwind any temporary equivalences | |
5953 | that might be recorded. */ | |
5954 | stack = VEC_alloc (tree, heap, 20); | |
5955 | ||
5956 | /* To avoid lots of silly node creation, we create a single | |
5957 | conditional and just modify it in-place when attempting to | |
5958 | thread jumps. */ | |
5959 | dummy = build2 (EQ_EXPR, boolean_type_node, NULL, NULL); | |
5960 | dummy = build3 (COND_EXPR, void_type_node, dummy, NULL, NULL); | |
5961 | ||
5962 | /* Walk through all the blocks finding those which present a | |
5963 | potential jump threading opportunity. We could set this up | |
5964 | as a dominator walker and record data during the walk, but | |
5965 | I doubt it's worth the effort for the classes of jump | |
5966 | threading opportunities we are trying to identify at this | |
5967 | point in compilation. */ | |
5968 | FOR_EACH_BB (bb) | |
5969 | { | |
5970 | tree last, cond; | |
5971 | ||
5972 | /* If the generic jump threading code does not find this block | |
5973 | interesting, then there is nothing to do. */ | |
5974 | if (! potentially_threadable_block (bb)) | |
5975 | continue; | |
5976 | ||
5977 | /* We only care about blocks ending in a COND_EXPR. While there | |
5978 | may be some value in handling SWITCH_EXPR here, I doubt it's | |
5979 | terribly important. */ | |
5980 | last = bsi_stmt (bsi_last (bb)); | |
5981 | if (TREE_CODE (last) != COND_EXPR) | |
5982 | continue; | |
5983 | ||
5984 | /* We're basically looking for any kind of conditional with | |
5985 | integral type arguments. */ | |
5986 | cond = COND_EXPR_COND (last); | |
5987 | if ((TREE_CODE (cond) == SSA_NAME | |
5988 | && INTEGRAL_TYPE_P (TREE_TYPE (cond))) | |
5989 | || (COMPARISON_CLASS_P (cond) | |
5990 | && TREE_CODE (TREE_OPERAND (cond, 0)) == SSA_NAME | |
5991 | && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (cond, 0))) | |
5992 | && (TREE_CODE (TREE_OPERAND (cond, 1)) == SSA_NAME | |
5993 | || is_gimple_min_invariant (TREE_OPERAND (cond, 1))) | |
5994 | && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (cond, 1))))) | |
5995 | { | |
5996 | edge_iterator ei; | |
5997 | edge e; | |
5998 | ||
5999 | /* We've got a block with multiple predecessors and multiple | |
6000 | successors which also ends in a suitable conditional. For | |
6001 | each predecessor, see if we can thread it to a specific | |
6002 | successor. */ | |
6003 | FOR_EACH_EDGE (e, ei, bb->preds) | |
6004 | { | |
6005 | /* Do not thread across back edges or abnormal edges | |
6006 | in the CFG. */ | |
6007 | if (e->flags & (EDGE_DFS_BACK | EDGE_COMPLEX)) | |
6008 | continue; | |
6009 | ||
6010 | thread_across_edge (dummy, e, true, | |
6011 | &stack, | |
6012 | simplify_stmt_for_jump_threading); | |
6013 | } | |
6014 | } | |
6015 | } | |
6016 | ||
6017 | /* We do not actually update the CFG or SSA graphs at this point as | |
6018 | ASSERT_EXPRs are still in the IL and cfg cleanup code does not yet | |
6019 | handle ASSERT_EXPRs gracefully. */ | |
6020 | } | |
6021 | ||
6022 | /* We identified all the jump threading opportunities earlier, but could | |
6023 | not transform the CFG at that time. This routine transforms the | |
6024 | CFG and arranges for the dominator tree to be rebuilt if necessary. | |
6025 | ||
6026 | Note the SSA graph update will occur during the normal TODO | |
6027 | processing by the pass manager. */ | |
6028 | static void | |
6029 | finalize_jump_threads (void) | |
6030 | { | |
b02b9b53 | 6031 | thread_through_all_blocks (false); |
2090d6a0 JL |
6032 | VEC_free (tree, heap, stack); |
6033 | } | |
1a557723 | 6034 | |
0bca51f0 DN |
6035 | |
6036 | /* Traverse all the blocks folding conditionals with known ranges. */ | |
6037 | ||
6038 | static void | |
6039 | vrp_finalize (void) | |
6040 | { | |
227858d1 DN |
6041 | size_t i; |
6042 | prop_value_t *single_val_range; | |
6043 | bool do_value_subst_p; | |
0bca51f0 DN |
6044 | |
6045 | if (dump_file) | |
6046 | { | |
6047 | fprintf (dump_file, "\nValue ranges after VRP:\n\n"); | |
6048 | dump_all_value_ranges (dump_file); | |
6049 | fprintf (dump_file, "\n"); | |
6050 | } | |
6051 | ||
227858d1 DN |
6052 | /* We may have ended with ranges that have exactly one value. Those |
6053 | values can be substituted as any other copy/const propagated | |
6054 | value using substitute_and_fold. */ | |
b9eae1a9 | 6055 | single_val_range = XCNEWVEC (prop_value_t, num_ssa_names); |
227858d1 DN |
6056 | |
6057 | do_value_subst_p = false; | |
6058 | for (i = 0; i < num_ssa_names; i++) | |
6059 | if (vr_value[i] | |
6060 | && vr_value[i]->type == VR_RANGE | |
6061 | && vr_value[i]->min == vr_value[i]->max) | |
6062 | { | |
6063 | single_val_range[i].value = vr_value[i]->min; | |
6064 | do_value_subst_p = true; | |
6065 | } | |
6066 | ||
6067 | if (!do_value_subst_p) | |
0bca51f0 | 6068 | { |
227858d1 DN |
6069 | /* We found no single-valued ranges, don't waste time trying to |
6070 | do single value substitution in substitute_and_fold. */ | |
6071 | free (single_val_range); | |
6072 | single_val_range = NULL; | |
0bca51f0 DN |
6073 | } |
6074 | ||
227858d1 DN |
6075 | substitute_and_fold (single_val_range, true); |
6076 | ||
590b1f2d | 6077 | if (warn_array_bounds) |
62e5bf5d | 6078 | check_all_array_refs (); |
590b1f2d | 6079 | |
2090d6a0 JL |
6080 | /* We must identify jump threading opportunities before we release |
6081 | the datastructures built by VRP. */ | |
6082 | identify_jump_threads (); | |
6083 | ||
227858d1 DN |
6084 | /* Free allocated memory. */ |
6085 | for (i = 0; i < num_ssa_names; i++) | |
6086 | if (vr_value[i]) | |
6087 | { | |
6088 | BITMAP_FREE (vr_value[i]->equiv); | |
6089 | free (vr_value[i]); | |
6090 | } | |
6091 | ||
6092 | free (single_val_range); | |
6093 | free (vr_value); | |
fc6827fe | 6094 | free (vr_phi_edge_counts); |
b16caf72 JL |
6095 | |
6096 | /* So that we can distinguish between VRP data being available | |
6097 | and not available. */ | |
6098 | vr_value = NULL; | |
fc6827fe | 6099 | vr_phi_edge_counts = NULL; |
0bca51f0 DN |
6100 | } |
6101 | ||
13285d51 ZD |
6102 | /* Calculates number of iterations for all loops, to ensure that they are |
6103 | cached. */ | |
6104 | ||
6105 | static void | |
6106 | record_numbers_of_iterations (void) | |
6107 | { | |
6108 | loop_iterator li; | |
6109 | struct loop *loop; | |
6110 | ||
6111 | FOR_EACH_LOOP (li, loop, 0) | |
6112 | { | |
6113 | number_of_latch_executions (loop); | |
6114 | } | |
6115 | } | |
0bca51f0 DN |
6116 | |
6117 | /* Main entry point to VRP (Value Range Propagation). This pass is | |
6118 | loosely based on J. R. C. Patterson, ``Accurate Static Branch | |
6119 | Prediction by Value Range Propagation,'' in SIGPLAN Conference on | |
6120 | Programming Language Design and Implementation, pp. 67-78, 1995. | |
6121 | Also available at http://citeseer.ist.psu.edu/patterson95accurate.html | |
6122 | ||
6123 | This is essentially an SSA-CCP pass modified to deal with ranges | |
6124 | instead of constants. | |
6125 | ||
227858d1 DN |
6126 | While propagating ranges, we may find that two or more SSA name |
6127 | have equivalent, though distinct ranges. For instance, | |
6128 | ||
6129 | 1 x_9 = p_3->a; | |
6130 | 2 p_4 = ASSERT_EXPR <p_3, p_3 != 0> | |
6131 | 3 if (p_4 == q_2) | |
6132 | 4 p_5 = ASSERT_EXPR <p_4, p_4 == q_2>; | |
6133 | 5 endif | |
6134 | 6 if (q_2) | |
6135 | ||
6136 | In the code above, pointer p_5 has range [q_2, q_2], but from the | |
6137 | code we can also determine that p_5 cannot be NULL and, if q_2 had | |
6138 | a non-varying range, p_5's range should also be compatible with it. | |
6139 | ||
8ab5f5c9 | 6140 | These equivalences are created by two expressions: ASSERT_EXPR and |
227858d1 DN |
6141 | copy operations. Since p_5 is an assertion on p_4, and p_4 was the |
6142 | result of another assertion, then we can use the fact that p_5 and | |
6143 | p_4 are equivalent when evaluating p_5's range. | |
6144 | ||
8ab5f5c9 | 6145 | Together with value ranges, we also propagate these equivalences |
227858d1 DN |
6146 | between names so that we can take advantage of information from |
6147 | multiple ranges when doing final replacement. Note that this | |
6148 | equivalency relation is transitive but not symmetric. | |
6149 | ||
6150 | In the example above, p_5 is equivalent to p_4, q_2 and p_3, but we | |
6151 | cannot assert that q_2 is equivalent to p_5 because q_2 may be used | |
6152 | in contexts where that assertion does not hold (e.g., in line 6). | |
6153 | ||
0bca51f0 DN |
6154 | TODO, the main difference between this pass and Patterson's is that |
6155 | we do not propagate edge probabilities. We only compute whether | |
6156 | edges can be taken or not. That is, instead of having a spectrum | |
6157 | of jump probabilities between 0 and 1, we only deal with 0, 1 and | |
6158 | DON'T KNOW. In the future, it may be worthwhile to propagate | |
6159 | probabilities to aid branch prediction. */ | |
6160 | ||
c2924966 | 6161 | static unsigned int |
0bca51f0 DN |
6162 | execute_vrp (void) |
6163 | { | |
b02b9b53 | 6164 | loop_optimizer_init (LOOPS_NORMAL | LOOPS_HAVE_RECORDED_EXITS); |
d51157de ZD |
6165 | rewrite_into_loop_closed_ssa (NULL, TODO_update_ssa); |
6166 | scev_initialize (); | |
b02b9b53 ZD |
6167 | |
6168 | insert_range_assertions (); | |
0bca51f0 | 6169 | |
13285d51 ZD |
6170 | /* Compute the # of iterations for each loop before we start the VRP |
6171 | analysis. The value ranges determined by VRP are used in expression | |
6172 | simplification, that is also used by the # of iterations analysis. | |
6173 | However, in the middle of the VRP analysis, the value ranges do not take | |
6174 | all the possible paths in CFG into account, so they do not have to be | |
6175 | correct, and the # of iterations analysis can obtain wrong results. | |
6176 | This is a problem, since the results of the # of iterations analysis | |
6177 | are cached, so these mistakes would not be corrected when the value | |
6178 | ranges are corrected. */ | |
6179 | record_numbers_of_iterations (); | |
6180 | ||
227858d1 DN |
6181 | vrp_initialize (); |
6182 | ssa_propagate (vrp_visit_stmt, vrp_visit_phi_node); | |
6183 | vrp_finalize (); | |
0bca51f0 | 6184 | |
2090d6a0 JL |
6185 | /* ASSERT_EXPRs must be removed before finalizing jump threads |
6186 | as finalizing jump threads calls the CFG cleanup code which | |
6187 | does not properly handle ASSERT_EXPRs. */ | |
0bca51f0 | 6188 | remove_range_assertions (); |
59c02d8a JL |
6189 | |
6190 | /* If we exposed any new variables, go ahead and put them into | |
6191 | SSA form now, before we handle jump threading. This simplifies | |
6192 | interactions between rewriting of _DECL nodes into SSA form | |
6193 | and rewriting SSA_NAME nodes into SSA form after block | |
6194 | duplication and CFG manipulation. */ | |
6195 | update_ssa (TODO_update_ssa); | |
6196 | ||
2090d6a0 | 6197 | finalize_jump_threads (); |
d51157de ZD |
6198 | scev_finalize (); |
6199 | loop_optimizer_finalize (); | |
b02b9b53 | 6200 | |
c2924966 | 6201 | return 0; |
0bca51f0 DN |
6202 | } |
6203 | ||
6204 | static bool | |
6205 | gate_vrp (void) | |
6206 | { | |
6207 | return flag_tree_vrp != 0; | |
6208 | } | |
6209 | ||
6210 | struct tree_opt_pass pass_vrp = | |
6211 | { | |
6212 | "vrp", /* name */ | |
6213 | gate_vrp, /* gate */ | |
6214 | execute_vrp, /* execute */ | |
6215 | NULL, /* sub */ | |
6216 | NULL, /* next */ | |
6217 | 0, /* static_pass_number */ | |
6218 | TV_TREE_VRP, /* tv_id */ | |
6219 | PROP_ssa | PROP_alias, /* properties_required */ | |
6220 | 0, /* properties_provided */ | |
ae07b463 | 6221 | 0, /* properties_destroyed */ |
0bca51f0 DN |
6222 | 0, /* todo_flags_start */ |
6223 | TODO_cleanup_cfg | |
6224 | | TODO_ggc_collect | |
6225 | | TODO_verify_ssa | |
6226 | | TODO_dump_func | |
706ca88e | 6227 | | TODO_update_ssa, /* todo_flags_finish */ |
0bca51f0 DN |
6228 | 0 /* letter */ |
6229 | }; |