Patchable AllocateArray stub, like instance allocation stubs.

runtime/vm/stub_code_ia32.cc

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/globals.h"
 #if defined(TARGET_ARCH_IA32)
 
 #include "vm/assembler.h"
 #include "vm/compiler.h"
 #include "vm/dart_entry.h"
@@ skipping 376 matching lines @@
   __ popl(EAX);  // Get Code object.
   __ popl(EDX);  // Restore arguments descriptor array.
   __ movl(EAX, FieldAddress(EAX, Code::instructions_offset()));
   __ addl(EAX, Immediate(Instructions::HeaderSize() - kHeapObjectTag));
   __ LeaveFrame();
   __ jmp(EAX);
   __ int3();
 }
 
 
-// Called from object allocate instruction when the allocation stub has been
-// disabled.
+// Called from object or array allocate instruction when the allocation stub has
+// been disabled.
+// EDX: if called for array, the length (preserved).
+// ECX: if called for array, the element type (preserved).
 void StubCode::GenerateFixAllocationStubTargetStub(Assembler* assembler) {
   const Immediate& raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   __ EnterStubFrame();
+  __ pushl(EDX);       // Preserve length.
+  __ pushl(ECX);       // Preserve element type.

[srdjan, 2014/09/25 17:42:53]

For non-arays, EDX and ECX can contain non-object, in which case you cannot push
them on stack. You can solve that by having a special FixArrayAllocation stub.

[koda, 2014/09/25 21:49:25]

Done.

   __ pushl(raw_null);  // Setup space on stack for return value.
   __ CallRuntime(kFixAllocationStubTargetRuntimeEntry, 0);
   __ popl(EAX);  // Get Code object.
+  __ popl(ECX);  // Restore element type.
+  __ popl(EDX);  // Restore length.
   __ movl(EAX, FieldAddress(EAX, Code::instructions_offset()));
   __ addl(EAX, Immediate(Instructions::HeaderSize() - kHeapObjectTag));
   __ LeaveFrame();
   __ jmp(EAX);
   __ int3();
 }
 
 
 // Input parameters:
 //   EDX: smi-tagged argument count, may be zero.
 //   EBP[kParamEndSlotFromFp + 1]: last argument.
 // Uses EAX, EBX, ECX, EDX.
 static void PushArgumentsArray(Assembler* assembler) {
   const Immediate& raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   StubCode* stub_code = Isolate::Current()->stub_code();
 
   // Allocate array to store arguments of caller.
   __ movl(ECX, raw_null);  // Null element type for raw Array.
-  __ call(&stub_code->AllocateArrayLabel());
+  const Code& array_stub = Code::Handle(stub_code->GetAllocateArrayStub());
+  const ExternalLabel array_label(array_stub.EntryPoint());
+  __ call(&array_label);
   __ SmiUntag(EDX);
   // EAX: newly allocated array.
   // EDX: length of the array (was preserved by the stub).
   __ pushl(EAX);  // Array is in EAX and on top of stack.
   __ leal(EBX, Address(EBP, EDX, TIMES_4, kParamEndSlotFromFp * kWordSize));
   __ leal(ECX, FieldAddress(EAX, Array::data_offset()));
   // EBX: address of first argument on stack.
   // ECX: address of first argument in array.
   Label loop, loop_condition;
   __ jmp(&loop_condition, Assembler::kNearJump);
@@ skipping 167 matching lines @@
   __ jmp(EBX);
 }
 
 
 // Called for inline allocation of arrays.
 // Input parameters:
 //   EDX : Array length as Smi (must be preserved).
 //   ECX : array element type (either NULL or an instantiated type).
 // Uses EAX, EBX, ECX, EDI  as temporary registers.
 // The newly allocated object is returned in EAX.
-void StubCode::GenerateAllocateArrayStub(Assembler* assembler) {
+void StubCode::GeneratePatchableAllocateArrayStub(Assembler* assembler,
+    uword* entry_patch_offset, uword* patch_code_pc_offset) {
+  *entry_patch_offset = assembler->CodeSize();
   Label slow_case;
   const Immediate& raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
 
   // Compute the size to be allocated, it is based on the array length
   // and is computed as:
   // RoundedAllocationSize((array_length * kwordSize) + sizeof(RawArray)).
   // Assert that length is a Smi.
   __ testl(EDX, Immediate(kSmiTagMask));
   if (FLAG_use_slow_path) {
@@ skipping 107 matching lines @@
   __ EnterStubFrame();
   __ pushl(raw_null);  // Setup space on stack for return value.
   __ pushl(EDX);  // Array length as Smi.
   __ pushl(ECX);  // Element type.
   __ CallRuntime(kAllocateArrayRuntimeEntry, 2);
   __ popl(EAX);  // Pop element type argument.
   __ popl(EDX);  // Pop array length argument (preserved).
   __ popl(EAX);  // Pop return value from return slot.
   __ LeaveFrame();
   __ ret();
+  // Emit function patching code. This will be swapped with the first 5 bytes
+  // at entry point.
+  *patch_code_pc_offset = assembler->CodeSize();
+  StubCode* stub_code = Isolate::Current()->stub_code();
+  __ jmp(&stub_code->FixAllocationStubTargetLabel());
 }
 
 
 // Called when invoking dart code from C++ (VM code).
 // Input parameters:
 //   ESP : points to return address.
 //   ESP + 4 : entrypoint of the dart function to call.
 //   ESP + 8 : arguments descriptor array.
 //   ESP + 12 : arguments array.
 //   ESP + 16 : new context containing the current isolate pointer.
@@ skipping 1299 matching lines @@
   const Register temp = ECX;
   __ movl(left, Address(ESP, 2 * kWordSize));
   __ movl(right, Address(ESP, 1 * kWordSize));
   GenerateIdenticalWithNumberCheckStub(assembler, left, right, temp);
   __ ret();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32