VM: Replace StoreVMField with StoreInstanceField.

runtime/vm/intermediate_language_arm.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_ARM.
 #if defined(TARGET_ARCH_ARM)
 
 #include "vm/intermediate_language.h"
 
 #include "vm/dart_entry.h"
@@ skipping 1621 matching lines @@
   StoreInstanceFieldInstr* instruction_;
   const Class& cls_;
 };
 
 
 LocationSummary* StoreInstanceFieldInstr::MakeLocationSummary(bool opt) const {
   const intptr_t kNumInputs = 2;
   const intptr_t kNumTemps = 0;
   LocationSummary* summary =
       new LocationSummary(kNumInputs, kNumTemps,
-          (field().guarded_cid() == kIllegalCid) || (is_initialization_)
+          !field().IsNull() &&
+          ((field().guarded_cid() == kIllegalCid) || is_initialization_)
           ? LocationSummary::kCallOnSlowPath
           : LocationSummary::kNoCall);
 
   summary->set_in(0, Location::RequiresRegister());
   if (IsUnboxedStore() && opt) {
     summary->set_in(1, Location::RequiresFpuRegister());
     summary->AddTemp(Location::RequiresRegister());
     summary->AddTemp(Location::RequiresRegister());
   } else if (IsPotentialUnboxedStore()) {
     summary->set_in(1, ShouldEmitStoreBarrier()
@@ skipping 41 matching lines @@
           new StoreInstanceFieldSlowPath(this, *cls);
       compiler->AddSlowPathCode(slow_path);
 
       __ TryAllocate(*cls,
                      slow_path->entry_label(),
                      temp,
                      temp2);
       __ Bind(slow_path->exit_label());
       __ MoveRegister(temp2, temp);
       __ StoreIntoObject(instance_reg,
-                         FieldAddress(instance_reg, field().Offset()),
+                         FieldAddress(instance_reg, offset_in_bytes_),
                          temp2);
     } else {
-      __ ldr(temp, FieldAddress(instance_reg, field().Offset()));
+      __ ldr(temp, FieldAddress(instance_reg, offset_in_bytes_));
     }
     switch (cid) {
       case kDoubleCid:
         __ Comment("UnboxedDoubleStoreInstanceFieldInstr");
         __ StoreDToOffset(value, temp, Double::value_offset() - kHeapObjectTag);
         break;
       case kFloat32x4Cid:
         __ Comment("UnboxedFloat32x4StoreInstanceFieldInstr");
         __ StoreDToOffset(value, temp,
             Float32x4::value_offset() - kHeapObjectTag);
@@ skipping 44 matching lines @@
         locs()->live_registers()->Add(locs()->in(1));
     }
 
     {
       __ Bind(&store_double);
       Label copy_double;
       StoreInstanceFieldSlowPath* slow_path =
           new StoreInstanceFieldSlowPath(this, compiler->double_class());
       compiler->AddSlowPathCode(slow_path);
 
-      __ ldr(temp, FieldAddress(instance_reg, field().Offset()));
+      __ ldr(temp, FieldAddress(instance_reg, offset_in_bytes_));
       __ CompareImmediate(temp,
                           reinterpret_cast<intptr_t>(Object::null()));
       __ b(&copy_double, NE);
 
       __ TryAllocate(compiler->double_class(),
                      slow_path->entry_label(),
                      temp,
                      temp2);
       __ Bind(slow_path->exit_label());
       __ MoveRegister(temp2, temp);
       __ StoreIntoObject(instance_reg,
-                         FieldAddress(instance_reg, field().Offset()),
+                         FieldAddress(instance_reg, offset_in_bytes_),
                          temp2);
       __ Bind(&copy_double);
       __ LoadDFromOffset(fpu_temp,
                          value_reg,
                          Double::value_offset() - kHeapObjectTag);
       __ StoreDToOffset(fpu_temp,
                         temp,
                         Double::value_offset() - kHeapObjectTag);
       __ b(&skip_store);
     }
 
     {
       __ Bind(&store_float32x4);
       Label copy_float32x4;
       StoreInstanceFieldSlowPath* slow_path =
           new StoreInstanceFieldSlowPath(this, compiler->float32x4_class());
       compiler->AddSlowPathCode(slow_path);
 
-      __ ldr(temp, FieldAddress(instance_reg, field().Offset()));
+      __ ldr(temp, FieldAddress(instance_reg, offset_in_bytes_));
       __ CompareImmediate(temp,
                           reinterpret_cast<intptr_t>(Object::null()));
       __ b(&copy_float32x4, NE);
 
       __ TryAllocate(compiler->float32x4_class(),
                      slow_path->entry_label(),
                      temp,
                      temp2);
       __ Bind(slow_path->exit_label());
       __ MoveRegister(temp2, temp);
       __ StoreIntoObject(instance_reg,
-                         FieldAddress(instance_reg, field().Offset()),
+                         FieldAddress(instance_reg, offset_in_bytes_),
                          temp2);
       __ Bind(&copy_float32x4);
       // TODO(zra): Maybe use vldmd here.
       __ LoadDFromOffset(fpu_temp, value_reg,
           Float32x4::value_offset() - kHeapObjectTag);
       __ LoadDFromOffset(fpu_temp_odd, value_reg,
           Float32x4::value_offset() + 2 * kWordSize - kHeapObjectTag);
       __ StoreDToOffset(fpu_temp, temp,
           Float32x4::value_offset() - kHeapObjectTag);
       __ StoreDToOffset(fpu_temp_odd, temp,
           Float32x4::value_offset() + 2 * kWordSize - kHeapObjectTag);
       __ b(&skip_store);
     }
 
     __ Bind(&store_pointer);
   }
 
   if (ShouldEmitStoreBarrier()) {
     Register value_reg = locs()->in(1).reg();
     __ StoreIntoObject(instance_reg,
-                       FieldAddress(instance_reg, field().Offset()),
+                       FieldAddress(instance_reg, offset_in_bytes_),
                        value_reg,
                        CanValueBeSmi());
   } else {
     if (locs()->in(1).IsConstant()) {
       __ StoreIntoObjectNoBarrier(
           instance_reg,
-          FieldAddress(instance_reg, field().Offset()),
+          FieldAddress(instance_reg, offset_in_bytes_),
           locs()->in(1).constant());
     } else {
       Register value_reg = locs()->in(1).reg();
       __ StoreIntoObjectNoBarrier(instance_reg,
-          FieldAddress(instance_reg, field().Offset()), value_reg);
+          FieldAddress(instance_reg, offset_in_bytes_), value_reg);
     }
   }
   __ Bind(&skip_store);
 }
 
 
 LocationSummary* LoadStaticFieldInstr::MakeLocationSummary(bool opt) const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
   LocationSummary* summary =
@@ skipping 3122 matching lines @@
 void BooleanNegateInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register value = locs()->in(0).reg();
   Register result = locs()->out().reg();
 
   __ LoadObject(result, Bool::True());
   __ cmp(result, ShifterOperand(value));
   __ LoadObject(result, Bool::False(), EQ);
 }
 
 
-LocationSummary* StoreVMFieldInstr::MakeLocationSummary(bool opt) const {
-  const intptr_t kNumInputs = 2;
-  const intptr_t kNumTemps = 0;
-  LocationSummary* locs =
-      new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
-  locs->set_in(0, value()->NeedsStoreBuffer() ? Location::WritableRegister()
-                                              : Location::RequiresRegister());
-  locs->set_in(1, Location::RequiresRegister());
-  return locs;
-}
-
-
-void StoreVMFieldInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  Register value_reg = locs()->in(0).reg();
-  Register dest_reg = locs()->in(1).reg();
-
-  if (value()->NeedsStoreBuffer()) {
-    __ StoreIntoObject(dest_reg, FieldAddress(dest_reg, offset_in_bytes()),
-                       value_reg);
-  } else {
-    __ StoreIntoObjectNoBarrier(
-        dest_reg, FieldAddress(dest_reg, offset_in_bytes()), value_reg);
-  }
-}
-
-
 LocationSummary* AllocateObjectInstr::MakeLocationSummary(bool opt) const {
   return MakeCallSummary();
 }
 
 
 void AllocateObjectInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const Code& stub = Code::Handle(StubCode::GetAllocationStubForClass(cls()));
   const ExternalLabel label(cls().ToCString(), stub.EntryPoint());
   compiler->GenerateCall(token_pos(),
                          &label,
@@ skipping 17 matching lines @@
   compiler->GenerateCall(token_pos(),
                          &label,
                          PcDescriptors::kOther,
                          locs());
   __ Drop(2);  // Discard type arguments and receiver.
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM