Bring gcc-4.4.0 to up-to-date.
[asac-android-toolchain:gcc-linaro.git] / gcc-4.4.0 / gcc / tree-vrp.c
1 /* Support routines for Value Range Propagation (VRP).
2    Copyright (C) 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
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
9 the Free Software Foundation; either version 3, or (at your option)
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
18 along with GCC; see the file COPYING3.  If not see
19 <http://www.gnu.org/licenses/>.  */
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"
34 #include "toplev.h"
35 #include "intl.h"
36 #include "cfgloop.h"
37 #include "tree-scalar-evolution.h"
38 #include "tree-ssa-propagate.h"
39 #include "tree-chrec.h"
40
41
42 /* Set of SSA names found live during the RPO traversal of the function
43    for still active basic-blocks.  */
44 static sbitmap *live;
45
46 /* Return true if the SSA name NAME is live on the edge E.  */
47
48 static bool
49 live_on_edge (edge e, tree name)
50 {
51   return (live[e->dest->index]
52           && TEST_BIT (live[e->dest->index], SSA_NAME_VERSION (name)));
53 }
54
55 /* Local functions.  */
56 static int compare_values (tree val1, tree val2);
57 static int compare_values_warnv (tree val1, tree val2, bool *);
58 static void vrp_meet (value_range_t *, value_range_t *);
59 static tree vrp_evaluate_conditional_warnv_with_ops (enum tree_code,
60                                                      tree, tree, bool, bool *,
61                                                      bool *);
62
63 /* Location information for ASSERT_EXPRs.  Each instance of this
64    structure describes an ASSERT_EXPR for an SSA name.  Since a single
65    SSA name may have more than one assertion associated with it, these
66    locations are kept in a linked list attached to the corresponding
67    SSA name.  */
68 struct assert_locus_d
69 {
70   /* Basic block where the assertion would be inserted.  */
71   basic_block bb;
72
73   /* Some assertions need to be inserted on an edge (e.g., assertions
74      generated by COND_EXPRs).  In those cases, BB will be NULL.  */
75   edge e;
76
77   /* Pointer to the statement that generated this assertion.  */
78   gimple_stmt_iterator si;
79
80   /* Predicate code for the ASSERT_EXPR.  Must be COMPARISON_CLASS_P.  */
81   enum tree_code comp_code;
82
83   /* Value being compared against.  */
84   tree val;
85
86   /* Expression to compare.  */
87   tree expr;
88
89   /* Next node in the linked list.  */
90   struct assert_locus_d *next;
91 };
92
93 typedef struct assert_locus_d *assert_locus_t;
94
95 /* If bit I is present, it means that SSA name N_i has a list of
96    assertions that should be inserted in the IL.  */
97 static bitmap need_assert_for;
98
99 /* Array of locations lists where to insert assertions.  ASSERTS_FOR[I]
100    holds a list of ASSERT_LOCUS_T nodes that describe where
101    ASSERT_EXPRs for SSA name N_I should be inserted.  */
102 static assert_locus_t *asserts_for;
103
104 /* Value range array.  After propagation, VR_VALUE[I] holds the range
105    of values that SSA name N_I may take.  */
106 static value_range_t **vr_value;
107
108 /* For a PHI node which sets SSA name N_I, VR_COUNTS[I] holds the
109    number of executable edges we saw the last time we visited the
110    node.  */
111 static int *vr_phi_edge_counts;
112
113 typedef struct {
114   gimple stmt;
115   tree vec;
116 } switch_update;
117
118 static VEC (edge, heap) *to_remove_edges;
119 DEF_VEC_O(switch_update);
120 DEF_VEC_ALLOC_O(switch_update, heap);
121 static VEC (switch_update, heap) *to_update_switch_stmts;
122
123
124 /* Return the maximum value for TYPEs base type.  */
125
126 static inline tree
127 vrp_val_max (const_tree type)
128 {
129   if (!INTEGRAL_TYPE_P (type))
130     return NULL_TREE;
131
132   /* For integer sub-types the values for the base type are relevant.  */
133   if (TREE_TYPE (type))
134     type = TREE_TYPE (type);
135
136   return TYPE_MAX_VALUE (type);
137 }
138
139 /* Return the minimum value for TYPEs base type.  */
140
141 static inline tree
142 vrp_val_min (const_tree type)
143 {
144   if (!INTEGRAL_TYPE_P (type))
145     return NULL_TREE;
146
147   /* For integer sub-types the values for the base type are relevant.  */
148   if (TREE_TYPE (type))
149     type = TREE_TYPE (type);
150
151   return TYPE_MIN_VALUE (type);
152 }
153
154 /* Return whether VAL is equal to the maximum value of its type.  This
155    will be true for a positive overflow infinity.  We can't do a
156    simple equality comparison with TYPE_MAX_VALUE because C typedefs
157    and Ada subtypes can produce types whose TYPE_MAX_VALUE is not ==
158    to the integer constant with the same value in the type.  */
159
160 static inline bool
161 vrp_val_is_max (const_tree val)
162 {
163   tree type_max = vrp_val_max (TREE_TYPE (val));
164   return (val == type_max
165           || (type_max != NULL_TREE
166               && operand_equal_p (val, type_max, 0)));
167 }
168
169 /* Return whether VAL is equal to the minimum value of its type.  This
170    will be true for a negative overflow infinity.  */
171
172 static inline bool
173 vrp_val_is_min (const_tree val)
174 {
175   tree type_min = vrp_val_min (TREE_TYPE (val));
176   return (val == type_min
177           || (type_min != NULL_TREE
178               && operand_equal_p (val, type_min, 0)));
179 }
180
181
182 /* Return whether TYPE should use an overflow infinity distinct from
183    TYPE_{MIN,MAX}_VALUE.  We use an overflow infinity value to
184    represent a signed overflow during VRP computations.  An infinity
185    is distinct from a half-range, which will go from some number to
186    TYPE_{MIN,MAX}_VALUE.  */
187
188 static inline bool
189 needs_overflow_infinity (const_tree type)
190 {
191   return (INTEGRAL_TYPE_P (type)
192           && !TYPE_OVERFLOW_WRAPS (type)
193           /* Integer sub-types never overflow as they are never
194              operands of arithmetic operators.  */
195           && !(TREE_TYPE (type) && TREE_TYPE (type) != type));
196 }
197
198 /* Return whether TYPE can support our overflow infinity
199    representation: we use the TREE_OVERFLOW flag, which only exists
200    for constants.  If TYPE doesn't support this, we don't optimize
201    cases which would require signed overflow--we drop them to
202    VARYING.  */
203
204 static inline bool
205 supports_overflow_infinity (const_tree type)
206 {
207   tree min = vrp_val_min (type), max = vrp_val_max (type);
208 #ifdef ENABLE_CHECKING
209   gcc_assert (needs_overflow_infinity (type));
210 #endif
211   return (min != NULL_TREE
212           && CONSTANT_CLASS_P (min)
213           && max != NULL_TREE
214           && CONSTANT_CLASS_P (max));
215 }
216
217 /* VAL is the maximum or minimum value of a type.  Return a
218    corresponding overflow infinity.  */
219
220 static inline tree
221 make_overflow_infinity (tree val)
222 {
223 #ifdef ENABLE_CHECKING
224   gcc_assert (val != NULL_TREE && CONSTANT_CLASS_P (val));
225 #endif
226   val = copy_node (val);
227   TREE_OVERFLOW (val) = 1;
228   return val;
229 }
230
231 /* Return a negative overflow infinity for TYPE.  */
232
233 static inline tree
234 negative_overflow_infinity (tree type)
235 {
236 #ifdef ENABLE_CHECKING
237   gcc_assert (supports_overflow_infinity (type));
238 #endif
239   return make_overflow_infinity (vrp_val_min (type));
240 }
241
242 /* Return a positive overflow infinity for TYPE.  */
243
244 static inline tree
245 positive_overflow_infinity (tree type)
246 {
247 #ifdef ENABLE_CHECKING
248   gcc_assert (supports_overflow_infinity (type));
249 #endif
250   return make_overflow_infinity (vrp_val_max (type));
251 }
252
253 /* Return whether VAL is a negative overflow infinity.  */
254
255 static inline bool
256 is_negative_overflow_infinity (const_tree val)
257 {
258   return (needs_overflow_infinity (TREE_TYPE (val))
259           && CONSTANT_CLASS_P (val)
260           && TREE_OVERFLOW (val)
261           && vrp_val_is_min (val));
262 }
263
264 /* Return whether VAL is a positive overflow infinity.  */
265
266 static inline bool
267 is_positive_overflow_infinity (const_tree val)
268 {
269   return (needs_overflow_infinity (TREE_TYPE (val))
270           && CONSTANT_CLASS_P (val)
271           && TREE_OVERFLOW (val)
272           && vrp_val_is_max (val));
273 }
274
275 /* Return whether VAL is a positive or negative overflow infinity.  */
276
277 static inline bool
278 is_overflow_infinity (const_tree val)
279 {
280   return (needs_overflow_infinity (TREE_TYPE (val))
281           && CONSTANT_CLASS_P (val)
282           && TREE_OVERFLOW (val)
283           && (vrp_val_is_min (val) || vrp_val_is_max (val)));
284 }
285
286 /* Return whether STMT has a constant rhs that is_overflow_infinity. */
287
288 static inline bool
289 stmt_overflow_infinity (gimple stmt)
290 {
291   if (is_gimple_assign (stmt)
292       && get_gimple_rhs_class (gimple_assign_rhs_code (stmt)) ==
293       GIMPLE_SINGLE_RHS)
294     return is_overflow_infinity (gimple_assign_rhs1 (stmt));
295   return false;
296 }
297
298 /* If VAL is now an overflow infinity, return VAL.  Otherwise, return
299    the same value with TREE_OVERFLOW clear.  This can be used to avoid
300    confusing a regular value with an overflow value.  */
301
302 static inline tree
303 avoid_overflow_infinity (tree val)
304 {
305   if (!is_overflow_infinity (val))
306     return val;
307
308   if (vrp_val_is_max (val))
309     return vrp_val_max (TREE_TYPE (val));
310   else
311     {
312 #ifdef ENABLE_CHECKING
313       gcc_assert (vrp_val_is_min (val));
314 #endif
315       return vrp_val_min (TREE_TYPE (val));
316     }
317 }
318
319
320 /* Return true if ARG is marked with the nonnull attribute in the
321    current function signature.  */
322
323 static bool
324 nonnull_arg_p (const_tree arg)
325 {
326   tree t, attrs, fntype;
327   unsigned HOST_WIDE_INT arg_num;
328
329   gcc_assert (TREE_CODE (arg) == PARM_DECL && POINTER_TYPE_P (TREE_TYPE (arg)));
330
331   /* The static chain decl is always non null.  */
332   if (arg == cfun->static_chain_decl)
333     return true;
334
335   fntype = TREE_TYPE (current_function_decl);
336   attrs = lookup_attribute ("nonnull", TYPE_ATTRIBUTES (fntype));
337
338   /* If "nonnull" wasn't specified, we know nothing about the argument.  */
339   if (attrs == NULL_TREE)
340     return false;
341
342   /* If "nonnull" applies to all the arguments, then ARG is non-null.  */
343   if (TREE_VALUE (attrs) == NULL_TREE)
344     return true;
345
346   /* Get the position number for ARG in the function signature.  */
347   for (arg_num = 1, t = DECL_ARGUMENTS (current_function_decl);
348        t;
349        t = TREE_CHAIN (t), arg_num++)
350     {
351       if (t == arg)
352         break;
353     }
354
355   gcc_assert (t == arg);
356
357   /* Now see if ARG_NUM is mentioned in the nonnull list.  */
358   for (t = TREE_VALUE (attrs); t; t = TREE_CHAIN (t))
359     {
360       if (compare_tree_int (TREE_VALUE (t), arg_num) == 0)
361         return true;
362     }
363
364   return false;
365 }
366
367
368 /* Set value range VR to VR_VARYING.  */
369
370 static inline void
371 set_value_range_to_varying (value_range_t *vr)
372 {
373   vr->type = VR_VARYING;
374   vr->min = vr->max = NULL_TREE;
375   if (vr->equiv)
376     bitmap_clear (vr->equiv);
377 }
378
379
380 /* Set value range VR to {T, MIN, MAX, EQUIV}.  */
381
382 static void
383 set_value_range (value_range_t *vr, enum value_range_type t, tree min,
384                  tree max, bitmap equiv)
385 {
386 #if defined ENABLE_CHECKING
387   /* Check the validity of the range.  */
388   if (t == VR_RANGE || t == VR_ANTI_RANGE)
389     {
390       int cmp;
391
392       gcc_assert (min && max);
393
394       if (INTEGRAL_TYPE_P (TREE_TYPE (min)) && t == VR_ANTI_RANGE)
395         gcc_assert (!vrp_val_is_min (min) || !vrp_val_is_max (max));
396
397       cmp = compare_values (min, max);
398       gcc_assert (cmp == 0 || cmp == -1 || cmp == -2);
399
400       if (needs_overflow_infinity (TREE_TYPE (min)))
401         gcc_assert (!is_overflow_infinity (min)
402                     || !is_overflow_infinity (max));
403     }
404
405   if (t == VR_UNDEFINED || t == VR_VARYING)
406     gcc_assert (min == NULL_TREE && max == NULL_TREE);
407
408   if (t == VR_UNDEFINED || t == VR_VARYING)
409     gcc_assert (equiv == NULL || bitmap_empty_p (equiv));
410 #endif
411
412   vr->type = t;
413   vr->min = min;
414   vr->max = max;
415
416   /* Since updating the equivalence set involves deep copying the
417      bitmaps, only do it if absolutely necessary.  */
418   if (vr->equiv == NULL
419       && equiv != NULL)
420     vr->equiv = BITMAP_ALLOC (NULL);
421
422   if (equiv != vr->equiv)
423     {
424       if (equiv && !bitmap_empty_p (equiv))
425         bitmap_copy (vr->equiv, equiv);
426       else
427         bitmap_clear (vr->equiv);
428     }
429 }
430
431
432 /* Set value range VR to the canonical form of {T, MIN, MAX, EQUIV}.
433    This means adjusting T, MIN and MAX representing the case of a
434    wrapping range with MAX < MIN covering [MIN, type_max] U [type_min, MAX]
435    as anti-rage ~[MAX+1, MIN-1].  Likewise for wrapping anti-ranges.
436    In corner cases where MAX+1 or MIN-1 wraps this will fall back
437    to varying.
438    This routine exists to ease canonicalization in the case where we
439    extract ranges from var + CST op limit.  */
440
441 static void
442 set_and_canonicalize_value_range (value_range_t *vr, enum value_range_type t,
443                                   tree min, tree max, bitmap equiv)
444 {
445   /* Nothing to canonicalize for symbolic or unknown or varying ranges.  */
446   if ((t != VR_RANGE
447        && t != VR_ANTI_RANGE)
448       || TREE_CODE (min) != INTEGER_CST
449       || TREE_CODE (max) != INTEGER_CST)
450     {
451       set_value_range (vr, t, min, max, equiv);
452       return;
453     }
454
455   /* Wrong order for min and max, to swap them and the VR type we need
456      to adjust them.  */
457   if (tree_int_cst_lt (max, min))
458     {
459       tree one = build_int_cst (TREE_TYPE (min), 1);
460       tree tmp = int_const_binop (PLUS_EXPR, max, one, 0);
461       max = int_const_binop (MINUS_EXPR, min, one, 0);
462       min = tmp;
463
464       /* There's one corner case, if we had [C+1, C] before we now have
465          that again.  But this represents an empty value range, so drop
466          to varying in this case.  */
467       if (tree_int_cst_lt (max, min))
468         {
469           set_value_range_to_varying (vr);
470           return;
471         }
472
473       t = t == VR_RANGE ? VR_ANTI_RANGE : VR_RANGE;
474     }
475
476   /* Anti-ranges that can be represented as ranges should be so.  */
477   if (t == VR_ANTI_RANGE)
478     {
479       bool is_min = vrp_val_is_min (min);
480       bool is_max = vrp_val_is_max (max);
481
482       if (is_min && is_max)
483         {
484           /* We cannot deal with empty ranges, drop to varying.  */
485           set_value_range_to_varying (vr);
486           return;
487         }
488       else if (is_min
489                /* As a special exception preserve non-null ranges.  */
490                && !(TYPE_UNSIGNED (TREE_TYPE (min))
491                     && integer_zerop (max)))
492         {
493           tree one = build_int_cst (TREE_TYPE (max), 1);
494           min = int_const_binop (PLUS_EXPR, max, one, 0);
495           max = vrp_val_max (TREE_TYPE (max));
496           t = VR_RANGE;
497         }
498       else if (is_max)
499         {
500           tree one = build_int_cst (TREE_TYPE (min), 1);
501           max = int_const_binop (MINUS_EXPR, min, one, 0);
502           min = vrp_val_min (TREE_TYPE (min));
503           t = VR_RANGE;
504         }
505     }
506
507   set_value_range (vr, t, min, max, equiv);
508 }
509
510 /* Copy value range FROM into value range TO.  */
511
512 static inline void
513 copy_value_range (value_range_t *to, value_range_t *from)
514 {
515   set_value_range (to, from->type, from->min, from->max, from->equiv);
516 }
517
518 /* Set value range VR to a single value.  This function is only called
519    with values we get from statements, and exists to clear the
520    TREE_OVERFLOW flag so that we don't think we have an overflow
521    infinity when we shouldn't.  */
522
523 static inline void
524 set_value_range_to_value (value_range_t *vr, tree val, bitmap equiv)
525 {
526   gcc_assert (is_gimple_min_invariant (val));
527   val = avoid_overflow_infinity (val);
528   set_value_range (vr, VR_RANGE, val, val, equiv);
529 }
530
531 /* Set value range VR to a non-negative range of type TYPE.
532    OVERFLOW_INFINITY indicates whether to use an overflow infinity
533    rather than TYPE_MAX_VALUE; this should be true if we determine
534    that the range is nonnegative based on the assumption that signed
535    overflow does not occur.  */
536
537 static inline void
538 set_value_range_to_nonnegative (value_range_t *vr, tree type,
539                                 bool overflow_infinity)
540 {
541   tree zero;
542
543   if (overflow_infinity && !supports_overflow_infinity (type))
544     {
545       set_value_range_to_varying (vr);
546       return;
547     }
548
549   zero = build_int_cst (type, 0);
550   set_value_range (vr, VR_RANGE, zero,
551                    (overflow_infinity
552                     ? positive_overflow_infinity (type)
553                     : TYPE_MAX_VALUE (type)),
554                    vr->equiv);
555 }
556
557 /* Set value range VR to a non-NULL range of type TYPE.  */
558
559 static inline void
560 set_value_range_to_nonnull (value_range_t *vr, tree type)
561 {
562   tree zero = build_int_cst (type, 0);
563   set_value_range (vr, VR_ANTI_RANGE, zero, zero, vr->equiv);
564 }
565
566
567 /* Set value range VR to a NULL range of type TYPE.  */
568
569 static inline void
570 set_value_range_to_null (value_range_t *vr, tree type)
571 {
572   set_value_range_to_value (vr, build_int_cst (type, 0), vr->equiv);
573 }
574
575
576 /* Set value range VR to a range of a truthvalue of type TYPE.  */
577
578 static inline void
579 set_value_range_to_truthvalue (value_range_t *vr, tree type)
580 {
581   if (TYPE_PRECISION (type) == 1)
582     set_value_range_to_varying (vr);
583   else
584     set_value_range (vr, VR_RANGE,
585                      build_int_cst (type, 0), build_int_cst (type, 1),
586                      vr->equiv);
587 }
588
589
590 /* Set value range VR to VR_UNDEFINED.  */
591
592 static inline void
593 set_value_range_to_undefined (value_range_t *vr)
594 {
595   vr->type = VR_UNDEFINED;
596   vr->min = vr->max = NULL_TREE;
597   if (vr->equiv)
598     bitmap_clear (vr->equiv);
599 }
600
601
602 /* If abs (min) < abs (max), set VR to [-max, max], if
603    abs (min) >= abs (max), set VR to [-min, min].  */
604
605 static void
606 abs_extent_range (value_range_t *vr, tree min, tree max)
607 {
608   int cmp;
609
610   gcc_assert (TREE_CODE (min) == INTEGER_CST);
611   gcc_assert (TREE_CODE (max) == INTEGER_CST);
612   gcc_assert (INTEGRAL_TYPE_P (TREE_TYPE (min)));
613   gcc_assert (!TYPE_UNSIGNED (TREE_TYPE (min)));
614   min = fold_unary (ABS_EXPR, TREE_TYPE (min), min);
615   max = fold_unary (ABS_EXPR, TREE_TYPE (max), max);
616   if (TREE_OVERFLOW (min) || TREE_OVERFLOW (max))
617     {
618       set_value_range_to_varying (vr);
619       return;
620     }
621   cmp = compare_values (min, max);
622   if (cmp == -1)
623     min = fold_unary (NEGATE_EXPR, TREE_TYPE (min), max);
624   else if (cmp == 0 || cmp == 1)
625     {
626       max = min;
627       min = fold_unary (NEGATE_EXPR, TREE_TYPE (min), min);
628     }
629   else
630     {
631       set_value_range_to_varying (vr);
632       return;
633     }
634   set_and_canonicalize_value_range (vr, VR_RANGE, min, max, NULL);
635 }
636
637
638 /* Return value range information for VAR.  
639
640    If we have no values ranges recorded (ie, VRP is not running), then
641    return NULL.  Otherwise create an empty range if none existed for VAR.  */
642
643 static value_range_t *
644 get_value_range (const_tree var)
645 {
646   value_range_t *vr;
647   tree sym;
648   unsigned ver = SSA_NAME_VERSION (var);
649
650   /* If we have no recorded ranges, then return NULL.  */
651   if (! vr_value)
652     return NULL;
653
654   vr = vr_value[ver];
655   if (vr)
656     return vr;
657
658   /* Create a default value range.  */
659   vr_value[ver] = vr = XCNEW (value_range_t);
660
661   /* Defer allocating the equivalence set.  */
662   vr->equiv = NULL;
663
664   /* If VAR is a default definition, the variable can take any value
665      in VAR's type.  */
666   sym = SSA_NAME_VAR (var);
667   if (SSA_NAME_IS_DEFAULT_DEF (var))
668     {
669       /* Try to use the "nonnull" attribute to create ~[0, 0]
670          anti-ranges for pointers.  Note that this is only valid with
671          default definitions of PARM_DECLs.  */
672       if (TREE_CODE (sym) == PARM_DECL
673           && POINTER_TYPE_P (TREE_TYPE (sym))
674           && nonnull_arg_p (sym))
675         set_value_range_to_nonnull (vr, TREE_TYPE (sym));
676       else
677         set_value_range_to_varying (vr);
678     }
679
680   return vr;
681 }
682
683 /* Return true, if VAL1 and VAL2 are equal values for VRP purposes.  */
684
685 static inline bool
686 vrp_operand_equal_p (const_tree val1, const_tree val2)
687 {
688   if (val1 == val2)
689     return true;
690   if (!val1 || !val2 || !operand_equal_p (val1, val2, 0))
691     return false;
692   if (is_overflow_infinity (val1))
693     return is_overflow_infinity (val2);
694   return true;
695 }
696
697 /* Return true, if the bitmaps B1 and B2 are equal.  */
698
699 static inline bool
700 vrp_bitmap_equal_p (const_bitmap b1, const_bitmap b2)
701 {
702   return (b1 == b2
703           || (b1 && b2
704               && bitmap_equal_p (b1, b2)));
705 }
706
707 /* Update the value range and equivalence set for variable VAR to
708    NEW_VR.  Return true if NEW_VR is different from VAR's previous
709    value.
710
711    NOTE: This function assumes that NEW_VR is a temporary value range
712    object created for the sole purpose of updating VAR's range.  The
713    storage used by the equivalence set from NEW_VR will be freed by
714    this function.  Do not call update_value_range when NEW_VR
715    is the range object associated with another SSA name.  */
716
717 static inline bool
718 update_value_range (const_tree var, value_range_t *new_vr)
719 {
720   value_range_t *old_vr;
721   bool is_new;
722
723   /* Update the value range, if necessary.  */
724   old_vr = get_value_range (var);
725   is_new = old_vr->type != new_vr->type
726            || !vrp_operand_equal_p (old_vr->min, new_vr->min)
727            || !vrp_operand_equal_p (old_vr->max, new_vr->max)
728            || !vrp_bitmap_equal_p (old_vr->equiv, new_vr->equiv);
729
730   if (is_new)
731     set_value_range (old_vr, new_vr->type, new_vr->min, new_vr->max,
732                      new_vr->equiv);
733
734   BITMAP_FREE (new_vr->equiv);
735
736   return is_new;
737 }
738
739
740 /* Add VAR and VAR's equivalence set to EQUIV.  This is the central
741    point where equivalence processing can be turned on/off.  */
742
743 static void
744 add_equivalence (bitmap *equiv, const_tree var)
745 {
746   unsigned ver = SSA_NAME_VERSION (var);
747   value_range_t *vr = vr_value[ver];
748
749   if (*equiv == NULL)
750     *equiv = BITMAP_ALLOC (NULL);
751   bitmap_set_bit (*equiv, ver);
752   if (vr && vr->equiv)
753     bitmap_ior_into (*equiv, vr->equiv);
754 }
755
756
757 /* Return true if VR is ~[0, 0].  */
758
759 static inline bool
760 range_is_nonnull (value_range_t *vr)
761 {
762   return vr->type == VR_ANTI_RANGE
763          && integer_zerop (vr->min)
764          && integer_zerop (vr->max);
765 }
766
767
768 /* Return true if VR is [0, 0].  */
769
770 static inline bool
771 range_is_null (value_range_t *vr)
772 {
773   return vr->type == VR_RANGE
774          && integer_zerop (vr->min)
775          && integer_zerop (vr->max);
776 }
777
778
779 /* Return true if value range VR involves at least one symbol.  */
780
781 static inline bool
782 symbolic_range_p (value_range_t *vr)
783 {
784   return (!is_gimple_min_invariant (vr->min)
785           || !is_gimple_min_invariant (vr->max));
786 }
787
788 /* Return true if value range VR uses an overflow infinity.  */
789
790 static inline bool
791 overflow_infinity_range_p (value_range_t *vr)
792 {
793   return (vr->type == VR_RANGE
794           && (is_overflow_infinity (vr->min)
795               || is_overflow_infinity (vr->max)));
796 }
797
798 /* Return false if we can not make a valid comparison based on VR;
799    this will be the case if it uses an overflow infinity and overflow
800    is not undefined (i.e., -fno-strict-overflow is in effect).
801    Otherwise return true, and set *STRICT_OVERFLOW_P to true if VR
802    uses an overflow infinity.  */
803
804 static bool
805 usable_range_p (value_range_t *vr, bool *strict_overflow_p)
806 {
807   gcc_assert (vr->type == VR_RANGE);
808   if (is_overflow_infinity (vr->min))
809     {
810       *strict_overflow_p = true;
811       if (!TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (vr->min)))
812         return false;
813     }
814   if (is_overflow_infinity (vr->max))
815     {
816       *strict_overflow_p = true;
817       if (!TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (vr->max)))
818         return false;
819     }
820   return true;
821 }
822
823
824 /* Like tree_expr_nonnegative_warnv_p, but this function uses value
825    ranges obtained so far.  */
826
827 static bool
828 vrp_expr_computes_nonnegative (tree expr, bool *strict_overflow_p)
829 {
830   return (tree_expr_nonnegative_warnv_p (expr, strict_overflow_p)
831           || (TREE_CODE (expr) == SSA_NAME
832               && ssa_name_nonnegative_p (expr)));
833 }
834
835 /* Return true if the result of assignment STMT is know to be non-negative.
836    If the return value is based on the assumption that signed overflow is
837    undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't change
838    *STRICT_OVERFLOW_P.*/
839
840 static bool
841 gimple_assign_nonnegative_warnv_p (gimple stmt, bool *strict_overflow_p)
842 {
843   enum tree_code code = gimple_assign_rhs_code (stmt);
844   switch (get_gimple_rhs_class (code))
845     {
846     case GIMPLE_UNARY_RHS:
847       return tree_unary_nonnegative_warnv_p (gimple_assign_rhs_code (stmt),
848                                              gimple_expr_type (stmt),
849                                              gimple_assign_rhs1 (stmt),
850                                              strict_overflow_p);
851     case GIMPLE_BINARY_RHS:
852       return tree_binary_nonnegative_warnv_p (gimple_assign_rhs_code (stmt),
853                                               gimple_expr_type (stmt),
854                                               gimple_assign_rhs1 (stmt),
855                                               gimple_assign_rhs2 (stmt),
856                                               strict_overflow_p);
857     case GIMPLE_SINGLE_RHS:
858       return tree_single_nonnegative_warnv_p (gimple_assign_rhs1 (stmt),
859                                               strict_overflow_p);
860     case GIMPLE_INVALID_RHS:
861       gcc_unreachable ();
862     default:
863       gcc_unreachable ();
864     }
865 }
866
867 /* Return true if return value of call STMT is know to be non-negative.
868    If the return value is based on the assumption that signed overflow is
869    undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't change
870    *STRICT_OVERFLOW_P.*/
871
872 static bool
873 gimple_call_nonnegative_warnv_p (gimple stmt, bool *strict_overflow_p)
874 {
875   tree arg0 = gimple_call_num_args (stmt) > 0 ?
876     gimple_call_arg (stmt, 0) : NULL_TREE;
877   tree arg1 = gimple_call_num_args (stmt) > 1 ?
878     gimple_call_arg (stmt, 1) : NULL_TREE;
879
880   return tree_call_nonnegative_warnv_p (gimple_expr_type (stmt),
881                                         gimple_call_fndecl (stmt),
882                                         arg0,
883                                         arg1,
884                                         strict_overflow_p);
885 }
886
887 /* Return true if STMT is know to to compute a non-negative value.
888    If the return value is based on the assumption that signed overflow is
889    undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't change
890    *STRICT_OVERFLOW_P.*/
891
892 static bool
893 gimple_stmt_nonnegative_warnv_p (gimple stmt, bool *strict_overflow_p)
894 {
895   switch (gimple_code (stmt))
896     {
897     case GIMPLE_ASSIGN:
898       return gimple_assign_nonnegative_warnv_p (stmt, strict_overflow_p);
899     case GIMPLE_CALL:
900       return gimple_call_nonnegative_warnv_p (stmt, strict_overflow_p);
901     default:
902       gcc_unreachable ();
903     }
904 }
905
906 /* Return true if the result of assignment STMT is know to be non-zero.
907    If the return value is based on the assumption that signed overflow is
908    undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't change
909    *STRICT_OVERFLOW_P.*/
910
911 static bool
912 gimple_assign_nonzero_warnv_p (gimple stmt, bool *strict_overflow_p)
913 {
914   enum tree_code code = gimple_assign_rhs_code (stmt);
915   switch (get_gimple_rhs_class (code))
916     {
917     case GIMPLE_UNARY_RHS:
918       return tree_unary_nonzero_warnv_p (gimple_assign_rhs_code (stmt),
919                                          gimple_expr_type (stmt),
920                                          gimple_assign_rhs1 (stmt),
921                                          strict_overflow_p);
922     case GIMPLE_BINARY_RHS:
923       return tree_binary_nonzero_warnv_p (gimple_assign_rhs_code (stmt),
924                                           gimple_expr_type (stmt),
925                                           gimple_assign_rhs1 (stmt),
926                                           gimple_assign_rhs2 (stmt),
927                                           strict_overflow_p);
928     case GIMPLE_SINGLE_RHS:
929       return tree_single_nonzero_warnv_p (gimple_assign_rhs1 (stmt),
930                                           strict_overflow_p);
931     case GIMPLE_INVALID_RHS:
932       gcc_unreachable ();
933     default:
934       gcc_unreachable ();
935     }
936 }
937
938 /* Return true if STMT is know to to compute a non-zero value.
939    If the return value is based on the assumption that signed overflow is
940    undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't change
941    *STRICT_OVERFLOW_P.*/
942
943 static bool
944 gimple_stmt_nonzero_warnv_p (gimple stmt, bool *strict_overflow_p)
945 {
946   switch (gimple_code (stmt))
947     {
948     case GIMPLE_ASSIGN:
949       return gimple_assign_nonzero_warnv_p (stmt, strict_overflow_p);
950     case GIMPLE_CALL:
951       return gimple_alloca_call_p (stmt);
952     default:
953       gcc_unreachable ();
954     }
955 }
956
957 /* Like tree_expr_nonzero_warnv_p, but this function uses value ranges
958    obtained so far.  */
959
960 static bool
961 vrp_stmt_computes_nonzero (gimple stmt, bool *strict_overflow_p)
962 {
963   if (gimple_stmt_nonzero_warnv_p (stmt, strict_overflow_p))
964     return true;
965
966   /* If we have an expression of the form &X->a, then the expression
967      is nonnull if X is nonnull.  */
968   if (is_gimple_assign (stmt)
969       && gimple_assign_rhs_code (stmt) == ADDR_EXPR)
970     {
971       tree expr = gimple_assign_rhs1 (stmt);
972       tree base = get_base_address (TREE_OPERAND (expr, 0));
973
974       if (base != NULL_TREE
975           && TREE_CODE (base) == INDIRECT_REF
976           && TREE_CODE (TREE_OPERAND (base, 0)) == SSA_NAME)
977         {
978           value_range_t *vr = get_value_range (TREE_OPERAND (base, 0));
979           if (range_is_nonnull (vr))
980             return true;
981         }
982     }
983
984   return false;
985 }
986
987 /* Returns true if EXPR is a valid value (as expected by compare_values) --
988    a gimple invariant, or SSA_NAME +- CST.  */
989
990 static bool
991 valid_value_p (tree expr)
992 {
993   if (TREE_CODE (expr) == SSA_NAME)
994     return true;
995
996   if (TREE_CODE (expr) == PLUS_EXPR
997       || TREE_CODE (expr) == MINUS_EXPR)
998     return (TREE_CODE (TREE_OPERAND (expr, 0)) == SSA_NAME
999             && TREE_CODE (TREE_OPERAND (expr, 1)) == INTEGER_CST);
1000   
1001   return is_gimple_min_invariant (expr);
1002 }
1003
1004 /* Return 
1005    1 if VAL < VAL2
1006    0 if !(VAL < VAL2)
1007    -2 if those are incomparable.  */
1008 static inline int
1009 operand_less_p (tree val, tree val2)
1010 {
1011   /* LT is folded faster than GE and others.  Inline the common case.  */
1012   if (TREE_CODE (val) == INTEGER_CST && TREE_CODE (val2) == INTEGER_CST)
1013     {
1014       if (TYPE_UNSIGNED (TREE_TYPE (val)))
1015         return INT_CST_LT_UNSIGNED (val, val2);
1016       else
1017         {
1018           if (INT_CST_LT (val, val2))
1019             return 1;
1020         }
1021     }
1022   else
1023     {
1024       tree tcmp;
1025
1026       fold_defer_overflow_warnings ();
1027
1028       tcmp = fold_binary_to_constant (LT_EXPR, boolean_type_node, val, val2);
1029
1030       fold_undefer_and_ignore_overflow_warnings ();
1031
1032       if (!tcmp
1033           || TREE_CODE (tcmp) != INTEGER_CST)
1034         return -2;
1035
1036       if (!integer_zerop (tcmp))
1037         return 1;
1038     }
1039
1040   /* val >= val2, not considering overflow infinity.  */
1041   if (is_negative_overflow_infinity (val))
1042     return is_negative_overflow_infinity (val2) ? 0 : 1;
1043   else if (is_positive_overflow_infinity (val2))
1044     return is_positive_overflow_infinity (val) ? 0 : 1;
1045
1046   return 0;
1047 }
1048
1049 /* Compare two values VAL1 and VAL2.  Return
1050    
1051         -2 if VAL1 and VAL2 cannot be compared at compile-time,
1052         -1 if VAL1 < VAL2,
1053          0 if VAL1 == VAL2,
1054         +1 if VAL1 > VAL2, and
1055         +2 if VAL1 != VAL2
1056
1057    This is similar to tree_int_cst_compare but supports pointer values
1058    and values that cannot be compared at compile time.
1059
1060    If STRICT_OVERFLOW_P is not NULL, then set *STRICT_OVERFLOW_P to
1061    true if the return value is only valid if we assume that signed
1062    overflow is undefined.  */
1063
1064 static int
1065 compare_values_warnv (tree val1, tree val2, bool *strict_overflow_p)
1066 {
1067   if (val1 == val2)
1068     return 0;
1069
1070   /* Below we rely on the fact that VAL1 and VAL2 are both pointers or
1071      both integers.  */
1072   gcc_assert (POINTER_TYPE_P (TREE_TYPE (val1))
1073               == POINTER_TYPE_P (TREE_TYPE (val2)));
1074   /* Convert the two values into the same type.  This is needed because
1075      sizetype causes sign extension even for unsigned types.  */
1076   val2 = fold_convert (TREE_TYPE (val1), val2);
1077   STRIP_USELESS_TYPE_CONVERSION (val2);
1078
1079   if ((TREE_CODE (val1) == SSA_NAME
1080        || TREE_CODE (val1) == PLUS_EXPR
1081        || TREE_CODE (val1) == MINUS_EXPR)
1082       && (TREE_CODE (val2) == SSA_NAME
1083           || TREE_CODE (val2) == PLUS_EXPR
1084           || TREE_CODE (val2) == MINUS_EXPR))
1085     {
1086       tree n1, c1, n2, c2;
1087       enum tree_code code1, code2;
1088   
1089       /* If VAL1 and VAL2 are of the form 'NAME [+-] CST' or 'NAME',
1090          return -1 or +1 accordingly.  If VAL1 and VAL2 don't use the
1091          same name, return -2.  */
1092       if (TREE_CODE (val1) == SSA_NAME)
1093         {
1094           code1 = SSA_NAME;
1095           n1 = val1;
1096           c1 = NULL_TREE;
1097         }
1098       else
1099         {
1100           code1 = TREE_CODE (val1);
1101           n1 = TREE_OPERAND (val1, 0);
1102           c1 = TREE_OPERAND (val1, 1);
1103           if (tree_int_cst_sgn (c1) == -1)
1104             {
1105               if (is_negative_overflow_infinity (c1))
1106                 return -2;
1107               c1 = fold_unary_to_constant (NEGATE_EXPR, TREE_TYPE (c1), c1);
1108               if (!c1)
1109                 return -2;
1110               code1 = code1 == MINUS_EXPR ? PLUS_EXPR : MINUS_EXPR;
1111             }
1112         }
1113
1114       if (TREE_CODE (val2) == SSA_NAME)
1115         {
1116           code2 = SSA_NAME;
1117           n2 = val2;
1118           c2 = NULL_TREE;
1119         }
1120       else
1121         {
1122           code2 = TREE_CODE (val2);
1123           n2 = TREE_OPERAND (val2, 0);
1124           c2 = TREE_OPERAND (val2, 1);
1125           if (tree_int_cst_sgn (c2) == -1)
1126             {
1127               if (is_negative_overflow_infinity (c2))
1128                 return -2;
1129               c2 = fold_unary_to_constant (NEGATE_EXPR, TREE_TYPE (c2), c2);
1130               if (!c2)
1131                 return -2;
1132               code2 = code2 == MINUS_EXPR ? PLUS_EXPR : MINUS_EXPR;
1133             }
1134         }
1135
1136       /* Both values must use the same name.  */
1137       if (n1 != n2)
1138         return -2;
1139
1140       if (code1 == SSA_NAME
1141           && code2 == SSA_NAME)
1142         /* NAME == NAME  */
1143         return 0;
1144
1145       /* If overflow is defined we cannot simplify more.  */
1146       if (!TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (val1)))
1147         return -2;
1148
1149       if (strict_overflow_p != NULL
1150           && (code1 == SSA_NAME || !TREE_NO_WARNING (val1))
1151           && (code2 == SSA_NAME || !TREE_NO_WARNING (val2)))
1152         *strict_overflow_p = true;
1153
1154       if (code1 == SSA_NAME)
1155         {
1156           if (code2 == PLUS_EXPR)
1157             /* NAME < NAME + CST  */
1158             return -1;
1159           else if (code2 == MINUS_EXPR)
1160             /* NAME > NAME - CST  */
1161             return 1;
1162         }
1163       else if (code1 == PLUS_EXPR)
1164         {
1165           if (code2 == SSA_NAME)
1166             /* NAME + CST > NAME  */
1167             return 1;
1168           else if (code2 == PLUS_EXPR)
1169             /* NAME + CST1 > NAME + CST2, if CST1 > CST2  */
1170             return compare_values_warnv (c1, c2, strict_overflow_p);
1171           else if (code2 == MINUS_EXPR)
1172             /* NAME + CST1 > NAME - CST2  */
1173             return 1;
1174         }
1175       else if (code1 == MINUS_EXPR)
1176         {
1177           if (code2 == SSA_NAME)
1178             /* NAME - CST < NAME  */
1179             return -1;
1180           else if (code2 == PLUS_EXPR)
1181             /* NAME - CST1 < NAME + CST2  */
1182             return -1;
1183           else if (code2 == MINUS_EXPR)
1184             /* NAME - CST1 > NAME - CST2, if CST1 < CST2.  Notice that
1185                C1 and C2 are swapped in the call to compare_values.  */
1186             return compare_values_warnv (c2, c1, strict_overflow_p);
1187         }
1188
1189       gcc_unreachable ();
1190     }
1191
1192   /* We cannot compare non-constants.  */
1193   if (!is_gimple_min_invariant (val1) || !is_gimple_min_invariant (val2))
1194     return -2;
1195
1196   if (!POINTER_TYPE_P (TREE_TYPE (val1)))
1197     {
1198       /* We cannot compare overflowed values, except for overflow
1199          infinities.  */
1200       if (TREE_OVERFLOW (val1) || TREE_OVERFLOW (val2))
1201         {
1202           if (strict_overflow_p != NULL)
1203             *strict_overflow_p = true;
1204           if (is_negative_overflow_infinity (val1))
1205             return is_negative_overflow_infinity (val2) ? 0 : -1;
1206           else if (is_negative_overflow_infinity (val2))
1207             return 1;
1208           else if (is_positive_overflow_infinity (val1))
1209             return is_positive_overflow_infinity (val2) ? 0 : 1;
1210           else if (is_positive_overflow_infinity (val2))
1211             return -1;
1212           return -2;
1213         }
1214
1215       return tree_int_cst_compare (val1, val2);
1216     }
1217   else
1218     {
1219       tree t;
1220
1221       /* First see if VAL1 and VAL2 are not the same.  */
1222       if (val1 == val2 || operand_equal_p (val1, val2, 0))
1223         return 0;
1224       
1225       /* If VAL1 is a lower address than VAL2, return -1.  */
1226       if (operand_less_p (val1, val2) == 1)
1227         return -1;
1228
1229       /* If VAL1 is a higher address than VAL2, return +1.  */
1230       if (operand_less_p (val2, val1) == 1)
1231         return 1;
1232
1233       /* If VAL1 is different than VAL2, return +2.
1234          For integer constants we either have already returned -1 or 1
1235          or they are equivalent.  We still might succeed in proving
1236          something about non-trivial operands.  */
1237       if (TREE_CODE (val1) != INTEGER_CST
1238           || TREE_CODE (val2) != INTEGER_CST)
1239         {
1240           t = fold_binary_to_constant (NE_EXPR, boolean_type_node, val1, val2);
1241           if (t && integer_onep (t))
1242             return 2;
1243         }
1244
1245       return -2;
1246     }
1247 }
1248
1249 /* Compare values like compare_values_warnv, but treat comparisons of
1250    nonconstants which rely on undefined overflow as incomparable.  */
1251
1252 static int
1253 compare_values (tree val1, tree val2)
1254 {
1255   bool sop;
1256   int ret;
1257
1258   sop = false;
1259   ret = compare_values_warnv (val1, val2, &sop);
1260   if (sop
1261       && (!is_gimple_min_invariant (val1) || !is_gimple_min_invariant (val2)))
1262     ret = -2;
1263   return ret;
1264 }
1265
1266
1267 /* Return 1 if VAL is inside value range VR (VR->MIN <= VAL <= VR->MAX),
1268           0 if VAL is not inside VR,
1269          -2 if we cannot tell either way.
1270
1271    FIXME, the current semantics of this functions are a bit quirky
1272           when taken in the context of VRP.  In here we do not care
1273           about VR's type.  If VR is the anti-range ~[3, 5] the call
1274           value_inside_range (4, VR) will return 1.
1275
1276           This is counter-intuitive in a strict sense, but the callers
1277           currently expect this.  They are calling the function
1278           merely to determine whether VR->MIN <= VAL <= VR->MAX.  The
1279           callers are applying the VR_RANGE/VR_ANTI_RANGE semantics
1280           themselves.
1281
1282           This also applies to value_ranges_intersect_p and
1283           range_includes_zero_p.  The semantics of VR_RANGE and
1284           VR_ANTI_RANGE should be encoded here, but that also means
1285           adapting the users of these functions to the new semantics.  
1286
1287    Benchmark compile/20001226-1.c compilation time after changing this
1288    function.  */
1289
1290 static inline int
1291 value_inside_range (tree val, value_range_t * vr)
1292 {
1293   int cmp1, cmp2;
1294
1295   cmp1 = operand_less_p (val, vr->min);
1296   if (cmp1 == -2)
1297     return -2;
1298   if (cmp1 == 1)
1299     return 0;
1300
1301   cmp2 = operand_less_p (vr->max, val);
1302   if (cmp2 == -2)
1303     return -2;
1304
1305   return !cmp2;
1306 }
1307
1308
1309 /* Return true if value ranges VR0 and VR1 have a non-empty
1310    intersection.  
1311    
1312    Benchmark compile/20001226-1.c compilation time after changing this
1313    function.
1314    */
1315
1316 static inline bool
1317 value_ranges_intersect_p (value_range_t *vr0, value_range_t *vr1)
1318 {
1319   /* The value ranges do not intersect if the maximum of the first range is
1320      less than the minimum of the second range or vice versa.
1321      When those relations are unknown, we can't do any better.  */
1322   if (operand_less_p (vr0->max, vr1->min) != 0)
1323     return false;
1324   if (operand_less_p (vr1->max, vr0->min) != 0)
1325     return false;
1326   return true;
1327 }
1328
1329
1330 /* Return true if VR includes the value zero, false otherwise.  FIXME,
1331    currently this will return false for an anti-range like ~[-4, 3].
1332    This will be wrong when the semantics of value_inside_range are
1333    modified (currently the users of this function expect these
1334    semantics).  */
1335
1336 static inline bool
1337 range_includes_zero_p (value_range_t *vr)
1338 {
1339   tree zero;
1340
1341   gcc_assert (vr->type != VR_UNDEFINED
1342               && vr->type != VR_VARYING
1343               && !symbolic_range_p (vr));
1344
1345   zero = build_int_cst (TREE_TYPE (vr->min), 0);
1346   return (value_inside_range (zero, vr) == 1);
1347 }
1348
1349 /* Return true if T, an SSA_NAME, is known to be nonnegative.  Return
1350    false otherwise or if no value range information is available.  */
1351
1352 bool
1353 ssa_name_nonnegative_p (const_tree t)
1354 {
1355   value_range_t *vr = get_value_range (t);
1356
1357   if (!vr)
1358     return false;
1359
1360   /* Testing for VR_ANTI_RANGE is not useful here as any anti-range
1361      which would return a useful value should be encoded as a VR_RANGE.  */
1362   if (vr->type == VR_RANGE)
1363     {
1364       int result = compare_values (vr->min, integer_zero_node);
1365
1366       return (result == 0 || result == 1);
1367     }
1368   return false;
1369 }
1370
1371 /* Return true if T, an SSA_NAME, is known to be nonzero.  Return
1372    false otherwise or if no value range information is available.  */
1373
1374 bool
1375 ssa_name_nonzero_p (const_tree t)
1376 {
1377   value_range_t *vr = get_value_range (t);
1378
1379   if (!vr)
1380     return false;
1381
1382   /* A VR_RANGE which does not include zero is a nonzero value.  */
1383   if (vr->type == VR_RANGE && !symbolic_range_p (vr))
1384     return ! range_includes_zero_p (vr);
1385
1386   /* A VR_ANTI_RANGE which does include zero is a nonzero value.  */
1387   if (vr->type == VR_ANTI_RANGE && !symbolic_range_p (vr))
1388     return range_includes_zero_p (vr);
1389
1390   return false;
1391 }
1392
1393 /* If OP has a value range with a single constant value return that,
1394    otherwise return NULL_TREE.  This returns OP itself if OP is a
1395    constant.  */
1396
1397 static tree
1398 op_with_constant_singleton_value_range (tree op)
1399 {
1400   value_range_t *vr;
1401
1402   if (is_gimple_min_invariant (op))
1403     return op;
1404
1405   if (TREE_CODE (op) != SSA_NAME)
1406     return NULL_TREE;
1407
1408   vr = get_value_range (op);
1409   if (vr->type == VR_RANGE
1410       && operand_equal_p (vr->min, vr->max, 0)
1411       && is_gimple_min_invariant (vr->min))
1412     return vr->min;
1413
1414   return NULL_TREE;
1415 }
1416
1417
1418 /* Extract value range information from an ASSERT_EXPR EXPR and store
1419    it in *VR_P.  */
1420
1421 static void
1422 extract_range_from_assert (value_range_t *vr_p, tree expr)
1423 {
1424   tree var, cond, limit, min, max, type;
1425   value_range_t *var_vr, *limit_vr;
1426   enum tree_code cond_code;
1427
1428   var = ASSERT_EXPR_VAR (expr);
1429   cond = ASSERT_EXPR_COND (expr);
1430
1431   gcc_assert (COMPARISON_CLASS_P (cond));
1432
1433   /* Find VAR in the ASSERT_EXPR conditional.  */
1434   if (var == TREE_OPERAND (cond, 0)
1435       || TREE_CODE (TREE_OPERAND (cond, 0)) == PLUS_EXPR
1436       || TREE_CODE (TREE_OPERAND (cond, 0)) == NOP_EXPR)
1437     {
1438       /* If the predicate is of the form VAR COMP LIMIT, then we just
1439          take LIMIT from the RHS and use the same comparison code.  */
1440       cond_code = TREE_CODE (cond);
1441       limit = TREE_OPERAND (cond, 1);
1442       cond = TREE_OPERAND (cond, 0);
1443     }
1444   else
1445     {
1446       /* If the predicate is of the form LIMIT COMP VAR, then we need
1447          to flip around the comparison code to create the proper range
1448          for VAR.  */
1449       cond_code = swap_tree_comparison (TREE_CODE (cond));
1450       limit = TREE_OPERAND (cond, 0);
1451       cond = TREE_OPERAND (cond, 1);
1452     }
1453
1454   limit = avoid_overflow_infinity (limit);
1455
1456   type = TREE_TYPE (limit);
1457   gcc_assert (limit != var);
1458
1459   /* For pointer arithmetic, we only keep track of pointer equality
1460      and inequality.  */
1461   if (POINTER_TYPE_P (type) && cond_code != NE_EXPR && cond_code != EQ_EXPR)
1462     {
1463       set_value_range_to_varying (vr_p);
1464       return;
1465     }
1466
1467   /* If LIMIT is another SSA name and LIMIT has a range of its own,
1468      try to use LIMIT's range to avoid creating symbolic ranges
1469      unnecessarily. */
1470   limit_vr = (TREE_CODE (limit) == SSA_NAME) ? get_value_range (limit) : NULL;
1471
1472   /* LIMIT's range is only interesting if it has any useful information.  */
1473   if (limit_vr
1474       && (limit_vr->type == VR_UNDEFINED
1475           || limit_vr->type == VR_VARYING
1476           || symbolic_range_p (limit_vr)))
1477     limit_vr = NULL;
1478
1479   /* Initially, the new range has the same set of equivalences of
1480      VAR's range.  This will be revised before returning the final
1481      value.  Since assertions may be chained via mutually exclusive
1482      predicates, we will need to trim the set of equivalences before
1483      we are done.  */
1484   gcc_assert (vr_p->equiv == NULL);
1485   add_equivalence (&vr_p->equiv, var);
1486
1487   /* Extract a new range based on the asserted comparison for VAR and
1488      LIMIT's value range.  Notice that if LIMIT has an anti-range, we
1489      will only use it for equality comparisons (EQ_EXPR).  For any
1490      other kind of assertion, we cannot derive a range from LIMIT's
1491      anti-range that can be used to describe the new range.  For
1492      instance, ASSERT_EXPR <x_2, x_2 <= b_4>.  If b_4 is ~[2, 10],
1493      then b_4 takes on the ranges [-INF, 1] and [11, +INF].  There is
1494      no single range for x_2 that could describe LE_EXPR, so we might
1495      as well build the range [b_4, +INF] for it.
1496      One special case we handle is extracting a range from a
1497      range test encoded as (unsigned)var + CST <= limit.  */
1498   if (TREE_CODE (cond) == NOP_EXPR
1499       || TREE_CODE (cond) == PLUS_EXPR)
1500     {
1501       if (TREE_CODE (cond) == PLUS_EXPR)
1502         {
1503           min = fold_build1 (NEGATE_EXPR, TREE_TYPE (TREE_OPERAND (cond, 1)),
1504                              TREE_OPERAND (cond, 1));
1505           max = int_const_binop (PLUS_EXPR, limit, min, 0);
1506           cond = TREE_OPERAND (cond, 0);
1507         }
1508       else
1509         {
1510           min = build_int_cst (TREE_TYPE (var), 0);
1511           max = limit;
1512         }
1513
1514       /* Make sure to not set TREE_OVERFLOW on the final type
1515          conversion.  We are willingly interpreting large positive
1516          unsigned values as negative singed values here.  */
1517       min = force_fit_type_double (TREE_TYPE (var), TREE_INT_CST_LOW (min),
1518                                    TREE_INT_CST_HIGH (min), 0, false);
1519       max = force_fit_type_double (TREE_TYPE (var), TREE_INT_CST_LOW (max),
1520                                    TREE_INT_CST_HIGH (max), 0, false);
1521
1522       /* We can transform a max, min range to an anti-range or
1523          vice-versa.  Use set_and_canonicalize_value_range which does
1524          this for us.  */
1525       if (cond_code == LE_EXPR)
1526         set_and_canonicalize_value_range (vr_p, VR_RANGE,
1527                                           min, max, vr_p->equiv);
1528       else if (cond_code == GT_EXPR)
1529         set_and_canonicalize_value_range (vr_p, VR_ANTI_RANGE,
1530                                           min, max, vr_p->equiv);
1531       else
1532         gcc_unreachable ();
1533     }
1534   else if (cond_code == EQ_EXPR)
1535     {
1536       enum value_range_type range_type;
1537
1538       if (limit_vr)
1539         {
1540           range_type = limit_vr->type;
1541           min = limit_vr->min;
1542           max = limit_vr->max;
1543         }
1544       else
1545         {
1546           range_type = VR_RANGE;
1547           min = limit;
1548           max = limit;
1549         }
1550
1551       set_value_range (vr_p, range_type, min, max, vr_p->equiv);
1552
1553       /* When asserting the equality VAR == LIMIT and LIMIT is another
1554          SSA name, the new range will also inherit the equivalence set
1555          from LIMIT.  */
1556       if (TREE_CODE (limit) == SSA_NAME)
1557         add_equivalence (&vr_p->equiv, limit);
1558     }
1559   else if (cond_code == NE_EXPR)
1560     {
1561       /* As described above, when LIMIT's range is an anti-range and
1562          this assertion is an inequality (NE_EXPR), then we cannot
1563          derive anything from the anti-range.  For instance, if
1564          LIMIT's range was ~[0, 0], the assertion 'VAR != LIMIT' does
1565          not imply that VAR's range is [0, 0].  So, in the case of
1566          anti-ranges, we just assert the inequality using LIMIT and
1567          not its anti-range.
1568
1569          If LIMIT_VR is a range, we can only use it to build a new
1570          anti-range if LIMIT_VR is a single-valued range.  For
1571          instance, if LIMIT_VR is [0, 1], the predicate
1572          VAR != [0, 1] does not mean that VAR's range is ~[0, 1].
1573          Rather, it means that for value 0 VAR should be ~[0, 0]
1574          and for value 1, VAR should be ~[1, 1].  We cannot
1575          represent these ranges.
1576
1577          The only situation in which we can build a valid
1578          anti-range is when LIMIT_VR is a single-valued range
1579          (i.e., LIMIT_VR->MIN == LIMIT_VR->MAX).  In that case, 
1580          build the anti-range ~[LIMIT_VR->MIN, LIMIT_VR->MAX].  */
1581       if (limit_vr
1582           && limit_vr->type == VR_RANGE
1583           && compare_values (limit_vr->min, limit_vr->max) == 0)
1584         {
1585           min = limit_vr->min;
1586           max = limit_vr->max;
1587         }
1588       else
1589         {
1590           /* In any other case, we cannot use LIMIT's range to build a
1591              valid anti-range.  */
1592           min = max = limit;
1593         }
1594
1595       /* If MIN and MAX cover the whole range for their type, then
1596          just use the original LIMIT.  */
1597       if (INTEGRAL_TYPE_P (type)
1598           && vrp_val_is_min (min)
1599           && vrp_val_is_max (max))
1600         min = max = limit;
1601
1602       set_value_range (vr_p, VR_ANTI_RANGE, min, max, vr_p->equiv);
1603     }
1604   else if (cond_code == LE_EXPR || cond_code == LT_EXPR)
1605     {
1606       min = TYPE_MIN_VALUE (type);
1607
1608       if (limit_vr == NULL || limit_vr->type == VR_ANTI_RANGE)
1609         max = limit;
1610       else
1611         {
1612           /* If LIMIT_VR is of the form [N1, N2], we need to build the
1613              range [MIN, N2] for LE_EXPR and [MIN, N2 - 1] for
1614              LT_EXPR.  */
1615           max = limit_vr->max;
1616         }
1617
1618       /* If the maximum value forces us to be out of bounds, simply punt.
1619          It would be pointless to try and do anything more since this
1620          all should be optimized away above us.  */
1621       if ((cond_code == LT_EXPR
1622            && compare_values (max, min) == 0)
1623           || (CONSTANT_CLASS_P (max) && TREE_OVERFLOW (max)))
1624         set_value_range_to_varying (vr_p);
1625       else
1626         {
1627           /* For LT_EXPR, we create the range [MIN, MAX - 1].  */
1628           if (cond_code == LT_EXPR)
1629             {
1630               tree one = build_int_cst (type, 1);
1631               max = fold_build2 (MINUS_EXPR, type, max, one);
1632               if (EXPR_P (max))
1633                 TREE_NO_WARNING (max) = 1;
1634             }
1635
1636           set_value_range (vr_p, VR_RANGE, min, max, vr_p->equiv);
1637         }
1638     }
1639   else if (cond_code == GE_EXPR || cond_code == GT_EXPR)
1640     {
1641       max = TYPE_MAX_VALUE (type);
1642
1643       if (limit_vr == NULL || limit_vr->type == VR_ANTI_RANGE)
1644         min = limit;
1645       else
1646         {
1647           /* If LIMIT_VR is of the form [N1, N2], we need to build the
1648              range [N1, MAX] for GE_EXPR and [N1 + 1, MAX] for
1649              GT_EXPR.  */
1650           min = limit_vr->min;
1651         }
1652
1653       /* If the minimum value forces us to be out of bounds, simply punt.
1654          It would be pointless to try and do anything more since this
1655          all should be optimized away above us.  */
1656       if ((cond_code == GT_EXPR
1657            && compare_values (min, max) == 0)
1658           || (CONSTANT_CLASS_P (min) && TREE_OVERFLOW (min)))
1659         set_value_range_to_varying (vr_p);
1660       else
1661         {
1662           /* For GT_EXPR, we create the range [MIN + 1, MAX].  */
1663           if (cond_code == GT_EXPR)
1664             {
1665               tree one = build_int_cst (type, 1);
1666               min = fold_build2 (PLUS_EXPR, type, min, one);
1667               if (EXPR_P (min))
1668                 TREE_NO_WARNING (min) = 1;
1669             }
1670
1671           set_value_range (vr_p, VR_RANGE, min, max, vr_p->equiv);
1672         }
1673     }
1674   else
1675     gcc_unreachable ();
1676
1677   /* If VAR already had a known range, it may happen that the new
1678      range we have computed and VAR's range are not compatible.  For
1679      instance,
1680
1681         if (p_5 == NULL)
1682           p_6 = ASSERT_EXPR <p_5, p_5 == NULL>;
1683           x_7 = p_6->fld;
1684           p_8 = ASSERT_EXPR <p_6, p_6 != NULL>;
1685
1686      While the above comes from a faulty program, it will cause an ICE
1687      later because p_8 and p_6 will have incompatible ranges and at
1688      the same time will be considered equivalent.  A similar situation
1689      would arise from
1690
1691         if (i_5 > 10)
1692           i_6 = ASSERT_EXPR <i_5, i_5 > 10>;
1693           if (i_5 < 5)
1694             i_7 = ASSERT_EXPR <i_6, i_6 < 5>;
1695
1696      Again i_6 and i_7 will have incompatible ranges.  It would be
1697      pointless to try and do anything with i_7's range because
1698      anything dominated by 'if (i_5 < 5)' will be optimized away.
1699      Note, due to the wa in which simulation proceeds, the statement
1700      i_7 = ASSERT_EXPR <...> we would never be visited because the
1701      conditional 'if (i_5 < 5)' always evaluates to false.  However,
1702      this extra check does not hurt and may protect against future
1703      changes to VRP that may get into a situation similar to the
1704      NULL pointer dereference example.
1705
1706      Note that these compatibility tests are only needed when dealing
1707      with ranges or a mix of range and anti-range.  If VAR_VR and VR_P
1708      are both anti-ranges, they will always be compatible, because two
1709      anti-ranges will always have a non-empty intersection.  */
1710
1711   var_vr = get_value_range (var);
1712
1713   /* We may need to make adjustments when VR_P and VAR_VR are numeric
1714      ranges or anti-ranges.  */
1715   if (vr_p->type == VR_VARYING
1716       || vr_p->type == VR_UNDEFINED
1717       || var_vr->type == VR_VARYING
1718       || var_vr->type == VR_UNDEFINED
1719       || symbolic_range_p (vr_p)
1720       || symbolic_range_p (var_vr))
1721     return;
1722
1723   if (var_vr->type == VR_RANGE && vr_p->type == VR_RANGE)
1724     {
1725       /* If the two ranges have a non-empty intersection, we can
1726          refine the resulting range.  Since the assert expression
1727          creates an equivalency and at the same time it asserts a
1728          predicate, we can take the intersection of the two ranges to
1729          get better precision.  */
1730       if (value_ranges_intersect_p (var_vr, vr_p))
1731         {
1732           /* Use the larger of the two minimums.  */
1733           if (compare_values (vr_p->min, var_vr->min) == -1)
1734             min = var_vr->min;
1735           else
1736             min = vr_p->min;
1737
1738           /* Use the smaller of the two maximums.  */
1739           if (compare_values (vr_p->max, var_vr->max) == 1)
1740             max = var_vr->max;
1741           else
1742             max = vr_p->max;
1743
1744           set_value_range (vr_p, vr_p->type, min, max, vr_p->equiv);
1745         }
1746       else
1747         {
1748           /* The two ranges do not intersect, set the new range to
1749              VARYING, because we will not be able to do anything
1750              meaningful with it.  */
1751           set_value_range_to_varying (vr_p);
1752         }
1753     }
1754   else if ((var_vr->type == VR_RANGE && vr_p->type == VR_ANTI_RANGE)
1755            || (var_vr->type == VR_ANTI_RANGE && vr_p->type == VR_RANGE))
1756     {
1757       /* A range and an anti-range will cancel each other only if
1758          their ends are the same.  For instance, in the example above,
1759          p_8's range ~[0, 0] and p_6's range [0, 0] are incompatible,
1760          so VR_P should be set to VR_VARYING.  */
1761       if (compare_values (var_vr->min, vr_p->min) == 0
1762           && compare_values (var_vr->max, vr_p->max) == 0)
1763         set_value_range_to_varying (vr_p);
1764       else
1765         {
1766           tree min, max, anti_min, anti_max, real_min, real_max;
1767           int cmp;
1768
1769           /* We want to compute the logical AND of the two ranges;
1770              there are three cases to consider.
1771
1772
1773              1. The VR_ANTI_RANGE range is completely within the 
1774                 VR_RANGE and the endpoints of the ranges are
1775                 different.  In that case the resulting range
1776                 should be whichever range is more precise.
1777                 Typically that will be the VR_RANGE.
1778
1779              2. The VR_ANTI_RANGE is completely disjoint from
1780                 the VR_RANGE.  In this case the resulting range
1781                 should be the VR_RANGE.
1782
1783              3. There is some overlap between the VR_ANTI_RANGE
1784                 and the VR_RANGE.
1785
1786                 3a. If the high limit of the VR_ANTI_RANGE resides
1787                     within the VR_RANGE, then the result is a new
1788                     VR_RANGE starting at the high limit of the
1789                     VR_ANTI_RANGE + 1 and extending to the
1790                     high limit of the original VR_RANGE.
1791
1792                 3b. If the low limit of the VR_ANTI_RANGE resides
1793                     within the VR_RANGE, then the result is a new
1794                     VR_RANGE starting at the low limit of the original
1795                     VR_RANGE and extending to the low limit of the
1796                     VR_ANTI_RANGE - 1.  */
1797           if (vr_p->type == VR_ANTI_RANGE)
1798             {
1799               anti_min = vr_p->min;
1800               anti_max = vr_p->max;
1801               real_min = var_vr->min;
1802               real_max = var_vr->max;
1803             }
1804           else
1805             {
1806               anti_min = var_vr->min;
1807               anti_max = var_vr->max;
1808               real_min = vr_p->min;
1809               real_max = vr_p->max;
1810             }
1811
1812
1813           /* Case 1, VR_ANTI_RANGE completely within VR_RANGE,
1814              not including any endpoints.  */
1815           if (compare_values (anti_max, real_max) == -1
1816               && compare_values (anti_min, real_min) == 1)
1817             {
1818               /* If the range is covering the whole valid range of
1819                  the type keep the anti-range.  */
1820               if (!vrp_val_is_min (real_min)
1821                   || !vrp_val_is_max (real_max))
1822                 set_value_range (vr_p, VR_RANGE, real_min,
1823                                  real_max, vr_p->equiv);
1824             }
1825           /* Case 2, VR_ANTI_RANGE completely disjoint from
1826              VR_RANGE.  */
1827           else if (compare_values (anti_min, real_max) == 1
1828                    || compare_values (anti_max, real_min) == -1)
1829             {
1830               set_value_range (vr_p, VR_RANGE, real_min,
1831                                real_max, vr_p->equiv);
1832             }
1833           /* Case 3a, the anti-range extends into the low
1834              part of the real range.  Thus creating a new
1835              low for the real range.  */
1836           else if (((cmp = compare_values (anti_max, real_min)) == 1
1837                     || cmp == 0)
1838                    && compare_values (anti_max, real_max) == -1)
1839             {
1840               gcc_assert (!is_positive_overflow_infinity (anti_max));
1841               if (needs_overflow_infinity (TREE_TYPE (anti_max))
1842                   && vrp_val_is_max (anti_max))
1843                 {
1844                   if (!supports_overflow_infinity (TREE_TYPE (var_vr->min)))
1845                     {
1846                       set_value_range_to_varying (vr_p);
1847                       return;
1848                     }
1849                   min = positive_overflow_infinity (TREE_TYPE (var_vr->min));
1850                 }
1851               else if (!POINTER_TYPE_P (TREE_TYPE (var_vr->min)))
1852                 min = fold_build2 (PLUS_EXPR, TREE_TYPE (var_vr->min),
1853                                    anti_max,
1854                                    build_int_cst (TREE_TYPE (var_vr->min), 1));
1855               else
1856                 min = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (var_vr->min),
1857                                    anti_max, size_int (1));
1858               max = real_max;
1859               set_value_range (vr_p, VR_RANGE, min, max, vr_p->equiv);
1860             }
1861           /* Case 3b, the anti-range extends into the high
1862              part of the real range.  Thus creating a new
1863              higher for the real range.  */
1864           else if (compare_values (anti_min, real_min) == 1
1865                    && ((cmp = compare_values (anti_min, real_max)) == -1
1866                        || cmp == 0))
1867             {
1868               gcc_assert (!is_negative_overflow_infinity (anti_min));
1869               if (needs_overflow_infinity (TREE_TYPE (anti_min))
1870                   && vrp_val_is_min (anti_min))
1871                 {
1872                   if (!supports_overflow_infinity (TREE_TYPE (var_vr->min)))
1873                     {
1874                       set_value_range_to_varying (vr_p);
1875                       return;
1876                     }
1877                   max = negative_overflow_infinity (TREE_TYPE (var_vr->min));
1878                 }
1879               else if (!POINTER_TYPE_P (TREE_TYPE (var_vr->min)))
1880                 max = fold_build2 (MINUS_EXPR, TREE_TYPE (var_vr->min),
1881                                    anti_min,
1882                                    build_int_cst (TREE_TYPE (var_vr->min), 1));
1883               else
1884                 max = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (var_vr->min),
1885                                    anti_min,
1886                                    size_int (-1));
1887               min = real_min;
1888               set_value_range (vr_p, VR_RANGE, min, max, vr_p->equiv);
1889             }
1890         }
1891     }
1892 }
1893
1894
1895 /* Extract range information from SSA name VAR and store it in VR.  If
1896    VAR has an interesting range, use it.  Otherwise, create the
1897    range [VAR, VAR] and return it.  This is useful in situations where
1898    we may have conditionals testing values of VARYING names.  For
1899    instance,
1900
1901         x_3 = y_5;
1902         if (x_3 > y_5)
1903           ...
1904
1905     Even if y_5 is deemed VARYING, we can determine that x_3 > y_5 is
1906     always false.  */
1907
1908 static void
1909 extract_range_from_ssa_name (value_range_t *vr, tree var)
1910 {
1911   value_range_t *var_vr = get_value_range (var);
1912
1913   if (var_vr->type != VR_UNDEFINED && var_vr->type != VR_VARYING)
1914     copy_value_range (vr, var_vr);
1915   else
1916     set_value_range (vr, VR_RANGE, var, var, NULL);
1917
1918   add_equivalence (&vr->equiv, var);
1919 }
1920
1921
1922 /* Wrapper around int_const_binop.  If the operation overflows and we
1923    are not using wrapping arithmetic, then adjust the result to be
1924    -INF or +INF depending on CODE, VAL1 and VAL2.  This can return
1925    NULL_TREE if we need to use an overflow infinity representation but
1926    the type does not support it.  */
1927
1928 static tree
1929 vrp_int_const_binop (enum tree_code code, tree val1, tree val2)
1930 {
1931   tree res;
1932
1933   res = int_const_binop (code, val1, val2, 0);
1934
1935   /* If we are not using wrapping arithmetic, operate symbolically
1936      on -INF and +INF.  */
1937   if (TYPE_OVERFLOW_WRAPS (TREE_TYPE (val1)))
1938     {
1939       int checkz = compare_values (res, val1);
1940       bool overflow = false;
1941
1942       /* Ensure that res = val1 [+*] val2 >= val1
1943          or that res = val1 - val2 <= val1.  */
1944       if ((code == PLUS_EXPR
1945            && !(checkz == 1 || checkz == 0))
1946           || (code == MINUS_EXPR
1947               && !(checkz == 0 || checkz == -1)))
1948         {
1949           overflow = true;
1950         }
1951       /* Checking for multiplication overflow is done by dividing the
1952          output of the multiplication by the first input of the
1953          multiplication.  If the result of that division operation is
1954          not equal to the second input of the multiplication, then the
1955          multiplication overflowed.  */
1956       else if (code == MULT_EXPR && !integer_zerop (val1))
1957         {
1958           tree tmp = int_const_binop (TRUNC_DIV_EXPR,
1959                                       res,
1960                                       val1, 0);
1961           int check = compare_values (tmp, val2);
1962
1963           if (check != 0)
1964             overflow = true;
1965         }
1966
1967       if (overflow)
1968         {
1969           res = copy_node (res);
1970           TREE_OVERFLOW (res) = 1;
1971         }
1972
1973     }
1974   else if ((TREE_OVERFLOW (res)
1975             && !TREE_OVERFLOW (val1)
1976             && !TREE_OVERFLOW (val2))
1977            || is_overflow_infinity (val1)
1978            || is_overflow_infinity (val2))
1979     {
1980       /* If the operation overflowed but neither VAL1 nor VAL2 are
1981          overflown, return -INF or +INF depending on the operation
1982          and the combination of signs of the operands.  */
1983       int sgn1 = tree_int_cst_sgn (val1);
1984       int sgn2 = tree_int_cst_sgn (val2);
1985
1986       if (needs_overflow_infinity (TREE_TYPE (res))
1987           && !supports_overflow_infinity (TREE_TYPE (res)))
1988         return NULL_TREE;
1989
1990       /* We have to punt on adding infinities of different signs,
1991          since we can't tell what the sign of the result should be.
1992          Likewise for subtracting infinities of the same sign.  */
1993       if (((code == PLUS_EXPR && sgn1 != sgn2)
1994            || (code == MINUS_EXPR && sgn1 == sgn2))
1995           && is_overflow_infinity (val1)
1996           && is_overflow_infinity (val2))
1997         return NULL_TREE;
1998
1999       /* Don't try to handle division or shifting of infinities.  */
2000       if ((code == TRUNC_DIV_EXPR
2001            || code == FLOOR_DIV_EXPR
2002            || code == CEIL_DIV_EXPR
2003            || code == EXACT_DIV_EXPR
2004            || code == ROUND_DIV_EXPR
2005            || code == RSHIFT_EXPR)
2006           && (is_overflow_infinity (val1)
2007               || is_overflow_infinity (val2)))
2008         return NULL_TREE;
2009
2010       /* Notice that we only need to handle the restricted set of
2011          operations handled by extract_range_from_binary_expr.
2012          Among them, only multiplication, addition and subtraction
2013          can yield overflow without overflown operands because we
2014          are working with integral types only... except in the
2015          case VAL1 = -INF and VAL2 = -1 which overflows to +INF
2016          for division too.  */
2017
2018       /* For multiplication, the sign of the overflow is given
2019          by the comparison of the signs of the operands.  */
2020       if ((code == MULT_EXPR && sgn1 == sgn2)
2021           /* For addition, the operands must be of the same sign
2022              to yield an overflow.  Its sign is therefore that
2023              of one of the operands, for example the first.  For
2024              infinite operands X + -INF is negative, not positive.  */
2025           || (code == PLUS_EXPR
2026               && (sgn1 >= 0
2027                   ? !is_negative_overflow_infinity (val2)
2028                   : is_positive_overflow_infinity (val2)))
2029           /* For subtraction, non-infinite operands must be of
2030              different signs to yield an overflow.  Its sign is
2031              therefore that of the first operand or the opposite of
2032              that of the second operand.  A first operand of 0 counts
2033              as positive here, for the corner case 0 - (-INF), which
2034              overflows, but must yield +INF.  For infinite operands 0
2035              - INF is negative, not positive.  */
2036           || (code == MINUS_EXPR
2037               && (sgn1 >= 0
2038                   ? !is_positive_overflow_infinity (val2)
2039                   : is_negative_overflow_infinity (val2)))
2040           /* We only get in here with positive shift count, so the
2041              overflow direction is the same as the sign of val1.
2042              Actually rshift does not overflow at all, but we only
2043              handle the case of shifting overflowed -INF and +INF.  */
2044           || (code == RSHIFT_EXPR
2045               && sgn1 >= 0)
2046           /* For division, the only case is -INF / -1 = +INF.  */
2047           || code == TRUNC_DIV_EXPR
2048           || code == FLOOR_DIV_EXPR
2049           || code == CEIL_DIV_EXPR
2050           || code == EXACT_DIV_EXPR
2051           || code == ROUND_DIV_EXPR)
2052         return (needs_overflow_infinity (TREE_TYPE (res))
2053                 ? positive_overflow_infinity (TREE_TYPE (res))
2054                 : TYPE_MAX_VALUE (TREE_TYPE (res)));
2055       else
2056         return (needs_overflow_infinity (TREE_TYPE (res))
2057                 ? negative_overflow_infinity (TREE_TYPE (res))
2058                 : TYPE_MIN_VALUE (TREE_TYPE (res)));
2059     }
2060
2061   return res;
2062 }
2063
2064
2065 /* Extract range information from a binary expression EXPR based on
2066    the ranges of each of its operands and the expression code.  */
2067
2068 static void
2069 extract_range_from_binary_expr (value_range_t *vr,
2070                                 enum tree_code code,
2071                                 tree expr_type, tree op0, tree op1)
2072 {
2073   enum value_range_type type;
2074   tree min, max;
2075   int cmp;
2076   value_range_t vr0 = { VR_UNDEFINED, NULL_TREE, NULL_TREE, NULL };
2077   value_range_t vr1 = { VR_UNDEFINED, NULL_TREE, NULL_TREE, NULL };
2078
2079   /* Not all binary expressions can be applied to ranges in a
2080      meaningful way.  Handle only arithmetic operations.  */
2081   if (code != PLUS_EXPR
2082       && code != MINUS_EXPR
2083       && code != POINTER_PLUS_EXPR
2084       && code != MULT_EXPR
2085       && code != TRUNC_DIV_EXPR
2086       && code != FLOOR_DIV_EXPR
2087       && code != CEIL_DIV_EXPR
2088       && code != EXACT_DIV_EXPR
2089       && code != ROUND_DIV_EXPR
2090       && code != RSHIFT_EXPR
2091       && code != MIN_EXPR
2092       && code != MAX_EXPR
2093       && code != BIT_AND_EXPR
2094       && code != BIT_IOR_EXPR
2095       && code != TRUTH_AND_EXPR
2096       && code != TRUTH_OR_EXPR)
2097     {
2098       /* We can still do constant propagation here.  */
2099       tree const_op0 = op_with_constant_singleton_value_range (op0);
2100       tree const_op1 = op_with_constant_singleton_value_range (op1);
2101       if (const_op0 || const_op1)
2102         {
2103           tree tem = fold_binary (code, expr_type,
2104                                   const_op0 ? const_op0 : op0,
2105                                   const_op1 ? const_op1 : op1);
2106           if (tem
2107               && is_gimple_min_invariant (tem)
2108               && !is_overflow_infinity (tem))
2109             {
2110               set_value_range (vr, VR_RANGE, tem, tem, NULL);
2111               return;
2112             }
2113         }
2114       set_value_range_to_varying (vr);
2115       return;
2116     }
2117
2118   /* Get value ranges for each operand.  For constant operands, create
2119      a new value range with the operand to simplify processing.  */
2120   if (TREE_CODE (op0) == SSA_NAME)
2121     vr0 = *(get_value_range (op0));
2122   else if (is_gimple_min_invariant (op0))
2123     set_value_range_to_value (&vr0, op0, NULL);
2124   else
2125     set_value_range_to_varying (&vr0);
2126
2127   if (TREE_CODE (op1) == SSA_NAME)
2128     vr1 = *(get_value_range (op1));
2129   else if (is_gimple_min_invariant (op1))
2130     set_value_range_to_value (&vr1, op1, NULL);
2131   else
2132     set_value_range_to_varying (&vr1);
2133
2134   /* If either range is UNDEFINED, so is the result.  */
2135   if (vr0.type == VR_UNDEFINED || vr1.type == VR_UNDEFINED)
2136     {
2137       set_value_range_to_undefined (vr);
2138       return;
2139     }
2140
2141   /* The type of the resulting value range defaults to VR0.TYPE.  */
2142   type = vr0.type;
2143
2144   /* Refuse to operate on VARYING ranges, ranges of different kinds
2145      and symbolic ranges.  As an exception, we allow BIT_AND_EXPR
2146      because we may be able to derive a useful range even if one of
2147      the operands is VR_VARYING or symbolic range.  Similarly for
2148      divisions.  TODO, we may be able to derive anti-ranges in
2149      some cases.  */
2150   if (code != BIT_AND_EXPR
2151       && code != TRUTH_AND_EXPR
2152       && code != TRUTH_OR_EXPR
2153       && code != TRUNC_DIV_EXPR
2154       && code != FLOOR_DIV_EXPR
2155       && code != CEIL_DIV_EXPR
2156       && code != EXACT_DIV_EXPR
2157       && code != ROUND_DIV_EXPR
2158       && (vr0.type == VR_VARYING
2159           || vr1.type == VR_VARYING
2160           || vr0.type != vr1.type
2161           || symbolic_range_p (&vr0)
2162           || symbolic_range_p (&vr1)))
2163     {
2164       set_value_range_to_varying (vr);
2165       return;
2166     }
2167
2168   /* Now evaluate the expression to determine the new range.  */
2169   if (POINTER_TYPE_P (expr_type)
2170       || POINTER_TYPE_P (TREE_TYPE (op0))
2171       || POINTER_TYPE_P (TREE_TYPE (op1)))
2172     {
2173       if (code == MIN_EXPR || code == MAX_EXPR)
2174         {
2175           /* For MIN/MAX expressions with pointers, we only care about
2176              nullness, if both are non null, then the result is nonnull.
2177              If both are null, then the result is null. Otherwise they
2178              are varying.  */
2179           if (range_is_nonnull (&vr0) && range_is_nonnull (&vr1))
2180             set_value_range_to_nonnull (vr, expr_type);
2181           else if (range_is_null (&vr0) && range_is_null (&vr1))
2182             set_value_range_to_null (vr, expr_type);
2183           else
2184             set_value_range_to_varying (vr);
2185
2186           return;
2187         }
2188       gcc_assert (code == POINTER_PLUS_EXPR);
2189       /* For pointer types, we are really only interested in asserting
2190          whether the expression evaluates to non-NULL.  */
2191       if (range_is_nonnull (&vr0) || range_is_nonnull (&vr1))
2192         set_value_range_to_nonnull (vr, expr_type);
2193       else if (range_is_null (&vr0) && range_is_null (&vr1))
2194         set_value_range_to_null (vr, expr_type);
2195       else
2196         set_value_range_to_varying (vr);
2197
2198       return;
2199     }
2200
2201   /* For integer ranges, apply the operation to each end of the
2202      range and see what we end up with.  */
2203   if (code == TRUTH_AND_EXPR
2204       || code == TRUTH_OR_EXPR)
2205     {
2206       /* If one of the operands is zero, we know that the whole
2207          expression evaluates zero.  */
2208       if (code == TRUTH_AND_EXPR
2209           && ((vr0.type == VR_RANGE
2210                && integer_zerop (vr0.min)
2211                && integer_zerop (vr0.max))
2212               || (vr1.type == VR_RANGE
2213                   && integer_zerop (vr1.min)
2214                   && integer_zerop (vr1.max))))
2215         {
2216           type = VR_RANGE;
2217           min = max = build_int_cst (expr_type, 0);
2218         }
2219       /* If one of the operands is one, we know that the whole
2220          expression evaluates one.  */
2221       else if (code == TRUTH_OR_EXPR
2222                && ((vr0.type == VR_RANGE
2223                     && integer_onep (vr0.min)
2224                     && integer_onep (vr0.max))
2225                    || (vr1.type == VR_RANGE
2226                        && integer_onep (vr1.min)
2227                        && integer_onep (vr1.max))))
2228         {
2229           type = VR_RANGE;
2230           min = max = build_int_cst (expr_type, 1);
2231         }
2232       else if (vr0.type != VR_VARYING
2233                && vr1.type != VR_VARYING
2234                && vr0.type == vr1.type
2235                && !symbolic_range_p (&vr0)
2236                && !overflow_infinity_range_p (&vr0)
2237                && !symbolic_range_p (&vr1)
2238                && !overflow_infinity_range_p (&vr1))
2239         {
2240           /* Boolean expressions cannot be folded with int_const_binop.  */
2241           min = fold_binary (code, expr_type, vr0.min, vr1.min);
2242           max = fold_binary (code, expr_type, vr0.max, vr1.max);
2243         }
2244       else
2245         {
2246           /* The result of a TRUTH_*_EXPR is always true or false.  */
2247           set_value_range_to_truthvalue (vr, expr_type);
2248           return;
2249         }
2250     }
2251   else if (code == PLUS_EXPR
2252            || code == MIN_EXPR
2253            || code == MAX_EXPR)
2254     {
2255       /* If we have a PLUS_EXPR with two VR_ANTI_RANGEs, drop to
2256          VR_VARYING.  It would take more effort to compute a precise
2257          range for such a case.  For example, if we have op0 == 1 and
2258          op1 == -1 with their ranges both being ~[0,0], we would have
2259          op0 + op1 == 0, so we cannot claim that the sum is in ~[0,0].
2260          Note that we are guaranteed to have vr0.type == vr1.type at
2261          this point.  */
2262       if (code == PLUS_EXPR && vr0.type == VR_ANTI_RANGE)
2263         {
2264           set_value_range_to_varying (vr);
2265           return;
2266         }
2267
2268       /* For operations that make the resulting range directly
2269          proportional to the original ranges, apply the operation to
2270          the same end of each range.  */
2271       min = vrp_int_const_binop (code, vr0.min, vr1.min);
2272       max = vrp_int_const_binop (code, vr0.max, vr1.max);
2273     }
2274   else if (code == MULT_EXPR
2275            || code == TRUNC_DIV_EXPR
2276            || code == FLOOR_DIV_EXPR
2277            || code == CEIL_DIV_EXPR
2278            || code == EXACT_DIV_EXPR
2279            || code == ROUND_DIV_EXPR
2280            || code == RSHIFT_EXPR)
2281     {
2282       tree val[4];
2283       size_t i;
2284       bool sop;
2285
2286       /* If we have an unsigned MULT_EXPR with two VR_ANTI_RANGEs,
2287          drop to VR_VARYING.  It would take more effort to compute a
2288          precise range for such a case.  For example, if we have
2289          op0 == 65536 and op1 == 65536 with their ranges both being
2290          ~[0,0] on a 32-bit machine, we would have op0 * op1 == 0, so
2291          we cannot claim that the product is in ~[0,0].  Note that we
2292          are guaranteed to have vr0.type == vr1.type at this
2293          point.  */
2294       if (code == MULT_EXPR
2295           && vr0.type == VR_ANTI_RANGE
2296           && !TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (op0)))
2297         {
2298           set_value_range_to_varying (vr);
2299           return;
2300         }
2301
2302       /* If we have a RSHIFT_EXPR with any shift values outside [0..prec-1],
2303          then drop to VR_VARYING.  Outside of this range we get undefined
2304          behavior from the shift operation.  We cannot even trust
2305          SHIFT_COUNT_TRUNCATED at this stage, because that applies to rtl
2306          shifts, and the operation at the tree level may be widened.  */
2307       if (code == RSHIFT_EXPR)
2308         {
2309           if (vr1.type == VR_ANTI_RANGE
2310               || !vrp_expr_computes_nonnegative (op1, &sop)
2311               || (operand_less_p
2312                   (build_int_cst (TREE_TYPE (vr1.max),
2313                                   TYPE_PRECISION (expr_type) - 1),
2314                    vr1.max) != 0))
2315             {
2316               set_value_range_to_varying (vr);
2317               return;
2318             }
2319         }
2320
2321       else if ((code == TRUNC_DIV_EXPR
2322                 || code == FLOOR_DIV_EXPR
2323                 || code == CEIL_DIV_EXPR
2324                 || code == EXACT_DIV_EXPR
2325                 || code == ROUND_DIV_EXPR)
2326                && (vr0.type != VR_RANGE || symbolic_range_p (&vr0)))
2327         {
2328           /* For division, if op1 has VR_RANGE but op0 does not, something
2329              can be deduced just from that range.  Say [min, max] / [4, max]
2330              gives [min / 4, max / 4] range.  */
2331           if (vr1.type == VR_RANGE
2332               && !symbolic_range_p (&vr1)
2333               && !range_includes_zero_p (&vr1))
2334             {
2335               vr0.type = type = VR_RANGE;
2336               vr0.min = vrp_val_min (TREE_TYPE (op0));
2337               vr0.max = vrp_val_max (TREE_TYPE (op1));
2338             }
2339           else
2340             {
2341               set_value_range_to_varying (vr);
2342               return;
2343             }
2344         }
2345
2346       /* For divisions, if op0 is VR_RANGE, we can deduce a range
2347          even if op1 is VR_VARYING, VR_ANTI_RANGE, symbolic or can
2348          include 0.  */
2349       if ((code == TRUNC_DIV_EXPR
2350            || code == FLOOR_DIV_EXPR
2351            || code == CEIL_DIV_EXPR
2352            || code == EXACT_DIV_EXPR
2353            || code == ROUND_DIV_EXPR)
2354           && vr0.type == VR_RANGE
2355           && (vr1.type != VR_RANGE
2356               || symbolic_range_p (&vr1)
2357               || range_includes_zero_p (&vr1)))
2358         {
2359           tree zero = build_int_cst (TREE_TYPE (vr0.min), 0);
2360           int cmp;
2361
2362           sop = false;
2363           min = NULL_TREE;
2364           max = NULL_TREE;
2365           if (vrp_expr_computes_nonnegative (op1, &sop) && !sop)
2366             {
2367               /* For unsigned division or when divisor is known
2368                  to be non-negative, the range has to cover
2369                  all numbers from 0 to max for positive max
2370                  and all numbers from min to 0 for negative min.  */
2371               cmp = compare_values (vr0.max, zero);
2372               if (cmp == -1)
2373                 max = zero;
2374               else if (cmp == 0 || cmp == 1)
2375                 max = vr0.max;
2376               else
2377                 type = VR_VARYING;
2378               cmp = compare_values (vr0.min, zero);
2379               if (cmp == 1)
2380                 min = zero;
2381               else if (cmp == 0 || cmp == -1)
2382                 min = vr0.min;
2383               else
2384                 type = VR_VARYING;
2385             }
2386           else
2387             {
2388               /* Otherwise the range is -max .. max or min .. -min
2389                  depending on which bound is bigger in absolute value,
2390                  as the division can change the sign.  */
2391               abs_extent_range (vr, vr0.min, vr0.max);
2392               return;
2393             }
2394           if (type == VR_VARYING)
2395             {
2396               set_value_range_to_varying (vr);
2397               return;
2398             }
2399         }
2400
2401       /* Multiplications and divisions are a bit tricky to handle,
2402          depending on the mix of signs we have in the two ranges, we
2403          need to operate on different values to get the minimum and
2404          maximum values for the new range.  One approach is to figure
2405          out all the variations of range combinations and do the
2406          operations.
2407
2408          However, this involves several calls to compare_values and it
2409          is pretty convoluted.  It's simpler to do the 4 operations
2410          (MIN0 OP MIN1, MIN0 OP MAX1, MAX0 OP MIN1 and MAX0 OP MAX0 OP
2411          MAX1) and then figure the smallest and largest values to form
2412          the new range.  */
2413       else
2414         {
2415           gcc_assert ((vr0.type == VR_RANGE
2416                        || (code == MULT_EXPR && vr0.type == VR_ANTI_RANGE))
2417                       && vr0.type == vr1.type);
2418
2419           /* Compute the 4 cross operations.  */
2420           sop = false;
2421           val[0] = vrp_int_const_binop (code, vr0.min, vr1.min);
2422           if (val[0] == NULL_TREE)
2423             sop = true;
2424
2425           if (vr1.max == vr1.min)
2426             val[1] = NULL_TREE;
2427           else
2428             {
2429               val[1] = vrp_int_const_binop (code, vr0.min, vr1.max);
2430               if (val[1] == NULL_TREE)
2431                 sop = true;
2432             }
2433
2434           if (vr0.max == vr0.min)
2435             val[2] = NULL_TREE;
2436           else
2437             {
2438               val[2] = vrp_int_const_binop (code, vr0.max, vr1.min);
2439               if (val[2] == NULL_TREE)
2440                 sop = true;
2441             }
2442
2443           if (vr0.min == vr0.max || vr1.min == vr1.max)
2444             val[3] = NULL_TREE;
2445           else
2446             {
2447               val[3] = vrp_int_const_binop (code, vr0.max, vr1.max);
2448               if (val[3] == NULL_TREE)
2449                 sop = true;
2450             }
2451
2452           if (sop)
2453             {
2454               set_value_range_to_varying (vr);
2455               return;
2456             }
2457
2458           /* Set MIN to the minimum of VAL[i] and MAX to the maximum
2459              of VAL[i].  */
2460           min = val[0];
2461           max = val[0];
2462           for (i = 1; i < 4; i++)
2463             {
2464               if (!is_gimple_min_invariant (min)
2465                   || (TREE_OVERFLOW (min) && !is_overflow_infinity (min))
2466                   || !is_gimple_min_invariant (max)
2467                   || (TREE_OVERFLOW (max) && !is_overflow_infinity (max)))
2468                 break;
2469
2470               if (val[i])
2471                 {
2472                   if (!is_gimple_min_invariant (val[i])
2473                       || (TREE_OVERFLOW (val[i])
2474                           && !is_overflow_infinity (val[i])))
2475                     {
2476                       /* If we found an overflowed value, set MIN and MAX
2477                          to it so that we set the resulting range to
2478                          VARYING.  */
2479                       min = max = val[i];
2480                       break;
2481                     }
2482
2483                   if (compare_values (val[i], min) == -1)
2484                     min = val[i];
2485
2486                   if (compare_values (val[i], max) == 1)
2487                     max = val[i];
2488                 }
2489             }
2490         }
2491     }
2492   else if (code == MINUS_EXPR)
2493     {
2494       /* If we have a MINUS_EXPR with two VR_ANTI_RANGEs, drop to
2495          VR_VARYING.  It would take more effort to compute a precise
2496          range for such a case.  For example, if we have op0 == 1 and
2497          op1 == 1 with their ranges both being ~[0,0], we would have
2498          op0 - op1 == 0, so we cannot claim that the difference is in
2499          ~[0,0].  Note that we are guaranteed to have
2500          vr0.type == vr1.type at this point.  */
2501       if (vr0.type == VR_ANTI_RANGE)
2502         {
2503           set_value_range_to_varying (vr);
2504           return;
2505         }
2506
2507       /* For MINUS_EXPR, apply the operation to the opposite ends of
2508          each range.  */
2509       min = vrp_int_const_binop (code, vr0.min, vr1.max);
2510       max = vrp_int_const_binop (code, vr0.max, vr1.min);
2511     }
2512   else if (code == BIT_AND_EXPR)
2513     {
2514       if (vr0.type == VR_RANGE
2515           && vr0.min == vr0.max
2516           && TREE_CODE (vr0.max) == INTEGER_CST
2517           && !TREE_OVERFLOW (vr0.max)
2518           && tree_int_cst_sgn (vr0.max) >= 0)
2519         {
2520           min = build_int_cst (expr_type, 0);
2521           max = vr0.max;
2522         }
2523       else if (vr1.type == VR_RANGE
2524                && vr1.min == vr1.max
2525                && TREE_CODE (vr1.max) == INTEGER_CST
2526                && !TREE_OVERFLOW (vr1.max)
2527                && tree_int_cst_sgn (vr1.max) >= 0)
2528         {
2529           type = VR_RANGE;
2530           min = build_int_cst (expr_type, 0);
2531           max = vr1.max;
2532         }
2533       else
2534         {
2535           set_value_range_to_varying (vr);
2536           return;
2537         }
2538     }
2539   else if (code == BIT_IOR_EXPR)
2540     {
2541       if (vr0.type == VR_RANGE
2542           && vr1.type == VR_RANGE
2543           && TREE_CODE (vr0.min) == INTEGER_CST
2544           && TREE_CODE (vr1.min) == INTEGER_CST
2545           && TREE_CODE (vr0.max) == INTEGER_CST
2546           && TREE_CODE (vr1.max) == INTEGER_CST
2547           && tree_int_cst_sgn (vr0.min) >= 0
2548           && tree_int_cst_sgn (vr1.min) >= 0)
2549         {
2550           double_int vr0_max = tree_to_double_int (vr0.max);
2551           double_int vr1_max = tree_to_double_int (vr1.max);
2552           double_int ior_max;
2553
2554           /* Set all bits to the right of the most significant one to 1.
2555              For example, [0, 4] | [4, 4] = [4, 7]. */
2556           ior_max.low = vr0_max.low | vr1_max.low;
2557           ior_max.high = vr0_max.high | vr1_max.high;
2558           if (ior_max.high != 0)
2559             {
2560               ior_max.low = ~(unsigned HOST_WIDE_INT)0u;
2561               ior_max.high |= ((HOST_WIDE_INT) 1
2562                                << floor_log2 (ior_max.high)) - 1;
2563             }
2564           else if (ior_max.low != 0)
2565             ior_max.low |= ((unsigned HOST_WIDE_INT) 1u
2566                             << floor_log2 (ior_max.low)) - 1;
2567
2568           /* Both of these endpoints are conservative.  */
2569           min = vrp_int_const_binop (MAX_EXPR, vr0.min, vr1.min);
2570           max = double_int_to_tree (expr_type, ior_max);
2571         }
2572       else
2573         {
2574           set_value_range_to_varying (vr);
2575           return;
2576         }
2577     }
2578   else
2579     gcc_unreachable ();
2580
2581   /* If either MIN or MAX overflowed, then set the resulting range to
2582      VARYING.  But we do accept an overflow infinity
2583      representation.  */
2584   if (min == NULL_TREE
2585       || !is_gimple_min_invariant (min)
2586       || (TREE_OVERFLOW (min) && !is_overflow_infinity (min))
2587       || max == NULL_TREE
2588       || !is_gimple_min_invariant (max)
2589       || (TREE_OVERFLOW (max) && !is_overflow_infinity (max)))
2590     {
2591       set_value_range_to_varying (vr);
2592       return;
2593     }
2594
2595   /* We punt if:
2596      1) [-INF, +INF]
2597      2) [-INF, +-INF(OVF)]
2598      3) [+-INF(OVF), +INF]
2599      4) [+-INF(OVF), +-INF(OVF)]
2600      We learn nothing when we have INF and INF(OVF) on both sides.
2601      Note that we do accept [-INF, -INF] and [+INF, +INF] without
2602      overflow.  */
2603   if ((vrp_val_is_min (min) || is_overflow_infinity (min))
2604       && (vrp_val_is_max&nb