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

src/compiler/typer.cc

 // Copyright 2014 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 "src/base/flags.h"
 #include "src/bootstrapper.h"
 #include "src/compiler/graph-reducer.h"
 #include "src/compiler/js-operator.h"
 #include "src/compiler/node.h"
 #include "src/compiler/node-properties.h"
@@ skipping 856 matching lines @@
 // JS bitwise operators.
 
 
 Type* Typer::Visitor::JSBitwiseOrTyper(Type* lhs, Type* rhs, Typer* t) {
   lhs = NumberToInt32(ToNumber(lhs, t), t);
   rhs = NumberToInt32(ToNumber(rhs, t), t);
   double lmin = lhs->Min();
   double rmin = rhs->Min();
   double lmax = lhs->Max();
   double rmax = rhs->Max();
+

[titzer, 2015/03/10 07:47:13]

Please add unit tests for the typer and mjsunit tests with JS code.

+  // Or-ing with 0 is essentially a conversion to int32, and or-ing
+  // with -1 returns -1.
+  if (rmin == rmax) {
+    if (rmin == 0) {
+      return Type::Range(lmin, lmax, t->zone());
+    }
+    if (rmin == -1) {
+      return Type::Range(rmin, rmax, t->zone());
+    }
+  }
+  if (lmin == lmax) {
+    if (lmin == 0) {
+      return Type::Range(rmin, rmax, t->zone());
+    }
+    if (lmin == -1) {
+      return Type::Range(lmin, lmax, t->zone());
+    }
+  }
+
+  if (lmin >= 0 && rmin >= 0) {
+    // Precise calculation of the result range for positive ranges.
+    double min, max;
+    int32_t lmin2, lmax2, rmin2, rmax2, bit, mask;
+
+    // Calculate the result minimum.
+    lmin2 = lmin, lmax2 = lmax, rmin2 = rmin, rmax2 = rmax;
+    bit = 0x40000000, mask = 0x3fffffff;
+    for (; lmin2 != lmax2 || rmin2 != rmax2; bit >>= 1, mask >>= 1) {
+      int32_t lminb = lmin2 & bit;
+      int32_t lmaxb = lmax2 & bit;
+      int32_t rminb = rmin2 & bit;
+      int32_t rmaxb = rmax2 & bit;
+      if (lminb != lmaxb || rminb != rmaxb) {
+        if (lminb == lmaxb) {
+          if (lminb) {
+            rmin2 = (rmin2 & ~mask) | bit;
+          } else {
+            rmax2 = (rmax2 & ~bit) | mask;
+          }
+        } else if (rminb == rmaxb) {
+          if (rminb) {
+            lmin2 = (lmin2 & ~mask) | bit;
+          } else {
+            lmax2 = (lmax2 & ~bit) | mask;
+          }
+        } else {
+          lmax2 = (lmax2 & ~bit) | mask;
+          rmax2 = (rmax2 & ~bit) | mask;
+        }
+      }
+    }
+    min = lmin2 | rmin2;
+
+    // Calculate the result maximum.
+    lmin2 = lmin, lmax2 = lmax, rmin2 = rmin, rmax2 = rmax;
+    bit = 0x40000000, mask = 0x3fffffff;
+    for (; lmin2 != lmax2 || rmin2 != rmax2; bit >>= 1, mask >>= 1) {
+      int32_t lminb = lmin2 & bit;
+      int32_t lmaxb = lmax2 & bit;
+      int32_t rminb = rmin2 & bit;
+      int32_t rmaxb = rmax2 & bit;
+      if (lminb != lmaxb || rminb != rmaxb) {
+        if (lminb == lmaxb) {
+          if (lminb) {
+            rmax2 = (rmax2 & ~bit) | mask;
+          } else {
+            rmin2 = (rmin2 & ~mask) | bit;
+          }
+        } else if (rminb == rmaxb) {
+          if (rminb) {
+            lmax2 = (lmax2 & ~bit) | mask;
+          } else {
+            lmin2 = (lmin2 & ~mask) | bit;
+          }
+        } else {
+          lmax2 = lmax2 | mask;
+          break;
+        }
+      }
+    }
+    max = lmax2 | rmax2;
+
+    return Type::Range(min, max, t->zone());
+  }
+
   // Or-ing any two values results in a value no smaller than their minimum.
-  // Even no smaller than their maximum if both values are non-negative.
-  double min =
-      lmin >= 0 && rmin >= 0 ? std::max(lmin, rmin) : std::min(lmin, rmin);
+  double min = std::min(lmin, rmin);
   double max = Type::Signed32()->Max();
 
-  // Or-ing with 0 is essentially a conversion to int32.
-  if (rmin == 0 && rmax == 0) {
-    min = lmin;
-    max = lmax;
-  }
-  if (lmin == 0 && lmax == 0) {
-    min = rmin;
-    max = rmax;
-  }
-
   if (lmax < 0 || rmax < 0) {
     // Or-ing two values of which at least one is negative results in a negative
     // value.
     max = std::min(max, -1.0);
   }
   return Type::Range(min, max, t->zone());
   // TODO(neis): Be precise for singleton inputs, here and elsewhere.
 }
 
 
@@ skipping 1308 matching lines @@
       TYPED_ARRAYS(TYPED_ARRAY_CASE)
 #undef TYPED_ARRAY_CASE
     }
   }
   return Type::Constant(value, zone());
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8