VM: Optimized context allocation on all platforms.

runtime/vm/intermediate_language_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"  // Needed here to get TARGET_ARCH_IA32.
 #if defined(TARGET_ARCH_IA32)
 
 #include "vm/intermediate_language.h"
 
 #include "vm/dart_entry.h"
 #include "vm/flow_graph.h"
 #include "vm/flow_graph_compiler.h"
 #include "vm/locations.h"
 #include "vm/object_store.h"
 #include "vm/parser.h"
 #include "vm/stack_frame.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
 
 #define __ compiler->assembler()->
 
 namespace dart {
 
 DECLARE_FLAG(bool, emit_edge_counters);
 DECLARE_FLAG(int, optimization_counter_threshold);
 DECLARE_FLAG(bool, propagate_ic_data);
 DECLARE_FLAG(bool, use_osr);
 DECLARE_FLAG(bool, throw_on_javascript_int_overflow);
-DECLARE_FLAG(bool, use_slow_path);
 
 // Generic summary for call instructions that have all arguments pushed
 // on the stack and return the result in a fixed register EAX.
 LocationSummary* Instruction::MakeCallSummary() {
   Isolate* isolate = Isolate::Current();
   LocationSummary* result = new(isolate) LocationSummary(
       isolate, 0, 0, LocationSummary::kCall);
   result->set_out(0, Location::RegisterLocation(EAX));
   return result;
 }
@@ skipping 1994 matching lines @@
       isolate, kNumInputs, kNumTemps, LocationSummary::kCall);
   locs->set_in(0, Location::RegisterLocation(ECX));
   locs->set_in(1, Location::RegisterLocation(EDX));
   locs->set_out(0, Location::RegisterLocation(EAX));
   return locs;
 }
 
 
 // Inlines array allocation for known constant values.
 static void InlineArrayAllocation(FlowGraphCompiler* compiler,
-                                   intptr_t num_elements,
-                                   Label* slow_path,
-                                   Label* done) {
+                                  intptr_t num_elements,
+                                  Label* slow_path,
+                                  Label* done) {
   const Register kLengthReg = EDX;
   const Register kElemTypeReg = ECX;
-  const intptr_t kArraySize = Array::InstanceSize(num_elements);
-  Isolate* isolate = Isolate::Current();
-  Heap* heap = isolate->heap();
+  const intptr_t instance_size = Array::InstanceSize(num_elements);
 
-  __ movl(EAX, Address::Absolute(heap->TopAddress()));
-  __ movl(EBX, EAX);
-
-  __ addl(EBX, Immediate(kArraySize));
-  __ j(CARRY, slow_path);
-
-  // Check if the allocation fits into the remaining space.
-  // EAX: potential new object start.
-  // EBX: potential next object start.
-  __ cmpl(EBX, Address::Absolute(heap->EndAddress()));
-  __ j(ABOVE_EQUAL, slow_path);
-
-  // Successfully allocated the object(s), now update top to point to
-  // next object start and initialize the object.
-  __ movl(Address::Absolute(heap->TopAddress()), EBX);
-  __ addl(EAX, Immediate(kHeapObjectTag));
-  __ UpdateAllocationStatsWithSize(kArrayCid, kArraySize, kNoRegister);
-
-  // Initialize the tags.
-  // EAX: new object start as a tagged pointer.
-  {
-    uword tags = 0;
-    tags = RawObject::ClassIdTag::update(kArrayCid, tags);
-    tags = RawObject::SizeTag::update(kArraySize, tags);
-    __ movl(FieldAddress(EAX, Array::tags_offset()), Immediate(tags));
-  }
+  // Instance in EAX.
+  // Object end address in EBX.
+  __ TryAllocateArray(kArrayCid, instance_size, slow_path, Assembler::kFarJump,
+                      EAX,  // instance
+                      EBX);  // end address
 
   // Store the type argument field.
   __ StoreIntoObjectNoBarrier(EAX,
                               FieldAddress(EAX, Array::type_arguments_offset()),
                               kElemTypeReg);
 
   // Set the length field.
   __ StoreIntoObjectNoBarrier(EAX,
                               FieldAddress(EAX, Array::length_offset()),
                               kLengthReg);
@@ skipping 281 matching lines @@
                                 deopt_id(),
                                 kInstantiateTypeArgumentsRuntimeEntry,
                                 2,
                                 locs());
   __ Drop(2);  // Drop instantiator and uninstantiated type arguments.
   __ popl(result_reg);  // Pop instantiated type arguments.
   __ Bind(&type_arguments_instantiated);
 }
 
 
-LocationSummary* AllocateContextInstr::MakeLocationSummary(Isolate* isolate,
-                                                           bool opt) const {
-  if (opt) {
-    const intptr_t kNumInputs = 0;
-    const intptr_t kNumTemps = 2;
-    LocationSummary* locs = new(isolate) LocationSummary(
-        isolate, kNumInputs, kNumTemps, LocationSummary::kCallOnSlowPath);
-    locs->set_temp(0, Location::RegisterLocation(ECX));
-    locs->set_temp(1, Location::RegisterLocation(EBX));
-    locs->set_out(0, Location::RegisterLocation(EAX));
-    return locs;
-  }
+LocationSummary* AllocateUninitializedContextInstr::MakeLocationSummary(
+    Isolate* isolate,
+    bool opt) const {
+  ASSERT(opt);
   const intptr_t kNumInputs = 0;
   const intptr_t kNumTemps = 1;
   LocationSummary* locs = new(isolate) LocationSummary(
-      isolate, kNumInputs, kNumTemps, LocationSummary::kCall);
-  locs->set_temp(0, Location::RegisterLocation(EDX));
+      isolate, kNumInputs, kNumTemps, LocationSummary::kCallOnSlowPath);
+  locs->set_temp(0, Location::RegisterLocation(ECX));
   locs->set_out(0, Location::RegisterLocation(EAX));
   return locs;
 }
 
 
 class AllocateContextSlowPath : public SlowPathCode {
  public:
-  explicit AllocateContextSlowPath(AllocateContextInstr* instruction)
+  explicit AllocateContextSlowPath(
+      AllocateUninitializedContextInstr* instruction)
       : instruction_(instruction) { }
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler) {
     __ Comment("AllocateContextSlowPath");
     __ Bind(entry_label());
 
     LocationSummary* locs = instruction_->locs();
     ASSERT(!locs->live_registers()->Contains(locs->out(0)));
 
     compiler->SaveLiveRegisters(locs);
 
     __ movl(EDX, Immediate(instruction_->num_context_variables()));
     StubCode* stub_code = compiler->isolate()->stub_code();
     const ExternalLabel label(stub_code->AllocateContextEntryPoint());
     compiler->GenerateCall(instruction_->token_pos(),
                            &label,
                            RawPcDescriptors::kOther,
                            locs);
     ASSERT(instruction_->locs()->out(0).reg() == EAX);
     compiler->RestoreLiveRegisters(instruction_->locs());
     __ jmp(exit_label());
   }
 
  private:
-  AllocateContextInstr* instruction_;
+  AllocateUninitializedContextInstr* instruction_;
 };
 
 
+void AllocateUninitializedContextInstr::EmitNativeCode(
+    FlowGraphCompiler* compiler) {
+  ASSERT(compiler->is_optimizing());
+  Register temp = locs()->temp(0).reg();
+  Register result = locs()->out(0).reg();
+  // Try allocate the object.
+  AllocateContextSlowPath* slow_path = new AllocateContextSlowPath(this);
+  compiler->AddSlowPathCode(slow_path);
+  intptr_t instance_size = Context::InstanceSize(num_context_variables());
+
+  __ TryAllocateArray(kContextCid, instance_size, slow_path->entry_label(),
+                      Assembler::kFarJump,
+                      result,  // instance
+                      temp);  // end address
+
+  // Setup up number of context variables field.
+  __ movl(FieldAddress(result, Context::num_variables_offset()),
+          Immediate(num_context_variables()));
+
+  // Setup isolate field.
+  __ movl(FieldAddress(result, Context::isolate_offset()),
+          Immediate(reinterpret_cast<int32_t>(Isolate::Current())));
+
+  __ Bind(slow_path->exit_label());
+}
+
+
+LocationSummary* AllocateContextInstr::MakeLocationSummary(Isolate* isolate,
+                                                           bool opt) const {
+  const intptr_t kNumInputs = 0;
+  const intptr_t kNumTemps = 1;
+  LocationSummary* locs = new(isolate) LocationSummary(
+      isolate, kNumInputs, kNumTemps, LocationSummary::kCall);
+  locs->set_temp(0, Location::RegisterLocation(EDX));
+  locs->set_out(0, Location::RegisterLocation(EAX));
+  return locs;
+}
+
 
 void AllocateContextInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  if (compiler->is_optimizing()) {
-    Register temp0 = locs()->temp(0).reg();
-    Register temp1 = locs()->temp(1).reg();
-    Register result = locs()->out(0).reg();
-    // Try allocate the object.
-    AllocateContextSlowPath* slow_path = new AllocateContextSlowPath(this);
-    compiler->AddSlowPathCode(slow_path);
-    intptr_t instance_size = Context::InstanceSize(num_context_variables());
-    __ movl(temp1, Immediate(instance_size));
-    Isolate* isolate = Isolate::Current();
-    Heap* heap = isolate->heap();
-    __ movl(result, Address::Absolute(heap->TopAddress()));
-    __ addl(temp1, result);
-    // Check if the allocation fits into the remaining space.
-    // EAX: potential new object.
-    // EBX: potential next object start.
-    __ cmpl(temp1, Address::Absolute(heap->EndAddress()));
-    if (FLAG_use_slow_path) {
-      __ jmp(slow_path->entry_label());
-    } else {
-      __ j(ABOVE_EQUAL, slow_path->entry_label());
-    }
-
-    // Successfully allocated the object, now update top to point to
-    // next object start and initialize the object.
-    // EAX: new object.
-    // EBX: next object start.
-    // EDX: number of context variables.
-    __ movl(Address::Absolute(heap->TopAddress()), temp1);
-    __ addl(result, Immediate(kHeapObjectTag));
-    __ UpdateAllocationStatsWithSize(kContextCid, instance_size, kNoRegister);
-
-    // Calculate the size tag and write tags.
-    intptr_t size_tag = (instance_size > RawObject::SizeTag::kMaxSizeTag)
-        ? 0 : instance_size << (RawObject::kSizeTagPos - kObjectAlignmentLog2);
-
-    intptr_t tags = size_tag | RawObject::ClassIdTag::encode(kContextCid);
-    __ movl(FieldAddress(result, Context::tags_offset()), Immediate(tags));
-
-    // Setup up number of context variables field.
-    // EAX: new object.
-    __ movl(FieldAddress(result, Context::num_variables_offset()),
-            Immediate(num_context_variables()));
-
-    // Setup isolate field.
-    __ movl(FieldAddress(result, Context::isolate_offset()),
-            Immediate(reinterpret_cast<int32_t>(isolate)));
-
-    // Setup the parent field.
-    const Immediate& raw_null =
-        Immediate(reinterpret_cast<intptr_t>(Object::null()));
-    __ movl(FieldAddress(result, Context::parent_offset()), raw_null);
-
-    // Initialize the context variables.
-    // EAX: new object.
-    if (num_context_variables() > 0) {
-      Label loop;
-      __ leal(temp1, FieldAddress(result, Context::variable_offset(0)));
-      __ movl(temp0, Immediate(num_context_variables()));
-      __ Bind(&loop);
-      __ decl(temp0);
-      __ movl(Address(temp1, temp0, TIMES_4, 0), raw_null);
-      __ j(NOT_ZERO, &loop, Assembler::kNearJump);
-    }
-    // EAX: new object.
-    __ Bind(slow_path->exit_label());
-    return;
-  }
-
   ASSERT(locs()->temp(0).reg() == EDX);
   ASSERT(locs()->out(0).reg() == EAX);
 
   __ movl(EDX, Immediate(num_context_variables()));
   StubCode* stub_code = compiler->isolate()->stub_code();
   const ExternalLabel label(stub_code->AllocateContextEntryPoint());
   compiler->GenerateCall(token_pos(),
                          &label,
                          RawPcDescriptors::kOther,
                          locs());
@@ skipping 4042 matching lines @@
   __ movl(EDX, Immediate(kInvalidObjectPointer));
   __ movl(EDX, Immediate(kInvalidObjectPointer));
 #endif
 }
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_IA32