Don't allocate handles for substrings when filling up the split result array.

src/runtime.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 5705 matching lines @@
     if (index < 0) return;
     indices->Add(index);
     index += pattern_length;
     limit--;
   }
 }
 
 
 RUNTIME_FUNCTION(MaybeObject*, Runtime_StringSplit) {
   ASSERT(args.length() == 3);
-  HandleScope handle_scope(isolate);
-  CONVERT_ARG_CHECKED(String, subject, 0);
-  CONVERT_ARG_CHECKED(String, pattern, 1);
+  CONVERT_CHECKED(String, subject, args[0]);
+  CONVERT_CHECKED(String, pattern, args[1]);
   CONVERT_NUMBER_CHECKED(uint32_t, limit, Uint32, args[2]);
 
   int subject_length = subject->length();
   int pattern_length = pattern->length();
   RUNTIME_ASSERT(pattern_length > 0);
 
   // The limit can be very large (0xffffffffu), but since the pattern
   // isn't empty, we can never create more parts than ~half the length
   // of the subject.
 
-  if (!subject->IsFlat()) FlattenString(subject);
-
+  if (!subject->IsFlat()) {
+    Object* flat;
+    { MaybeObject* maybe_flat = subject->TryFlatten();
+      if (!maybe_flat->ToObject(&flat)) return maybe_flat;
+    }
+    subject = String::cast(flat);
+  }
   static const int kMaxInitialListCapacity = 16;
 
   ZoneScope scope(isolate, DELETE_ON_EXIT);
 
   // Find (up to limit) indices of separator and end-of-string in subject
   int initial_capacity = Min<uint32_t>(kMaxInitialListCapacity, limit);
   ZoneList<int> indices(initial_capacity);
-  if (!pattern->IsFlat()) FlattenString(pattern);
+  if (!pattern->IsFlat()) {
+    Object* flat;
+    { MaybeObject* maybe_flat = pattern->TryFlatten();
+      if (!maybe_flat->ToObject(&flat)) return maybe_flat;
+    }
+    pattern = String::cast(flat);
+  }
 
   // No allocation block.
   {
     AssertNoAllocation nogc;
     if (subject->IsAsciiRepresentation()) {
       Vector<const char> subject_vector = subject->ToAsciiVector();
       if (pattern->IsAsciiRepresentation()) {
         FindStringIndices(isolate,
                           subject_vector,
                           pattern->ToAsciiVector(),
@@ skipping 25 matching lines @@
   }
 
   if (static_cast<uint32_t>(indices.length()) < limit) {
     indices.Add(subject_length);
   }
 
   // The list indices now contains the end of each part to create.
 
   // Create JSArray of substrings separated by separator.
   int part_count = indices.length();
-
-  Handle<JSArray> result = isolate->factory()->NewJSArray(part_count);
-  result->set_length(Smi::FromInt(part_count));
-
-  ASSERT(result->HasFastElements());
+  Object* result;
+  { MaybeObject* maybe_result =
+      isolate->heap()->AllocateFixedArray(part_count);
+    if (!maybe_result->ToObject(&result)) return maybe_result;
+  }
+  FixedArray* elements = FixedArray::cast(result);
 
   if (part_count == 1 && indices.at(0) == subject_length) {
-    FixedArray::cast(result->elements())->set(0, *subject);
-    return *result;
+    elements->set(0, subject);
+  } else {
+    int part_start = 0;
+    for (int i = 0; i < part_count; i++) {
+      int part_end = indices.at(i);
+      Object* result;
+      { MaybeObject* maybe_result =
+            isolate->heap()->AllocateSubString(subject, part_start, part_end);
+        if (!maybe_result->ToObject(&result)) return maybe_result;
+      }
+      elements->set(i, result);
+      part_start = part_end + pattern_length;
+    }
   }
-
-  Handle<FixedArray> elements(FixedArray::cast(result->elements()));
-  int part_start = 0;
-  for (int i = 0; i < part_count; i++) {
-    HandleScope local_loop_handle;
-    int part_end = indices.at(i);
-    Handle<String> substring =
-        isolate->factory()->NewSubString(subject, part_start, part_end);
-    elements->set(i, *substring);
-    part_start = part_end + pattern_length;
+  { MaybeObject* maybe_result = isolate->heap()->AllocateJSObject(
+        isolate->context()->global_context()->array_function());
+      if (!maybe_result->ToObject(&result)) return maybe_result;
   }
-
-  return *result;
+  JSArray* array = JSArray::cast(result);
+  array->SetContent(elements);
+  ASSERT(array->HasFastElements());
+  return array;
 }
 
 
 // Copies ascii characters to the given fixed array looking up
 // one-char strings in the cache. Gives up on the first char that is
 // not in the cache and fills the remainder with smi zeros. Returns
 // the length of the successfully copied prefix.
 static int CopyCachedAsciiCharsToArray(Heap* heap,
                                        const char* chars,
                                        FixedArray* elements,
@@ skipping 6537 matching lines @@
   } else {
     // Handle last resort GC and make sure to allow future allocations
     // to grow the heap without causing GCs (if possible).
     isolate->counters()->gc_last_resort_from_js()->Increment();
     isolate->heap()->CollectAllGarbage(false);
   }
 }
 
 
 } }  // namespace v8::internal