Overlay next_ and value_/string_ in AstValue/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 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();
+    set_string(isolate->factory()->empty_string());
   } else {
     AstRawStringInternalizationKey key(this);
-    string_ = StringTable::LookupKey(isolate, &key);
+    set_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
   // figure out whether the string is convertible to an array index.
   if ((hash_ & Name::kIsNotArrayIndexMask) != 0) return false;
   if (length() <= Name::kMaxCachedArrayIndexLength) {
     *index = Name::ArrayIndexValueBits::decode(hash_);
   } else {
     OneByteStringStream stream(literal_bytes_);
     CHECK(StringToArrayIndex(&stream, index));
   }
   return true;
 }
 
 bool AstRawString::IsOneByteEqualTo(const char* data) const {
   int length = static_cast<int>(strlen(data));
   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.
-  string_ = isolate->factory()
-                ->NewConsString(left_->string(), right_->string())
-                .ToHandleChecked();
+  set_string(isolate->factory()
+                 ->NewConsString(left_->string(), right_->string())
+                 .ToHandleChecked());
 }
 
 bool AstValue::IsPropertyName() const {
   if (type_ == STRING) {
     uint32_t index;
     return !string_->AsArrayIndex(&index);
   }
   return false;
 }
 
@@ skipping 23 matching lines @@
       return false;
   }
   UNREACHABLE();
   return false;
 }
 
 
 void AstValue::Internalize(Isolate* isolate) {
   switch (type_) {
     case STRING:
-      DCHECK(string_ != NULL);
+      DCHECK_NOT_NULL(string_);
       // Strings are already internalized.
       DCHECK(!string_->string().is_null());
       break;
     case SYMBOL:
       if (symbol_name_[0] == 'i') {
         DCHECK_EQ(0, strcmp(symbol_name_, "iterator_symbol"));
-        value_ = isolate->factory()->iterator_symbol();
+        set_value(isolate->factory()->iterator_symbol());
       } else if (strcmp(symbol_name_, "hasInstance_symbol") == 0) {
-        value_ = isolate->factory()->has_instance_symbol();
+        set_value(isolate->factory()->has_instance_symbol());
       } else {
         DCHECK_EQ(0, strcmp(symbol_name_, "home_object_symbol"));
-        value_ = isolate->factory()->home_object_symbol();
+        set_value(isolate->factory()->home_object_symbol());
       }
       break;
     case NUMBER_WITH_DOT:
     case NUMBER:
-      value_ = isolate->factory()->NewNumber(number_, TENURED);
+      set_value(isolate->factory()->NewNumber(number_, TENURED));
       break;
     case SMI_WITH_DOT:
     case SMI:
-      value_ = handle(Smi::FromInt(smi_), isolate);
+      set_value(handle(Smi::FromInt(smi_), isolate));
       break;
     case BOOLEAN:
       if (bool_) {
-        value_ = isolate->factory()->true_value();
+        set_value(isolate->factory()->true_value());
       } else {
-        value_ = isolate->factory()->false_value();
+        set_value(isolate->factory()->false_value());
       }
       break;
     case NULL_TYPE:
-      value_ = isolate->factory()->null_value();
+      set_value(isolate->factory()->null_value());
       break;
     case THE_HOLE:
-      value_ = isolate->factory()->the_hole_value();
+      set_value(isolate->factory()->the_hole_value());
       break;
     case UNDEFINED:
-      value_ = isolate->factory()->undefined_value();
+      set_value(isolate->factory()->undefined_value());
       break;
   }
 }
 
 
 AstRawString* AstValueFactory::GetOneByteStringInternal(
     Vector<const uint8_t> literal) {
   uint32_t hash = StringHasher::HashSequentialString<uint8_t>(
       literal.start(), literal.length(), hash_seed_);
   return GetString(hash, true, literal);
@@ skipping 21 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);
-  AddConsString(new_string);
+  AddString(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. 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();
+  // strings.
+  for (AstString* current = strings_; current != nullptr;) {
+    AstString* next = current->next();
     current->Internalize(isolate);
     current = next;
   }
 
   for (AstValue* current = values_; current != nullptr;) {
     AstValue* next = current->next();
     current->Internalize(isolate);
     current = next;
   }
-  ResetConsStrings();
+  ResetStrings();
   values_ = nullptr;
 }
 
 
 const AstValue* AstValueFactory::NewString(const AstRawString* string) {
   AstValue* value = new (zone_) AstValue(string);
-  CHECK(string != nullptr);
+  CHECK_NOT_NULL(string);
   return AddValue(value);
 }
 
 
 const AstValue* AstValueFactory::NewSymbol(const char* name) {
   AstValue* value = new (zone_) AstValue(name);
   return AddValue(value);
 }
 
 
@@ skipping 49 matching lines @@
   // return this AstRawString.
   AstRawString key(is_one_byte, literal_bytes, hash);
   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);
+    CHECK_NOT_NULL(new_string);
+    AddString(new_string);
     entry->key = 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);
@@ skipping 19 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