Track live instance and allocation counts for classes

runtime/vm/intrinsifier_arm.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"  // Needed here to get TARGET_ARCH_ARM.
 #if defined(TARGET_ARCH_ARM)
 
 #include "vm/intrinsifier.h"
 
 #include "vm/assembler.h"
@@ skipping 53 matching lines @@
   // R2: allocation size.
   __ LoadImmediate(R3, heap->EndAddress());
   __ ldr(R3, Address(R3, 0));
   __ cmp(R1, ShifterOperand(R3));
   __ b(&fall_through, CS);
 
   // Successfully allocated the object(s), now update top to point to
   // next object start and initialize the object.
   __ str(R1, Address(R6, 0));
   __ add(R0, R0, ShifterOperand(kHeapObjectTag));
+  __ BumpAllocationCount(Heap::kNew, kArrayCid, R2, R4);
 
   // Initialize the tags.
   // R0: new object start as a tagged pointer.
   // R1: new object end address.
   // R2: allocation size.
   {
     const intptr_t shift = RawObject::kSizeTagBit - kObjectAlignmentLog2;
     const Class& cls = Class::Handle(isolate->object_store()->array_class());
 
     __ CompareImmediate(R2, RawObject::SizeTag::kMaxSizeTag);
@@ skipping 29 matching lines @@
   // R3: null
   __ LoadImmediate(R3, reinterpret_cast<intptr_t>(Object::null()));
   __ AddImmediate(R2, R0, sizeof(RawArray) - kHeapObjectTag);
 
   Label init_loop;
   __ Bind(&init_loop);
   __ cmp(R2, ShifterOperand(R1));
   __ str(R3, Address(R2, 0), CC);
   __ AddImmediate(R2, kWordSize, CC);
   __ b(&init_loop, CC);
-
   __ Ret();  // Returns the newly allocated object in R0.
   __ Bind(&fall_through);
 }
 
 
 void Intrinsifier::Array_getLength(Assembler* assembler) {
   __ ldr(R0, Address(SP, 0 * kWordSize));
   __ ldr(R0, FieldAddress(R0, Array::length_offset()));
   __ Ret();
 }
@@ skipping 165 matching lines @@
   // Store the type argument field in the growable array object.
   __ ldr(R1, Address(SP, kTypeArgumentsOffset));  // Type argument.
   __ StoreIntoObjectNoBarrier(
       R0,
       FieldAddress(R0, GrowableObjectArray::type_arguments_offset()),
       R1);
 
   // Set the length field in the growable array object to 0.
   __ LoadImmediate(R1, 0);
   __ str(R1, FieldAddress(R0, GrowableObjectArray::length_offset()));
+  __ BumpAllocationCount(Heap::kNew, kGrowableObjectArrayCid, R1);
   __ Ret();  // Returns the newly allocated object in R0.
 
   __ Bind(&fall_through);
 }
 
 
 void Intrinsifier::GrowableList_getLength(Assembler* assembler) {
   __ ldr(R0, Address(SP, 0 * kWordSize));
   __ ldr(R0, FieldAddress(R0, GrowableObjectArray::length_offset()));
   __ Ret();
@@ skipping 165 matching lines @@
   __ LoadImmediate(R3, heap->EndAddress());                                    \
   __ ldr(R3, Address(R3, 0));                                                  \
   __ cmp(R1, ShifterOperand(R3));                                              \
   __ b(&fall_through, CS);                                                     \
                                                                                \
   /* Successfully allocated the object(s), now update top to point to */       \
   /* next object start and initialize the object. */                           \
   __ LoadImmediate(R3, heap->TopAddress());                                    \
   __ str(R1, Address(R3, 0));                                                  \
   __ AddImmediate(R0, kHeapObjectTag);                                         \
-                                                                               \
+  __ BumpAllocationCount(Heap::kNew, cid, R2, R4);                             \
   /* Initialize the tags. */                                                   \
   /* R0: new object start as a tagged pointer. */                              \
   /* R1: new object end address. */                                            \
   /* R2: allocation size. */                                                   \
   {                                                                            \
     __ CompareImmediate(R2, RawObject::SizeTag::kMaxSizeTag);                  \
     __ mov(R2, ShifterOperand(R2, LSL,                                         \
         RawObject::kSizeTagBit - kObjectAlignmentLog2), LS);                   \
     __ mov(R2, ShifterOperand(0), HI);                                         \
                                                                                \
@@ skipping 16 matching lines @@
   /* R3: scratch register. */                                                  \
   /* data area to be initialized. */                                           \
   __ LoadImmediate(R3, 0);                                                     \
   __ AddImmediate(R2, R0, sizeof(Raw##type_name) - 1);                         \
   Label init_loop;                                                             \
   __ Bind(&init_loop);                                                         \
   __ cmp(R2, ShifterOperand(R1));                                              \
   __ str(R3, Address(R2, 0), CC);                                              \
   __ add(R2, R2, ShifterOperand(kWordSize), CC);                               \
   __ b(&init_loop, CC);                                                        \
-                                                                               \
   __ Ret();                                                                    \
   __ Bind(&fall_through);                                                      \
 
 
 // Gets the length of a TypedData.
 void Intrinsifier::TypedData_getLength(Assembler* assembler) {
   __ ldr(R0, Address(SP, 0 * kWordSize));
   __ ldr(R0, FieldAddress(R0, TypedData::length_offset()));
   __ Ret();
 }
@@ skipping 297 matching lines @@
   __ sub(R7, R7, ShifterOperand(1));  // R7 <- R7 - 1
   __ rsb(R8, R0, ShifterOperand(32));  // R8 <- 32 - R0
   __ mov(R7, ShifterOperand(R7, LSL, R8));  // R7 <- R7 << R8
   __ and_(R7, R1, ShifterOperand(R7));  // R7 <- R7 & R1
   __ mov(R7, ShifterOperand(R7, LSR, R8));  // R7 <- R7 >> R8
   // Now R7 has the bits that fall off of R1 on a left shift.
   __ mov(R1, ShifterOperand(R1, LSL, R0));  // R1 gets the low bits.
 
   const Class& mint_class = Class::Handle(
       Isolate::Current()->object_store()->mint_class());
-  __ TryAllocate(mint_class, &fall_through, R0);
+  __ TryAllocate(mint_class, &fall_through, R0, R2);
 
 
   __ str(R1, FieldAddress(R0, Mint::value_offset()));
   __ str(R7, FieldAddress(R0, Mint::value_offset() + kWordSize));
   __ Ret();
   __ Bind(&fall_through);
 }
 
 
 static void Get64SmiOrMint(Assembler* assembler,
@@ skipping 281 matching lines @@
   __ LoadDFromOffset(D0, R0, Double::value_offset() - kHeapObjectTag);
   switch (kind) {
     case Token::kADD: __ vaddd(D0, D0, D1); break;
     case Token::kSUB: __ vsubd(D0, D0, D1); break;
     case Token::kMUL: __ vmuld(D0, D0, D1); break;
     case Token::kDIV: __ vdivd(D0, D0, D1); break;
     default: UNREACHABLE();
   }
   const Class& double_class = Class::Handle(
       Isolate::Current()->object_store()->double_class());
-  __ TryAllocate(double_class, &fall_through, R0);  // Result register.
+  __ TryAllocate(double_class, &fall_through, R0, R1);  // Result register.
   __ StoreDToOffset(D0, R0, Double::value_offset() - kHeapObjectTag);
   __ Ret();
   __ Bind(&fall_through);
 }
 
 
 void Intrinsifier::Double_add(Assembler* assembler) {
   return DoubleArithmeticOperations(assembler, Token::kADD);
 }
 
@@ skipping 22 matching lines @@
   __ b(&fall_through, NE);
   // Is Smi.
   __ SmiUntag(R0);
   __ vmovsr(S0, R0);
   __ vcvtdi(D1, S0);
   __ ldr(R0, Address(SP, 1 * kWordSize));
   __ LoadDFromOffset(D0, R0, Double::value_offset() - kHeapObjectTag);
   __ vmuld(D0, D0, D1);
   const Class& double_class = Class::Handle(
       Isolate::Current()->object_store()->double_class());
-  __ TryAllocate(double_class, &fall_through, R0);  // Result register.
+  __ TryAllocate(double_class, &fall_through, R0, R1);  // Result register.
   __ StoreDToOffset(D0, R0, Double::value_offset() - kHeapObjectTag);
   __ Ret();
   __ Bind(&fall_through);
 }
 
 
 void Intrinsifier::Double_fromInteger(Assembler* assembler) {
   Label fall_through;
 
   __ ldr(R0, Address(SP, 0 * kWordSize));
   __ tst(R0, ShifterOperand(kSmiTagMask));
   __ b(&fall_through, NE);
   // Is Smi.
   __ SmiUntag(R0);
   __ vmovsr(S0, R0);
   __ vcvtdi(D0, S0);
   const Class& double_class = Class::Handle(
       Isolate::Current()->object_store()->double_class());
-  __ TryAllocate(double_class, &fall_through, R0);  // Result register.
+  __ TryAllocate(double_class, &fall_through, R0, R1);  // Result register.
   __ StoreDToOffset(D0, R0, Double::value_offset() - kHeapObjectTag);
   __ Ret();
   __ Bind(&fall_through);
 }
 
 
 void Intrinsifier::Double_getIsNaN(Assembler* assembler) {
   Label is_true;
   __ ldr(R0, Address(SP, 0 * kWordSize));
   __ LoadDFromOffset(D0, R0, Double::value_offset() - kHeapObjectTag);
@@ skipping 60 matching lines @@
 
 void Intrinsifier::Math_sqrt(Assembler* assembler) {
   Label fall_through, is_smi, double_op;
   TestLastArgumentIsDouble(assembler, &is_smi, &fall_through);
   // Argument is double and is in R0.
   __ LoadDFromOffset(D1, R0, Double::value_offset() - kHeapObjectTag);
   __ Bind(&double_op);
   __ vsqrtd(D0, D1);
   const Class& double_class = Class::Handle(
       Isolate::Current()->object_store()->double_class());
-  __ TryAllocate(double_class, &fall_through, R0);  // Result register.
+  __ TryAllocate(double_class, &fall_through, R0, R1);  // Result register.
   __ StoreDToOffset(D0, R0, Double::value_offset() - kHeapObjectTag);
   __ Ret();
   __ Bind(&is_smi);
   __ SmiUntag(R0);
   __ vmovsr(S0, R0);
   __ vcvtdi(D1, S0);
   __ b(&double_op);
   __ Bind(&fall_through);
 }
 
@@ skipping 210 matching lines @@
   // R3: heap->Top->Address().
   __ LoadImmediate(R7, heap->EndAddress());
   __ ldr(R7, Address(R7, 0));
   __ cmp(R1, ShifterOperand(R7));
   __ b(&fail, CS);
 
   // Successfully allocated the object(s), now update top to point to
   // next object start and initialize the object.
   __ str(R1, Address(R3, 0));
   __ AddImmediate(R0, kHeapObjectTag);
+  __ BumpAllocationCount(Heap::kNew, kOneByteStringCid, R2, R3);
 
   // Initialize the tags.
   // R0: new object start as a tagged pointer.
   // R1: new object end address.
   // R2: allocation size.
   {
     const intptr_t shift = RawObject::kSizeTagBit - kObjectAlignmentLog2;
     const Class& cls =
         Class::Handle(isolate->object_store()->one_byte_string_class());
 
     __ CompareImmediate(R2, RawObject::SizeTag::kMaxSizeTag);
     __ mov(R2, ShifterOperand(R2, LSL, shift), LS);
     __ mov(R2, ShifterOperand(0), HI);
 
     // Get the class index and insert it into the tags.
     // R2: size and bit tags.
     __ LoadImmediate(TMP, RawObject::ClassIdTag::encode(cls.id()));
     __ orr(R2, R2, ShifterOperand(TMP));
     __ str(R2, FieldAddress(R0, String::tags_offset()));  // Store tags.
   }
 
   // Set the length field using the saved length (R6).
   __ StoreIntoObjectNoBarrier(R0,
                               FieldAddress(R0, String::length_offset()),
                               R6);
   // Clear hash.
   __ LoadImmediate(TMP, 0);
   __ str(TMP, FieldAddress(R0, String::hash_offset()));
   __ b(ok);
-
   __ Bind(&fail);
   __ b(failure);
 }
 
 
 // Arg0: OneByteString (receiver).
 // Arg1: Start index as Smi.
 // Arg2: End index as Smi.
 // The indexes must be valid.
 void Intrinsifier::OneByteString_substringUnchecked(Assembler* assembler) {
@@ skipping 146 matching lines @@
 
 
 void Intrinsifier::TwoByteString_equality(Assembler* assembler) {
   StringEquality(assembler, kTwoByteStringCid);
 }
 
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM