VM: Optimized context allocation on all platforms.

runtime/vm/assembler_ia32.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_IA32)
 
 #include "vm/assembler.h"
 #include "vm/code_generator.h"
 #include "vm/cpu.h"
@@ skipping 2425 matching lines @@
     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();
   *count_address = Address::Absolute(
       class_heap_stats_table_address + class_offset + count_field_offset);
   *size_address = Address::Absolute(
       class_heap_stats_table_address + class_offset + size_field_offset);
 }
 
+
 void Assembler::UpdateAllocationStats(intptr_t cid,
                                       Register temp_reg,
                                       Heap::Space space) {
   ASSERT(cid > 0);
   if (cid < kNumPredefinedCids) {
     Address count_address(kNoRegister, 0), size_address(kNoRegister, 0);
     ComputeCounterAddressesForCid(cid, space, &count_address, &size_address);
     incl(count_address);
   } else {
     ASSERT(temp_reg != kNoRegister);
@@ skipping 60 matching lines @@
     tags = RawObject::SizeTag::update(instance_size, tags);
     ASSERT(cls.id() != kIllegalCid);
     tags = RawObject::ClassIdTag::update(cls.id(), tags);
     movl(FieldAddress(instance_reg, Object::tags_offset()), Immediate(tags));
   } 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();
+    movl(instance, Address::Absolute(heap->TopAddress()));
+    movl(end_address, instance);
+
+    addl(end_address, Immediate(instance_size));
+    j(CARRY, failure);
+
+    // Check if the allocation fits into the remaining space.
+    // EAX: potential new object start.
+    // EBX: potential next object start.
+    cmpl(end_address, Address::Absolute(heap->EndAddress()));
+    j(ABOVE_EQUAL, failure);
+
+    // Successfully allocated the object(s), now update top to point to
+    // next object start and initialize the object.
+    movl(Address::Absolute(heap->TopAddress()), end_address);
+    addl(instance, Immediate(kHeapObjectTag));
+    UpdateAllocationStatsWithSize(cid, instance_size, kNoRegister);
+
+    // Initialize the tags.
+    uword tags = 0;
+    tags = RawObject::ClassIdTag::update(cid, tags);
+    tags = RawObject::SizeTag::update(instance_size, tags);
+    movl(FieldAddress(instance, Object::tags_offset()), Immediate(tags));
+  } else {
+    jmp(failure);
+  }
+}
+
+
 void Assembler::EnterDartFrame(intptr_t frame_size) {
   EnterFrame(0);
   Label dart_entry;
   call(&dart_entry);
   Bind(&dart_entry);
   // The runtime system assumes that the code marker address is
   // kEntryPointToPcMarkerOffset bytes from the entry.  If there is any code
   // generated before entering the frame, the address needs to be adjusted.
   const intptr_t offset = kEntryPointToPcMarkerOffset - CodeSize();
   if (offset != 0) {
@@ skipping 273 matching lines @@
 
 const char* Assembler::FpuRegisterName(FpuRegister reg) {
   ASSERT((0 <= reg) && (reg < kNumberOfXmmRegisters));
   return xmm_reg_names[reg];
 }
 
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32