VM: Replace StoreVMField with StoreInstanceField.

runtime/vm/flow_graph_optimizer.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/flow_graph_optimizer.h"
 
 #include "vm/bit_vector.h"
 #include "vm/cha.h"
 #include "vm/cpu.h"
 #include "vm/dart_entry.h"
@@ skipping 2198 matching lines @@
   const String& field_name =
       String::Handle(Field::NameFromGetter(call->function_name()));
   const Field& field = Field::ZoneHandle(GetField(class_ids[0], field_name));
   ASSERT(!field.IsNull());
 
   if (InstanceCallNeedsClassCheck(call)) {
     AddReceiverCheck(call);
   }
   LoadFieldInstr* load = new LoadFieldInstr(
       new Value(call->ArgumentAt(0)),
-      field.Offset(),
+      &field,
       AbstractType::ZoneHandle(field.type()),
       field.is_final());
-  load->set_field(&field);
   if (field.guarded_cid() != kIllegalCid) {
     if (!field.is_nullable() || (field.guarded_cid() == kNullCid)) {
       load->set_result_cid(field.guarded_cid());
     }
     FlowGraph::AddToGuardedFields(flow_graph_->guarded_fields(), &field);
   }
 
   // Discard the environment from the original instruction because the load
   // can't deoptimize.
   call->RemoveEnvironment();
@@ skipping 452 matching lines @@
   ic_data.GetCheckAt(0, &class_ids, &target);
   MethodRecognizer::Kind recognized_kind =
       MethodRecognizer::RecognizeKind(target);
 
   if ((recognized_kind == MethodRecognizer::kGrowableArraySetData) &&
       (ic_data.NumberOfChecks() == 1) &&
       (class_ids[0] == kGrowableObjectArrayCid)) {
     // This is an internal method, no need to check argument types.
     Definition* array = call->ArgumentAt(0);
     Definition* value = call->ArgumentAt(1);
-    StoreVMFieldInstr* store = new StoreVMFieldInstr(
+    StoreInstanceFieldInstr* store = new StoreInstanceFieldInstr(
+        GrowableObjectArray::data_offset(),
         new Value(array),
-        GrowableObjectArray::data_offset(),
         new Value(value),
-        Type::ZoneHandle());
+        kEmitStoreBarrier);
     ReplaceCall(call, store);
     return true;
   }
 
   if ((recognized_kind == MethodRecognizer::kGrowableArraySetLength) &&
       (ic_data.NumberOfChecks() == 1) &&
       (class_ids[0] == kGrowableObjectArrayCid)) {
     // This is an internal method, no need to check argument types nor
     // range.
     Definition* array = call->ArgumentAt(0);
     Definition* value = call->ArgumentAt(1);
-    StoreVMFieldInstr* store = new StoreVMFieldInstr(
+    StoreInstanceFieldInstr* store = new StoreInstanceFieldInstr(
+        GrowableObjectArray::length_offset(),
         new Value(array),
-        GrowableObjectArray::length_offset(),
         new Value(value),
-        Type::ZoneHandle());
+        kEmitStoreBarrier);
     ReplaceCall(call, store);
     return true;
   }
 
   if (((recognized_kind == MethodRecognizer::kStringBaseCodeUnitAt) ||
        (recognized_kind == MethodRecognizer::kStringBaseCharAt)) &&
       (ic_data.NumberOfChecks() == 1) &&
       ((class_ids[0] == kOneByteStringCid) ||
        (class_ids[0] == kTwoByteStringCid))) {
     return TryReplaceInstanceCallWithInline(call);
@@ skipping 2230 matching lines @@
           field_ = load_field->field();
         } else {
           kind_ = kVMField;
           offset_in_bytes_ = load_field->offset_in_bytes();
         }
         *is_load = true;
         break;
       }
 
       case Instruction::kStoreInstanceField: {
-        StoreInstanceFieldInstr* store_instance_field =
+        StoreInstanceFieldInstr* store =
             instr->AsStoreInstanceField();
-        kind_ = kField;
-        representation_ = store_instance_field->
-            RequiredInputRepresentation(StoreInstanceFieldInstr::kValuePos);
-        instance_ =
-            OriginalDefinition(store_instance_field->instance()->definition());
-        field_ = &store_instance_field->field();
-        break;
-      }
-
-      case Instruction::kStoreVMField: {
-        StoreVMFieldInstr* store_vm_field = instr->AsStoreVMField();
-        kind_ = kVMField;
-        representation_ = store_vm_field->
-            RequiredInputRepresentation(StoreVMFieldInstr::kValuePos);
-        instance_ = OriginalDefinition(store_vm_field->dest()->definition());
-        offset_in_bytes_ = store_vm_field->offset_in_bytes();
+        representation_ = store->RequiredInputRepresentation(
+            StoreInstanceFieldInstr::kValuePos);
+        instance_ = OriginalDefinition(store->instance()->definition());
+        if (!store->field().IsNull()) {
+          kind_ = kField;
+          field_ = &store->field();
+        } else {
+          kind_ = kVMField;
+          offset_in_bytes_ = store->offset_in_bytes();
+        }
         break;
       }
 
       case Instruction::kLoadStaticField:
         kind_ = kField;
         representation_ = instr->AsLoadStaticField()->representation();
         field_ = &instr->AsLoadStaticField()->StaticField();
         *is_load = true;
         break;
 
@@ skipping 264 matching lines @@
           return Alias::ConstantIndex(GetIndexId(Smi::Cast(index).Value()));
         }
       }
       return Alias::Indexes();
     }
 
     StoreInstanceFieldInstr* store_instance_field =
         instr->AsStoreInstanceField();
     if (store_instance_field != NULL) {
       Definition* instance = store_instance_field->instance()->definition();
-      return Alias::Field(GetInstanceFieldId(instance,
-                                             store_instance_field->field()));
-    }
-
-    StoreVMFieldInstr* store_vm_field = instr->AsStoreVMField();
-    if (store_vm_field != NULL) {
-      return Alias::VMField(store_vm_field->offset_in_bytes());
+      if (!store_instance_field->field().IsNull()) {
+        return Alias::Field(GetInstanceFieldId(instance,
+                                               store_instance_field->field()));
+      }
+      return Alias::VMField(store_instance_field->offset_in_bytes());
     }
 
     if (instr->IsStoreContext()) {
       return Alias::CurrentContext();
     }
 
     StoreStaticFieldInstr* store_static_field = instr->AsStoreStaticField();
     if (store_static_field != NULL) {
       return Alias::Field(GetStaticFieldId(store_static_field->field()));
     }
@@ skipping 83 matching lines @@
   // this value is stored in a field, escapes to another function or
   // participates in a phi.
   static bool CanBeAliased(AllocateObjectInstr* alloc) {
     if (alloc->identity() == AllocateObjectInstr::kUnknown) {
       bool escapes = false;
       for (Value* use = alloc->input_use_list();
            use != NULL;
            use = use->next_use()) {
         Instruction* instr = use->instruction();
         if (instr->IsPushArgument() ||
-            (instr->IsStoreVMField()
-             && (use->use_index() != StoreVMFieldInstr::kObjectPos)) ||
             (instr->IsStoreInstanceField()
              && (use->use_index() != StoreInstanceFieldInstr::kInstancePos)) ||
             instr->IsStoreStaticField() ||
             instr->IsPhi() ||
             instr->IsAssertAssignable() ||
             instr->IsRedefinition()) {
           escapes = true;
           break;
         }
       }
@@ skipping 180 matching lines @@
 static Definition* GetStoredValue(Instruction* instr) {
   if (instr->IsStoreIndexed()) {
     return instr->AsStoreIndexed()->value()->definition();
   }
 
   StoreInstanceFieldInstr* store_instance_field = instr->AsStoreInstanceField();
   if (store_instance_field != NULL) {
     return store_instance_field->value()->definition();
   }
 
-  StoreVMFieldInstr* store_vm_field = instr->AsStoreVMField();
-  if (store_vm_field != NULL) {
-    return store_vm_field->value()->definition();
-  }
-
   StoreStaticFieldInstr* store_static_field = instr->AsStoreStaticField();
   if (store_static_field != NULL) {
     return store_static_field->value()->definition();
   }
 
   if (instr->IsStoreContext()) {
     return instr->InputAt(0)->definition();
   }
 
   UNREACHABLE();  // Should only be called for supported store instructions.
@@ skipping 1725 matching lines @@
         SetValue(instr, Smi::ZoneHandle(
             Smi::New(Array::Cast(constant->value()).Length())));
         return;
       }
     }
   }
   SetValue(instr, non_constant_);
 }
 
 
-void ConstantPropagator::VisitStoreVMField(StoreVMFieldInstr* instr) {
-  SetValue(instr, instr->value()->definition()->constant_value());
-}
-
-
 void ConstantPropagator::VisitInstantiateType(InstantiateTypeInstr* instr) {
   const Object& object =
       instr->instantiator()->definition()->constant_value();
   if (IsNonConstant(object)) {
     SetValue(instr, non_constant_);
     return;
   }
   if (IsConstant(object)) {
     if (instr->type().IsTypeParameter()) {
       if (object.IsNull()) {
@@ skipping 635 matching lines @@
       // Replace constant-valued instructions without observable side
       // effects.  Do this for smis only to avoid having to copy other
       // objects into the heap's old generation.
       if ((defn != NULL) &&
           IsConstant(defn->constant_value()) &&
           (defn->constant_value().IsSmi() || defn->constant_value().IsOld()) &&
           !defn->IsConstant() &&
           !defn->IsPushArgument() &&
           !defn->IsStoreIndexed() &&
           !defn->IsStoreInstanceField() &&
-          !defn->IsStoreStaticField() &&
-          !defn->IsStoreVMField()) {
+          !defn->IsStoreStaticField()) {
         if (FLAG_trace_constant_propagation) {
           OS::Print("Constant v%" Pd " = %s\n",
                     defn->ssa_temp_index(),
                     defn->constant_value().ToCString());
         }
         ConstantInstr* constant = graph_->GetConstant(defn->constant_value());
         defn->ReplaceUsesWith(constant);
         i.RemoveCurrentFromGraph();
       }
     }
@@ skipping 569 matching lines @@
     AllocateObjectInstr* alloc,
     const Class& cls,
     const ZoneGrowableArray<const Field*>& fields) {
   ZoneGrowableArray<Value*>* values =
       new ZoneGrowableArray<Value*>(fields.length());
 
   // Insert load instruction for every field.
   for (intptr_t i = 0; i < fields.length(); i++) {
     const Field* field = fields[i];
     LoadFieldInstr* load = new LoadFieldInstr(new Value(alloc),
-                                              field->Offset(),
+                                              field,
                                               AbstractType::ZoneHandle());
-    load->set_field(field);
     flow_graph_->InsertBefore(
         exit, load, NULL, Definition::kValue);
     values->Add(new Value(load));
   }
 
   MaterializeObjectInstr* mat = new MaterializeObjectInstr(cls, fields, values);
   flow_graph_->InsertBefore(exit, mat, NULL, Definition::kValue);
 
   // Replace all mentions of this allocation with a newly inserted
   // MaterializeObject instruction.
@@ skipping 51 matching lines @@
   }
 
   // Insert materializations at environment uses.
   for (intptr_t i = 0; i < exits.length(); i++) {
     CreateMaterializationAt(exits[i], alloc, alloc->cls(), *fields);
   }
 }
 
 
 }  // namespace dart