Supporting AllocationSiteInfo for Nested arrays

src/arm/code-stubs-arm.cc

 // Copyright 2012 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 392 matching lines @@
 
     // Copy the elements array.
     ASSERT((elements_size % kPointerSize) == 0);
     __ CopyFields(r2, r3, r1.bit(), elements_size / kPointerSize);
   }
 }
 
 void FastCloneShallowArrayStub::Generate(MacroAssembler* masm) {
   // Stack layout on entry:
   //
-  // [sp]: constant elements.
-  // [sp + kPointerSize]: literal index.
-  // [sp + (2 * kPointerSize)]: literals array.
+  // [sp]: flags (ignored)

[danno, 2013/02/08 13:44:38]

I don't think you need to pass flags explicitly. Instead, parameterize the flags
into the MinorKey of the stub, keeping the same calling convention as before.
Create then two versions, one that passes ALLOCATE_SITE_INFO to the tail call
into the runtime, and one that doesn't. At the callee site, you know which
version you need, but you don't have to pay the extra expense of always
pushing/popping the ignored parameter in the fast case. 

[mvstanton, 2013/02/11 11:11:24]

good idea, thanks.

+  // [sp + kPointerSize]: constant elements.
+  // [sp + (2 * kPointerSize)]: literal index.
+  // [sp + (3 * kPointerSize)]: literals array.
 
   // Load boilerplate object into r3 and check if we need to create a
   // boilerplate.
   Label slow_case;
-  __ ldr(r3, MemOperand(sp, 2 * kPointerSize));
-  __ ldr(r0, MemOperand(sp, 1 * kPointerSize));
+  __ ldr(r3, MemOperand(sp, 3 * kPointerSize));
+  __ ldr(r0, MemOperand(sp, 2 * kPointerSize));
   __ add(r3, r3, Operand(FixedArray::kHeaderSize - kHeapObjectTag));
   __ ldr(r3, MemOperand(r3, r0, LSL, kPointerSizeLog2 - kSmiTagSize));
   __ CompareRoot(r3, Heap::kUndefinedValueRootIndex);
   __ b(eq, &slow_case);
 
   FastCloneShallowArrayStub::Mode mode = mode_;
   if (mode == CLONE_ANY_ELEMENTS) {
     Label double_elements, check_fast_elements;
     __ ldr(r0, FieldMemOperand(r3, JSArray::kElementsOffset));
     __ ldr(r0, FieldMemOperand(r0, HeapObject::kMapOffset));
     __ CompareRoot(r0, Heap::kFixedCOWArrayMapRootIndex);
     __ b(ne, &check_fast_elements);
     GenerateFastCloneShallowArrayCommon(masm, 0, COPY_ON_WRITE_ELEMENTS,
                                         allocation_site_mode_,
                                         &slow_case);
     // Return and remove the on-stack parameters.
-    __ add(sp, sp, Operand(3 * kPointerSize));
+    __ add(sp, sp, Operand(4 * kPointerSize));
     __ Ret();
 
     __ bind(&check_fast_elements);
     __ CompareRoot(r0, Heap::kFixedArrayMapRootIndex);
     __ b(ne, &double_elements);
     GenerateFastCloneShallowArrayCommon(masm, length_, CLONE_ELEMENTS,
                                         allocation_site_mode_,
                                         &slow_case);
     // Return and remove the on-stack parameters.
-    __ add(sp, sp, Operand(3 * kPointerSize));
+    __ add(sp, sp, Operand(4 * kPointerSize));
     __ Ret();
 
     __ bind(&double_elements);
     mode = CLONE_DOUBLE_ELEMENTS;
     // Fall through to generate the code to handle double elements.
   }
 
   if (FLAG_debug_code) {
     const char* message;
     Heap::RootListIndex expected_map_index;
@@ skipping 14 matching lines @@
     __ CompareRoot(r3, expected_map_index);
     __ Assert(eq, message);
     __ pop(r3);
   }
 
   GenerateFastCloneShallowArrayCommon(masm, length_, mode,
                                       allocation_site_mode_,
                                       &slow_case);
 
   // Return and remove the on-stack parameters.
-  __ add(sp, sp, Operand(3 * kPointerSize));
+  __ add(sp, sp, Operand(4 * kPointerSize));
   __ Ret();
 
   __ bind(&slow_case);

[danno, 2013/02/08 13:44:38]

In the parameterized stub, you'd have to push the flags here before calling
through.

[mvstanton, 2013/02/11 11:11:24]

Done.

-  __ TailCallRuntime(Runtime::kCreateArrayLiteralShallow, 3, 1);
+  __ TailCallRuntime(Runtime::kCreateArrayLiteralShallow, 4, 1);
 }
 
 
 void FastCloneShallowObjectStub::Generate(MacroAssembler* masm) {
   // Stack layout on entry:
   //
   // [sp]: object literal flags.
   // [sp + kPointerSize]: constant properties.
   // [sp + (2 * kPointerSize)]: literal index.
   // [sp + (3 * kPointerSize)]: literals array.
@@ skipping 7431 matching lines @@
 
   __ Pop(lr, r5, r1);
   __ Ret();
 }
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_ARM