AllocationProfiler: Inital version of RecordObjectAllocation for hydrogen.

src/hydrogen.cc

 // Copyright 2013 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 1616 matching lines @@
   Add<HStoreNamedField>(array, HObjectAccess::ForArrayLength(elements_kind),
                         length_field);
 
   if (mode == TRACK_ALLOCATION_SITE) {
     BuildCreateAllocationMemento(array,
                                  JSArray::kSize,
                                  allocation_site_payload);
   }
 
   int elements_location = JSArray::kSize;
+
+  if (isolate()->heap_profiler()->is_tracking_allocations()) {
+    RecordObjectAllocation(array, Add<HConstant>(JSArray::kSize));
+  }
+
   if (mode == TRACK_ALLOCATION_SITE) {
     elements_location += AllocationMemento::kSize;
+    if (isolate()->heap_profiler()->is_tracking_allocations()) {
+      RecordObjectAllocation(Add<HInnerAllocatedObject>(array, JSArray::kSize),
+                             Add<HConstant>(AllocationMemento::kSize));
+    }
   }
 
   HValue* elements = Add<HInnerAllocatedObject>(array, elements_location);
   Add<HStoreNamedField>(array, HObjectAccess::ForElementsPointer(), elements);
+
   return static_cast<HInnerAllocatedObject*>(elements);
 }
 
 
+void HGraphBuilder::RecordObjectAllocation(HValue* object, HValue* size) {
+  Add<HPushArgument>(object);
+  Add<HPushArgument>(size);
+  Add<HCallExternal>(
+      ExternalReference::record_object_allocation_function(isolate()), 2);
+}
+
+
 HInstruction* HGraphBuilder::AddElementAccess(
     HValue* elements,
     HValue* checked_key,
     HValue* val,
     HValue* dependency,
     ElementsKind elements_kind,
     bool is_store,
     LoadKeyedHoleMode load_mode) {
   if (is_store) {
     ASSERT(val != NULL);
@@ skipping 391 matching lines @@
 }
 
 
 HValue* HGraphBuilder::JSArrayBuilder::EmitInternalMapCode() {
   // Find the map near the constructor function
   HObjectAccess access = HObjectAccess::ForPrototypeOrInitialMap();
   return builder()->AddLoadNamedField(constructor_function_, access);
 }
 
 
+HInstruction* HGraphBuilder::JSArrayBuilder::EstablishTotalSize(
+    int base_size, HValue* length_node) {
+  HInstruction* elements_size_value =
+      builder()->Add<HConstant>(elements_size());
+  HInstruction* mul = builder()->Add<HMul>(length_node, elements_size_value);
+  mul->ClearFlag(HValue::kCanOverflow);
+  HInstruction* base = builder()->Add<HConstant>(base_size);
+  HInstruction* total_size = builder()->Add<HAdd>(base, mul);
+  total_size->ClearFlag(HValue::kCanOverflow);
+  return total_size;
+}
+
+
 HValue* HGraphBuilder::JSArrayBuilder::EstablishAllocationSize(
     HValue* length_node) {
   ASSERT(length_node != NULL);
 
   int base_size = JSArray::kSize;
   if (mode_ == TRACK_ALLOCATION_SITE) {
     base_size += AllocationMemento::kSize;
   }
 
   STATIC_ASSERT(FixedDoubleArray::kHeaderSize == FixedArray::kHeaderSize);
   base_size += FixedArray::kHeaderSize;
 
-  HInstruction* elements_size_value =
-      builder()->Add<HConstant>(elements_size());
-  HInstruction* mul = builder()->Add<HMul>(length_node, elements_size_value);
-  mul->ClearFlag(HValue::kCanOverflow);
-
-  HInstruction* base = builder()->Add<HConstant>(base_size);
-  HInstruction* total_size = builder()->Add<HAdd>(base, mul);
-  total_size->ClearFlag(HValue::kCanOverflow);
-  return total_size;
+  return EstablishTotalSize(base_size, length_node);
 }
 
 
 HValue* HGraphBuilder::JSArrayBuilder::EstablishEmptyArrayAllocationSize() {
   int base_size = JSArray::kSize;
   if (mode_ == TRACK_ALLOCATION_SITE) {
     base_size += AllocationMemento::kSize;
   }
 
   base_size += IsFastDoubleElementsKind(kind_)
@@ skipping 48 matching lines @@
     map = EmitInternalMapCode();
   } else {
     map = EmitMapCode();
   }
   elements_location_ = builder()->BuildJSArrayHeader(new_object,
                                                      map,
                                                      mode_,
                                                      kind_,
                                                      allocation_site_payload_,
                                                      length_field);
+  if (builder()->isolate()->heap_profiler()->is_tracking_allocations()) {
+    HValue* elements_size = EstablishTotalSize(
+        FixedArray::kHeaderSize, length_field);
+    builder()->RecordObjectAllocation(elements_location_, elements_size);
+  }
 
   // Initialize the elements
   builder()->BuildInitializeElementsHeader(elements_location_, kind_, capacity);
 
   if (fill_with_hole) {
     builder()->BuildFillElementsWithHole(elements_location_, kind_,
                                          graph()->GetConstant0(), capacity);
   }
 
   return new_object;
@@ skipping 7667 matching lines @@
   if (ShouldProduceTraceOutput()) {
     isolate()->GetHTracer()->TraceHydrogen(name(), graph_);
   }
 
 #ifdef DEBUG
   graph_->Verify(false);  // No full verify.
 #endif
 }
 
 } }  // namespace v8::internal