contrib/gcc/tree-vrp.c

301 set_value_range (value_range_t *vr, enum value_range_type t, tree min,
330   vr->type = t;
331   vr->min = min;
332   vr->max = max;
336   if (vr->equiv == NULL)
337     vr->equiv = BITMAP_ALLOC (NULL);
339   if (equiv != vr->equiv)
342 	bitmap_copy (vr->equiv, equiv);
344 	bitmap_clear (vr->equiv);
361 set_value_range_to_varying (value_range_t *vr)
363   vr->type = VR_VARYING;
364   vr->min = vr->max = NULL_TREE;
365   if (vr->equiv)
366     bitmap_clear (vr->equiv);
375 set_value_range_to_value (value_range_t *vr, tree val, bitmap equiv)
379   set_value_range (vr, VR_RANGE, val, val, equiv);
389 set_value_range_to_nonnegative (value_range_t *vr, tree type,
396       set_value_range_to_varying (vr);
401   set_value_range (vr, VR_RANGE, zero,
405 		   vr->equiv);
411 set_value_range_to_nonnull (value_range_t *vr, tree type)
414   set_value_range (vr, VR_ANTI_RANGE, zero, zero, vr->equiv);
421 set_value_range_to_null (value_range_t *vr, tree type)
423   set_value_range_to_value (vr, build_int_cst (type, 0), vr->equiv);
430 set_value_range_to_undefined (value_range_t *vr)
432   vr->type = VR_UNDEFINED;
433   vr->min = vr->max = NULL_TREE;
434   if (vr->equiv)
435     bitmap_clear (vr->equiv);
447   value_range_t *vr;
455   vr = vr_value[ver];
456   if (vr)
457     return vr;
460   vr_value[ver] = vr = XNEW (value_range_t);
461   memset (vr, 0, sizeof (*vr));
464   vr->equiv = BITMAP_ALLOC (NULL);
477 	set_value_range_to_nonnull (vr, TREE_TYPE (sym));
479 	set_value_range_to_varying (vr);
482   return vr;
549   value_range_t *vr = vr_value[ver];
552   if (vr && vr->equiv)
553     bitmap_ior_into (equiv, vr->equiv);
560 range_is_nonnull (value_range_t *vr)
562   return vr->type == VR_ANTI_RANGE
563 	 && integer_zerop (vr->min)
564 	 && integer_zerop (vr->max);
571 range_is_null (value_range_t *vr)
573   return vr->type == VR_RANGE
574 	 && integer_zerop (vr->min)
575 	 && integer_zerop (vr->max);
582 symbolic_range_p (value_range_t *vr)
584   return (!is_gimple_min_invariant (vr->min)
585           || !is_gimple_min_invariant (vr->max));
591 overflow_infinity_range_p (value_range_t *vr)
593   return (vr->type == VR_RANGE
594 	  && (is_overflow_infinity (vr->min)
595 	      || is_overflow_infinity (vr->max)));
605 usable_range_p (value_range_t *vr, bool *strict_overflow_p)
607   gcc_assert (vr->type == VR_RANGE);
608   if (is_overflow_infinity (vr->min))
611       if (!TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (vr->min)))
614   if (is_overflow_infinity (vr->max))
617       if (!TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (vr->max)))
652 	  value_range_t *vr = get_value_range (TREE_OPERAND (base, 0));
653 	  if (range_is_nonnull (vr))
908 value_inside_range (tree val, value_range_t *vr)
914   cmp1 = fold_binary_to_constant (GE_EXPR, boolean_type_node, val, vr->min);
921   cmp2 = fold_binary_to_constant (LE_EXPR, boolean_type_node, val, vr->max);
952 range_includes_zero_p (value_range_t *vr)
956   gcc_assert (vr->type != VR_UNDEFINED
957               && vr->type != VR_VARYING
958 	      && !symbolic_range_p (vr));
960   zero = build_int_cst (TREE_TYPE (vr->min), 0);
961   return (value_inside_range (zero, vr) == 1);
970   value_range_t *vr = get_value_range (t);
972   if (!vr)
977   if (vr->type == VR_RANGE)
979       int result = compare_values (vr->min, integer_zero_node);
992   value_range_t *vr = get_value_range (t);
994   if (!vr)
998   if (vr->type == VR_RANGE && !symbolic_range_p (vr))
999     return ! range_includes_zero_p (vr);
1002   if (vr->type == VR_ANTI_RANGE && !symbolic_range_p (vr))
1003     return range_includes_zero_p (vr);
1447 extract_range_from_ssa_name (value_range_t *vr, tree var)
1452     copy_value_range (vr, var_vr);
1454     set_value_range (vr, VR_RANGE, var, var, NULL);
1456   add_equivalence (vr->equiv, var);
1601 extract_range_from_binary_expr (value_range_t *vr, tree expr)
1628       set_value_range_to_varying (vr);
1653       set_value_range_to_undefined (vr);
1674       set_value_range_to_varying (vr);
1691 	    set_value_range_to_nonnull (vr, TREE_TYPE (expr));
1693 	    set_value_range_to_null (vr, TREE_TYPE (expr));
1695 	    set_value_range_to_varying (vr);
1701 	  set_value_range_to_varying (vr);
1754 	  set_value_range_to_varying (vr);
1771 	  set_value_range_to_varying (vr);
1804 	  set_value_range_to_varying (vr);
1825 	  set_value_range_to_varying (vr);
1864 	  set_value_range_to_varying (vr);
1912 	  set_value_range_to_varying (vr);
1944 	  set_value_range_to_varying (vr);
1961       set_value_range_to_varying (vr);
1976       set_value_range_to_varying (vr);
1986       set_value_range_to_varying (vr);
1989     set_value_range (vr, type, min, max, NULL);
1997 extract_range_from_unary_expr (value_range_t *vr, tree expr)
2015       set_value_range_to_varying (vr);
2032       set_value_range_to_undefined (vr);
2043       set_value_range_to_varying (vr);
2057 	set_value_range_to_nonnull (vr, TREE_TYPE (expr));
2059 	set_value_range_to_null (vr, TREE_TYPE (expr));
2061 	set_value_range_to_varying (vr);
2115 	      set_value_range (vr, VR_RANGE, new_min, new_max, vr->equiv);
2129 	  set_value_range_to_varying (vr);
2140       set_value_range_to_varying (vr);
2165 	      set_value_range_to_varying (vr);
2184 	      set_value_range_to_varying (vr);
2202 	    set_value_range_to_null (vr, TREE_TYPE (expr));
2204 	    set_value_range_to_varying (vr);
2220 	  set_value_range_to_varying (vr);
2236 	  set_value_range_to_varying (vr);
2250 	  set_value_range_to_varying (vr);
2300 		      set_value_range_to_varying (vr);
2345 	      set_value_range_to_varying (vr);
2359 		  set_value_range_to_varying (vr);
2374 		  set_value_range_to_varying (vr);
2387       set_value_range_to_varying (vr);
2390     set_value_range (vr, vr0.type, min, max, NULL);
2398 extract_range_from_comparison (value_range_t *vr, tree expr)
2415 	set_value_range_to_value (vr, val, vr->equiv);
2417 	set_value_range (vr, VR_RANGE, val, val, vr->equiv);
2420     set_value_range_to_varying (vr);
2428 extract_range_from_expr (value_range_t *vr, tree expr)
2433     extract_range_from_assert (vr, expr);
2435     extract_range_from_ssa_name (vr, expr);
2442     extract_range_from_binary_expr (vr, expr);
2444     extract_range_from_unary_expr (vr, expr);
2446     extract_range_from_comparison (vr, expr);
2448     set_value_range_to_value (vr, expr, NULL);
2450     set_value_range_to_varying (vr);
2456   if (vr->type == VR_VARYING)
2462 	set_value_range_to_nonnegative (vr, TREE_TYPE (expr),
2466         set_value_range_to_nonnull (vr, TREE_TYPE (expr));
2475 adjust_range_with_scev (value_range_t *vr, struct loop *loop, tree stmt,
2483   if (vr->type == VR_ANTI_RANGE)
2533   if (vr->type == VR_VARYING || vr->type == VR_UNDEFINED)
2553       set_value_range (vr, VR_RANGE, min, max, vr->equiv);
2555   else if (vr->type == VR_RANGE)
2557       min = vr->min;
2558       max = vr->max;
2599       set_value_range (vr, VR_RANGE, min, max, vr->equiv);
2822 compare_range_with_value (enum tree_code comp, value_range_t *vr, tree val,
2825   if (vr->type == VR_VARYING || vr->type == VR_UNDEFINED)
2829   if (vr->type == VR_ANTI_RANGE)
2840       if (value_inside_range (val, vr) == 1)
2846   if (!usable_range_p (vr, strict_overflow_p))
2853       if (compare_values_warnv (vr->min, vr->max, strict_overflow_p) == 0)
2855 	  int cmp = compare_values_warnv (vr->min, val, strict_overflow_p);
2861       else if (compare_values_warnv (val, vr->min, strict_overflow_p) == -1
2862 	       || compare_values_warnv (vr->max, val, strict_overflow_p) == -1)
2870       if (compare_values_warnv (vr->max, val, strict_overflow_p) == -1
2871 	  || compare_values_warnv (vr->min, val, strict_overflow_p) == 1)
2876       if (compare_values_warnv (vr->min, vr->max, strict_overflow_p) == 0
2877 	  && compare_values_warnv (vr->min, val, strict_overflow_p) == 0)
2888       tst = compare_values_warnv (vr->max, val, strict_overflow_p);
2892 	  if (overflow_infinity_range_p (vr))
2898       tst = compare_values_warnv (vr->min, val, strict_overflow_p);
2902 	  if (overflow_infinity_range_p (vr))
2915       tst = compare_values_warnv (vr->min, val, strict_overflow_p);
2919 	  if (overflow_infinity_range_p (vr))
2925       tst = compare_values_warnv (vr->max, val, strict_overflow_p);
2929 	  if (overflow_infinity_range_p (vr))
2955 dump_value_range (FILE *file, value_range_t *vr)
2957   if (vr == NULL)
2959   else if (vr->type == VR_UNDEFINED)
2961   else if (vr->type == VR_RANGE || vr->type == VR_ANTI_RANGE)
2963       tree type = TREE_TYPE (vr->min);
2965       fprintf (file, "%s[", (vr->type == VR_ANTI_RANGE) ? "~" : "");
2967       if (is_negative_overflow_infinity (vr->min))
2971 	       && vrp_val_is_min (vr->min))
2974 	print_generic_expr (file, vr->min, 0);
2978       if (is_positive_overflow_infinity (vr->max))
2981 	       && vrp_val_is_max (vr->max))
2984 	print_generic_expr (file, vr->max, 0);
2988       if (vr->equiv)
2995 	  EXECUTE_IF_SET_IN_BITMAP (vr->equiv, 0, i, bi)
3005   else if (vr->type == VR_VARYING)
3015 debug_value_range (value_range_t *vr)
3017   dump_value_range (stderr, vr);
4317       value_range_t *vr;
4325 	  value_range_t *vr = get_value_range (cond);
4326 	  retval = compare_range_with_value (NE_EXPR, vr, boolean_false_node,
4336       vr = get_value_range (cond);
4337       if (vr->type == VR_RANGE && vr->min == vr->max)
4338 	return vr->min;
4913   value_range_t *vr = get_value_range (TREE_OPERAND (rhs, 0));
4923       val = compare_range_with_value (GE_EXPR, vr, integer_zero_node, &sop);
4977   value_range_t *vr = get_value_range (TREE_OPERAND (rhs, 0));
4983   else if (vr)
4987       val = compare_range_with_value (LE_EXPR, vr, integer_zero_node, &sop);
4991 	  val = compare_range_with_value (GE_EXPR, vr, integer_zero_node,
5041 		      tree op1, value_range_t *vr)
5083       if (compare_values (vr->min, min) == -1)
5086 	min = vr->min;
5087       if (compare_values (vr->max, max) == 1)
5090 	max = vr->max;
5119       value_range_t *vr = get_value_range (op0);
5123       if (vr->type == VR_RANGE)
5125 	  tree new = test_for_singularity (cond_code, op0, op1, vr);
5153 	  new = test_for_singularity (cond_code, op0, op1, vr);