[turbofan] Quit storing strings in types.

src/compiler/types.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 <iomanip>
 
 #include "src/compiler/types.h"
 
 #include "src/handles-inl.h"
 #include "src/ostreams.h"
@@ skipping 388 matching lines @@
 // static
 bool OtherNumberConstantType::IsOtherNumberConstant(Object* value) {
   return value->IsHeapNumber() &&
          IsOtherNumberConstant(HeapNumber::cast(value)->value());
 }
 
 HeapConstantType::HeapConstantType(BitsetType::bitset bitset,
                                    i::Handle<i::HeapObject> object)
     : TypeBase(kHeapConstant), bitset_(bitset), object_(object) {
   DCHECK(!object->IsHeapNumber());
+  DCHECK(!object->IsString());
 }
 
 // -----------------------------------------------------------------------------
 // Predicates.
 
 bool Type::SimplyEquals(Type* that) {
   DisallowHeapAllocation no_allocation;
   if (this->IsHeapConstant()) {
     return that->IsHeapConstant() &&
            this->AsHeapConstant()->Value().address() ==
@@ skipping 355 matching lines @@
   DCHECK(OtherNumberConstantType::IsOtherNumberConstant(value));
   return OtherNumberConstant(value, zone);
 }
 
 Type* Type::NewConstant(i::Handle<i::Object> value, Zone* zone) {
   if (IsInteger(*value)) {
     double v = value->Number();
     return Range(v, v, zone);
   } else if (value->IsHeapNumber()) {
     return NewConstant(value->Number(), zone);
+  } else if (value->IsString()) {
+    bitset b = BitsetType::Lub(*value);
+    DCHECK(b == BitsetType::kInternalizedString ||
+           b == BitsetType::kOtherString);
+    if (b == BitsetType::kInternalizedString) {
+      return Type::InternalizedString();
+    } else if (b == BitsetType::kOtherString) {
+      return Type::OtherString();
+    } else {
+      UNREACHABLE();
+    }
   }
   return HeapConstant(i::Handle<i::HeapObject>::cast(value), zone);
 }
 
 Type* Type::Union(Type* type1, Type* type2, Zone* zone) {
   // Fast case: bit sets.
   if (type1->IsBitset() && type2->IsBitset()) {
     return BitsetType::New(type1->AsBitset() | type2->AsBitset());
   }
 
@@ skipping 200 matching lines @@
   return i::SmiValuesAre31Bits() ? kSigned31 : kSigned32;
 }
 
 BitsetType::bitset BitsetType::UnsignedSmall() {
   return i::SmiValuesAre31Bits() ? kUnsigned30 : kUnsigned31;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8