Don't flatten every time we call CharCodeAt

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 61 matching lines @@
 //         - HashTable
 //           - Dictionary
 //           - SymbolTable
 //           - CompilationCacheTable
 //           - CodeCacheHashTable
 //           - MapCache
 //         - Context
 //         - JSFunctionResultCache
 //         - SerializedScopeInfo
 //       - String
-//         - SeqString
-//           - SeqAsciiString
-//           - SeqTwoByteString
 //         - ConsString
-//         - ExternalString
-//           - ExternalAsciiString
-//           - ExternalTwoByteString
+//         - FlatString
+//           - SeqString
+//             - SeqAsciiString
+//             - SeqTwoByteString
+//           - ExternalString
+//             - ExternalAsciiString
+//             - ExternalTwoByteString
 //       - HeapNumber
 //       - Code
 //       - Map
 //       - Oddball
 //       - Proxy
 //       - SharedFunctionInfo
 //       - Struct
 //         - AccessorInfo
 //         - AccessCheckInfo
 //         - InterceptorInfo
@@ skipping 575 matching lines @@
 
 #define OBJECT_TYPE_LIST(V)                    \
   V(Smi)                                       \
   V(HeapObject)                                \
   V(Number)                                    \
 
 #define HEAP_OBJECT_TYPE_LIST(V)               \
   V(HeapNumber)                                \
   V(String)                                    \
   V(Symbol)                                    \
+  V(FlatString)                                \
   V(SeqString)                                 \
   V(ExternalString)                            \
   V(ConsString)                                \
   V(ExternalTwoByteString)                     \
   V(ExternalAsciiString)                       \
   V(SeqTwoByteString)                          \
   V(SeqAsciiString)                            \
                                                \
   V(ExternalArray)                             \
   V(ExternalByteArray)                         \
@@ skipping 4652 matching lines @@
   // NOTE: this should be considered only a hint.  False negatives are
   // possible.
   inline bool HasOnlyAsciiChars();
 
   // 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);
 
+  // Try to get a character (smi encoded) from the string.
+  // The method may try to flatten the string, or part of the string.
+  inline MaybeObject* GetMayFlatten(int index);
+
   // 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 267 matching lines @@
   // Slow case of AsArrayIndex.
   bool SlowAsArrayIndex(uint32_t* index);
 
   // Compute and set the hash code.
   uint32_t ComputeAndSetHash();
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(String);
 };
 
 
+class FlatString: public String {
+ public:
+  // Casting.
+  static inline FlatString* cast(Object* obj);
+
+  // Get a character from a flat string.
+  inline uint16_t FlatStringGet(int index);
+
+ private:
+  DISALLOW_IMPLICIT_CONSTRUCTORS(FlatString);
+};
+
+
 // The SeqString abstract class captures sequential string values.
-class SeqString: public String {
+class SeqString: public FlatString {
  public:
-
   // Casting.
   static inline SeqString* cast(Object* obj);
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(SeqString);
 };
 
 
 // The AsciiString class captures sequential ascii string objects.
 // Each character in the AsciiString is an ascii character.
@@ skipping 118 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);
+  MaybeObject* ConsStringGetMayFlatten(int index);
 
   // 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 17 matching lines @@
 
 // The ExternalString class describes string values that are backed by
 // a string resource that lies outside the V8 heap.  ExternalStrings
 // consist of the length field common to all strings, a pointer to the
 // external resource.  It is important to ensure (externally) that the
 // 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 {
+class ExternalString: public FlatString {
  public:
   // Casting
   static inline ExternalString* cast(Object* obj);
 
   // Layout description.
   static const int kResourceOffset = POINTER_SIZE_ALIGN(String::kSize);
   static const int kSize = kResourceOffset + kPointerSize;
 
   STATIC_CHECK(kResourceOffset == Internals::kStringResourceOffset);
 
@@ skipping 879 matching lines @@
     } else {
       value &= ~(1 << bit_position);
     }
     return value;
   }
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_H_