[turbofan] Unify number operation typing rules.

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/compiler/typer.h"
 
 #include "src/base/flags.h"
 #include "src/bootstrapper.h"
 #include "src/compiler/common-operator.h"
 #include "src/compiler/graph-reducer.h"
@@ skipping 21 matching lines @@
 
 Typer::Typer(Isolate* isolate, Graph* graph)
     : isolate_(isolate),
       graph_(graph),
       decorator_(nullptr),
       cache_(TypeCache::Get()),
       operation_typer_(isolate, zone()) {
   Zone* zone = this->zone();
   Factory* const factory = isolate->factory();
 
-  Type* infinity = Type::Constant(factory->infinity_value(), zone);
-  Type* minus_infinity = Type::Constant(factory->minus_infinity_value(), zone);
-  // Unfortunately, the infinities created in other places might be different
-  // ones (eg the result of NewNumber in TypeNumberConstant).
-  Type* truncating_to_zero =
-      Type::Union(Type::Union(infinity, minus_infinity, zone),
-                  Type::MinusZeroOrNaN(), zone);
-  DCHECK(!truncating_to_zero->Maybe(Type::Integral32()));
-
   singleton_false_ = Type::Constant(factory->false_value(), zone);
   singleton_true_ = Type::Constant(factory->true_value(), zone);
   singleton_the_hole_ = Type::Constant(factory->the_hole_value(), zone);
-  signed32ish_ = Type::Union(Type::Signed32(), truncating_to_zero, zone);
-  unsigned32ish_ = Type::Union(Type::Unsigned32(), truncating_to_zero, zone);
   falsish_ = Type::Union(
       Type::Undetectable(),
       Type::Union(Type::Union(singleton_false_, cache_.kZeroish, zone),
                   singleton_the_hole_, zone),
       zone);
   truish_ = Type::Union(
       singleton_true_,
       Type::Union(Type::DetectableReceiver(), Type::Symbol(), zone), zone);
 
   decorator_ = new (zone) Decorator(this);
@@ skipping 32 matching lines @@
       SIMPLIFIED_COMPARE_BINOP_LIST(DECLARE_CASE)
       SIMPLIFIED_OTHER_OP_LIST(DECLARE_CASE)
       MACHINE_OP_LIST(DECLARE_CASE)
       MACHINE_SIMD_OP_LIST(DECLARE_CASE)
       JS_SIMPLE_UNOP_LIST(DECLARE_CASE)
       JS_OBJECT_OP_LIST(DECLARE_CASE)
       JS_CONTEXT_OP_LIST(DECLARE_CASE)
       JS_OTHER_OP_LIST(DECLARE_CASE)
 #undef DECLARE_CASE
 
+#define DECLARE_CASE(x) \
+  case IrOpcode::k##x:  \
+    return UpdateType(node, TypeBinaryOp(node, x));
+      SIMPLIFIED_NUMBER_BINOP_LIST(DECLARE_CASE)
+      SIMPLIFIED_SPECULATIVE_NUMBER_BINOP_LIST(DECLARE_CASE)
+#undef DECLARE_CASE
+
+#define DECLARE_CASE(x) \
+  case IrOpcode::k##x:  \
+    return UpdateType(node, TypeUnaryOp(node, x));
+      SIMPLIFIED_NUMBER_UNOP_LIST(DECLARE_CASE)
+#undef DECLARE_CASE
+
 #define DECLARE_CASE(x) case IrOpcode::k##x:
       DECLARE_CASE(Loop)
       DECLARE_CASE(Branch)
       DECLARE_CASE(IfTrue)
       DECLARE_CASE(IfFalse)
       DECLARE_CASE(IfSuccess)
       DECLARE_CASE(Switch)
       DECLARE_CASE(IfValue)
       DECLARE_CASE(IfDefault)
       DECLARE_CASE(Merge)
@@ skipping 30 matching lines @@
       SIMPLIFIED_COMPARE_BINOP_LIST(DECLARE_CASE)
       SIMPLIFIED_OTHER_OP_LIST(DECLARE_CASE)
       MACHINE_OP_LIST(DECLARE_CASE)
       MACHINE_SIMD_OP_LIST(DECLARE_CASE)
       JS_SIMPLE_UNOP_LIST(DECLARE_CASE)
       JS_OBJECT_OP_LIST(DECLARE_CASE)
       JS_CONTEXT_OP_LIST(DECLARE_CASE)
       JS_OTHER_OP_LIST(DECLARE_CASE)
 #undef DECLARE_CASE
 
+#define DECLARE_CASE(x) \
+  case IrOpcode::k##x:  \
+    return TypeBinaryOp(node, x);
+      SIMPLIFIED_NUMBER_BINOP_LIST(DECLARE_CASE)
+      SIMPLIFIED_SPECULATIVE_NUMBER_BINOP_LIST(DECLARE_CASE)
+#undef DECLARE_CASE
+
+#define DECLARE_CASE(x) \
+  case IrOpcode::k##x:  \
+    return TypeUnaryOp(node, x);
+      SIMPLIFIED_NUMBER_UNOP_LIST(DECLARE_CASE)
+#undef DECLARE_CASE
+
 #define DECLARE_CASE(x) case IrOpcode::k##x:
       DECLARE_CASE(Loop)
       DECLARE_CASE(Branch)
       DECLARE_CASE(IfTrue)
       DECLARE_CASE(IfFalse)
       DECLARE_CASE(IfSuccess)
       DECLARE_CASE(Switch)
       DECLARE_CASE(IfValue)
       DECLARE_CASE(IfDefault)
       DECLARE_CASE(Merge)
@@ skipping 74 matching lines @@
   static Type* FalsifyUndefined(ComparisonOutcome, Typer*);
 
   static Type* ToPrimitive(Type*, Typer*);
   static Type* ToBoolean(Type*, Typer*);
   static Type* ToInteger(Type*, Typer*);
   static Type* ToLength(Type*, Typer*);
   static Type* ToName(Type*, Typer*);
   static Type* ToNumber(Type*, Typer*);
   static Type* ToObject(Type*, Typer*);
   static Type* ToString(Type*, Typer*);
-  static Type* NumberCeil(Type*, Typer*);
-  static Type* NumberFloor(Type*, Typer*);
-  static Type* NumberMax(Type*, Type*, Typer*);
-  static Type* NumberMin(Type*, Type*, Typer*);
-  static Type* NumberRound(Type*, Typer*);
-  static Type* NumberSign(Type*, Typer*);
-  static Type* NumberTrunc(Type*, Typer*);
-  static Type* NumberToInt32(Type*, Typer*);
-  static Type* NumberToUint32(Type*, Typer*);
+#define DECLARE_METHOD(Name)                \
+  static Type* Name(Type* type, Typer* t) { \
+    return t->operation_typer_.Name(type);  \
+  }
+  SIMPLIFIED_NUMBER_UNOP_LIST(DECLARE_METHOD)
+#undef DECLARE_METHOD
+#define DECLARE_METHOD(Name)                          \
+  static Type* Name(Type* lhs, Type* rhs, Typer* t) { \
+    return t->operation_typer_.Name(lhs, rhs);        \
+  }
+  SIMPLIFIED_NUMBER_BINOP_LIST(DECLARE_METHOD)
+  SIMPLIFIED_SPECULATIVE_NUMBER_BINOP_LIST(DECLARE_METHOD)
+#undef DECLARE_METHOD
 
   static Type* ObjectIsCallable(Type*, Typer*);
   static Type* ObjectIsNumber(Type*, Typer*);
   static Type* ObjectIsReceiver(Type*, Typer*);
   static Type* ObjectIsSmi(Type*, Typer*);
   static Type* ObjectIsString(Type*, Typer*);
   static Type* ObjectIsUndetectable(Type*, Typer*);
 
   static ComparisonOutcome JSCompareTyper(Type*, Type*, Typer*);
 
@@ skipping 173 matching lines @@
   // ES6 section 7.1.14 ToPropertyKey ( argument )
   type = ToPrimitive(type, t);
   if (type->Is(Type::Name())) return type;
   if (type->Maybe(Type::Symbol())) return Type::Name();
   return ToString(type, t);
 }
 
 
 // static
 Type* Typer::Visitor::ToNumber(Type* type, Typer* t) {
-  if (type->Is(Type::Number())) return type;
-  if (type->Is(Type::NullOrUndefined())) {
-    if (type->Is(Type::Null())) return t->cache_.kSingletonZero;
-    if (type->Is(Type::Undefined())) return Type::NaN();
-    return Type::Union(Type::NaN(), t->cache_.kSingletonZero, t->zone());
-  }
-  if (type->Is(Type::NumberOrUndefined())) {
-    return Type::Union(Type::Intersect(type, Type::Number(), t->zone()),
-                       Type::NaN(), t->zone());
-  }
-  if (type->Is(t->singleton_false_)) return t->cache_.kSingletonZero;
-  if (type->Is(t->singleton_true_)) return t->cache_.kSingletonOne;
-  if (type->Is(Type::Boolean())) return t->cache_.kZeroOrOne;
-  if (type->Is(Type::BooleanOrNumber())) {
-    return Type::Union(Type::Intersect(type, Type::Number(), t->zone()),
-                       t->cache_.kZeroOrOne, t->zone());
-  }
-  return Type::Number();
+  return t->operation_typer_.ToNumber(type);
 }
 
 
 // static
 Type* Typer::Visitor::ToObject(Type* type, Typer* t) {
   // ES6 section 7.1.13 ToObject ( argument )
   if (type->Is(Type::Receiver())) return type;
   if (type->Is(Type::Primitive())) return Type::OtherObject();
   if (!type->Maybe(Type::OtherUndetectable())) {
     return Type::DetectableReceiver();
   }
   return Type::Receiver();
 }
 
 
 // static
 Type* Typer::Visitor::ToString(Type* type, Typer* t) {
   // ES6 section 7.1.12 ToString ( argument )
   type = ToPrimitive(type, t);
   if (type->Is(Type::String())) return type;
   return Type::String();
 }
 
-// static
-Type* Typer::Visitor::NumberCeil(Type* type, Typer* t) {
-  DCHECK(type->Is(Type::Number()));
-  if (type->Is(t->cache_.kIntegerOrMinusZeroOrNaN)) return type;
-  // TODO(bmeurer): We could infer a more precise type here.
-  return t->cache_.kIntegerOrMinusZeroOrNaN;
-}
-
-// static
-Type* Typer::Visitor::NumberFloor(Type* type, Typer* t) {
-  DCHECK(type->Is(Type::Number()));
-  if (type->Is(t->cache_.kIntegerOrMinusZeroOrNaN)) return type;
-  // TODO(bmeurer): We could infer a more precise type here.
-  return t->cache_.kIntegerOrMinusZeroOrNaN;
-}
-
-// static
-Type* Typer::Visitor::NumberMax(Type* lhs, Type* rhs, Typer* t) {
-  DCHECK(lhs->Is(Type::Number()));
-  DCHECK(rhs->Is(Type::Number()));
-  if (lhs->Is(Type::NaN()) || rhs->Is(Type::NaN())) {
-    return Type::NaN();
-  }
-  Type* type = Type::None();
-  // TODO(turbofan): Improve minus zero handling here.
-  if (lhs->Maybe(Type::NaN()) || rhs->Maybe(Type::NaN())) {
-    type = Type::Union(type, Type::NaN(), t->zone());
-  }
-  lhs = Type::Intersect(lhs, Type::OrderedNumber(), t->zone());
-  rhs = Type::Intersect(rhs, Type::OrderedNumber(), t->zone());
-  if (lhs->Is(t->cache_.kInteger) && rhs->Is(t->cache_.kInteger)) {
-    double max = std::max(lhs->Max(), rhs->Max());
-    double min = std::max(lhs->Min(), rhs->Min());
-    type = Type::Union(type, Type::Range(min, max, t->zone()), t->zone());
-  } else {
-    type = Type::Union(type, Type::Union(lhs, rhs, t->zone()), t->zone());
-  }
-  return type;
-}
-
-// static
-Type* Typer::Visitor::NumberMin(Type* lhs, Type* rhs, Typer* t) {
-  DCHECK(lhs->Is(Type::Number()));
-  DCHECK(rhs->Is(Type::Number()));
-  if (lhs->Is(Type::NaN()) || rhs->Is(Type::NaN())) {
-    return Type::NaN();
-  }
-  Type* type = Type::None();
-  // TODO(turbofan): Improve minus zero handling here.
-  if (lhs->Maybe(Type::NaN()) || rhs->Maybe(Type::NaN())) {
-    type = Type::Union(type, Type::NaN(), t->zone());
-  }
-  lhs = Type::Intersect(lhs, Type::OrderedNumber(), t->zone());
-  rhs = Type::Intersect(rhs, Type::OrderedNumber(), t->zone());
-  if (lhs->Is(t->cache_.kInteger) && rhs->Is(t->cache_.kInteger)) {
-    double max = std::min(lhs->Max(), rhs->Max());
-    double min = std::min(lhs->Min(), rhs->Min());
-    type = Type::Union(type, Type::Range(min, max, t->zone()), t->zone());
-  } else {
-    type = Type::Union(type, Type::Union(lhs, rhs, t->zone()), t->zone());
-  }
-  return type;
-}
-
-// static
-Type* Typer::Visitor::NumberRound(Type* type, Typer* t) {
-  DCHECK(type->Is(Type::Number()));
-  if (type->Is(t->cache_.kIntegerOrMinusZeroOrNaN)) return type;
-  // TODO(bmeurer): We could infer a more precise type here.
-  return t->cache_.kIntegerOrMinusZeroOrNaN;
-}
-
-// static
-Type* Typer::Visitor::NumberSign(Type* type, Typer* t) {
-  DCHECK(type->Is(Type::Number()));
-  if (type->Is(t->cache_.kZeroish)) return type;
-  bool maybe_minuszero = type->Maybe(Type::MinusZero());
-  bool maybe_nan = type->Maybe(Type::NaN());
-  type = Type::Intersect(type, Type::PlainNumber(), t->zone());
-  if (type->Max() < 0.0) {
-    type = t->cache_.kSingletonMinusOne;
-  } else if (type->Max() <= 0.0) {
-    type = t->cache_.kMinusOneOrZero;
-  } else if (type->Min() > 0.0) {
-    type = t->cache_.kSingletonOne;
-  } else if (type->Min() >= 0.0) {
-    type = t->cache_.kZeroOrOne;
-  } else {
-    type = Type::Range(-1.0, 1.0, t->zone());
-  }
-  if (maybe_minuszero) {
-    type = Type::Union(type, Type::MinusZero(), t->zone());
-  }
-  if (maybe_nan) {
-    type = Type::Union(type, Type::NaN(), t->zone());
-  }
-  return type;
-}
-
-// static
-Type* Typer::Visitor::NumberTrunc(Type* type, Typer* t) {
-  DCHECK(type->Is(Type::Number()));
-  if (type->Is(t->cache_.kIntegerOrMinusZeroOrNaN)) return type;
-  // TODO(bmeurer): We could infer a more precise type here.
-  return t->cache_.kIntegerOrMinusZeroOrNaN;
-}
-
-Type* Typer::Visitor::NumberToInt32(Type* type, Typer* t) {
-  if (type->Is(Type::Signed32())) return type;
-  if (type->Is(t->cache_.kZeroish)) return t->cache_.kSingletonZero;
-  if (type->Is(t->signed32ish_)) {
-    return Type::Intersect(
-        Type::Union(type, t->cache_.kSingletonZero, t->zone()),
-        Type::Signed32(), t->zone());
-  }
-  return Type::Signed32();
-}
-
-
-Type* Typer::Visitor::NumberToUint32(Type* type, Typer* t) {
-  if (type->Is(Type::Unsigned32())) return type;
-  if (type->Is(t->cache_.kZeroish)) return t->cache_.kSingletonZero;
-  if (type->Is(t->unsigned32ish_)) {
-    return Type::Intersect(
-        Type::Union(type, t->cache_.kSingletonZero, t->zone()),
-        Type::Unsigned32(), t->zone());
-  }
-  return Type::Unsigned32();
-}
-
 // Type checks.
 
 Type* Typer::Visitor::ObjectIsCallable(Type* type, Typer* t) {
   if (type->Is(Type::Function())) return t->singleton_true_;
   if (type->Is(Type::Primitive())) return t->singleton_false_;
   return Type::Boolean();
 }
 
 Type* Typer::Visitor::ObjectIsNumber(Type* type, Typer* t) {
   if (type->Is(Type::Number())) return t->singleton_true_;
@@ skipping 382 matching lines @@
 
 Type* Typer::Visitor::JSGreaterThanOrEqualTyper(
     Type* lhs, Type* rhs, Typer* t) {
   return FalsifyUndefined(Invert(JSCompareTyper(lhs, rhs, t), t), t);
 }
 
 // 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();
-  // 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 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());
+  return NumberBitwiseOr(ToNumber(lhs, t), ToNumber(rhs, t), t);
 }
 
 
 Type* Typer::Visitor::JSBitwiseAndTyper(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();
-  double min = Type::Signed32()->Min();
-  // 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.
-  double max =
-      lmin >= 0 && rmin >= 0 ? std::min(lmax, rmax) : std::max(lmax, rmax);
-  // And-ing with a non-negative value x causes the result to be between
-  // zero and x.
-  if (lmin >= 0) {
-    min = 0;
-    max = std::min(max, lmax);
-  }
-  if (rmin >= 0) {
-    min = 0;
-    max = std::min(max, rmax);
-  }
-  return Type::Range(min, max, t->zone());
+  return NumberBitwiseAnd(ToNumber(lhs, t), ToNumber(rhs, t), t);
 }
 
 
 Type* Typer::Visitor::JSBitwiseXorTyper(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();
-  if ((lmin >= 0 && rmin >= 0) || (lmax < 0 && rmax < 0)) {
-    // Xor-ing negative or non-negative values results in a non-negative value.
-    return Type::Unsigned31();
-  }
-  if ((lmax < 0 && rmin >= 0) || (lmin >= 0 && rmax < 0)) {
-    // Xor-ing a negative and a non-negative value results in a negative value.
-    // TODO(jarin) Use a range here.
-    return Type::Negative32();
-  }
-  return Type::Signed32();
+  return NumberBitwiseXor(ToNumber(lhs, t), ToNumber(rhs, t), t);
 }
 
 
 Type* Typer::Visitor::JSShiftLeftTyper(Type* lhs, Type* rhs, Typer* t) {
-  return Type::Signed32();
+  return NumberShiftLeft(ToNumber(lhs, t), ToNumber(rhs, t), t);
 }
 
 
 Type* Typer::Visitor::JSShiftRightTyper(Type* lhs, Type* rhs, Typer* t) {
-  lhs = NumberToInt32(ToNumber(lhs, t), t);
-  rhs = NumberToUint32(ToNumber(rhs, t), t);
-  double min = kMinInt;
-  double max = kMaxInt;
-  if (lhs->Min() >= 0) {
-    // Right-shifting a non-negative value cannot make it negative, nor larger.
-    min = std::max(min, 0.0);
-    max = std::min(max, lhs->Max());
-    if (rhs->Min() > 0 && rhs->Max() <= 31) {
-      max = static_cast<int>(max) >> static_cast<int>(rhs->Min());
-    }
-  }
-  if (lhs->Max() < 0) {
-    // Right-shifting a negative value cannot make it non-negative, nor smaller.
-    min = std::max(min, lhs->Min());
-    max = std::min(max, -1.0);
-    if (rhs->Min() > 0 && rhs->Max() <= 31) {
-      min = static_cast<int>(min) >> static_cast<int>(rhs->Min());
-    }
-  }
-  if (rhs->Min() > 0 && rhs->Max() <= 31) {
-    // Right-shifting by a positive value yields a small integer value.
-    double shift_min = kMinInt >> static_cast<int>(rhs->Min());
-    double shift_max = kMaxInt >> static_cast<int>(rhs->Min());
-    min = std::max(min, shift_min);
-    max = std::min(max, shift_max);
-  }
-  // TODO(jarin) Ideally, the following micro-optimization should be performed
-  // by the type constructor.
-  if (max != Type::Signed32()->Max() || min != Type::Signed32()->Min()) {
-    return Type::Range(min, max, t->zone());
-  }
-  return Type::Signed32();
+  return NumberShiftRight(ToNumber(lhs, t), ToNumber(rhs, t), t);
 }
 
 
 Type* Typer::Visitor::JSShiftRightLogicalTyper(Type* lhs, Type* rhs, Typer* t) {
-  lhs = NumberToUint32(ToNumber(lhs, t), t);
-  // Logical right-shifting any value cannot make it larger.
-  return Type::Range(0.0, lhs->Max(), t->zone());
+  return NumberShiftRightLogical(ToNumber(lhs, t), ToNumber(rhs, t), t);
 }
 
 
 // JS arithmetic operators.
 
 Type* Typer::Visitor::JSAddTyper(Type* lhs, Type* rhs, Typer* t) {
   lhs = ToPrimitive(lhs, t);
   rhs = ToPrimitive(rhs, t);
   if (lhs->Maybe(Type::String()) || rhs->Maybe(Type::String())) {
     if (lhs->Is(Type::String()) || rhs->Is(Type::String())) {
       return Type::String();
     } else {
       return Type::NumberOrString();
     }
   }
   // The addition must be numeric.
-  return t->operation_typer()->NumberAdd(ToNumber(lhs, t), ToNumber(rhs, t));
+  return NumberAdd(ToNumber(lhs, t), ToNumber(rhs, t), t);
 }
 
 Type* Typer::Visitor::JSSubtractTyper(Type* lhs, Type* rhs, Typer* t) {
-  return t->operation_typer()->NumberSubtract(ToNumber(lhs, t),
-                                              ToNumber(rhs, t));
+  return NumberSubtract(ToNumber(lhs, t), ToNumber(rhs, t), t);
 }
 
 Type* Typer::Visitor::JSMultiplyTyper(Type* lhs, Type* rhs, Typer* t) {
-  return t->operation_typer()->NumberMultiply(ToNumber(lhs, t),
-                                              ToNumber(rhs, t));
+  return NumberMultiply(ToNumber(lhs, t), ToNumber(rhs, t), t);
 }
 
 Type* Typer::Visitor::JSDivideTyper(Type* lhs, Type* rhs, Typer* t) {
-  return t->operation_typer()->NumberDivide(ToNumber(lhs, t), ToNumber(rhs, t));
+  return NumberDivide(ToNumber(lhs, t), ToNumber(rhs, t), t);
 }
 
 Type* Typer::Visitor::JSModulusTyper(Type* lhs, Type* rhs, Typer* t) {
-  return t->operation_typer()->NumberModulus(ToNumber(lhs, t),
-                                             ToNumber(rhs, t));
+  return NumberModulus(ToNumber(lhs, t), ToNumber(rhs, t), t);
 }
 
 
 // JS unary operators.
 
 
 Type* Typer::Visitor::JSTypeOfTyper(Type* type, Typer* t) {
   Factory* const f = t->isolate()->factory();
   if (type->Is(Type::Boolean())) {
     return Type::Constant(f->boolean_string(), t->zone());
@@ skipping 466 matching lines @@
 }
 
 Type* Typer::Visitor::TypeSpeculativeNumberLessThan(Node* node) {
   return Type::Boolean();
 }
 
 Type* Typer::Visitor::TypeSpeculativeNumberLessThanOrEqual(Node* node) {
   return Type::Boolean();
 }
 
-Type* Typer::Visitor::TypeNumberAdd(Node* node) { return Type::Number(); }
-
-Type* Typer::Visitor::TypeNumberSubtract(Node* node) { return Type::Number(); }
-
-Type* Typer::Visitor::TypeSpeculativeNumberAdd(Node* node) {
-  return Type::Number();
-}
-
-Type* Typer::Visitor::TypeSpeculativeNumberSubtract(Node* node) {
-  return Type::Number();
-}
-
-Type* Typer::Visitor::TypeSpeculativeNumberMultiply(Node* node) {
-  return Type::Number();
-}
-
-Type* Typer::Visitor::TypeSpeculativeNumberDivide(Node* node) {
-  return Type::Number();
-}
-
-Type* Typer::Visitor::TypeSpeculativeNumberModulus(Node* node) {
-  return Type::Number();
-}
-
-Type* Typer::Visitor::TypeSpeculativeNumberShiftLeft(Node* node) {
-  return Type::Signed32();
-}
-
-Type* Typer::Visitor::TypeSpeculativeNumberShiftRight(Node* node) {
-  return Type::Signed32();
-}
-
-Type* Typer::Visitor::TypeSpeculativeNumberShiftRightLogical(Node* node) {
-  return Type::Unsigned32();
-}
-
-Type* Typer::Visitor::TypeSpeculativeNumberBitwiseOr(Node* node) {
-  return Type::Signed32();
-}
-
-Type* Typer::Visitor::TypeSpeculativeNumberBitwiseXor(Node* node) {
-  return Type::Signed32();
-}
-
-Type* Typer::Visitor::TypeSpeculativeNumberBitwiseAnd(Node* node) {
-  return Type::Signed32();
-}
-
-Type* Typer::Visitor::TypeNumberMultiply(Node* node) { return Type::Number(); }
-
-Type* Typer::Visitor::TypeNumberDivide(Node* node) { return Type::Number(); }
-
-Type* Typer::Visitor::TypeNumberModulus(Node* node) { return Type::Number(); }
-
-Type* Typer::Visitor::TypeNumberBitwiseOr(Node* node) {
-  return Type::Signed32();
-}
-
-
-Type* Typer::Visitor::TypeNumberBitwiseXor(Node* node) {
-  return Type::Signed32();
-}
-
-
-Type* Typer::Visitor::TypeNumberBitwiseAnd(Node* node) {
-  return Type::Signed32();
-}
-
-
-Type* Typer::Visitor::TypeNumberShiftLeft(Node* node) {
-  return Type::Signed32();
-}
-
-
-Type* Typer::Visitor::TypeNumberShiftRight(Node* node) {
-  return Type::Signed32();
-}
-
-
-Type* Typer::Visitor::TypeNumberShiftRightLogical(Node* node) {
-  return Type::Unsigned32();
-}
-
 Type* Typer::Visitor::TypePlainPrimitiveToNumber(Node* node) {
   return TypeUnaryOp(node, ToNumber);
 }
 
 Type* Typer::Visitor::TypePlainPrimitiveToWord32(Node* node) {
   return Type::Integral32();
 }
 
 Type* Typer::Visitor::TypePlainPrimitiveToFloat64(Node* node) {
   return Type::Number();
 }
 
-Type* Typer::Visitor::TypeNumberImul(Node* node) { return Type::Signed32(); }
-
-Type* Typer::Visitor::TypeNumberAbs(Node* node) {
-  return typer_->operation_typer()->NumberAbs(Operand(node, 0));
-}
-
-Type* Typer::Visitor::TypeNumberClz32(Node* node) {
-  return typer_->cache_.kZeroToThirtyTwo;
-}
-
-Type* Typer::Visitor::TypeNumberCeil(Node* node) {
-  return TypeUnaryOp(node, NumberCeil);
-}
-
-Type* Typer::Visitor::TypeNumberFloor(Node* node) {
-  return TypeUnaryOp(node, NumberFloor);
-}
-
-Type* Typer::Visitor::TypeNumberFround(Node* node) { return Type::Number(); }
-
-Type* Typer::Visitor::TypeNumberSign(Node* node) {
-  return TypeUnaryOp(node, NumberSign);
-}
-
-Type* Typer::Visitor::TypeNumberAcos(Node* node) { return Type::Number(); }
-
-Type* Typer::Visitor::TypeNumberAcosh(Node* node) { return Type::Number(); }
-
-Type* Typer::Visitor::TypeNumberAsin(Node* node) { return Type::Number(); }
-
-Type* Typer::Visitor::TypeNumberAsinh(Node* node) { return Type::Number(); }
-
-Type* Typer::Visitor::TypeNumberAtan(Node* node) { return Type::Number(); }
-
-Type* Typer::Visitor::TypeNumberAtanh(Node* node) { return Type::Number(); }
-
-Type* Typer::Visitor::TypeNumberAtan2(Node* node) { return Type::Number(); }
-
-Type* Typer::Visitor::TypeNumberCos(Node* node) { return Type::Number(); }
-
-Type* Typer::Visitor::TypeNumberCosh(Node* node) { return Type::Number(); }
-
-Type* Typer::Visitor::TypeNumberExp(Node* node) {
-  return Type::Union(Type::PlainNumber(), Type::NaN(), zone());
-}
-
-// TODO(mvstanton): Is this type sufficient, or should it look like Exp()?
-Type* Typer::Visitor::TypeNumberExpm1(Node* node) { return Type::Number(); }
-
-Type* Typer::Visitor::TypeNumberLog(Node* node) { return Type::Number(); }
-
-Type* Typer::Visitor::TypeNumberLog1p(Node* node) { return Type::Number(); }
-
-Type* Typer::Visitor::TypeNumberLog2(Node* node) { return Type::Number(); }
-
-Type* Typer::Visitor::TypeNumberLog10(Node* node) { return Type::Number(); }
-
-Type* Typer::Visitor::TypeNumberCbrt(Node* node) { return Type::Number(); }
-
-Type* Typer::Visitor::TypeNumberMax(Node* node) {
-  return TypeBinaryOp(node, NumberMax);
-}
-
-Type* Typer::Visitor::TypeNumberMin(Node* node) {
-  return TypeBinaryOp(node, NumberMin);
-}
-
-Type* Typer::Visitor::TypeNumberPow(Node* node) { return Type::Number(); }
-
-Type* Typer::Visitor::TypeNumberRound(Node* node) {
-  return TypeUnaryOp(node, NumberRound);
-}
-
-Type* Typer::Visitor::TypeNumberSin(Node* node) { return Type::Number(); }
-
-Type* Typer::Visitor::TypeNumberSinh(Node* node) { return Type::Number(); }
-
-Type* Typer::Visitor::TypeNumberSqrt(Node* node) { return Type::Number(); }
-
-Type* Typer::Visitor::TypeNumberTan(Node* node) { return Type::Number(); }
-
-Type* Typer::Visitor::TypeNumberTanh(Node* node) { return Type::Number(); }
-
-Type* Typer::Visitor::TypeNumberTrunc(Node* node) {
-  return TypeUnaryOp(node, NumberTrunc);
-}
-
-Type* Typer::Visitor::TypeNumberToInt32(Node* node) {
-  return TypeUnaryOp(node, NumberToInt32);
-}
-
-
-Type* Typer::Visitor::TypeNumberToUint32(Node* node) {
-  return TypeUnaryOp(node, NumberToUint32);
-}
-
-
 // static
 Type* Typer::Visitor::ReferenceEqualTyper(Type* lhs, Type* rhs, Typer* t) {
   if (lhs->IsConstant() && rhs->Is(lhs)) {
     return t->singleton_true_;
   }
   return Type::Boolean();
 }
 
 
 Type* Typer::Visitor::TypeReferenceEqual(Node* node) {
@@ skipping 390 matching lines @@
 
 Type* Typer::Visitor::TypeChangeFloat32ToFloat64(Node* node) {
   return Type::Intersect(Type::Number(), Type::UntaggedFloat64(), zone());
 }
 
 
 Type* Typer::Visitor::TypeChangeFloat64ToInt32(Node* node) {
   return Type::Intersect(Type::Signed32(), Type::UntaggedIntegral32(), zone());
 }
 
-Type* Typer::Visitor::TypeNumberSilenceNaN(Node* node) {
-  return Type::Number();
-}
-
 Type* Typer::Visitor::TypeChangeFloat64ToUint32(Node* node) {
   return Type::Intersect(Type::Unsigned32(), Type::UntaggedIntegral32(),
                          zone());
 }
 
 Type* Typer::Visitor::TypeTruncateFloat64ToUint32(Node* node) {
   return Type::Intersect(Type::Unsigned32(), Type::UntaggedIntegral32(),
                          zone());
 }
 
@@ skipping 416 matching lines @@
   }
   if (Type::IsInteger(*value)) {
     return Type::Range(value->Number(), value->Number(), zone());
   }
   return Type::Constant(value, zone());
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8