Internalize AstRawStrings by walking the string_table_ instead of adding them to a list

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 79 matching lines @@
 }
 
 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) {
+  // Skip over already internalized strings.
+  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 {
   // The StringHasher will set up the hash in such a way that we can use it to
@@ skipping 139 matching lines @@
   return result;
 }
 
 
 const AstConsString* AstValueFactory::NewConsString(
     const AstString* left, const AstString* right) {
   // This Vector will be valid as long as the Collector is alive (meaning that
   // the AstRawString will not be moved).
   AstConsString* new_string = new (zone_) AstConsString(left, right);
   CHECK(new_string != nullptr);
-  AddString(new_string);
+  AddConsString(new_string);
   return new_string;
 }
 
 const AstRawString* AstValueFactory::ConcatStrings(const AstRawString* left,
                                                    const AstRawString* right) {
   int left_length = left->length();
   int right_length = right->length();
   const unsigned char* left_data = left->raw_data();
   const unsigned char* right_data = right->raw_data();
   if (left->is_one_byte() && right->is_one_byte()) {
@@ skipping 18 matching lines @@
     } else {
       memcpy(buffer + left_length, right_data, 2 * right_length);
     }
     Vector<const uint16_t> literal(buffer, left_length + right_length);
     return GetTwoByteStringInternal(literal);
   }
 }
 
 void AstValueFactory::Internalize(Isolate* isolate) {
   // Strings need to be internalized before values, because values refer to
-  // strings.
-  for (AstString* current = strings_; current != nullptr;) {
-    AstString* next = current->next();
+  // strings. Internalize flat strings before cons strings since cons strings
+  // may point to flat strings.
+  for (base::CustomMatcherHashMap::Entry* entry = string_table_.Start();
+       entry != nullptr; entry = string_table_.Next(entry)) {
+    reinterpret_cast<AstRawString*>(entry->key)->Internalize(isolate);
+  }
+
+  for (AstConsString* current = cons_strings_; current != nullptr;) {
+    AstConsString* next = current->next();
     current->Internalize(isolate);
     current = next;
   }
+
   for (AstValue* current = values_; current != nullptr;) {
     AstValue* next = current->next();
     current->Internalize(isolate);
     current = next;
   }
-  ResetStrings();
+  ResetConsStrings();
   values_ = nullptr;
 }
 
 
 const AstValue* AstValueFactory::NewString(const AstRawString* string) {
   AstValue* value = new (zone_) AstValue(string);
   CHECK(string != nullptr);
   return AddValue(value);
 }
 
@@ skipping 58 matching lines @@
   base::HashMap::Entry* entry = string_table_.LookupOrInsert(&key, hash);
   if (entry->value == NULL) {
     // Copy literal contents for later comparison.
     int length = literal_bytes.length();
     byte* new_literal_bytes = zone_->NewArray<byte>(length);
     memcpy(new_literal_bytes, literal_bytes.start(), length);
     AstRawString* new_string = new (zone_) AstRawString(
         is_one_byte, Vector<const byte>(new_literal_bytes, length), hash);
     CHECK(new_string != nullptr);
     entry->key = new_string;
-    AddString(new_string);
     entry->value = reinterpret_cast<void*>(1);
   }
   return reinterpret_cast<AstRawString*>(entry->key);
 }
 
 
 bool AstValueFactory::AstRawStringCompare(void* a, void* b) {
   const AstRawString* lhs = static_cast<AstRawString*>(a);
   const AstRawString* rhs = static_cast<AstRawString*>(b);
   DCHECK_EQ(lhs->hash(), rhs->hash());
@@ skipping 18 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