[Turbofan] Introduce OtherNumberConstant.

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 <iomanip>
 
 #include "src/base/flags.h"
 #include "src/bootstrapper.h"
@@ skipping 23 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();
 
-  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);
+  singleton_false_ = Type::HeapConstant(factory->false_value(), zone);
+  singleton_true_ = Type::HeapConstant(factory->true_value(), zone);
+  singleton_the_hole_ = Type::HeapConstant(factory->the_hole_value(), 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 540 matching lines @@
 }
 
 
 Type* Typer::Visitor::TypeFloat64Constant(Node* node) {
   UNREACHABLE();
   return nullptr;
 }
 
 
 Type* Typer::Visitor::TypeNumberConstant(Node* node) {
-  Factory* f = isolate()->factory();
   double number = OpParameter<double>(node);
-  if (Type::IsInteger(number)) {
-    return Type::Range(number, number, zone());
-  }
-  return Type::Constant(f->NewNumber(number), zone());
+  return Type::NewConstant(number, zone());
 }
 
-
 Type* Typer::Visitor::TypeHeapConstant(Node* node) {
   return TypeConstant(OpParameter<Handle<HeapObject>>(node));
 }
 
 
 Type* Typer::Visitor::TypeExternalConstant(Node* node) {
   return Type::Internal();
 }
 
 
@@ skipping 203 matching lines @@
 
 Type* Typer::Visitor::JSEqualTyper(Type* lhs, Type* rhs, Typer* t) {
   if (lhs->Is(Type::NaN()) || rhs->Is(Type::NaN())) return t->singleton_false_;
   if (lhs->Is(Type::NullOrUndefined()) && rhs->Is(Type::NullOrUndefined())) {
     return t->singleton_true_;
   }
   if (lhs->Is(Type::Number()) && rhs->Is(Type::Number()) &&
       (lhs->Max() < rhs->Min() || lhs->Min() > rhs->Max())) {
     return t->singleton_false_;
   }
-  if (lhs->IsConstant() && rhs->Is(lhs)) {
+  if (lhs->IsHeapConstant() && rhs->Is(lhs)) {
     // Types are equal and are inhabited only by a single semantic value,
     // which is not nan due to the earlier check.
     return t->singleton_true_;
   }
   return Type::Boolean();
 }
 
 
 Type* Typer::Visitor::JSNotEqualTyper(Type* lhs, Type* rhs, Typer* t) {
   return Invert(JSEqualTyper(lhs, rhs, t), t);
@@ skipping 16 matching lines @@
   if (!JSType(lhs)->Maybe(JSType(rhs))) return t->singleton_false_;
   if (lhs->Is(Type::NaN()) || rhs->Is(Type::NaN())) return t->singleton_false_;
   if (lhs->Is(Type::Number()) && rhs->Is(Type::Number()) &&
       (lhs->Max() < rhs->Min() || lhs->Min() > rhs->Max())) {
     return t->singleton_false_;
   }
   if ((lhs->Is(t->singleton_the_hole_) || rhs->Is(t->singleton_the_hole_)) &&
       !lhs->Maybe(rhs)) {
     return t->singleton_false_;
   }
-  if (lhs->IsConstant() && rhs->Is(lhs)) {
+  if (lhs->IsHeapConstant() && rhs->Is(lhs)) {
     // Types are equal and are inhabited only by a single semantic value,
     // which is not nan due to the earlier check.
     return t->singleton_true_;
   }
   return Type::Boolean();
 }
 
 
 Type* Typer::Visitor::JSStrictNotEqualTyper(Type* lhs, Type* rhs, Typer* t) {
   return Invert(JSStrictEqualTyper(lhs, rhs, t), t);
@@ skipping 13 matching lines @@
     return ComparisonOutcome(kComparisonTrue) |
            ComparisonOutcome(kComparisonFalse);
   }
   lhs = ToNumber(lhs, t);
   rhs = ToNumber(rhs, t);
 
   // Shortcut for NaNs.
   if (lhs->Is(Type::NaN()) || rhs->Is(Type::NaN())) return kComparisonUndefined;
 
   ComparisonOutcome result;
-  if (lhs->IsConstant() && rhs->Is(lhs)) {
+  if (lhs->IsHeapConstant() && rhs->Is(lhs)) {
     // Types are equal and are inhabited only by a single semantic value.
     result = kComparisonFalse;
   } else if (lhs->Min() >= rhs->Max()) {
     result = kComparisonFalse;
   } else if (lhs->Max() < rhs->Min()) {
     result = kComparisonTrue;
   } else {
     // We cannot figure out the result, return both true and false. (We do not
     // have to return undefined because that cannot affect the result of
     // FalsifyUndefined.)
@@ skipping 93 matching lines @@
   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());
+    return Type::HeapConstant(f->boolean_string(), t->zone());
   } else if (type->Is(Type::Number())) {
-    return Type::Constant(f->number_string(), t->zone());
+    return Type::HeapConstant(f->number_string(), t->zone());
   } else if (type->Is(Type::String())) {
-    return Type::Constant(f->string_string(), t->zone());
+    return Type::HeapConstant(f->string_string(), t->zone());
   } else if (type->Is(Type::Symbol())) {
-    return Type::Constant(f->symbol_string(), t->zone());
+    return Type::HeapConstant(f->symbol_string(), t->zone());
   } else if (type->Is(Type::Union(Type::Undefined(), Type::OtherUndetectable(),
                                   t->zone()))) {
-    return Type::Constant(f->undefined_string(), t->zone());
+    return Type::HeapConstant(f->undefined_string(), t->zone());
   } else if (type->Is(Type::Null())) {
-    return Type::Constant(f->object_string(), t->zone());
+    return Type::HeapConstant(f->object_string(), t->zone());
   } else if (type->Is(Type::Function())) {
-    return Type::Constant(f->function_string(), t->zone());
-  } else if (type->IsConstant()) {
-    return Type::Constant(
-        Object::TypeOf(t->isolate(), type->AsConstant()->Value()), t->zone());
+    return Type::HeapConstant(f->function_string(), t->zone());
+  } else if (type->IsHeapConstant()) {
+    return Type::HeapConstant(
+        Object::TypeOf(t->isolate(), type->AsHeapConstant()->Value()),
+        t->zone());
+  } else if (type->IsOtherNumberConstant()) {
+    return Type::HeapConstant(f->number_string(), t->zone());
   }
   return Type::InternalizedString();
 }
 
 
 Type* Typer::Visitor::TypeJSTypeOf(Node* node) {
   return TypeUnaryOp(node, JSTypeOfTyper);
 }
 
 
@@ skipping 234 matching lines @@
 
 // JS other operators.
 
 
 Type* Typer::Visitor::TypeJSCallConstruct(Node* node) {
   return Type::Receiver();
 }
 
 
 Type* Typer::Visitor::JSCallFunctionTyper(Type* fun, Typer* t) {
-  if (fun->IsConstant() && fun->AsConstant()->Value()->IsJSFunction()) {
+  if (fun->IsHeapConstant() && fun->AsHeapConstant()->Value()->IsJSFunction()) {
     Handle<JSFunction> function =
-        Handle<JSFunction>::cast(fun->AsConstant()->Value());
+        Handle<JSFunction>::cast(fun->AsHeapConstant()->Value());
     if (function->shared()->HasBuiltinFunctionId()) {
       switch (function->shared()->builtin_function_id()) {
         case kMathRandom:
           return Type::PlainNumber();
         case kMathFloor:
         case kMathCeil:
         case kMathRound:
         case kMathTrunc:
           return t->cache_.kIntegerOrMinusZeroOrNaN;
         // Unary math functions.
@@ skipping 222 matching lines @@
 Type* Typer::Visitor::TypePlainPrimitiveToWord32(Node* node) {
   return Type::Integral32();
 }
 
 Type* Typer::Visitor::TypePlainPrimitiveToFloat64(Node* node) {
   return Type::Number();
 }
 
 // static
 Type* Typer::Visitor::ReferenceEqualTyper(Type* lhs, Type* rhs, Typer* t) {
-  if (lhs->IsConstant() && rhs->Is(lhs)) {
+  if (lhs->IsHeapConstant() && rhs->Is(lhs)) {
     return t->singleton_true_;
   }
   return Type::Boolean();
 }
 
 
 Type* Typer::Visitor::TypeReferenceEqual(Node* node) {
   return TypeBinaryOp(node, ReferenceEqualTyper);
 }
 
 Type* Typer::Visitor::TypeStringEqual(Node* node) { return Type::Boolean(); }
 
 Type* Typer::Visitor::TypeStringLessThan(Node* node) { return Type::Boolean(); }
 
 Type* Typer::Visitor::TypeStringLessThanOrEqual(Node* node) {
   return Type::Boolean();
 }
 
 Type* Typer::Visitor::StringFromCharCodeTyper(Type* type, Typer* t) {
   type = NumberToUint32(ToNumber(type, t), t);
   Factory* f = t->isolate()->factory();
   double min = type->Min();
   double max = type->Max();
   if (min == max) {
     uint32_t code = static_cast<uint32_t>(min) & String::kMaxUtf16CodeUnitU;
     Handle<String> string = f->LookupSingleCharacterStringFromCode(code);
-    return Type::Constant(string, t->zone());
+    return Type::HeapConstant(string, t->zone());
   }
   return Type::String();
 }
 
 Type* Typer::Visitor::StringFromCodePointTyper(Type* type, Typer* t) {
   type = NumberToUint32(ToNumber(type, t), t);
   Factory* f = t->isolate()->factory();
   double min = type->Min();
   double max = type->Max();
   if (min == max) {
     uint32_t code = static_cast<uint32_t>(min) & String::kMaxUtf16CodeUnitU;
     Handle<String> string = f->LookupSingleCharacterStringFromCode(code);
-    return Type::Constant(string, t->zone());
+    return Type::HeapConstant(string, t->zone());
   }
   return Type::String();
 }
 
 Type* Typer::Visitor::TypeStringCharCodeAt(Node* node) {
   // TODO(bmeurer): We could do better here based on inputs.
   return Type::Range(0, kMaxUInt16, zone());
 }
 
 Type* Typer::Visitor::TypeStringFromCharCode(Node* node) {
@@ skipping 154 matching lines @@
 Type* Typer::Visitor::TypeArrayBufferWasNeutered(Node* node) {
   return Type::Boolean();
 }
 
 // Heap constants.
 
 Type* Typer::Visitor::TypeConstant(Handle<Object> value) {
   if (Type::IsInteger(*value)) {
     return Type::Range(value->Number(), value->Number(), zone());
   }
-  return Type::Constant(value, zone());
+  return Type::NewConstant(value, zone());
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8