Supporting AllocationSiteInfo for Nested arrays

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 5704 matching lines @@
     // Load map into r2.
     __ ldr(r2, FieldMemOperand(r1, HeapObject::kMapOffset));
     // Load the map's "bit field 2".
     __ ldrb(r2, FieldMemOperand(r2, Map::kBitField2Offset));
     // Retrieve elements_kind from bit field 2.
     __ ubfx(r2, r2, Map::kElementsKindShift, Map::kElementsKindBitCount);
     __ cmp(r2, Operand(boilerplate_elements_kind));
     DeoptimizeIf(ne, instr->environment());
   }
 
+  int flags = allocation_site_mode == TRACK_ALLOCATION_SITE
+      ? ArrayLiteral::kCreateAllocationSiteInfos
+      : ArrayLiteral::kNoFlags;
+
   // Set up the parameters to the stub/runtime call.
   __ LoadHeapObject(r3, literals);
   __ mov(r2, Operand(Smi::FromInt(instr->hydrogen()->literal_index())));
   // Boilerplate already exists, constant elements are never accessed.
   // Pass an empty fixed array.
   __ mov(r1, Operand(isolate()->factory()->empty_fixed_array()));
   __ Push(r3, r2, r1);
 
   // Pick the right runtime function or stub to call.
   int length = instr->hydrogen()->length();
   if (instr->hydrogen()->IsCopyOnWrite()) {
     ASSERT(instr->hydrogen()->depth() == 1);
     FastCloneShallowArrayStub::Mode mode =
         FastCloneShallowArrayStub::COPY_ON_WRITE_ELEMENTS;
     FastCloneShallowArrayStub stub(mode, DONT_TRACK_ALLOCATION_SITE, length);
     CallCode(stub.GetCode(isolate()), RelocInfo::CODE_TARGET, instr);
   } else if (instr->hydrogen()->depth() > 1) {
-    CallRuntime(Runtime::kCreateArrayLiteral, 3, instr);
+    __ mov(r0, Operand(Smi::FromInt(flags)));
+    __ push(r0);
+    CallRuntime(Runtime::kCreateArrayLiteral, 4, instr);
   } else if (length > FastCloneShallowArrayStub::kMaximumClonedLength) {
-    CallRuntime(Runtime::kCreateArrayLiteralShallow, 3, instr);
+    __ mov(r0, Operand(Smi::FromInt(flags)));
+    __ push(r0);
+    CallRuntime(Runtime::kCreateArrayLiteralShallow, 4, instr);
   } else {
     FastCloneShallowArrayStub::Mode mode =
         boilerplate_elements_kind == FAST_DOUBLE_ELEMENTS
         ? FastCloneShallowArrayStub::CLONE_DOUBLE_ELEMENTS
         : FastCloneShallowArrayStub::CLONE_ELEMENTS;
     FastCloneShallowArrayStub stub(mode, allocation_site_mode, length);
     CallCode(stub.GetCode(isolate()), RelocInfo::CODE_TARGET, instr);
   }
 }
 
 
 void LCodeGen::EmitDeepCopy(Handle<JSObject> object,
+                            Handle<JSObject> original_object,
                             Register result,
                             Register source,
                             int* offset,
                             AllocationSiteMode mode) {
   ASSERT(!source.is(r2));
   ASSERT(!result.is(r2));
 
+  // Should we track allocation info for *this* object in the tree?
   bool create_allocation_site_info = mode == TRACK_ALLOCATION_SITE &&
-      object->map()->CanTrackAllocationSite();
+      object->ShouldTrackAllocationInfo();
 
   // Only elements backing stores for non-COW arrays need to be copied.
   Handle<FixedArrayBase> elements(object->elements());
+  Handle<FixedArrayBase> original_elements(original_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_size = has_elements ? elements->Size() : 0;
   int elements_offset = *offset + object_size;
   if (create_allocation_site_info) {
@@ skipping 16 matching lines @@
     __ str(r2, FieldMemOperand(result, object_offset + i));
   }
 
   // Copy in-object properties.
   for (int i = 0; i < inobject_properties; i++) {
     int total_offset = object_offset + object->GetInObjectPropertyOffset(i);
     Handle<Object> value = Handle<Object>(object->InObjectPropertyAt(i),
                                           isolate());
     if (value->IsJSObject()) {
       Handle<JSObject> value_object = Handle<JSObject>::cast(value);
+      Handle<JSObject> original_value_object = Handle<JSObject>::cast(
+          Handle<Object>(original_object->InObjectPropertyAt(i), isolate()));
+
       __ add(r2, result, Operand(*offset));
       __ str(r2, FieldMemOperand(result, total_offset));
       __ LoadHeapObject(source, value_object);
-      EmitDeepCopy(value_object, result, source, offset,
-                   DONT_TRACK_ALLOCATION_SITE);
+      EmitDeepCopy(value_object, original_value_object, result, source,
+                   offset, mode);
     } 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));
+    __ str(r2, FieldMemOperand(result, object_size + object_offset));
+    __ LoadHeapObject(r2, original_object);
+    __ str(r2, FieldMemOperand(result,
+                               object_size + object_offset + 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;
     if (elements->IsFixedDoubleArray()) {
       Handle<FixedDoubleArray> double_array =
           Handle<FixedDoubleArray>::cast(elements);
       for (int i = 0; i < elements_length; i++) {
         int64_t value = double_array->get_representation(i);
         // We only support little endian mode...
         int32_t value_low = static_cast<int32_t>(value & 0xFFFFFFFF);
         int32_t value_high = static_cast<int32_t>(value >> 32);
         int total_offset =
             elements_offset + FixedDoubleArray::OffsetOfElementAt(i);
         __ mov(r2, Operand(value_low));
         __ str(r2, FieldMemOperand(result, total_offset));
         __ mov(r2, Operand(value_high));
         __ str(r2, FieldMemOperand(result, total_offset + 4));
       }
     } else if (elements->IsFixedArray()) {
       Handle<FixedArray> fast_elements = Handle<FixedArray>::cast(elements);
+      ASSERT(original_object->HasFastObjectElements());
+      Handle<FixedArray> original_fast_elements =
+          Handle<FixedArray>::cast(original_elements);
       for (int i = 0; i < elements_length; i++) {
         int total_offset = elements_offset + FixedArray::OffsetOfElementAt(i);
         Handle<Object> value(fast_elements->get(i), isolate());
         if (value->IsJSObject()) {
           Handle<JSObject> value_object = Handle<JSObject>::cast(value);
+          Handle<JSObject> original_value_object = Handle<JSObject>::cast(
+              Handle<Object>(original_fast_elements->get(i), isolate()));
           __ add(r2, result, Operand(*offset));
           __ str(r2, FieldMemOperand(result, total_offset));
           __ LoadHeapObject(source, value_object);
-          EmitDeepCopy(value_object, result, source, offset,
-                       DONT_TRACK_ALLOCATION_SITE);
+          ASSERT(!value_object.is_identical_to(original_value_object));
+          EmitDeepCopy(value_object, original_value_object, result, source,
+                       offset, mode);
         } 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));
         }
       }
     } else {
       UNREACHABLE();
     }
   }
 }
 
 
-void LCodeGen::DoFastLiteral(LFastLiteral* instr) {
-  int size = instr->hydrogen()->total_size();
-  ElementsKind boilerplate_elements_kind =
-      instr->hydrogen()->boilerplate()->GetElementsKind();
+void LCodeGen::FastLiteralHelper(LFastLiteral* instr, AllocationSiteMode mode) {
+  int size = mode == DONT_TRACK_ALLOCATION_SITE
+      ? instr->hydrogen()->size_without_allocation_sites()
+      : instr->hydrogen()->total_size();
 
-  // Deopt if the array literal boilerplate ElementsKind is of a type different
-  // than the expected one. The check isn't necessary if the boilerplate has
-  // already been converted to TERMINAL_FAST_ELEMENTS_KIND.
-  if (CanTransitionToMoreGeneralFastElementsKind(
-          boilerplate_elements_kind, true)) {
-    __ LoadHeapObject(r1, instr->hydrogen()->boilerplate());
-    // Load map into r2.
-    __ ldr(r2, FieldMemOperand(r1, HeapObject::kMapOffset));
-    // Load the map's "bit field 2".
-    __ ldrb(r2, FieldMemOperand(r2, Map::kBitField2Offset));
-    // Retrieve elements_kind from bit field 2.
-    __ ubfx(r2, r2, Map::kElementsKindShift, Map::kElementsKindBitCount);
-    __ cmp(r2, Operand(boilerplate_elements_kind));
-    DeoptimizeIf(ne, instr->environment());
-  }
-
-  // Allocate all objects that are part of the literal in one big
   // allocation. This avoids multiple limit checks.
   Label allocated, runtime_allocate;
   __ Allocate(size, r0, r2, r3, &runtime_allocate, TAG_OBJECT);
   __ 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(),
+               instr->hydrogen()->original_boilerplate(),
+               r0, r1, &offset,
                instr->hydrogen()->allocation_site_mode());
   ASSERT_EQ(size, offset);
 }
 
 
+void LCodeGen::DoFastLiteral(LFastLiteral* instr) {
+  // TODO(mvstanton): Revisit this heuristic as site info matures.
+  // If allocation site mode is on, then we need the ability to turn it off
+  // after "awhile." Later, better options should be available, but for
+  // now just allow a certain number of gcs to pass.
+  if (instr->hydrogen()->allocation_site_mode() == TRACK_ALLOCATION_SITE) {
+    // How many gcs have passed?
+    const int maxCount = 3;
+    ExternalReference gc_count_address =
+        ExternalReference::gc_count_address(isolate());
+    Label continue_using, done;
+    __ mov(r0, Operand(gc_count_address));
+    __ ldr(r0, MemOperand(r0));
+    __ cmp(r0, Operand(maxCount));
+    __ b(lt, &continue_using);
+    FastLiteralHelper(instr, DONT_TRACK_ALLOCATION_SITE);
+    __ jmp(&done);
+    __ bind(&continue_using);
+    FastLiteralHelper(instr, TRACK_ALLOCATION_SITE);
+    __ bind(&done);
+  } else {
+    FastLiteralHelper(instr, DONT_TRACK_ALLOCATION_SITE);
+  }
+}
+
+
 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.
   __ LoadHeapObject(r3, literals);
   __ mov(r2, Operand(Smi::FromInt(instr->hydrogen()->literal_index())));
   __ mov(r1, Operand(constant_properties));
   int flags = instr->hydrogen()->fast_elements()
       ? ObjectLiteral::kFastElements
       : ObjectLiteral::kNoFlags;
+
+  if (instr->hydrogen()->allocation_site_mode() == TRACK_ALLOCATION_SITE) {
+    flags |= ObjectLiteral::kCreateAllocationSiteInfos;
+  }
+
   __ mov(r0, Operand(Smi::FromInt(flags)));
-
   // Pick the right runtime function or stub to call.
   int properties_count = constant_properties->length() / 2;
   if (instr->hydrogen()->depth() > 1) {
     __ Push(r3, r2, r1, r0);
     CallRuntime(Runtime::kCreateObjectLiteral, 4, instr);
   } else if (flags != ObjectLiteral::kFastElements ||
       properties_count > FastCloneShallowObjectStub::kMaximumClonedProperties) {
     __ Push(r3, r2, r1, r0);
     CallRuntime(Runtime::kCreateObjectLiteralShallow, 4, instr);
   } else {
@@ skipping 448 matching lines @@
   __ sub(scratch, result, Operand(index, LSL, kPointerSizeLog2 - kSmiTagSize));
   __ ldr(result, FieldMemOperand(scratch,
                                  FixedArray::kHeaderSize - kPointerSize));
   __ bind(&done);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal