VM: Load allocation-top and -end via Thread.

runtime/vm/intermediate_language_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"  // Needed here to get TARGET_ARCH_X64.
 #if defined(TARGET_ARCH_X64)
 
 #include "vm/intermediate_language.h"
 
 #include "vm/dart_entry.h"
@@ skipping 1667 matching lines @@
                            RawPcDescriptors::kOther,
                            locs);
     __ MoveRegister(result_, RAX);
     compiler->RestoreLiveRegisters(locs);
     __ jmp(exit_label());
   }
 
   static void Allocate(FlowGraphCompiler* compiler,
                        Instruction* instruction,
                        const Class& cls,
-                       Register result) {
+                       Register result,
+                       Register temp) {
     if (compiler->intrinsic_mode()) {
       __ TryAllocate(cls,
                      compiler->intrinsic_slow_path_label(),
                      Assembler::kFarJump,
                      result,
-                     PP);
+                     PP,
+                     temp);
     } else {
       BoxAllocationSlowPath* slow_path =
           new BoxAllocationSlowPath(instruction, cls, result);
       compiler->AddSlowPathCode(slow_path);
 
       __ TryAllocate(cls,
                      slow_path->entry_label(),
                      Assembler::kFarJump,
                      result,
-                     PP);
+                     PP,
+                     temp);
       __ Bind(slow_path->exit_label());
     }
   }
 
  private:
   Instruction* instruction_;
   const Class& cls_;
   const Register result_;
 };
 
@@ skipping 37 matching lines @@
                              StoreInstanceFieldInstr* instruction,
                              Register box_reg,
                              const Class& cls,
                              Register instance_reg,
                              intptr_t offset,
                              Register temp) {
   Label done;
   __ movq(box_reg, FieldAddress(instance_reg, offset));
   __ CompareObject(box_reg, Object::null_object(), PP);
   __ j(NOT_EQUAL, &done);
-  BoxAllocationSlowPath::Allocate(compiler, instruction, cls, box_reg);
+  BoxAllocationSlowPath::Allocate(compiler, instruction, cls, box_reg, temp);
   __ movq(temp, box_reg);
   __ StoreIntoObject(instance_reg,
                      FieldAddress(instance_reg, offset),
                      temp);
 
   __ Bind(&done);
 }
 
 
 void StoreInstanceFieldInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
@@ skipping 17 matching lines @@
         case kFloat32x4Cid:
           cls = &compiler->float32x4_class();
           break;
         case kFloat64x2Cid:
           cls = &compiler->float64x2_class();
           break;
         default:
           UNREACHABLE();
       }
 
-      BoxAllocationSlowPath::Allocate(compiler, this, *cls, temp);
+      BoxAllocationSlowPath::Allocate(compiler, this, *cls, temp, temp2);
       __ movq(temp2, temp);
       __ StoreIntoObject(instance_reg,
                          FieldAddress(instance_reg, offset_in_bytes_),
                          temp2);
     } else {
       __ movq(temp, FieldAddress(instance_reg, offset_in_bytes_));
     }
     switch (cid) {
       case kDoubleCid:
         __ Comment("UnboxedDoubleStoreInstanceFieldInstr");
@@ skipping 232 matching lines @@
                                    intptr_t num_elements,
                                    Label* slow_path,
                                    Label* done) {
   const int kInlineArraySize = 12;  // Same as kInlineInstanceSize.
   const Register kLengthReg = R10;
   const Register kElemTypeReg = RBX;
   const intptr_t instance_size = Array::InstanceSize(num_elements);
 
   __ TryAllocateArray(kArrayCid, instance_size, slow_path, Assembler::kFarJump,
                       RAX,  // instance
-                      RCX);  // end address
+                      RCX,  // end address
+                      R13);  // temp
 
   // RAX: new object start as a tagged pointer.
   // Store the type argument field.
   __ InitializeFieldNoBarrier(RAX,
                               FieldAddress(RAX, Array::type_arguments_offset()),
                               kElemTypeReg);
 
   // Set the length field.
   __ InitializeFieldNoBarrier(RAX,
                               FieldAddress(RAX, Array::length_offset()),
@@ skipping 155 matching lines @@
     // Fall through.
     __ jmp(&load_pointer);
 
     if (!compiler->is_optimizing()) {
       locs()->live_registers()->Add(locs()->in(0));
     }
 
     {
       __ Bind(&load_double);
       BoxAllocationSlowPath::Allocate(
-          compiler, this, compiler->double_class(), result);
+          compiler, this, compiler->double_class(), result, temp);
       __ movq(temp, FieldAddress(instance_reg, offset_in_bytes()));
       __ movsd(value, FieldAddress(temp, Double::value_offset()));
       __ movsd(FieldAddress(result, Double::value_offset()), value);
       __ jmp(&done);
     }
 
     {
       __ Bind(&load_float32x4);
       BoxAllocationSlowPath::Allocate(
-          compiler, this, compiler->float32x4_class(), result);
+          compiler, this, compiler->float32x4_class(), result, temp);
       __ movq(temp, FieldAddress(instance_reg, offset_in_bytes()));
       __ movups(value, FieldAddress(temp, Float32x4::value_offset()));
       __ movups(FieldAddress(result, Float32x4::value_offset()), value);
       __ jmp(&done);
     }
 
     {
       __ Bind(&load_float64x2);
       BoxAllocationSlowPath::Allocate(
-          compiler, this, compiler->float64x2_class(), result);
+          compiler, this, compiler->float64x2_class(), result, temp);
       __ movq(temp, FieldAddress(instance_reg, offset_in_bytes()));
       __ movups(value, FieldAddress(temp, Float64x2::value_offset()));
       __ movups(FieldAddress(result, Float64x2::value_offset()), value);
       __ jmp(&done);
     }
 
     __ Bind(&load_pointer);
   }
   __ movq(result, FieldAddress(instance_reg, offset_in_bytes()));
   __ Bind(&done);
@@ skipping 102 matching lines @@
   __ Bind(&type_arguments_instantiated);
   ASSERT(instantiator_reg == result_reg);
 }
 
 
 LocationSummary* AllocateUninitializedContextInstr::MakeLocationSummary(
     Zone* zone,
     bool opt) const {
   ASSERT(opt);
   const intptr_t kNumInputs = 0;
-  const intptr_t kNumTemps = 1;
+  const intptr_t kNumTemps = 2;
   LocationSummary* locs = new(zone) LocationSummary(
       zone, kNumInputs, kNumTemps, LocationSummary::kCallOnSlowPath);
   locs->set_temp(0, Location::RegisterLocation(R10));
+  locs->set_temp(1, Location::RegisterLocation(R13));
   locs->set_out(0, Location::RegisterLocation(RAX));
   return locs;
 }
 
 
 class AllocateContextSlowPath : public SlowPathCode {
  public:
   explicit AllocateContextSlowPath(
       AllocateUninitializedContextInstr* instruction)
       : instruction_(instruction) { }
@@ skipping 29 matching lines @@
   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
+                      temp,  // end address
+                      locs()->temp(1).reg());
 
   // Setup up number of context variables field.
   __ movq(FieldAddress(result, Context::num_variables_offset()),
           Immediate(num_context_variables()));
 
   __ Bind(slow_path->exit_label());
 }
 
 
 LocationSummary* AllocateContextInstr::MakeLocationSummary(Zone* zone,
@@ skipping 820 matching lines @@
     __ orq(temp, right);
     __ testq(temp, Immediate(kSmiTagMask));
   }
   __ j(ZERO, deopt);
 }
 
 
 LocationSummary* BoxInstr::MakeLocationSummary(Zone* zone,
                                                      bool opt) const {
   const intptr_t kNumInputs = 1;
-  const intptr_t kNumTemps = 0;
+  const intptr_t kNumTemps = 1;
   LocationSummary* summary = new(zone) LocationSummary(
       zone, kNumInputs, kNumTemps, LocationSummary::kCallOnSlowPath);
   summary->set_in(0, Location::RequiresFpuRegister());
+  summary->set_temp(0, Location::RequiresRegister());
   summary->set_out(0, Location::RequiresRegister());
   return summary;
 }
 
 
 void BoxInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register out_reg = locs()->out(0).reg();
+  Register temp = locs()->temp(0).reg();
   XmmRegister value = locs()->in(0).fpu_reg();
 
   BoxAllocationSlowPath::Allocate(
-      compiler, this, compiler->BoxClassFor(from_representation()), out_reg);
+      compiler, this, compiler->BoxClassFor(from_representation()), out_reg,
+      temp);
   __ movsd(FieldAddress(out_reg, Double::value_offset()), value);
   switch (from_representation()) {
     case kUnboxedDouble:
       __ movsd(FieldAddress(out_reg, ValueOffset()), value);
       break;
     case kUnboxedFloat32x4:
     case kUnboxedFloat64x2:
     case kUnboxedInt32x4:
       __ movups(FieldAddress(out_reg, ValueOffset()), value);
       break;
@@ skipping 208 matching lines @@
     ASSERT(from_representation() == kUnboxedUint32);
     __ movl(out, value);
   }
   __ SmiTag(out);
 }
 
 
 LocationSummary* BoxInt64Instr::MakeLocationSummary(Zone* zone,
                                                     bool opt) const {
   const intptr_t kNumInputs = 1;
-  const intptr_t kNumTemps = 0;
+  const intptr_t kNumTemps = ValueFitsSmi() ? 0 : 1;
   LocationSummary* summary = new(zone) LocationSummary(
       zone,
       kNumInputs,
       kNumTemps,
       ValueFitsSmi() ? LocationSummary::kNoCall
                      : LocationSummary::kCallOnSlowPath);
   summary->set_in(0, Location::RequiresRegister());
+  if (!ValueFitsSmi()) {
+    summary->set_temp(0, Location::RequiresRegister());
+  }
   summary->set_out(0, Location::RequiresRegister());
   return summary;
 }
 
 
 void BoxInt64Instr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const Register out = locs()->out(0).reg();
   const Register value = locs()->in(0).reg();
+  const Register temp = locs()->temp(0).reg();
   __ MoveRegister(out, value);
   __ SmiTag(out);
   if (!ValueFitsSmi()) {
     Label done;
     __ j(NO_OVERFLOW, &done);
     BoxAllocationSlowPath::Allocate(
-        compiler, this, compiler->mint_class(), out);
+        compiler, this, compiler->mint_class(), out, temp);
     __ movq(FieldAddress(out, Mint::value_offset()), value);
     __ Bind(&done);
   }
 }
 
 
 LocationSummary* BinaryDoubleOpInstr::MakeLocationSummary(Zone* zone,
                                                           bool opt) const {
   const intptr_t kNumInputs = 2;
   const intptr_t kNumTemps = 0;
@@ skipping 2880 matching lines @@
   __ Drop(1);
   __ popq(result);
 }
 
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_X64