Precise shift right result type derivation for all int32 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 <class BinaryFunction>
+  void TestPreciseBinaryArithOp(const Operator* op, BinaryFunction opfun,
+                                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) {
+            Type* r1 = NewRange(lmin, lmax);
+            Type* r2 = NewRange(rmin, rmax);
+            Type* derived_type = TypeBinaryOp(op, r1, r2);
+
+            double min = +V8_INFINITY, max = -V8_INFINITY;
+            for (int64_t x1 = lmin; x1 <= lmax; x1++) {
+              for (int64_t x2 = rmin; x2 <= rmax; x2++) {
+                double result_value = opfun(int32_t(x1), int32_t(x2));
+                if (result_value < min) min = result_value;
+                if (result_value > max) max = result_value;
+              }
+            }
+            Type* expected_type = NewRange(min, max);
+
+            EXPECT_TRUE(derived_type->Is(expected_type));
+            EXPECT_TRUE(expected_type->Is(derived_type));
+          }
+        }
+      }
+    }
+  }
+
   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 121 matching lines @@
 
 TEST_F(TyperTest, TypeJSShiftLeft) {
   TestBinaryBitOp(javascript_.ShiftLeft(LanguageMode::SLOPPY), shift_left);
   TestBinaryBitOp(javascript_.ShiftLeft(LanguageMode::STRONG), shift_left);
 }
 
 
 TEST_F(TyperTest, TypeJSShiftRight) {
   TestBinaryBitOp(javascript_.ShiftRight(LanguageMode::SLOPPY), shift_right);
   TestBinaryBitOp(javascript_.ShiftRight(LanguageMode::STRONG), shift_right);
+  TestPreciseBinaryArithOp(javascript_.ShiftRight(LanguageMode::SLOPPY),
+                           shift_right, -16, 15, 1, 0, 31, 1);
+  TestPreciseBinaryArithOp(javascript_.ShiftRight(LanguageMode::STRONG),
+                           shift_right, -16, 15, 1, 0, 31, 1);
+  TestPreciseBinaryArithOp(javascript_.ShiftRight(LanguageMode::SLOPPY),
+                           shift_right, -8, 7, 1, -64, 63, 1);
+  TestPreciseBinaryArithOp(javascript_.ShiftRight(LanguageMode::STRONG),
+                           shift_right, -8, 7, 1, -64, 63, 1);
 }
 
 
 TEST_F(TyperTest, TypeJSLessThan) {
   TestBinaryCompareOp(javascript_.LessThan(LanguageMode::SLOPPY),
                       std::less<double>());
   TestBinaryCompareOp(javascript_.LessThan(LanguageMode::STRONG),
                       std::less<double>());
 }
 
@@ skipping 96 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)));
   }
 }