Don't flatten every time we call CharCodeAt

src/objects.cc

 // 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 5164 matching lines @@
   }
 }
 
 
 uint16_t ConsString::ConsStringGet(int index) {
   ASSERT(index >= 0 && index < this->length());
 
   // Check for a flattened cons string
   if (second()->length() == 0) {
     String* left = first();
-    return left->Get(index);
+    return FlatString::cast(left)->FlatStringGet(index);
   }
 
   String* string = String::cast(this);
 
   while (true) {
     if (StringShape(string).IsCons()) {
       ConsString* cons_string = ConsString::cast(string);
       String* left = cons_string->first();
       if (left->length() > index) {
         string = left;
       } else {
         index -= left->length();
         string = cons_string->second();
       }
     } else {
-      return string->Get(index);
+      return FlatString::cast(string)->FlatStringGet(index);
     }
   }
 
   UNREACHABLE();
   return 0;
 }
 
 
+MaybeObject* ConsString::ConsStringGetMayFlatten(int index) {
+  ASSERT(index >= 0);
+  ASSERT(index < this->length());
+
+  String* string = this;
+  if (this->GetIsolate()->ShouldFlattenString()) {
+    MaybeObject* flatten_result = this->TryFlatten();
+    if (flatten_result->IsFailure()) return flatten_result;
+    string = String::cast(flatten_result->ToObjectUnchecked());
+  } else {
+    int recurse_limit = 7;

[Vitaly Repeshko, 2011/05/12 15:54:53]

Make this a (documented) constant in ConsString.

+    String* cursor = string;
+    int index_in_cursor = index;
+    while (cursor->IsConsString()) {
+      ConsString* cons = ConsString::cast(cursor);
+      String* first = cons->first();
+      int first_length = first->length();
+      if (index_in_cursor < first_length) {
+        cursor = first;
+      } else {
+        cursor = cons->second();
+        index_in_cursor -= first_length;
+      }
+      if (--recurse_limit <= 0) {
+        MaybeObject* flatten_result = this->TryFlatten();
+        if (flatten_result->IsFailure()) return flatten_result;
+        cursor = String::cast(flatten_result->ToObjectUnchecked());

[Vitaly Repeshko, 2011/05/12 15:54:53]

It's more straightforward to simply return 
Smi::FromInt(String::cast(flatten_result->ToObjectUnchecked())->Get(index))
here.

+        index_in_cursor = index;
+        break;
+      }
+    }
+    string = cursor;
+    index = index_in_cursor;
+  }
+  return Smi::FromInt(string->Get(index));
+}
+
+
 template <typename sinkchar>
 void String::WriteToFlat(String* src,
                          sinkchar* sink,
                          int f,
                          int t) {
   String* source = src;
   int from = f;
   int to = t;
   while (true) {
     ASSERT(0 <= from && from <= to && to <= source->length());
@@ skipping 5202 matching lines @@
   if (break_point_objects()->IsUndefined()) return 0;
   // Single beak point.
   if (!break_point_objects()->IsFixedArray()) return 1;
   // Multiple break points.
   return FixedArray::cast(break_point_objects())->length();
 }
 #endif
 
 
 } }  // namespace v8::internal