From c5a6c2237a1156dc43fa32c938fc32acdfc2bff9 Mon Sep 17 00:00:00 2001 From: Aldy Hernandez Date: Fri, 4 Sep 2020 09:05:04 +0200 Subject: [PATCH] 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. --- gcc/range-op.cc | 132 ++++++++++++++++++++++----------------------- gcc/tree-vrp.c | 4 +- gcc/value-range.cc | 4 +- gcc/value-range.h | 2 +- 4 files changed, 71 insertions(+), 71 deletions(-) diff --git a/gcc/range-op.cc b/gcc/range-op.cc index b7b708b488b..fbf78be0a3c 100644 --- 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 a165164bb40..f7b0692a407 100644 --- 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 93164b7e2e2..20aa4f114c9 100644 --- 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 1ab39939703..8497791c7b3 100644 --- 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 -- 2.30.2