[TurboFan] Calculate precise ranges for bitwise-or with positive input ranges.

test/unittests/compiler/typer-unittest.cc

 // Copyright 2015 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <functional>
 
 #include "src/codegen.h"
 #include "src/compiler/js-operator.h"
 #include "src/compiler/node-properties.h"
 #include "test/cctest/types-fuzz.h"
@@ skipping 128 matching lines @@
         double x1 = RandomInt(r1);
         double x2 = RandomInt(r2);
         double result_value = opfun(x1, x2);
         Type* result_type = Type::Constant(
             isolate()->factory()->NewNumber(result_value), zone());
         EXPECT_TRUE(result_type->Is(expected_type));
       }
     }
   }
 
+  // Careful, this function scales poorly.
+  template <int32_t op(int32_t, int32_t), class DeriveFunction>
+  void TestPreciseBinaryArithOp(DeriveFunction derive,
+                                int32_t llow, int32_t lhigh, int32_t linc,
+                                int32_t rlow, int32_t rhigh, int32_t rinc) {
+    for (int64_t lmin = llow; lmin <= lhigh; lmin += linc) {
+      for (int64_t lmax = lmin; lmax <= lhigh; lmax += linc) {
+        for (int64_t rmin = rlow; rmin <= rhigh; rmin += rinc) {
+          for (int64_t rmax = rmin; rmax <= rhigh; rmax += rinc) {
+            IntType r1 = IntType(int32_t(lmin), int32_t(lmax));
+            IntType r2 = IntType(int32_t(rmin), int32_t(rmax));
+            IntType derived_type = derive(r1, r2);
+            int32_t min = kMaxInt, max = kMinInt;
+            for (int32_t x1 = int32_t(lmin); x1 <= int32_t(lmax); x1++) {
+              for (int32_t x2 = int32_t(rmin); x2 <= int32_t(rmax); x2++) {
+                int32_t result_value = op(x1, x2);
+                min = std::min(result_value, min);
+                max = std::max(result_value, max);
+              }
+            }
+            EXPECT_TRUE(derived_type.min == min && derived_type.max == max);
+          }
+        }
+      }
+    }
+  }
+
   template <class BinaryFunction>
   void TestBinaryCompareOp(const Operator* op, BinaryFunction opfun) {
     for (int i = 0; i < 100; ++i) {
       Type::RangeType* r1 = RandomRange()->AsRange();
       Type::RangeType* r2 = RandomRange()->AsRange();
       Type* expected_type = TypeBinaryOp(op, r1, r2);
       for (int i = 0; i < 10; i++) {
         double x1 = RandomInt(r1);
         double x2 = RandomInt(r2);
         bool result_value = opfun(x1, x2);
@@ skipping 97 matching lines @@
 
 TEST_F(TyperTest, TypeJSModulus) {
   TestBinaryArithOp(javascript_.Modulus(LanguageMode::SLOPPY), modulo);
   TestBinaryArithOp(javascript_.Modulus(LanguageMode::STRONG), modulo);
 }
 
 
 TEST_F(TyperTest, TypeJSBitwiseOr) {
   TestBinaryBitOp(javascript_.BitwiseOr(LanguageMode::SLOPPY), bit_or);
   TestBinaryBitOp(javascript_.BitwiseOr(LanguageMode::STRONG), bit_or);
+  // The derivation algorithm works one bit at a time and scales to
+  // any bit width so verify on practical bit widths.
+  TestPreciseBinaryArithOp<bit_or>(JSBitwiseOrIntType,
+                                   -16, 15, 1, -16, 15, 1);
+  TestPreciseBinaryArithOp<bit_or>(JSBitwiseOrIntType,
+                                   kMaxInt - 32, kMaxInt, 1,
+                                   kMaxInt - 32, kMaxInt, 1);
+  TestPreciseBinaryArithOp<bit_or>(JSBitwiseOrIntType,
+                                   kMinInt, kMinInt + 32, 1,
+                                   kMinInt, kMinInt + 32, 1);
+  TestPreciseBinaryArithOp<bit_or>(JSBitwiseOrIntType,
+                                   kMaxInt - 32 * 2, kMaxInt, 2,
+                                   kMaxInt - 32 * 2, kMaxInt, 2);
+  TestPreciseBinaryArithOp<bit_or>(JSBitwiseOrIntType,
+                                   kMinInt, kMinInt + 32 * 2, 2,
+                                   kMinInt, kMinInt + 32 * 2, 2);
 }
 
 
 TEST_F(TyperTest, TypeJSBitwiseAnd) {
   TestBinaryBitOp(javascript_.BitwiseAnd(LanguageMode::SLOPPY), bit_and);
   TestBinaryBitOp(javascript_.BitwiseAnd(LanguageMode::STRONG), bit_and);
 }
 
 
 TEST_F(TyperTest, TypeJSBitwiseXor) {
@@ skipping 120 matching lines @@
 
 
 TEST_F(TyperTest, TypeRegressInt32Constant) {
   int values[] = {-5, 10};
   for (auto i : values) {
     Node* c = graph()->NewNode(common()->Int32Constant(i));
     Type* type = NodeProperties::GetBounds(c).upper;
     EXPECT_TRUE(type->Is(NewRange(i, i)));
   }
 }