Range Analysis: Compute range of Binary with << operator

This patch computes the range of a `Binary` with `<<`
(shift-left) operator when the `lhs` is a non-negative integer.

Bug: 348701956
Test: tint_unittests
Change-Id: I5e52e5504ba749312edbaef0a6f88c0b40dd3367
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/245775
Reviewed-by: James Price <[email protected]>
Commit-Queue: Jiawei Shao <[email protected]>

Author: Jiawei-Shao

src/tint/lang/core/ir/analysis/integer_range_analysis.cc

@@ -281,6 +281,9 @@ struct IntegerRangeAnalysisImpl {
             case BinaryOp::kDivide:
                 return ComputeAndCacheIntegerRangeForBinaryDivide(binary, range_lhs, range_rhs);
 
+            case BinaryOp::kShiftLeft:
+                return ComputeAndCacheIntegerRangeForBinaryShiftLeft(binary, range_lhs, range_rhs);
+
             default:
                 return nullptr;
         }
@@ -1038,6 +1041,60 @@ struct IntegerRangeAnalysisImpl {
         }
     }
 
+    const IntegerRangeInfo* ComputeAndCacheIntegerRangeForBinaryShiftLeft(
+        const Binary* binary,
+        const IntegerRangeInfo* lhs,
+        const IntegerRangeInfo* rhs) {
+        auto rhs_u32 = std::get<IntegerRangeInfo::UnsignedIntegerRange>(rhs->range);
+
+        // rhs_u32 must be less than the bit width of i32 and u32 (32):
+        // rhs_u32.min_bound <= rhs_u32.max_bound < 32
+        if (rhs_u32.max_bound >= 32) {
+            return nullptr;
+        }
+
+        if (std::holds_alternative<IntegerRangeInfo::SignedIntegerRange>(lhs->range)) {
+            auto lhs_i32 = std::get<IntegerRangeInfo::SignedIntegerRange>(lhs->range);
+
+            // Currently we require `lhs` must be non-negative.
+            // 0 <= lhs.min_bound <= lhs.max_bound
+            if (lhs_i32.min_bound < 0) {
+                return nullptr;
+            }
+
+            // [min1, max1] << [min2, max2] => [min1 << min2, max1 << max2]
+            // `max_bound` (as a uint64_t) won't be overflow because `rhs_u32.max_bound` < 32.
+            uint64_t max_bound = static_cast<uint64_t>(lhs_i32.max_bound) << rhs_u32.max_bound;
+
+            // Overflow an `i32` is not allowed, which means:
+            // min_bound <= max_bound <= i32::kHighestValue
+            if (max_bound > static_cast<uint64_t>(i32::kHighestValue)) {
+                return nullptr;
+            }
+
+            int64_t min_bound = lhs_i32.min_bound << rhs_u32.min_bound;
+            auto result = integer_binary_range_info_map_.Add(
+                binary, IntegerRangeInfo(min_bound, static_cast<int64_t>(max_bound)));
+            return &result.value;
+        } else {
+            auto lhs_u32 = std::get<IntegerRangeInfo::UnsignedIntegerRange>(lhs->range);
+
+            // `max_bound` (as a uint64_t) won't be overflow because `rhs_u32.max_bound` < 32.
+            uint64_t max_bound = lhs_u32.max_bound << rhs_u32.max_bound;
+
+            // Overflow a `u32` is not allowed, which means:
+            // min_bound <= max_bound <= u32::kHighestValue
+            if (max_bound > u32::kHighestValue) {
+                return nullptr;
+            }
+
+            uint64_t min_bound = lhs_u32.min_bound << rhs_u32.min_bound;
+            auto result =
+                integer_binary_range_info_map_.Add(binary, IntegerRangeInfo(min_bound, max_bound));
+            return &result.value;
+        }
+    }
+
     Hashmap<const FunctionParam*, Vector<IntegerRangeInfo, 3>, 4>
         integer_function_param_range_info_map_;
     Hashmap<const Var*, IntegerRangeInfo, 8> integer_var_range_info_map_;