Introduce read buffer for external strings when using charAt (ia32).

src/objects.h

 // Copyright 2011 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 223 matching lines @@
   V(EXTERNAL_ASCII_SYMBOL_TYPE)                                                \
   V(STRING_TYPE)                                                               \
   V(ASCII_STRING_TYPE)                                                         \
   V(CONS_STRING_TYPE)                                                          \
   V(CONS_ASCII_STRING_TYPE)                                                    \
   V(SLICED_STRING_TYPE)                                                        \
   V(EXTERNAL_STRING_TYPE)                                                      \
   V(EXTERNAL_STRING_WITH_ASCII_DATA_TYPE)                                      \
   V(EXTERNAL_ASCII_STRING_TYPE)                                                \
   V(PRIVATE_EXTERNAL_ASCII_STRING_TYPE)                                        \
-                                                                               \
+  V(EXTERNAL_BUFFERED_STRING_TYPE)                                             \
+  V(EXTERNAL_BUFFERED_STRING_WITH_ASCII_DATA_TYPE)                             \
+  V(EXTERNAL_BUFFERED_ASCII_STRING_TYPE)                                       \
   V(MAP_TYPE)                                                                  \
   V(CODE_TYPE)                                                                 \
   V(ODDBALL_TYPE)                                                              \
   V(JS_GLOBAL_PROPERTY_CELL_TYPE)                                              \
                                                                                \
   V(HEAP_NUMBER_TYPE)                                                          \
   V(FOREIGN_TYPE)                                                              \
   V(BYTE_ARRAY_TYPE)                                                           \
   V(FREE_SPACE_TYPE)                                                           \
   /* Note: the order of these external array */                                \
@@ skipping 113 matching lines @@
     ExternalTwoByteString::kSize,                                              \
     external_string,                                                           \
     ExternalString)                                                            \
   V(EXTERNAL_STRING_WITH_ASCII_DATA_TYPE,                                      \
     ExternalTwoByteString::kSize,                                              \
     external_string_with_ascii_data,                                           \
     ExternalStringWithAsciiData)                                               \
   V(EXTERNAL_ASCII_STRING_TYPE,                                                \
     ExternalAsciiString::kSize,                                                \
     external_ascii_string,                                                     \
-    ExternalAsciiString)
+    ExternalAsciiString)                                                       \
+  V(EXTERNAL_BUFFERED_SYMBOL_TYPE,                                             \
+    ExternalTwoByteString::kExtendedSize,                                      \
+    external_buffered_symbol,                                                  \
+    ExternalBufferedSymbol)                                                    \
+  V(EXTERNAL_BUFFERED_SYMBOL_WITH_ASCII_DATA_TYPE,                             \
+    ExternalTwoByteString::kExtendedSize,                                      \
+    external_buffered_symbol_with_ascii_data,                                  \
+    ExternalBufferedSymbolWithAsciiData)                                       \
+  V(EXTERNAL_BUFFERED_ASCII_SYMBOL_TYPE,                                       \
+    ExternalAsciiString::kExtendedSize,                                        \
+    external_buffered_ascii_symbol,                                            \
+    ExternalBufferedAsciiSymbol)                                               \
+  V(EXTERNAL_BUFFERED_STRING_TYPE,                                             \
+    ExternalTwoByteString::kExtendedSize,                                      \
+    external_buffered_string,                                                  \
+    ExternalBufferedString)                                                    \
+  V(EXTERNAL_BUFFERED_STRING_WITH_ASCII_DATA_TYPE,                             \
+    ExternalTwoByteString::kExtendedSize,                                      \
+    external_buffered_string_with_ascii_data,                                  \
+    ExternalBufferedStringWithAsciiData)                                       \
+  V(EXTERNAL_BUFFERED_ASCII_STRING_TYPE,                                       \
+    ExternalAsciiString::kExtendedSize,                                        \
+    external_buffered_ascii_string,                                            \
+    ExternalBufferedAsciiString)
 
 // A struct is a simple object a set of object-valued fields.  Including an
 // object type in this causes the compiler to generate most of the boilerplate
 // code for the class including allocation and garbage collection routines,
 // casts and predicates.  All you need to define is the class, methods and
 // object verification routines.  Easy, no?
 //
 // Note that for subtle reasons related to the ordering or numerical values of
 // type tags, elements in this list have to be added to the INSTANCE_TYPE_LIST
 // manually.
@@ skipping 63 matching lines @@
 // Use this mask to distinguish between cons and slice only after making
 // sure that the string is one of the two (an indirect string).
 const uint32_t kSlicedNotConsMask = kSlicedStringTag & ~kConsStringTag;
 STATIC_ASSERT(IS_POWER_OF_TWO(kSlicedNotConsMask) && kSlicedNotConsMask != 0);
 
 // If bit 7 is clear, then bit 3 indicates whether this two-byte
 // string actually contains ascii data.
 const uint32_t kAsciiDataHintMask = 0x08;
 const uint32_t kAsciiDataHintTag = 0x08;
 
+// In the case of external string, bit 4 indicates whether it has a buffer.
+const uint32_t kBufferedStringMask = 0x10;
+const uint32_t kBufferedStringTag = 0x10;
 
 // A ConsString with an empty string as the right side is a candidate
 // for being shortcut by the garbage collector unless it is a
 // symbol. It's not common to have non-flat symbols, so we do not
 // shortcut them thereby avoiding turning symbols into strings. See
 // heap.cc and mark-compact.cc.
 const uint32_t kShortcutTypeMask =
     kIsNotStringMask |
     kIsSymbolMask |
     kStringRepresentationMask;
@@ skipping 13 matching lines @@
       kAsciiStringTag | kSymbolTag | kExternalStringTag,
   STRING_TYPE = kTwoByteStringTag | kSeqStringTag,
   ASCII_STRING_TYPE = kAsciiStringTag | kSeqStringTag,
   CONS_STRING_TYPE = kTwoByteStringTag | kConsStringTag,
   CONS_ASCII_STRING_TYPE = kAsciiStringTag | kConsStringTag,
   SLICED_STRING_TYPE = kTwoByteStringTag | kSlicedStringTag,
   SLICED_ASCII_STRING_TYPE = kAsciiStringTag | kSlicedStringTag,
   EXTERNAL_STRING_TYPE = kTwoByteStringTag | kExternalStringTag,
   EXTERNAL_STRING_WITH_ASCII_DATA_TYPE =
       kTwoByteStringTag | kExternalStringTag | kAsciiDataHintTag,
-  // LAST_STRING_TYPE
   EXTERNAL_ASCII_STRING_TYPE = kAsciiStringTag | kExternalStringTag,
   PRIVATE_EXTERNAL_ASCII_STRING_TYPE = EXTERNAL_ASCII_STRING_TYPE,
+  EXTERNAL_BUFFERED_SYMBOL_TYPE =
+      kTwoByteStringTag | kExternalStringTag |
+      kBufferedStringTag | kSymbolTag,
+  EXTERNAL_BUFFERED_SYMBOL_WITH_ASCII_DATA_TYPE =
+      kTwoByteStringTag | kExternalStringTag |
+      kAsciiDataHintTag | kBufferedStringTag | kSymbolTag,
+  // LAST_STRING_TYPE
+  EXTERNAL_BUFFERED_ASCII_SYMBOL_TYPE =
+      kAsciiStringTag | kExternalStringTag |
+      kBufferedStringTag | kSymbolTag,
+  EXTERNAL_BUFFERED_STRING_TYPE =
+      kTwoByteStringTag | kExternalStringTag | kBufferedStringTag,
+  EXTERNAL_BUFFERED_STRING_WITH_ASCII_DATA_TYPE =
+      kTwoByteStringTag | kExternalStringTag |
+      kAsciiDataHintTag | kBufferedStringTag,
+  // LAST_STRING_TYPE
+  EXTERNAL_BUFFERED_ASCII_STRING_TYPE =
+      kAsciiStringTag | kExternalStringTag | kBufferedStringTag,
+
 
   // Objects allocated in their own spaces (never in new space).
   MAP_TYPE = kNotStringTag,  // FIRST_NONSTRING_TYPE
   CODE_TYPE,
   ODDBALL_TYPE,
   JS_GLOBAL_PROPERTY_CELL_TYPE,
 
   // "Data", objects that cannot contain non-map-word pointers to heap
   // objects.
   HEAP_NUMBER_TYPE,
@@ skipping 5700 matching lines @@
   // Cons and slices have an encoding flag that may not represent the actual
   // encoding of the underlying string.  This is taken into account here.
   // Requires: this->IsFlat()
   inline bool IsAsciiRepresentationUnderneath();
   inline bool IsTwoByteRepresentationUnderneath();
 
   // NOTE: this should be considered only a hint.  False negatives are
   // possible.
   inline bool HasOnlyAsciiChars();
 
+  enum ExternalStringBufferFlag {
+    IGNORE_EXTERNAL_STRING_BUFFER,
+    UPDATE_EXTERNAL_STRING_BUFFER
+  };
+
   // Get and set individual two byte chars in the string.
   inline void Set(int index, uint16_t value);
   // Get individual two byte char in the string.  Repeated calls
   // to this method are not efficient unless the string is flat.
-  inline uint16_t Get(int index);
+  inline uint16_t Get(
+      int index, ExternalStringBufferFlag flag = IGNORE_EXTERNAL_STRING_BUFFER);
 
   // Try to flatten the string.  Checks first inline to see if it is
   // necessary.  Does nothing if the string is not a cons string.
   // Flattening allocates a sequential string with the same data as
   // the given string and mutates the cons string to a degenerate
   // form, where the first component is the new sequential string and
   // the second component is the empty string.  If allocation fails,
   // this function returns a failure.  If flattening succeeds, this
   // function returns the sequential string that is now the first
   // component of the cons string.
@@ skipping 414 matching lines @@
 
   // Second string of the cons cell.
   inline String* second();
   // Doesn't check that the result is a string, even in debug mode.  This is
   // useful during GC where the mark bits confuse the checks.
   inline Object* unchecked_second();
   inline void set_second(String* second,
                          WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
 
   // Dispatched behavior.
-  uint16_t ConsStringGet(int index);
+  uint16_t ConsStringGet(
+      int index, ExternalStringBufferFlag flag = IGNORE_EXTERNAL_STRING_BUFFER);
 
   // Casting.
   static inline ConsString* cast(Object* obj);
 
   // Layout description.
   static const int kFirstOffset = POINTER_SIZE_ALIGN(String::kSize);
   static const int kSecondOffset = kFirstOffset + kPointerSize;
   static const int kSize = kSecondOffset + kPointerSize;
 
   // Support for StringInputBuffer.
@@ skipping 32 matching lines @@
 //  - external strings as parent
 //  - truncating sliced string to enable otherwise unneeded parent to be GC'ed.
 class SlicedString: public String {
  public:
   inline String* parent();
   inline void set_parent(String* parent);
   inline int offset();
   inline void set_offset(int offset);
 
   // Dispatched behavior.
-  uint16_t SlicedStringGet(int index);
+  uint16_t SlicedStringGet(
+      int index, ExternalStringBufferFlag flag = IGNORE_EXTERNAL_STRING_BUFFER);
 
   // Casting.
   static inline SlicedString* cast(Object* obj);
 
   // Layout description.
   static const int kParentOffset = POINTER_SIZE_ALIGN(String::kSize);
   static const int kOffsetOffset = kParentOffset + kPointerSize;
   static const int kSize = kOffsetOffset + kPointerSize;
 
   // Support for StringInputBuffer
@@ skipping 26 matching lines @@
 // resource is not deallocated while the ExternalString is live in the
 // V8 heap.
 //
 // The API expects that all ExternalStrings are created through the
 // API.  Therefore, ExternalStrings should not be used internally.
 class ExternalString: public String {
  public:
   // Casting
   static inline ExternalString* cast(Object* obj);
 
+  // Read-ahead buffer.
+  inline Address buffer();
+  inline int buffer_index();
+  inline void set_buffer_index(int index);
+  inline bool IsBuffered();
+
   // Layout description.
   static const int kResourceOffset = POINTER_SIZE_ALIGN(String::kSize);
   static const int kSize = kResourceOffset + kPointerSize;
 
+  // Long external strings have a read-ahead buffer attached.
+  static const int kBufferIndexOffset = kSize;
+  static const int kBufferContentOffset = kBufferIndexOffset + kPointerSize;
+
+  static const int kBufferSize = 11 * kPointerSize;
+  static const int kExtendedSize = kBufferContentOffset + kBufferSize;
+  static const int kMinBufferedStringLength = 256;
+  static const int kInvalidBufferIndex = String::kMaxLength;
+
   STATIC_CHECK(kResourceOffset == Internals::kStringResourceOffset);
 
+#ifdef DEBUG
+  void ExternalStringVerify();
+#endif
+
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(ExternalString);
 };
 
 
 // The ExternalAsciiString class is an external string backed by an
 // ASCII string.
 class ExternalAsciiString: public ExternalString {
  public:
   static const bool kHasAsciiEncoding = true;
 
+  static const int kBufferedChars = kBufferSize / kASCIISize;
+  static const int kBackwardBufferedChars = kBufferedChars >> 2;
+  static const int kForwardBufferedChars =
+      kBufferedChars - kBackwardBufferedChars;
+
   typedef v8::String::ExternalAsciiStringResource Resource;
 
   // The underlying resource.
   inline const Resource* resource();
   inline void set_resource(const Resource* buffer);
 
   // Dispatched behavior.
-  uint16_t ExternalAsciiStringGet(int index);
+  uint16_t ExternalAsciiStringGet(
+      int index, ExternalStringBufferFlag flag = IGNORE_EXTERNAL_STRING_BUFFER);
 
   // Casting.
   static inline ExternalAsciiString* cast(Object* obj);
 
   // Garbage collection support.
   inline void ExternalAsciiStringIterateBody(ObjectVisitor* v);
 
   template<typename StaticVisitor>
   inline void ExternalAsciiStringIterateBody();
 
   // Support for StringInputBuffer.
   const unibrow::byte* ExternalAsciiStringReadBlock(unsigned* remaining,
                                                     unsigned* offset,
                                                     unsigned chars);
   inline void ExternalAsciiStringReadBlockIntoBuffer(ReadBlockBuffer* buffer,
                                                      unsigned* offset,
                                                      unsigned chars);
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(ExternalAsciiString);
 };
 
 
 // The ExternalTwoByteString class is an external string backed by a UTF-16
 // encoded string.
 class ExternalTwoByteString: public ExternalString {
  public:
   static const bool kHasAsciiEncoding = false;
 
+  static const int kBufferedChars = kBufferSize / kUC16Size;
+  static const int kBackwardBufferedChars = kBufferedChars >> 2;
+  static const int kForwardBufferedChars =
+      kBufferedChars - kBackwardBufferedChars;
+
   typedef v8::String::ExternalStringResource Resource;
 
   // The underlying string resource.
   inline const Resource* resource();
   inline void set_resource(const Resource* buffer);
 
   // Dispatched behavior.
-  uint16_t ExternalTwoByteStringGet(int index);
+  uint16_t ExternalTwoByteStringGet(
+      int index, ExternalStringBufferFlag flag = IGNORE_EXTERNAL_STRING_BUFFER);
 
   // For regexp code.
   const uint16_t* ExternalTwoByteStringGetData(unsigned start);
 
   // Casting.
   static inline ExternalTwoByteString* cast(Object* obj);
 
   // Garbage collection support.
   inline void ExternalTwoByteStringIterateBody(ObjectVisitor* v);
 
@@ skipping 1047 matching lines @@
     } else {
       value &= ~(1 << bit_position);
     }
     return value;
   }
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_H_