rename widest_irange to int_range_max.

gcc/ChangeLog:

	* range-op.cc (range_operator::fold_range): Rename widest_irange
	to int_range_max.
	(operator_div::wi_fold): Same.
	(operator_lshift::op1_range): Same.
	(operator_rshift::op1_range): Same.
	(operator_cast::fold_range): Same.
	(operator_cast::op1_range): Same.
	(operator_bitwise_and::remove_impossible_ranges): Same.
	(operator_bitwise_and::op1_range): Same.
	(operator_abs::op1_range): Same.
	(range_cast): Same.
	(widest_irange_tests): Same.
	(range3_tests): Rename irange3 to int_range3.
	(int_range_max_tests): Rename from widest_irange_tests.
	Rename widest_irange to int_range_max.
	(operator_tests): Rename widest_irange to int_range_max.
	(range_tests): Same.
	* tree-vrp.c (find_case_label_range): Same.
	* value-range.cc (irange::irange_intersect): Same.
	(irange::invert): Same.
	* value-range.h: Same.

diff --git a/gcc/range-op.cc b/gcc/range-op.cc
index b7b708b488b71ea6e0c39771c96b934567c83209..fbf78be0a3c3e064338fab1772c1c85f561c6fad 100644 (file)
--- a/gcc/range-op.cc
+++ b/gcc/range-op.cc
@@ -160,7 +160,7 @@ range_operator::fold_range (irange &r, tree type,
       return true;
     }
 
-  widest_irange tmp;
+  int_range_max tmp;
   r.set_undefined ();
   for (unsigned x = 0; x < num_lh; ++x)
     for (unsigned y = 0; y < num_rh; ++y)
@@ -1367,7 +1367,7 @@ operator_div::wi_fold (irange &r, tree type,
   // Then divide by the non-zero positive numbers, if any.
   if (wi::gt_p (divisor_max, wi::zero (prec), sign))
     {
-      widest_irange tmp;
+      int_range_max tmp;
       wi_cross_product (tmp, type, dividend_min, dividend_max,
                        wi::one (prec), divisor_max);
       r.union_ (tmp);
@@ -1567,7 +1567,7 @@ operator_lshift::op1_range (irange &r,
       //
       // Perform a logical rshift by doing the rshift as unsigned.
       tree unsigned_type = unsigned_type_for (type);
-      widest_irange unsigned_lhs = lhs;
+      int_range_max unsigned_lhs = lhs;
       range_cast (unsigned_lhs, unsigned_type);
       rshift_op = range_op_handler (RSHIFT_EXPR, unsigned_type);
       rshift_op->fold_range (lb, unsigned_type, unsigned_lhs, shifted);
@@ -1611,7 +1611,7 @@ operator_rshift::op1_range (irange &r,
     {
       // Folding the original operation may discard some impossible
       // ranges from the LHS.
-      widest_irange lhs_refined;
+      int_range_max lhs_refined;
       op_rshift.fold_range (lhs_refined, type, int_range<1> (type), op2);
       lhs_refined.intersect (lhs);
       if (lhs_refined.undefined_p ())
@@ -1619,8 +1619,8 @@ operator_rshift::op1_range (irange &r,
          r.set_undefined ();
          return true;
        }
-      widest_irange shift_range (shift, shift);
-      widest_irange lb, ub;
+      int_range_max shift_range (shift, shift);
+      int_range_max lb, ub;
       op_lshift.fold_range (lb, type, lhs_refined, shift_range);
       //    LHS
       // 0000 0111 = OP1 >> 3
@@ -1632,7 +1632,7 @@ operator_rshift::op1_range (irange &r,
                               fold_build2 (LSHIFT_EXPR, type,
                                            build_minus_one_cst (type),
                                            shift));
-      widest_irange mask_range (build_zero_cst (type), mask);
+      int_range_max mask_range (build_zero_cst (type), mask);
       op_plus.fold_range (ub, type, lb, mask_range);
       r = lb;
       r.union_ (ub);
@@ -1786,7 +1786,7 @@ operator_cast::fold_range (irange &r, tree type ATTRIBUTE_UNUSED,
   // Then process any additonal pairs by unioning with their results.
   for (unsigned x = 1; x < inner.num_pairs (); ++x)
     {
-      widest_irange tmp;
+      int_range_max tmp;
       fold_pair (tmp, x, inner, outer);
       r.union_ (tmp);
       if (r.varying_p ())
@@ -1811,7 +1811,7 @@ operator_cast::op1_range (irange &r, tree type,
         {
          // We want to insert the LHS as an unsigned value since it
          // would not trigger the signed bit of the larger type.
-         widest_irange converted_lhs = lhs;
+         int_range_max converted_lhs = lhs;
          range_cast (converted_lhs, unsigned_type_for (lhs_type));
          range_cast (converted_lhs, type);
          // Start by building the positive signed outer range for the type.
@@ -1826,14 +1826,14 @@ operator_cast::op1_range (irange &r, tree type,
          lim = wi::mask (TYPE_PRECISION (lhs_type), true,
                          TYPE_PRECISION (type));
          // Add this to the unsigned LHS range(s).
-         widest_irange lim_range (type, lim, lim);
-         widest_irange lhs_neg;
+         int_range_max lim_range (type, lim, lim);
+         int_range_max lhs_neg;
          range_op_handler (PLUS_EXPR, type)->fold_range (lhs_neg,
                                                          type,
                                                          converted_lhs,
                                                          lim_range);
          // And union this with the entire outer types negative range.
-         widest_irange neg (type,
+         int_range_max neg (type,
                             wi::min_value (TYPE_PRECISION (type),
                                            SIGNED),
                             lim - 1);
@@ -1846,7 +1846,7 @@ operator_cast::op1_range (irange &r, tree type,
       return true;
     }
 
-  widest_irange tmp;
+  int_range_max tmp;
   if (TYPE_PRECISION (lhs_type) == TYPE_PRECISION (type))
     tmp = lhs;
   else
@@ -1984,7 +1984,7 @@ operator_bitwise_and::remove_impossible_ranges (irange &r,
   tree type = r.type ();
   int prec = TYPE_PRECISION (type);
   int leading_zeros = wi::clz (mask);
-  widest_irange impossible_ranges;
+  int_range_max impossible_ranges;
 
   /* We know that starting at the most significant bit, any 0 in the
      mask means the resulting range cannot contain a 1 in that same
@@ -2315,10 +2315,10 @@ operator_bitwise_and::op1_range (irange &r, tree type,
   r.set_undefined ();
   for (unsigned i = 0; i < lhs.num_pairs (); ++i)
     {
-      widest_irange chunk (lhs.type (),
+      int_range_max chunk (lhs.type (),
                           lhs.lower_bound (i),
                           lhs.upper_bound (i));
-      widest_irange res;
+      int_range_max res;
       simple_op1_range_solver (res, type, chunk, op2);
       r.union_ (res);
     }
@@ -2872,7 +2872,7 @@ operator_abs::op1_range (irange &r, tree type,
       return true;
     }
   // Start with the positives because negatives are an impossible result.
-  widest_irange positives = range_positives (type);
+  int_range_max positives = range_positives (type);
   positives.intersect (lhs);
   r = positives;
   // Then add the negative of each pair:
@@ -3284,7 +3284,7 @@ range_op_handler (enum tree_code code, tree type)
 void
 range_cast (irange &r, tree type)
 {
-  widest_irange tmp = r;
+  int_range_max tmp = r;
   range_operator *op = range_op_handler (CONVERT_EXPR, type);
   // Call op_convert, if it fails, the result is varying.
   if (!op->fold_range (r, type, tmp, int_range<1> (type)))
@@ -3321,84 +3321,84 @@ build_range3 (int a, int b, int c, int d, int e, int f)
 static void
 range3_tests ()
 {
-  typedef int_range<3> irange3;
-  irange3 r0, r1, r2;
-  irange3 i1, i2, i3;
+  typedef int_range<3> int_range3;
+  int_range3 r0, r1, r2;
+  int_range3 i1, i2, i3;
 
   // ([10,20] U [5,8]) U [1,3] ==> [1,3][5,8][10,20].
-  r0 = irange3 (INT (10), INT (20));
-  r1 = irange3 (INT (5), INT (8));
+  r0 = int_range3 (INT (10), INT (20));
+  r1 = int_range3 (INT (5), INT (8));
   r0.union_ (r1);
-  r1 = irange3 (INT (1), INT (3));
+  r1 = int_range3 (INT (1), INT (3));
   r0.union_ (r1);
   ASSERT_TRUE (r0 == build_range3 (1, 3, 5, 8, 10, 20));
 
   // [1,3][5,8][10,20] U [-5,0] => [-5,3][5,8][10,20].
-  r1 = irange3 (INT (-5), INT (0));
+  r1 = int_range3 (INT (-5), INT (0));
   r0.union_ (r1);
   ASSERT_TRUE (r0 == build_range3 (-5, 3, 5, 8, 10, 20));
 
   // [10,20][30,40] U [50,60] ==> [10,20][30,40][50,60].
-  r1 = irange3 (INT (50), INT (60));
-  r0 = irange3 (INT (10), INT (20));
-  r0.union_ (irange3 (INT (30), INT (40)));
+  r1 = int_range3 (INT (50), INT (60));
+  r0 = int_range3 (INT (10), INT (20));
+  r0.union_ (int_range3 (INT (30), INT (40)));
   r0.union_ (r1);
   ASSERT_TRUE (r0 == build_range3 (10, 20, 30, 40, 50, 60));
   // [10,20][30,40][50,60] U [70, 80] ==> [10,20][30,40][50,60][70,80].
-  r1 = irange3 (INT (70), INT (80));
+  r1 = int_range3 (INT (70), INT (80));
   r0.union_ (r1);
 
   r2 = build_range3 (10, 20, 30, 40, 50, 60);
-  r2.union_ (irange3 (INT (70), INT (80)));
+  r2.union_ (int_range3 (INT (70), INT (80)));
   ASSERT_TRUE (r0 == r2);
 
   // [10,20][30,40][50,60] U [6,35] => [6,40][50,60].
   r0 = build_range3 (10, 20, 30, 40, 50, 60);
-  r1 = irange3 (INT (6), INT (35));
+  r1 = int_range3 (INT (6), INT (35));
   r0.union_ (r1);
-  r1 = irange3 (INT (6), INT (40));
-  r1.union_ (irange3 (INT (50), INT (60)));
+  r1 = int_range3 (INT (6), INT (40));
+  r1.union_ (int_range3 (INT (50), INT (60)));
   ASSERT_TRUE (r0 == r1);
 
   // [10,20][30,40][50,60] U [6,60] => [6,60].
   r0 = build_range3 (10, 20, 30, 40, 50, 60);
-  r1 = irange3 (INT (6), INT (60));
+  r1 = int_range3 (INT (6), INT (60));
   r0.union_ (r1);
-  ASSERT_TRUE (r0 == irange3 (INT (6), INT (60)));
+  ASSERT_TRUE (r0 == int_range3 (INT (6), INT (60)));
 
   // [10,20][30,40][50,60] U [6,70] => [6,70].
   r0 = build_range3 (10, 20, 30, 40, 50, 60);
-  r1 = irange3 (INT (6), INT (70));
+  r1 = int_range3 (INT (6), INT (70));
   r0.union_ (r1);
-  ASSERT_TRUE (r0 == irange3 (INT (6), INT (70)));
+  ASSERT_TRUE (r0 == int_range3 (INT (6), INT (70)));
 
   // [10,20][30,40][50,60] U [35,70] => [10,20][30,70].
   r0 = build_range3 (10, 20, 30, 40, 50, 60);
-  r1 = irange3 (INT (35), INT (70));
+  r1 = int_range3 (INT (35), INT (70));
   r0.union_ (r1);
-  r1 = irange3 (INT (10), INT (20));
-  r1.union_ (irange3 (INT (30), INT (70)));
+  r1 = int_range3 (INT (10), INT (20));
+  r1.union_ (int_range3 (INT (30), INT (70)));
   ASSERT_TRUE (r0 == r1);
 
   // [10,20][30,40][50,60] U [15,35] => [10,40][50,60].
   r0 = build_range3 (10, 20, 30, 40, 50, 60);
-  r1 = irange3 (INT (15), INT (35));
+  r1 = int_range3 (INT (15), INT (35));
   r0.union_ (r1);
-  r1 = irange3 (INT (10), INT (40));
-  r1.union_ (irange3 (INT (50), INT (60)));
+  r1 = int_range3 (INT (10), INT (40));
+  r1.union_ (int_range3 (INT (50), INT (60)));
   ASSERT_TRUE (r0 == r1);
 
   // [10,20][30,40][50,60] U [35,35] => [10,20][30,40][50,60].
   r0 = build_range3 (10, 20, 30, 40, 50, 60);
-  r1 = irange3 (INT (35), INT (35));
+  r1 = int_range3 (INT (35), INT (35));
   r0.union_ (r1);
   ASSERT_TRUE (r0 == build_range3 (10, 20, 30, 40, 50, 60));
 }
 
 static void
-widest_irange_tests ()
+int_range_max_tests ()
 {
-  widest_irange big;
+  int_range_max big;
   unsigned int nrange;
 
   // Build a huge multi-range range.
@@ -3410,7 +3410,7 @@ widest_irange_tests ()
   ASSERT_TRUE (big.num_pairs () == nrange);
 
   // Verify that we can copy it without loosing precision.
-  widest_irange copy (big);
+  int_range_max copy (big);
   ASSERT_TRUE (copy.num_pairs () == nrange);
 
   // Inverting it should produce one more sub-range.
@@ -3423,9 +3423,9 @@ widest_irange_tests ()
 
   // Test that [10,10][20,20] does NOT contain 15.
   {
-    widest_irange i1 (build_int_cst (integer_type_node, 10),
+    int_range_max i1 (build_int_cst (integer_type_node, 10),
                      build_int_cst (integer_type_node, 10));
-    widest_irange i2 (build_int_cst (integer_type_node, 20),
+    int_range_max i2 (build_int_cst (integer_type_node, 20),
                      build_int_cst (integer_type_node, 20));
     i1.union_ (i2);
     ASSERT_FALSE (i1.contains_p (build_int_cst (integer_type_node, 15)));
@@ -3463,9 +3463,9 @@ operator_tests ()
   tree max = vrp_val_max (integer_type_node);
   tree tiny = fold_build2 (PLUS_EXPR, integer_type_node, min,
                           build_one_cst (integer_type_node));
-  widest_irange res;
-  widest_irange i1 (tiny, max);
-  widest_irange i2 (build_int_cst (integer_type_node, 255),
+  int_range_max res;
+  int_range_max i1 (tiny, max);
+  int_range_max i2 (build_int_cst (integer_type_node, 255),
                    build_int_cst (integer_type_node, 255));
 
   // [MIN+1, MAX] = OP1 & 255: OP1 is VARYING
@@ -3497,20 +3497,20 @@ operator_tests ()
 
   // unsigned: [3, MAX] = OP1 >> 1
   {
-    widest_irange lhs (build_int_cst (unsigned_type_node, 3),
+    int_range_max lhs (build_int_cst (unsigned_type_node, 3),
                       TYPE_MAX_VALUE (unsigned_type_node));
-    widest_irange one (build_one_cst (unsigned_type_node),
+    int_range_max one (build_one_cst (unsigned_type_node),
                       build_one_cst (unsigned_type_node));
-    widest_irange op1;
+    int_range_max op1;
     op_rshift.op1_range (op1, unsigned_type_node, lhs, one);
     ASSERT_FALSE (op1.contains_p (UINT (3)));
   }
 
   // signed: [3, MAX] = OP1 >> 1
   {
-    widest_irange lhs (INT (3), TYPE_MAX_VALUE (integer_type_node));
-    widest_irange one (INT (1), INT (1));
-    widest_irange op1;
+    int_range_max lhs (INT (3), TYPE_MAX_VALUE (integer_type_node));
+    int_range_max one (INT (1), INT (1));
+    int_range_max op1;
     op_rshift.op1_range (op1, integer_type_node, lhs, one);
     ASSERT_FALSE (op1.contains_p (INT (-2)));
   }
@@ -3518,10 +3518,10 @@ operator_tests ()
   // This is impossible, so OP1 should be [].
   // signed: [MIN, MIN] = OP1 >> 1
   {
-    widest_irange lhs (TYPE_MIN_VALUE (integer_type_node),
+    int_range_max lhs (TYPE_MIN_VALUE (integer_type_node),
                       TYPE_MIN_VALUE (integer_type_node));
-    widest_irange one (INT (1), INT (1));
-    widest_irange op1;
+    int_range_max one (INT (1), INT (1));
+    int_range_max op1;
     op_rshift.op1_range (op1, integer_type_node, lhs, one);
     ASSERT_TRUE (op1.undefined_p ());
   }
@@ -3529,11 +3529,11 @@ operator_tests ()
   // signed: ~[-1] = OP1 >> 31
   if (TYPE_PRECISION (integer_type_node) > 31)
     {
-      widest_irange lhs (INT (-1), INT (-1), VR_ANTI_RANGE);
-      widest_irange shift (INT (31), INT (31));
-      widest_irange op1;
+      int_range_max lhs (INT (-1), INT (-1), VR_ANTI_RANGE);
+      int_range_max shift (INT (31), INT (31));
+      int_range_max op1;
       op_rshift.op1_range (op1, integer_type_node, lhs, shift);
-      widest_irange negatives = range_negatives (integer_type_node);
+      int_range_max negatives = range_negatives (integer_type_node);
       negatives.intersect (op1);
       ASSERT_TRUE (negatives.undefined_p ());
     }
@@ -3823,7 +3823,7 @@ range_tests ()
   ASSERT_TRUE (r0.nonzero_p ());
 
   multi_precision_range_tests ();
-  widest_irange_tests ();
+  int_range_max_tests ();
   operator_tests ();
 }
 

diff --git a/gcc/tree-vrp.c b/gcc/tree-vrp.c
index a165164bb40db03151ae2e3e86cd1c06109f8046..f7b0692a407674a46a8c4844c57bda86c287dde2 100644 (file)
--- a/gcc/tree-vrp.c
+++ b/gcc/tree-vrp.c
@@ -3827,7 +3827,7 @@ find_case_label_range (gswitch *switch_stmt, const irange *range_of_op)
       tree label = gimple_switch_label (switch_stmt, i);
       tree case_high
        = CASE_HIGH (label) ? CASE_HIGH (label) : CASE_LOW (label);
-      widest_irange label_range (CASE_LOW (label), case_high);
+      int_range_max label_range (CASE_LOW (label), case_high);
       label_range.intersect (range_of_op);
       if (label_range == *range_of_op)
        return label;
@@ -3849,7 +3849,7 @@ find_case_label_range (gswitch *switch_stmt, const irange *range_of_op)
       tree case_high = CASE_HIGH (max_label);
       if (!case_high)
        case_high = CASE_LOW (max_label);
-      widest_irange label_range (CASE_LOW (min_label), case_high);
+      int_range_max label_range (CASE_LOW (min_label), case_high);
       if (!types_compatible_p (label_range.type (), range_of_op->type ()))
        range_cast (label_range, range_of_op->type ());
       label_range.intersect (range_of_op);

diff --git a/gcc/value-range.cc b/gcc/value-range.cc
index 93164b7e2e213895a294d9a806806c326caefbe2..20aa4f114c9fe43c09cfbcae1e5710413243b891 100644 (file)
--- a/gcc/value-range.cc
+++ b/gcc/value-range.cc
@@ -1690,7 +1690,7 @@ irange::irange_intersect (const irange &r)
   signop sign = TYPE_SIGN (TREE_TYPE(m_base[0]));
   unsigned bld_pair = 0;
   unsigned bld_lim = m_max_ranges;
-  widest_irange r2 (*this);
+  int_range_max r2 (*this);
   unsigned r2_lim = r2.num_pairs ();
   unsigned i2 = 0;
   for (unsigned i = 0; i < r.num_pairs (); )
@@ -1827,7 +1827,7 @@ irange::invert ()
   unsigned i = 0;
   wi::overflow_type ovf;
   // Construct leftmost range.
-  widest_irange orig_range (*this);
+  int_range_max orig_range (*this);
   unsigned nitems = 0;
   wide_int tmp;
   // If this is going to underflow on the MINUS 1, don't even bother

diff --git a/gcc/value-range.h b/gcc/value-range.h
index 1ab399397034aa30623d31b9cbec6ff8f7b317f7..8497791c7b3a0e7a2b4c4e12d186fe71fc078856 100644 (file)
--- a/gcc/value-range.h
+++ b/gcc/value-range.h
@@ -174,7 +174,7 @@ typedef int_range<1> value_range;
 
 // This is an "infinite" precision irange for use in temporary
 // calculations.
-typedef int_range<255> widest_irange;
+typedef int_range<255> int_range_max;
 
 // Returns true for an old-school value_range as described above.
 inline bool