Use a stub in crankshaft for grow store arrays.

src/runtime.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stdlib.h>
 #include <limits>
 
 #include "src/v8.h"
 
 #include "src/accessors.h"
@@ skipping 14879 matching lines @@
     ASSERT(arg_count == caller_args->length());
   }
 #endif
   return ArrayConstructorCommon(isolate,
                                 constructor,
                                 Handle<AllocationSite>::null(),
                                 caller_args);
 }
 
 
+RUNTIME_FUNCTION(Runtime_GrowArrayElements) {
+  HandleScope scope(isolate);
+  ASSERT(args.length() == 3);
+  CONVERT_ARG_HANDLE_CHECKED(JSObject, object, 0);
+  CONVERT_SMI_ARG_CHECKED(key, 1);
+
+  Handle<FixedArrayBase> elements(object->elements());

[danno, 2014/07/21 10:31:43]

I guess this is function is OK, but it bothers me a little that this logic seems
to be duplication of a bunch of logic that is in
ElementsAccessors::SetLengthWithoutNormalize,
ElementsAccessors::SetCapacityAndLength and JSArray::SetLength, or some
combination of them. It seems to me that we should try really hard to reduce
that duplication. Maybe that's for another CL, but perhaps you can take a look
whether there is an easy way to reduce the explicit duplication in this CL. 

+  uint32_t capacity = static_cast<uint32_t>(elements->length());
+  uint32_t unsigned_key = static_cast<uint32_t>(key);
+
+  if (unsigned_key >= capacity) {
+    if ((unsigned_key - capacity) < JSObject::kMaxGap) {
+      uint32_t new_capacity = JSObject::NewElementsCapacity(capacity);
+      if (object->ShouldConvertToSlowElements(new_capacity)) {
+        JSObject::NormalizeElements(object);
+        return Smi::FromInt(0);
+      }
+      Handle<FixedArrayBase> new_elems;
+      ElementsKind kind = object->GetElementsKind();
+      if (IsFastDoubleElementsKind(kind)) {
+        new_elems = isolate->factory()->NewFixedDoubleArray(new_capacity);
+      } else {
+        new_elems = isolate->factory()->NewFixedArray(new_capacity);
+      }
+      ElementsAccessor* accessor = object->GetElementsAccessor();
+      accessor->CopyElements(object, new_elems, kind);
+      Handle<Map> same_map = JSObject::GetElementsTransitionMap(object, kind);
+      object->SetMapAndElements(object, same_map, new_elems);
+    } else {
+      JSObject::NormalizeElements(object);
+      return Smi::FromInt(0);
+    }
+  }
+
+  // On success, return the fixed array elements.
+  return object->elements();
+}
+
+
 RUNTIME_FUNCTION(Runtime_MaxSmi) {
   ASSERT(args.length() == 0);
   return Smi::FromInt(Smi::kMaxValue);
 }
 
 
 // ----------------------------------------------------------------------------
 // Implementation of Runtime
 
 #define F(name, number_of_args, result_size)                             \
@@ skipping 51 matching lines @@
   }
   return NULL;
 }
 
 
 const Runtime::Function* Runtime::FunctionForId(Runtime::FunctionId id) {
   return &(kIntrinsicFunctions[static_cast<int>(id)]);
 }
 
 } }  // namespace v8::internal