Use a stub in crankshaft for grow store arrays.

src/code-stubs.h

 // 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.
 
 #ifndef V8_CODE_STUBS_H_
 #define V8_CODE_STUBS_H_
 
 #include "src/allocation.h"
 #include "src/assembler.h"
 #include "src/codegen.h"
@@ skipping 26 matching lines @@
   V(Instanceof)                          \
   V(ConvertToDouble)                     \
   V(WriteInt32ToHeapNumber)              \
   V(StackCheck)                          \
   V(Interrupt)                           \
   V(FastNewClosure)                      \
   V(FastNewContext)                      \
   V(FastCloneShallowArray)               \
   V(FastCloneShallowObject)              \
   V(CreateAllocationSite)                \
+  V(GrowArrayElements)                   \
   V(ToBoolean)                           \
   V(ToNumber)                            \
   V(ArgumentsAccess)                     \
   V(RegExpConstructResult)               \
   V(NumberToString)                      \
   V(DoubleToI)                           \
   V(CEntry)                              \
   V(JSEntry)                             \
   V(KeyedLoadElement)                    \
   V(KeyedLoadGeneric)                    \
@@ skipping 245 matching lines @@
   }
 
   bool has_miss_handler() const {
     return has_miss_handler_;
   }
 
   Register GetParameterRegister(int index) const {
     return register_params_[index];
   }
 
-  Representation GetRegisterParameterRepresentation(int index) const {
+  Representation GetParameterRepresentation(int index) const {
     ASSERT(index < register_param_count_);
     if (register_param_representations_.get() == NULL) {
       return Representation::Tagged();
     }
 
     return register_param_representations_[index];
   }
 
   bool IsParameterCountRegister(int index) const {
     return GetParameterRegister(index).is(stack_parameter_count_);
@@ skipping 382 matching lines @@
       CodeStubInterfaceDescriptor* descriptor) V8_OVERRIDE;
 
  private:
   Major MajorKey() { return CreateAllocationSite; }
   int NotMissMinorKey() { return 0; }
 
   DISALLOW_COPY_AND_ASSIGN(CreateAllocationSiteStub);
 };
 
 
+class GrowArrayElementsStub : public HydrogenCodeStub {
+ public:
+  explicit GrowArrayElementsStub(Isolate* isolate, bool is_js_array,
+                                 ElementsKind kind)
+      : HydrogenCodeStub(isolate) {
+    bit_field_ = ElementsKindBits::encode(kind) |
+        IsJsArrayBits::encode(is_js_array);
+  }
+
+  virtual Handle<Code> GenerateCode() V8_OVERRIDE;
+
+  static void GenerateAheadOfTime(Isolate* isolate);
+
+  enum RegisterInfo {
+    kObjectIndex,
+    kKeyIndex,
+    kCapacityIndex,
+    kRegisterArgumentCount
+  };
+  static const Register ObjectRegister();
+  static const Register KeyRegister();
+  static const Register CapacityRegister();
+
+  virtual void InitializeInterfaceDescriptor(
+      CodeStubInterfaceDescriptor* descriptor) V8_OVERRIDE;
+
+  static void InstallDescriptors(Isolate* isolate) {
+    GrowArrayElementsStub stub(isolate, true, GetInitialFastElementsKind());
+    stub.InitializeInterfaceDescriptor(
+        isolate->code_stub_interface_descriptor(CodeStub::GrowArrayElements));
+  }
+
+  ElementsKind elements_kind() const {
+    return ElementsKindBits::decode(bit_field_);
+  }
+
+  bool is_js_array() const { return IsJsArrayBits::decode(bit_field_); }
+
+ private:
+  class ElementsKindBits: public BitField<ElementsKind, 0, 8> {};
+  class IsJsArrayBits: public BitField<bool, 16, 1> {};

[danno, 2014/07/11 12:30:30]

Any particular reason you start this field at bit 16 and not 8? You may want to
make the bit selection semi-automatic like FieldIndex does.

[mvstanton, 2014/07/21 09:41:17]

Oops, thanks that is a bug because I removed a NewElementsKindBits field that
was there before. Done.

+
+  uint32_t bit_field_;
+
+  Major MajorKey() { return GrowArrayElements; }
+  int NotMissMinorKey() { return bit_field_; }
+
+  DISALLOW_COPY_AND_ASSIGN(GrowArrayElementsStub);
+};
+
+
 class InstanceofStub: public PlatformCodeStub {
  public:
   enum Flags {
     kNoFlags = 0,
     kArgsInRegisters = 1 << 0,
     kCallSiteInlineCheck = 1 << 1,
     kReturnTrueFalseObject = 1 << 2
   };
 
   InstanceofStub(Isolate* isolate, Flags flags)
@@ skipping 1808 matching lines @@
 
 
 class CallDescriptors {
  public:
   static void InitializeForIsolate(Isolate* isolate);
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_CODE_STUBS_H_