De-virtualize AstString.

src/ast/ast-value-factory.cc

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 40 matching lines @@
 };
 
 }  // namespace
 
 class AstRawStringInternalizationKey : public HashTableKey {
  public:
   explicit AstRawStringInternalizationKey(const AstRawString* string)
       : string_(string) {}
 
   bool IsMatch(Object* other) override {
-    if (string_->is_one_byte_)
+    if (string_->is_one_byte())
       return String::cast(other)->IsOneByteEqualTo(string_->literal_bytes_);
     return String::cast(other)->IsTwoByteEqualTo(
         Vector<const uint16_t>::cast(string_->literal_bytes_));
   }
 
   uint32_t Hash() override { return string_->hash() >> Name::kHashShift; }
 
   uint32_t HashForObject(Object* key) override {
     return String::cast(key)->Hash();
   }
 
   Handle<Object> AsHandle(Isolate* isolate) override {
-    if (string_->is_one_byte_)
+    if (string_->is_one_byte())
       return isolate->factory()->NewOneByteInternalizedString(
           string_->literal_bytes_, string_->hash());
     return isolate->factory()->NewTwoByteInternalizedString(
         Vector<const uint16_t>::cast(string_->literal_bytes_), string_->hash());
   }
 
  private:
   const AstRawString* string_;
 };
 
+int AstString::length() const {
+  if (IsRawStringBits::decode(bit_field_)) {
+    return reinterpret_cast<const AstRawString*>(this)->length();
+  }
+  return reinterpret_cast<const AstConsString*>(this)->length();
+}
+
+void AstString::Internalize(Isolate* isolate) {
+  if (IsRawStringBits::decode(bit_field_)) {
+    return reinterpret_cast<AstRawString*>(this)->Internalize(isolate);
+  }
+  return reinterpret_cast<AstConsString*>(this)->Internalize(isolate);
+}
 
 void AstRawString::Internalize(Isolate* isolate) {
   if (!string_.is_null()) return;
   if (literal_bytes_.length() == 0) {
     string_ = isolate->factory()->empty_string();
   } else {
     AstRawStringInternalizationKey key(this);
     string_ = StringTable::LookupKey(isolate, &key);
   }
 }
 
 
 bool AstRawString::AsArrayIndex(uint32_t* index) const {
   if (!string_.is_null())
     return string_->AsArrayIndex(index);
-  if (!is_one_byte_ || literal_bytes_.length() == 0 ||
+  if (!is_one_byte() || literal_bytes_.length() == 0 ||
       literal_bytes_.length() > String::kMaxArrayIndexSize)
     return false;
   OneByteStringStream stream(literal_bytes_);
   return StringToArrayIndex(&stream, index);
 }
 
 
 bool AstRawString::IsOneByteEqualTo(const char* data) const {
   int length = static_cast<int>(strlen(data));
-  if (is_one_byte_ && literal_bytes_.length() == length) {
+  if (is_one_byte() && literal_bytes_.length() == length) {
     const char* token = reinterpret_cast<const char*>(literal_bytes_.start());
     return !strncmp(token, data, length);
   }
   return false;
 }
 
 
 void AstConsString::Internalize(Isolate* isolate) {
   // AstRawStrings are internalized before AstConsStrings so left and right are
   // already internalized.
@@ skipping 285 matching lines @@
                                   length) == 0;
     } else {
       return CompareCharsUnsigned(reinterpret_cast<const uint16_t*>(l),
                                   reinterpret_cast<const uint16_t*>(r),
                                   length) == 0;
     }
   }
 }
 }  // namespace internal
 }  // namespace v8