Track live instance and allocation counts for classes

runtime/vm/stub_code_x64.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_X64)
 
 #include "vm/assembler.h"
 #include "vm/compiler.h"
 #include "vm/dart_entry.h"
@@ skipping 573 matching lines @@
     __ cmpq(R12, Address(R13, Scavenger::end_offset()));
     __ j(ABOVE_EQUAL, &slow_case);
 
     // Successfully allocated the object(s), now update top to point to
     // next object start and initialize the object.
     // RAX: potential new object start.
     // R12: potential next object start.
     // R13: Points to new space object.
     __ movq(Address(R13, Scavenger::top_offset()), R12);
     __ addq(RAX, Immediate(kHeapObjectTag));
+    // R13: Size of allocation in bytes.
+    __ movq(R13, R12);
+    __ subq(R13, RAX);
+    __ UpdateAllocationStatsWithSize(kArrayCid, R13);
 
     // RAX: new object start as a tagged pointer.
     // R12: new object end address.
     // RBX: array element type.
     // R10: Array length as Smi.
 
     // Store the type argument field.
     __ StoreIntoObjectNoBarrier(
         RAX, FieldAddress(RAX, Array::type_arguments_offset()), RBX);
 
@@ skipping 334 matching lines @@
     }
 
     // Successfully allocated the object, now update top to point to
     // next object start and initialize the object.
     // RAX: new object.
     // R13: next object start.
     // R10: number of context variables.
     __ movq(RDI, Immediate(heap->TopAddress()));
     __ movq(Address(RDI, 0), R13);
     __ addq(RAX, Immediate(kHeapObjectTag));
+    // R13: Size of allocation in bytes.
+    __ subq(R13, RAX);
+    __ UpdateAllocationStatsWithSize(context_class.id(), R13);
 
     // Calculate the size tag.
     // RAX: new object.
     // R10: number of context variables.
     {
       Label size_tag_overflow, done;
       __ leaq(R13, Address(R10, TIMES_8, fixed_size));
       __ andq(R13, Immediate(-kObjectAlignment));
       __ cmpq(R13, Immediate(RawObject::SizeTag::kMaxSizeTag));
       __ j(ABOVE, &size_tag_overflow, Assembler::kNearJump);
@@ skipping 179 matching lines @@
     if (FLAG_use_slow_path) {
       __ jmp(&slow_case);
     } else {
       __ j(ABOVE_EQUAL, &slow_case);
     }
 
     // Successfully allocated the object(s), now update top to point to
     // next object start and initialize the object.
     __ movq(RDI, Immediate(heap->TopAddress()));
     __ movq(Address(RDI, 0), RBX);
+    __ UpdateAllocationStats(cls.id());
 
     if (is_cls_parameterized) {
       // Initialize the type arguments field in the object.
       // RAX: new object start.
       // RCX: potential new object end and, if RCX != RBX, potential new
       // InstantiatedTypeArguments object start.
       // RBX: next object start.
       Label type_arguments_ready;
       __ movq(RDI, Address(RSP, kObjectTypeArgumentsOffset));
       __ cmpq(RCX, RBX);
@@ skipping 146 matching lines @@
       __ j(ABOVE_EQUAL, &slow_case);
     }
 
     // Successfully allocated the object, now update top to point to
     // next object start and initialize the object.
     __ movq(RDI, Immediate(heap->TopAddress()));
     __ movq(Address(RDI, 0), R13);
 
     // RAX: new closure object.
     // RBX: new context object (only if is_implicit_closure).
+    if (is_implicit_instance_closure) {
+      // This closure allocates a context, update allocation stats.
+      // RDI: context size.
+      __ movq(RDI, Immediate(context_size));
+     __ UpdateAllocationStatsWithSize(kContextCid, RDI);
+    }
+    // The closure allocation is attributed to the signature class.
+    __ UpdateAllocationStats(cls.id());
+
+    // RAX: new closure object.
+    // RBX: new context object (only if is_implicit_closure).
     // Set the tags.
     uword tags = 0;
     tags = RawObject::SizeTag::update(closure_size, tags);
     tags = RawObject::ClassIdTag::update(cls.id(), tags);
     __ movq(Address(RAX, Instance::tags_offset()), Immediate(tags));
 
     // Initialize the function field in the object.
     // RAX: new closure object.
     // RBX: new context object (only if is_implicit_closure).
     // R13: next object start.
@@ skipping 806 matching lines @@
 
   __ movq(left, Address(RSP, 2 * kWordSize));
   __ movq(right, Address(RSP, 1 * kWordSize));
   GenerateIdenticalWithNumberCheckStub(assembler, left, right);
   __ ret();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64