VM: Optimized context allocation on all platforms.

runtime/vm/assembler_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/cpu.h"
 #include "vm/heap.h"
@@ skipping 3101 matching lines @@
 }
 
 
 void Assembler::LeaveStubFrame() {
   // Restore caller's PP register that was pushed in EnterStubFrame.
   movq(PP, Address(RBP, (kSavedCallerPpSlotFromFp * kWordSize)));
   LeaveFrame();
 }
 
 
+void Assembler::ComputeCounterAddressesForCid(intptr_t cid,
+                                              Heap::Space space,
+                                              Address* count_address,
+                                              Address* size_address) {
+  ASSERT(cid < kNumPredefinedCids);
+  Register temp_reg = TMP;
+  Isolate* isolate = Isolate::Current();
+  ClassTable* class_table = isolate->class_table();
+  const uword class_heap_stats_table_address =
+      class_table->PredefinedClassHeapStatsTableAddress();
+  const uword class_offset = cid * sizeof(ClassHeapStats);  // NOLINT
+  const uword count_field_offset = (space == Heap::kNew)
+      ? ClassHeapStats::allocated_since_gc_new_space_offset()
+      : ClassHeapStats::allocated_since_gc_old_space_offset();
+  const uword size_field_offset = (space == Heap::kNew)
+      ? ClassHeapStats::allocated_size_since_gc_new_space_offset()
+      : ClassHeapStats::allocated_size_since_gc_old_space_offset();
+  movq(temp_reg, Immediate(class_heap_stats_table_address + class_offset));
+  *count_address = Address(temp_reg, count_field_offset);
+  *size_address = Address(temp_reg, size_field_offset);
+}
+
+
 void Assembler::UpdateAllocationStats(intptr_t cid,
                                       Heap::Space space) {
-  Register temp_reg = TMP;
   ASSERT(cid > 0);
-  Isolate* isolate = Isolate::Current();
-  ClassTable* class_table = isolate->class_table();
   if (cid < kNumPredefinedCids) {
-    const uword class_heap_stats_table_address =
-        class_table->PredefinedClassHeapStatsTableAddress();
-    const uword class_offset = cid * sizeof(ClassHeapStats);  // NOLINT
-    const uword count_field_offset = (space == Heap::kNew) ?
-      ClassHeapStats::allocated_since_gc_new_space_offset() :
-      ClassHeapStats::allocated_since_gc_old_space_offset();
-    movq(temp_reg, Immediate(class_heap_stats_table_address + class_offset));
-    const Address& count_address = Address(temp_reg, count_field_offset);
+    Address count_address(kNoRegister, 0), size_address(kNoRegister, 0);
+    ComputeCounterAddressesForCid(cid, space, &count_address, &size_address);
     incq(count_address);
   } else {
-    ASSERT(temp_reg != kNoRegister);
+    Register temp_reg = TMP;
     const uword class_offset = cid * sizeof(ClassHeapStats);  // NOLINT
-    const uword count_field_offset = (space == Heap::kNew) ?
-      ClassHeapStats::allocated_since_gc_new_space_offset() :
-      ClassHeapStats::allocated_since_gc_old_space_offset();
+    const uword count_field_offset = (space == Heap::kNew)
+        ? ClassHeapStats::allocated_since_gc_new_space_offset()
+        : ClassHeapStats::allocated_since_gc_old_space_offset();
+    ClassTable* class_table = Isolate::Current()->class_table();
     movq(temp_reg, Immediate(class_table->ClassStatsTableAddress()));
     movq(temp_reg, Address(temp_reg, 0));
     incq(Address(temp_reg, class_offset + count_field_offset));
   }
 }
 
 
 void Assembler::UpdateAllocationStatsWithSize(intptr_t cid,
                                               Register size_reg,
                                               Heap::Space space) {
-  Register temp_reg = TMP;
   ASSERT(cid > 0);
-  Isolate* isolate = Isolate::Current();
-  ClassTable* class_table = isolate->class_table();
-  if (cid < kNumPredefinedCids) {
-    const uword class_heap_stats_table_address =
-        class_table->PredefinedClassHeapStatsTableAddress();
-    const uword class_offset = cid * sizeof(ClassHeapStats);  // NOLINT
-    const uword count_field_offset = (space == Heap::kNew) ?
-      ClassHeapStats::allocated_since_gc_new_space_offset() :
-      ClassHeapStats::allocated_since_gc_old_space_offset();
-    const uword size_field_offset = (space == Heap::kNew) ?
-      ClassHeapStats::allocated_size_since_gc_new_space_offset() :
-      ClassHeapStats::allocated_size_since_gc_old_space_offset();
-    movq(temp_reg, Immediate(class_heap_stats_table_address + class_offset));
-    const Address& count_address = Address(temp_reg, count_field_offset);
-    const Address& size_address = Address(temp_reg, size_field_offset);
-    incq(count_address);
-    addq(size_address, size_reg);
-  } else {
-    ASSERT(temp_reg != kNoRegister);
-    const uword class_offset = cid * sizeof(ClassHeapStats);  // NOLINT
-    const uword count_field_offset = (space == Heap::kNew) ?
-      ClassHeapStats::allocated_since_gc_new_space_offset() :
-      ClassHeapStats::allocated_since_gc_old_space_offset();
-    const uword size_field_offset = (space == Heap::kNew) ?
-      ClassHeapStats::allocated_size_since_gc_new_space_offset() :
-      ClassHeapStats::allocated_size_since_gc_old_space_offset();
-    movq(temp_reg, Immediate(class_table->ClassStatsTableAddress()));
-    movq(temp_reg, Address(temp_reg, 0));
-    incq(Address(temp_reg, class_offset + count_field_offset));
-    addq(Address(temp_reg, class_offset + size_field_offset), size_reg);
-  }
+  ASSERT(cid < kNumPredefinedCids);
+  Address count_address(kNoRegister, 0), size_address(kNoRegister, 0);
+  ComputeCounterAddressesForCid(cid, space, &count_address, &size_address);
+  incq(count_address);
+  addq(size_address, size_reg);
+}
+
+
+void Assembler::UpdateAllocationStatsWithSize(intptr_t cid,
+                                              intptr_t size_in_bytes,
+                                              Heap::Space space) {
+  ASSERT(cid > 0);
+  ASSERT(cid < kNumPredefinedCids);
+  Address count_address(kNoRegister, 0), size_address(kNoRegister, 0);
+  ComputeCounterAddressesForCid(cid, space, &count_address, &size_address);
+  incq(count_address);
+  addq(size_address, Immediate(size_in_bytes));
 }
 
 
 void Assembler::TryAllocate(const Class& cls,
                             Label* failure,
                             bool near_jump,
                             Register instance_reg,
                             Register pp) {
   ASSERT(failure != NULL);
   if (FLAG_inline_alloc) {
@@ skipping 18 matching lines @@
     ASSERT(cls.id() != kIllegalCid);
     tags = RawObject::ClassIdTag::update(cls.id(), tags);
     LoadImmediate(FieldAddress(instance_reg, Object::tags_offset()),
                   Immediate(tags), pp);
   } else {
     jmp(failure);
   }
 }
 
 
+void Assembler::TryAllocateArray(intptr_t cid,
+                                 intptr_t instance_size,
+                                 Label* failure,
+                                 bool near_jump,
+                                 Register instance,
+                                 Register end_address) {
+  ASSERT(failure != NULL);
+  if (FLAG_inline_alloc) {
+    Isolate* isolate = Isolate::Current();
+    Heap* heap = isolate->heap();
+
+    movq(instance, Immediate(heap->TopAddress()));
+    movq(instance, Address(instance, 0));
+    movq(end_address, RAX);
+
+    addq(end_address, Immediate(instance_size));
+    j(CARRY, failure);
+
+    // Check if the allocation fits into the remaining space.
+    // instance: potential new object start.
+    // end_address: potential next object start.
+    movq(TMP, Immediate(heap->EndAddress()));
+    cmpq(end_address, Address(TMP, 0));
+    j(ABOVE_EQUAL, failure);
+
+    // Successfully allocated the object(s), now update top to point to
+    // next object start and initialize the object.
+    movq(TMP, Immediate(heap->TopAddress()));
+    movq(Address(TMP, 0), end_address);
+    addq(instance, Immediate(kHeapObjectTag));
+    UpdateAllocationStatsWithSize(kArrayCid, instance_size);
+
+    // Initialize the tags.
+    // instance: new object start as a tagged pointer.
+    uword tags = 0;
+    tags = RawObject::ClassIdTag::update(cid, tags);
+    tags = RawObject::SizeTag::update(instance_size, tags);
+    movq(FieldAddress(instance, Array::tags_offset()), Immediate(tags));
+  } else {
+    jmp(failure);
+  }
+}
+
 void Assembler::Align(int alignment, intptr_t offset) {
   ASSERT(Utils::IsPowerOfTwo(alignment));
   intptr_t pos = offset + buffer_.GetPosition();
   int mod = pos & (alignment - 1);
   if (mod == 0) {
     return;
   }
   intptr_t bytes_needed = alignment - mod;
   while (bytes_needed > MAX_NOP_SIZE) {
     nop(MAX_NOP_SIZE);
@@ skipping 245 matching lines @@
 
 
 const char* Assembler::FpuRegisterName(FpuRegister reg) {
   ASSERT((0 <= reg) && (reg < kNumberOfXmmRegisters));
   return xmm_reg_names[reg];
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64