Make the AstValueFactory more efficient and less memory hungry

src/ast/ast-value-factory.h

 // 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 25 matching lines @@
 // independent of the V8 heap and internalizing them later. During parsing,
 // AstStrings and AstValues are created and stored outside the heap, in
 // AstValueFactory. After parsing, the strings and values are internalized
 // (moved into the V8 heap).
 namespace v8 {
 namespace internal {
 
 class AstString : public ZoneObject {
  public:
   explicit AstString(bool is_raw)
-      : bit_field_(IsRawStringBits::encode(is_raw)) {}
-
-  ~AstString() {}
+      : next_(nullptr), bit_field_(IsRawStringBits::encode(is_raw)) {}
 
   int length() const;
   bool IsEmpty() const { return length() == 0; }
 
   // Puts the string into the V8 heap.
   void Internalize(Isolate* isolate);
 
   // This function can be called after internalizing.
   V8_INLINE Handle<String> string() const {
     DCHECK(!string_.is_null());
     return string_;
   }
 
+  AstString** next_location() { return &next_; }
+  AstString* next() const { return next_; }
+
  protected:
-  // This is null until the string is internalized.
+  // Handle<String>::null() until internalized.
   Handle<String> string_;
+  AstString* next_;
   // Poor-man's virtual dispatch to AstRawString / AstConsString. Takes less
   // memory.
   class IsRawStringBits : public BitField<bool, 0, 1> {};
   int bit_field_;
 };
 
 
 class AstRawString final : public AstString {
  public:
   int length() const {
     if (is_one_byte()) return literal_bytes_.length();
     return literal_bytes_.length() / 2;
   }
 
   int byte_length() const { return literal_bytes_.length(); }
 
   void Internalize(Isolate* isolate);
 
-  bool AsArrayIndex(uint32_t* index, HandleDereferenceMode deref_mode =
-                                         HandleDereferenceMode::kAllowed) const;
+  bool AsArrayIndex(uint32_t* index) const;
 
   // The string is not null-terminated, use length() to find out the length.
   const unsigned char* raw_data() const {
     return literal_bytes_.start();
   }
 
   bool is_one_byte() const { return IsOneByteBits::decode(bit_field_); }
 
   bool IsOneByteEqualTo(const char* data) const;
   uint16_t FirstCharacter() const {
@@ skipping 79 matching lines @@
 
   Smi* AsSmi() const {
     CHECK_EQ(SMI, type_);
     return Smi::FromInt(smi_);
   }
 
   bool EqualsString(const AstRawString* string) const {
     return type_ == STRING && string_ == string;
   }
 
-  bool IsPropertyName(
-      HandleDereferenceMode deref_mode = HandleDereferenceMode::kAllowed) const;
+  bool IsPropertyName() const;
 
   bool BooleanValue() const;
 
   bool IsSmi() const { return type_ == SMI; }
   bool IsFalse() const { return type_ == BOOLEAN && !bool_; }
   bool IsTrue() const { return type_ == BOOLEAN && bool_; }
   bool IsUndefined() const { return type_ == UNDEFINED; }
   bool IsTheHole() const { return type_ == THE_HOLE; }
   bool IsNull() const { return type_ == NULL_TYPE; }
 
   void Internalize(Isolate* isolate);
 
   // Can be called after Internalize has been called.
   V8_INLINE Handle<Object> value() const {
     if (type_ == STRING) {
       return string_->string();
     }
     DCHECK(!value_.is_null());
     return value_;
   }
+  AstValue* next() const { return next_; }
+  void set_next(AstValue* next) { next_ = next; }
 
  private:
   friend class AstValueFactory;
 
   enum Type {
     STRING,
     SYMBOL,
     NUMBER,
     NUMBER_WITH_DOT,
     SMI,
     BOOLEAN,
     NULL_TYPE,
     UNDEFINED,
     THE_HOLE
   };
 
-  explicit AstValue(const AstRawString* s) : type_(STRING) { string_ = s; }
+  explicit AstValue(const AstRawString* s) : type_(STRING), next_(nullptr) {
+    string_ = s;
+  }
 
-  explicit AstValue(const char* name) : type_(SYMBOL) { symbol_name_ = name; }
+  explicit AstValue(const char* name) : type_(SYMBOL), next_(nullptr) {
+    symbol_name_ = name;
+  }
 
-  explicit AstValue(double n, bool with_dot) {
+  explicit AstValue(double n, bool with_dot) : next_(nullptr) {
     if (with_dot) {
       type_ = NUMBER_WITH_DOT;
       number_ = n;
     } else {
       int int_value;
       if (DoubleToSmiInteger(n, &int_value)) {
         type_ = SMI;
         smi_ = int_value;
       } else {
         type_ = NUMBER;
         number_ = n;
       }
     }
   }
 
-  AstValue(Type t, int i) : type_(t) {
+  AstValue(Type t, int i) : type_(t), next_(nullptr) {
     DCHECK(type_ == SMI);
     smi_ = i;
   }
 
-  explicit AstValue(bool b) : type_(BOOLEAN) { bool_ = b; }
+  explicit AstValue(bool b) : type_(BOOLEAN), next_(nullptr) { bool_ = b; }
 
-  explicit AstValue(Type t) : type_(t) {
+  explicit AstValue(Type t) : type_(t), next_(nullptr) {
     DCHECK(t == NULL_TYPE || t == UNDEFINED || t == THE_HOLE);
   }
 
   Type type_;
 
   // Uninternalized value.
   union {
     const AstRawString* string_;
     double number_;
     int smi_;
     bool bool_;
-    ZoneList<const AstRawString*>* strings_;
+    const AstRawString* strings_;
     const char* symbol_name_;
   };
 
-  // Internalized value (empty before internalized).
+  // Handle<String>::null() until internalized.
   Handle<Object> value_;
+  AstValue* next_;
 };
 
 
 // For generating constants.
 #define STRING_CONSTANTS(F)                     \
   F(anonymous_function, "(anonymous function)") \
   F(arguments, "arguments")                     \
   F(async, "async")                             \
   F(await, "await")                             \
   F(constructor, "constructor")                 \
@@ skipping 32 matching lines @@
   F(true_value)            \
   F(false_value)           \
   F(null_value)            \
   F(undefined_value)       \
   F(the_hole_value)
 
 class AstValueFactory {
  public:
   AstValueFactory(Zone* zone, uint32_t hash_seed)
       : string_table_(AstRawStringCompare),
+        values_(nullptr),
+        strings_end_(&strings_),
         zone_(zone),
         isolate_(NULL),
         hash_seed_(hash_seed) {
+    ResetStrings();
 #define F(name, str) name##_string_ = NULL;
     STRING_CONSTANTS(F)
 #undef F
 #define F(name) name##_ = NULL;
     OTHER_CONSTANTS(F)
 #undef F
   }
 
   Zone* zone() const { return zone_; }
 
@@ skipping 34 matching lines @@
   const AstValue* NewSymbol(const char* name);
   const AstValue* NewNumber(double number, bool with_dot = false);
   const AstValue* NewSmi(int number);
   const AstValue* NewBoolean(bool b);
   const AstValue* NewStringList(ZoneList<const AstRawString*>* strings);
   const AstValue* NewNull();
   const AstValue* NewUndefined();
   const AstValue* NewTheHole();
 
  private:
+  AstValue* AddValue(AstValue* value) {
+    if (isolate_) {
+      value->Internalize(isolate_);
+    } else {
+      value->set_next(values_);
+      values_ = value;
+    }
+    return value;
+  }
+  AstString* AddString(AstString* string) {
+    if (isolate_) {
+      string->Internalize(isolate_);
+    } else {
+      *strings_end_ = string;
+      strings_end_ = string->next_location();
+    }
+    return string;
+  }
+  void ResetStrings() {
+    strings_ = nullptr;
+    strings_end_ = &strings_;
+  }
   AstRawString* GetOneByteStringInternal(Vector<const uint8_t> literal);
   AstRawString* GetTwoByteStringInternal(Vector<const uint16_t> literal);
   AstRawString* GetString(uint32_t hash, bool is_one_byte,
                           Vector<const byte> literal_bytes);
 
   static bool AstRawStringCompare(void* a, void* b);
 
   // All strings are copied here, one after another (no NULLs inbetween).
   base::HashMap string_table_;
   // For keeping track of all AstValues and AstRawStrings we've created (so that
   // they can be internalized later).
-  List<AstValue*> values_;
-  List<AstString*> strings_;
+  AstValue* values_;
+  // We need to keep track of strings_ in order, since cons strings require
+  // their members to be internalized first.
+  AstString* strings_;
+  AstString** strings_end_;
   Zone* zone_;
   Isolate* isolate_;
 
   uint32_t hash_seed_;
 
 #define F(name, str) const AstRawString* name##_string_;
   STRING_CONSTANTS(F)
 #undef F
 
 #define F(name) AstValue* name##_;
   OTHER_CONSTANTS(F)
 #undef F
 };
 }  // namespace internal
 }  // namespace v8
 
 #undef STRING_CONSTANTS
 #undef OTHER_CONSTANTS
 
 #endif  // V8_AST_AST_VALUE_FACTORY_H_