Additional work to get array literal allocation tracking working, even with --always-opt

src/arm/lithium-codegen-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 5451 matching lines @@
     ASSERT(instr->hydrogen()->depth() == 1);
     FastCloneShallowArrayStub::Mode mode =
         FastCloneShallowArrayStub::COPY_ON_WRITE_ELEMENTS;
     FastCloneShallowArrayStub stub(mode, length);
     CallCode(stub.GetCode(), RelocInfo::CODE_TARGET, instr);
   } else if (instr->hydrogen()->depth() > 1) {
     CallRuntime(Runtime::kCreateArrayLiteral, 3, instr);
   } else if (length > FastCloneShallowArrayStub::kMaximumClonedLength) {
     CallRuntime(Runtime::kCreateArrayLiteralShallow, 3, instr);
   } else {
-    FastCloneShallowArrayStub::Mode mode =
+    // TODO(mvstanton): I'm doing more work than necessary here by running
+    // CLONE_ANY_ELEMENTS instead of the more specific stub, but I'm doing it
+    // just because I want to track allocation info. Alternative approach: quick
+    // baking allocation tracking info into this field, instead just have it on
+    // all the time?

[danno, 2013/01/10 22:58:59]

Be careful (here and on other platforms). Originally when I wrote this code, I
only had the CLONE_ANY_ELEMENTS version. When it landed in Chromium, I tanked
performance in the page cycler performance bots and had to make sure that the
CLONE_ELEMENTS and CLONE_DOUBLE_ELEMENTS were used whenever possible. May it's
time to separate FastCloneShallowArrayStub::Mode and the flag to create site
info always into to fields, and generate 6 versions of the copy stub,
CLONE_DOUBLE, CLONE_ELEMENTS, CLONE_ANY in two versions, one with
AllocationInfo, one without.

[mvstanton, 2013/01/11 13:43:01]

Done.

+    FastCloneShallowArrayStub::Mode mode = FastCloneShallowArrayStub::
+        CLONE_ANY_ELEMENTS_WITH_ALLOCATION_SITE_INFO;
+    /*
         boilerplate_elements_kind == FAST_DOUBLE_ELEMENTS
             ? FastCloneShallowArrayStub::CLONE_DOUBLE_ELEMENTS
             : FastCloneShallowArrayStub::CLONE_ELEMENTS;
+    */
     FastCloneShallowArrayStub stub(mode, length);
     CallCode(stub.GetCode(), RelocInfo::CODE_TARGET, instr);
   }
 }
 
 
 void LCodeGen::EmitDeepCopy(Handle<JSObject> object,
                             Register result,
                             Register source,
-                            int* offset) {
+                            int* offset,
+                            bool create_allocation_site_info) {
   ASSERT(!source.is(r2));
   ASSERT(!result.is(r2));
 
   // Only elements backing stores for non-COW arrays need to be copied.
   Handle<FixedArrayBase> elements(object->elements());
   bool has_elements = elements->length() > 0 &&
       elements->map() != isolate()->heap()->fixed_cow_array_map();
 
   // Increase the offset so that subsequent objects end up right after
   // this object and its backing store.
   int object_offset = *offset;
   int object_size = object->map()->instance_size();
   int elements_offset = *offset + object_size;
+  if (create_allocation_site_info) {
+    elements_offset += AllocationSiteInfo::kSize;
+  }
   int elements_size = has_elements ? elements->Size() : 0;
   *offset += object_size + elements_size;
+  if (create_allocation_site_info) {
+    *offset += AllocationSiteInfo::kSize;
+  }
 
   // Copy object header.
   ASSERT(object->properties()->length() == 0);
   int inobject_properties = object->map()->inobject_properties();
   int header_size = object_size - inobject_properties * kPointerSize;
   for (int i = 0; i < header_size; i += kPointerSize) {
     if (has_elements && i == JSObject::kElementsOffset) {
       __ add(r2, result, Operand(elements_offset));
     } else {
       __ ldr(r2, FieldMemOperand(source, i));
@@ skipping 13 matching lines @@
       EmitDeepCopy(value_object, result, source, offset);
     } else if (value->IsHeapObject()) {
       __ LoadHeapObject(r2, Handle<HeapObject>::cast(value));
       __ str(r2, FieldMemOperand(result, total_offset));
     } else {
       __ mov(r2, Operand(value));
       __ str(r2, FieldMemOperand(result, total_offset));
     }
   }
 
+  // Build Allocation Site Info if desired
+  if (create_allocation_site_info) {
+    __ mov(r2, Operand(Handle<Map>(isolate()->heap()->
+                                   allocation_site_info_map())));
+    __ str(r2, FieldMemOperand(result, object_size));
+    __ str(source, FieldMemOperand(result, object_size + kPointerSize));
+  }
+
   if (has_elements) {
     // Copy elements backing store header.
     __ LoadHeapObject(source, elements);
     for (int i = 0; i < FixedArray::kHeaderSize; i += kPointerSize) {
       __ ldr(r2, FieldMemOperand(source, i));
       __ str(r2, FieldMemOperand(result, elements_offset + i));
     }
 
     // Copy elements backing store content.
     int elements_length = has_elements ? elements->length() : 0;
@@ skipping 66 matching lines @@
   __ jmp(&allocated);
 
   __ bind(&runtime_allocate);
   __ mov(r0, Operand(Smi::FromInt(size)));
   __ push(r0);
   CallRuntime(Runtime::kAllocateInNewSpace, 1, instr);
 
   __ bind(&allocated);
   int offset = 0;
   __ LoadHeapObject(r1, instr->hydrogen()->boilerplate());
-  EmitDeepCopy(instr->hydrogen()->boilerplate(), r0, r1, &offset);
+  EmitDeepCopy(instr->hydrogen()->boilerplate(), r0, r1, &offset,
+               instr->hydrogen()->create_allocation_site_info());
   ASSERT_EQ(size, offset);
 }
 
 
 void LCodeGen::DoObjectLiteral(LObjectLiteral* instr) {
   Handle<FixedArray> literals(instr->environment()->closure()->literals());
   Handle<FixedArray> constant_properties =
       instr->hydrogen()->constant_properties();
 
   // Set up the parameters to the stub/runtime call.
@@ skipping 453 matching lines @@
   __ sub(scratch, result, Operand(index, LSL, kPointerSizeLog2 - kSmiTagSize));
   __ ldr(result, FieldMemOperand(scratch,
                                  FixedArray::kHeaderSize - kPointerSize));
   __ bind(&done);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal