De-virtualize AstString.

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 24 matching lines @@
 // AstString, AstValue and AstValueFactory are for storing strings and values
 // 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:
-  virtual ~AstString() {}
+  explicit AstString(bool is_raw) : is_raw_(is_raw) {}
+  ~AstString() {}
 
-  virtual int length() const = 0;
+  int length() const;
   bool IsEmpty() const { return length() == 0; }
 
   // Puts the string into the V8 heap.
-  virtual void Internalize(Isolate* isolate) = 0;
+  void Internalize(Isolate* isolate);
 
   // This function can be called after internalizing.
   V8_INLINE Handle<String> string() const {
     DCHECK(!string_.is_null());
     return string_;
   }
 
  protected:
+  // Poor-man's virtual dispatch to AstRawString / AstConsString. But faster!
+  bool is_raw_;

[Toon Verwaest, 2016/08/08 09:43:24]

You probably want to pack this better with fields in subclasses, using
BitField<>

   // This is null until the string is internalized.
   Handle<String> string_;
 };
 
 
 class AstRawString final : public AstString {
  public:
-  int length() const override {
+  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) override;
+  void Internalize(Isolate* isolate);
 
   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 is_one_byte_; }
   bool IsOneByteEqualTo(const char* data) const;
   uint16_t FirstCharacter() const {
     if (is_one_byte_)
       return literal_bytes_[0];
     const uint16_t* c =
         reinterpret_cast<const uint16_t*>(literal_bytes_.start());
     return *c;
   }
 
   // For storing AstRawStrings in a hash map.
   uint32_t hash() const {
     return hash_;
   }
 
  private:
   friend class AstValueFactory;
   friend class AstRawStringInternalizationKey;
 
   AstRawString(bool is_one_byte, const Vector<const byte>& literal_bytes,
-            uint32_t hash)
-      : is_one_byte_(is_one_byte), literal_bytes_(literal_bytes), hash_(hash) {}
+               uint32_t hash)
+      : AstString(true),
+        is_one_byte_(is_one_byte),
+        literal_bytes_(literal_bytes),
+        hash_(hash) {}
 
-  AstRawString()
-      : is_one_byte_(true),
-        hash_(0) {}
+  AstRawString() : AstString(true), is_one_byte_(true), hash_(0) {}
 
   bool is_one_byte_;
 
   // Points to memory owned by Zone.
   Vector<const byte> literal_bytes_;
   uint32_t hash_;
 };
 
 
 class AstConsString final : public AstString {
  public:
   AstConsString(const AstString* left, const AstString* right)
-      : length_(left->length() + right->length()), left_(left), right_(right) {}
+      : AstString(false),
+        length_(left->length() + right->length()),
+        left_(left),
+        right_(right) {}
 
-  int length() const override { return length_; }
+  int length() const { return length_; }
 
-  void Internalize(Isolate* isolate) override;
+  void Internalize(Isolate* isolate);
 
  private:
   const int length_;
   const AstString* left_;
   const AstString* right_;
 };
 
 
 // AstValue is either a string, a number, a string array, a boolean, or a
 // special value (null, undefined, the hole).
@@ skipping 249 matching lines @@
   OTHER_CONSTANTS(F)
 #undef F
 };
 }  // namespace internal
 }  // namespace v8
 
 #undef STRING_CONSTANTS
 #undef OTHER_CONSTANTS
 
 #endif  // V8_AST_AST_VALUE_FACTORY_H_