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 5163 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()) {

[Vitaly Repeshko, 2011/05/10 13:07:02]

Here "this" can already be a flat cons (i.e. with empty second). We shouldn't
update the isolate counter in this case. Maybe ShouldFlattenString() should take
a string argument.

[Lasse Reichstein, 2011/05/10 16:27:46]

Good point. We should probably not get here for a flat string.

+    MaybeObject* flatten_result = this->TryFlatten();
+    if (flatten_result->IsFailure()) return flatten_result;
+    string = String::cast(flatten_result->ToObjectUnchecked());
+  }
+  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