[WIP] Faster smi tagging.

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/bootstrapper.h"
 #include "src/compiler/graph-inl.h"
 #include "src/compiler/js-operator.h"
 #include "src/compiler/node.h"
 #include "src/compiler/node-properties-inl.h"
 #include "src/compiler/node-properties.h"
@@ skipping 721 matching lines @@
 
 
 Type* Typer::Visitor::JSBitwiseAndTyper(Type* lhs, Type* rhs, Typer* t) {
   Factory* f = t->isolate()->factory();
   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();
+  if (std::min(lmax, rmax) < kMaxInt) {
+    Handle<Object> min = f->NewNumber(0);
+    Handle<Object> max = f->NewNumber(std::min(lmax, rmax));
+    return Type::Range(min, max, t->zone());
+  }
   // And-ing any two values results in a value no larger than their maximum.
   // Even no larger than their minimum if both values are non-negative.
   Handle<Object> max = f->NewNumber(
       lmin >= 0 && rmin >= 0 ? std::min(lmax, rmax) : std::max(lmax, rmax));
   if (lmin >= 0 || rmin >= 0) {
     // And-ing two values of which at least one is non-negative results in a
     // non-negative value.
     Handle<Object> min = f->NewNumber(0);
     return Type::Range(min, max, t->zone());
   }
@@ skipping 21 matching lines @@
 }
 
 
 Type* Typer::Visitor::JSShiftLeftTyper(Type* lhs, Type* rhs, Typer* t) {
   return Type::Signed32();
 }
 
 
 Type* Typer::Visitor::JSShiftRightTyper(Type* lhs, Type* rhs, Typer* t) {
   lhs = NumberToInt32(ToNumber(lhs, t), t);
+  rhs = NumberToInt32(ToNumber(rhs, t), t);
   Factory* f = t->isolate()->factory();
   if (lhs->Min() >= 0) {
     // Right-shifting a non-negative value cannot make it negative, nor larger.
     Handle<Object> min = f->NewNumber(0);
     Handle<Object> max = f->NewNumber(lhs->Max());
     return Type::Range(min, max, t->zone());
   }
   if (lhs->Max() < 0) {
     // Right-shifting a negative value cannot make it non-negative, nor smaller.
     Handle<Object> min = f->NewNumber(lhs->Min());
     Handle<Object> max = f->NewNumber(-1);
     return Type::Range(min, max, t->zone());
   }
+  if (rhs->Min() > 0) {
+    // Right-shifting by a positve value yields a small integer value.
+    Handle<Object> min = f->NewNumber(kMinInt >> static_cast<int>(rhs->Min()));
+    Handle<Object> max = f->NewNumber(kMaxInt >> static_cast<int>(rhs->Min()));
+    return Type::Range(min, max, t->zone());
+  }
   return Type::Signed32();
 }
 
 
 Type* Typer::Visitor::JSShiftRightLogicalTyper(Type* lhs, Type* rhs, Typer* t) {
   lhs = NumberToUint32(ToNumber(lhs, t), t);
   Factory* f = t->isolate()->factory();
   // Logical right-shifting any value cannot make it larger.
   Handle<Object> min = f->NewNumber(0);
   Handle<Object> max = f->NewNumber(lhs->Max());
@@ skipping 1127 matching lines @@
         return typer_->float64_array_fun_;
       }
     }
   }
   return Type::Constant(value, zone());
 }
 
 }
 }
 }  // namespace v8::internal::compiler