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

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"
@@ skipping 2033 matching lines @@
                                   Label* done) {
   const int kInlineArraySize = 12;  // Same as kInlineInstanceSize.
   const Register kLengthReg = EDX;
   const Register kElemTypeReg = ECX;
   const intptr_t instance_size = Array::InstanceSize(num_elements);
 
   // Instance in EAX.
   // Object end address in EBX.
   __ TryAllocateArray(kArrayCid, instance_size, slow_path, Assembler::kFarJump,
                       EAX,  // instance
-                      EBX);  // end address
+                      EBX,  // end address
+                      EDI);  // temp
 
   // Store the type argument field.
   __ InitializeFieldNoBarrier(EAX,
                               FieldAddress(EAX, Array::type_arguments_offset()),
                               kElemTypeReg);
 
   // Set the length field.
   __ InitializeFieldNoBarrier(EAX,
                               FieldAddress(EAX, Array::length_offset()),
                               kLengthReg);
@@ skipping 301 matching lines @@
   __ popl(result_reg);  // Pop instantiated type arguments.
   __ Bind(&type_arguments_instantiated);
 }
 
 
 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(ECX));
+  locs->set_temp(1, Location::RegisterLocation(EDI));
   locs->set_out(0, Location::RegisterLocation(EAX));
   return locs;
 }
 
 
 class AllocateContextSlowPath : public SlowPathCode {
  public:
   explicit AllocateContextSlowPath(
       AllocateUninitializedContextInstr* instruction)
       : instruction_(instruction) { }
@@ skipping 20 matching lines @@
 
  private:
   AllocateUninitializedContextInstr* instruction_;
 };
 
 
 void AllocateUninitializedContextInstr::EmitNativeCode(
     FlowGraphCompiler* compiler) {
   ASSERT(compiler->is_optimizing());
   Register temp = locs()->temp(0).reg();
+  Register temp2 = 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());
 
   __ TryAllocateArray(kContextCid, instance_size, slow_path->entry_label(),
                       Assembler::kFarJump,
                       result,  // instance
-                      temp);  // end address
+                      temp,  // end address
+                      temp2);  // temp
 
   // Setup up number of context variables field.
   __ movl(FieldAddress(result, Context::num_variables_offset()),
           Immediate(num_context_variables()));
 
   __ Bind(slow_path->exit_label());
 }
 
 
 LocationSummary* AllocateContextInstr::MakeLocationSummary(Zone* zone,
@@ skipping 877 matching lines @@
     __ orl(temp, right);
     __ testl(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();
   XmmRegister value = locs()->in(0).fpu_reg();
 
   BoxAllocationSlowPath::Allocate(
       compiler,
       this,
       compiler->BoxClassFor(from_representation()),
       out_reg,
-      kNoRegister);
+      locs()->temp(0).reg());
 
   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 127 matching lines @@
       EmitSmiConversion(compiler);
       __ Bind(&done);
     }
   }
 }
 
 
 LocationSummary* BoxInteger32Instr::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);
   const bool needs_writable_input = ValueFitsSmi() ||
       (from_representation() == kUnboxedUint32);
   summary->set_in(0, needs_writable_input ? Location::RequiresRegister()
                                           : Location::WritableRegister());
+  if (!ValueFitsSmi()) {
+    summary->set_temp(0, Location::RequiresRegister());
+  }
   summary->set_out(0, ValueFitsSmi() ? Location::SameAsFirstInput()
                                      : Location::RequiresRegister());
   return summary;
 }
 
 
 void BoxInteger32Instr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const Register value = locs()->in(0).reg();
   const Register out = locs()->out(0).reg();
 
   __ MoveRegister(out, value);
   __ shll(out, Immediate(kSmiTagSize));
   if (!ValueFitsSmi()) {
     Label done;
     ASSERT(value != out);
     if (from_representation() == kUnboxedInt32) {
       __ j(NO_OVERFLOW, &done);
     } else {
       __ testl(value, Immediate(0xC0000000));
       __ j(ZERO, &done);
     }
 
     // Allocate a mint.
     // Value input is writable register and has to be manually preserved
     // on the slow path.
     locs()->live_registers()->Add(locs()->in(0), kUnboxedInt32);
     BoxAllocationSlowPath::Allocate(
-        compiler, this, compiler->mint_class(), out, kNoRegister);
+        compiler, this, compiler->mint_class(), out, locs()->temp(0).reg());
     __ movl(FieldAddress(out, Mint::value_offset()), value);
     if (from_representation() == kUnboxedInt32) {
       __ sarl(value, Immediate(31));  // Sign extend.
       __ movl(FieldAddress(out, Mint::value_offset() + kWordSize), value);
     } else {
       __ movl(FieldAddress(out, Mint::value_offset() + kWordSize),
               Immediate(0));
     }
     __ Bind(&done);
   }
@@ skipping 54 matching lines @@
   // 3. Restore lower half if result is a smi.
   __ subl(value_lo, Immediate(0x40000000));
   __ movl(out_reg, value_lo);
   __ SmiTag(out_reg);
   __ jmp(&done);
   __ Bind(&not_smi);
   // 3. Restore lower half of input before using it.
   __ subl(value_lo, Immediate(0x40000000));
 
   BoxAllocationSlowPath::Allocate(
-      compiler, this, compiler->mint_class(), out_reg, kNoRegister);
+      compiler, this, compiler->mint_class(), out_reg, locs()->temp(0).reg());
   __ movl(FieldAddress(out_reg, Mint::value_offset()), value_lo);
   __ movl(FieldAddress(out_reg, Mint::value_offset() + kWordSize), value_hi);
   __ Bind(&done);
 }
 
 
 LocationSummary* UnboxInteger32Instr::MakeLocationSummary(Zone* zone,
                                                           bool opt) const {
   const intptr_t value_cid = value()->Type()->ToCid();
   const intptr_t kNumInputs = 1;
@@ skipping 86 matching lines @@
                       out_of_range);
     __ Bind(&done);
   }
 }
 
 
 LocationSummary* LoadCodeUnitsInstr::MakeLocationSummary(Zone* zone,
                                                          bool opt) const {
   const bool might_box = (representation() == kTagged) && !can_pack_into_smi();
   const intptr_t kNumInputs = 2;
-  const intptr_t kNumTemps = might_box ? 1 : 0;
+  const intptr_t kNumTemps = might_box ? 2 : 0;
   LocationSummary* summary = new(zone) LocationSummary(
       zone, kNumInputs, kNumTemps,
       might_box ? LocationSummary::kCallOnSlowPath : LocationSummary::kNoCall);
   summary->set_in(0, Location::RequiresRegister());
   // The smi index is either untagged (element size == 1), or it is left smi
   // tagged (for all element sizes > 1).
   summary->set_in(1, (index_scale() == 1) ? Location::WritableRegister()
                                           : Location::RequiresRegister());
   if (might_box) {
     summary->set_temp(0, Location::RequiresRegister());
+    summary->set_temp(1, Location::RequiresRegister());
   }
 
   if (representation() == kUnboxedMint) {
     summary->set_out(0, Location::Pair(Location::RequiresRegister(),
                                        Location::RequiresRegister()));
   } else {
     ASSERT(representation() == kTagged);
     summary->set_out(0, Location::RequiresRegister());
   }
 
@@ skipping 59 matching lines @@
         break;
       default:
         UNREACHABLE();
         break;
     }
     if (can_pack_into_smi()) {
       __ SmiTag(result);
     } else {
       // If the value cannot fit in a smi then allocate a mint box for it.
       Register temp = locs()->temp(0).reg();
+      Register temp2 = locs()->temp(1).reg();
       // Temp register needs to be manually preserved on allocation slow-path.
       locs()->live_registers()->Add(locs()->temp(0), kUnboxedInt32);
 
       ASSERT(temp != result);
       __ MoveRegister(temp, result);
       __ SmiTag(result);
 
       Label done;
       __ testl(temp, Immediate(0xC0000000));
       __ j(ZERO, &done);
       BoxAllocationSlowPath::Allocate(
-          compiler, this, compiler->mint_class(), result, kNoRegister);
+          compiler, this, compiler->mint_class(), result, temp2);
       __ movl(FieldAddress(result, Mint::value_offset()), temp);
       __ movl(FieldAddress(result, Mint::value_offset() + kWordSize),
               Immediate(0));
       __ Bind(&done);
     }
   }
 }
 
 
 LocationSummary* BinaryDoubleOpInstr::MakeLocationSummary(Zone* zone,
@@ skipping 3023 matching lines @@
   __ Drop(1);
   __ popl(result);
 }
 
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_IA32