VM: Replace StoreVMField with StoreInstanceField.

runtime/vm/intermediate_language.h

 // 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.
 
 #ifndef VM_INTERMEDIATE_LANGUAGE_H_
 #define VM_INTERMEDIATE_LANGUAGE_H_
 
 #include "vm/allocation.h"
 #include "vm/ast.h"
 #include "vm/growable_array.h"
@@ skipping 630 matching lines @@
   M(StoreIndexed)                                                              \
   M(StoreInstanceField)                                                        \
   M(LoadStaticField)                                                           \
   M(StoreStaticField)                                                          \
   M(BooleanNegate)                                                             \
   M(InstanceOf)                                                                \
   M(CreateArray)                                                               \
   M(CreateClosure)                                                             \
   M(AllocateObject)                                                            \
   M(LoadField)                                                                 \
-  M(StoreVMField)                                                              \
   M(LoadUntagged)                                                              \
   M(LoadClassId)                                                               \
   M(InstantiateType)                                                           \
   M(InstantiateTypeArguments)                                                  \
   M(AllocateContext)                                                           \
   M(CloneContext)                                                              \
   M(BinarySmiOp)                                                               \
   M(UnarySmiOp)                                                                \
   M(UnaryDoubleOp)                                                             \
   M(CheckStackOverflow)                                                        \
@@ skipping 2821 matching lines @@
 
 
 class StoreInstanceFieldInstr : public TemplateDefinition<2> {
  public:
   StoreInstanceFieldInstr(const Field& field,
                           Value* instance,
                           Value* value,
                           StoreBarrierType emit_store_barrier,
                           bool is_initialization = false)
       : field_(field),
+        offset_in_bytes_(field.Offset()),
+        emit_store_barrier_(emit_store_barrier),
+        is_initialization_(is_initialization) {
+    SetInputAt(kInstancePos, instance);
+    SetInputAt(kValuePos, value);
+  }
+
+  StoreInstanceFieldInstr(intptr_t offset_in_bytes,
+                          Value* instance,
+                          Value* value,
+                          StoreBarrierType emit_store_barrier,
+                          bool is_initialization = false)
+      : field_(Field::Handle()),
+        offset_in_bytes_(offset_in_bytes),
         emit_store_barrier_(emit_store_barrier),
         is_initialization_(is_initialization) {
     SetInputAt(kInstancePos, instance);
     SetInputAt(kValuePos, value);
   }
 
   DECLARE_INSTRUCTION(StoreInstanceField)
 
   enum {
     kInstancePos = 0,
     kValuePos = 1
   };
 
   Value* instance() const { return inputs_[kInstancePos]; }
   Value* value() const { return inputs_[kValuePos]; }
 
   virtual CompileType* ComputeInitialType() const;
 
   const Field& field() const { return field_; }
+  intptr_t offset_in_bytes() const { return offset_in_bytes_; }
 
   bool ShouldEmitStoreBarrier() const {
     return value()->NeedsStoreBuffer()
         && (emit_store_barrier_ == kEmitStoreBarrier);
   }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
@@ skipping 19 matching lines @@
   friend class FlowGraphOptimizer;  // For ASSERT(initialization_).
 
   bool CanValueBeSmi() const {
     const intptr_t cid = value()->Type()->ToNullableCid();
     // Write barrier is skipped for nullable and non-nullable smis.
     ASSERT(cid != kSmiCid);
     return (cid == kDynamicCid);
   }
 
   const Field& field_;
+  intptr_t offset_in_bytes_;
   const StoreBarrierType emit_store_barrier_;
   const bool is_initialization_;  // Marks stores in the constructor.
 
   DISALLOW_COPY_AND_ASSIGN(StoreInstanceFieldInstr);
 };
 
 
 class GuardFieldInstr : public TemplateInstruction<1> {
  public:
   GuardFieldInstr(Value* value,
@@ skipping 677 matching lines @@
         type_(type),
         result_cid_(kDynamicCid),
         immutable_(immutable),
         recognized_kind_(MethodRecognizer::kUnknown),
         field_(NULL) {
     ASSERT(offset_in_bytes >= 0);
     ASSERT(type.IsZoneHandle());  // May be null if field is not an instance.
     SetInputAt(0, instance);
   }
 
+  LoadFieldInstr(Value* instance,
+                 const Field* field,
+                 const AbstractType& type,
+                 bool immutable = false)
+      : offset_in_bytes_(field->Offset()),
+        type_(type),
+        result_cid_(kDynamicCid),
+        immutable_(immutable),
+        recognized_kind_(MethodRecognizer::kUnknown),
+        field_(field) {
+    ASSERT(field->IsZoneHandle());
+    ASSERT(type.IsZoneHandle());  // May be null if field is not an instance.
+    SetInputAt(0, instance);
+  }
+
   Value* instance() const { return inputs_[0]; }
   intptr_t offset_in_bytes() const { return offset_in_bytes_; }
   const AbstractType& type() const { return type_; }
   void set_result_cid(intptr_t value) { result_cid_ = value; }
   intptr_t result_cid() const { return result_cid_; }
 
   const Field* field() const { return field_; }
-  void set_field(const Field* field) { field_ = field; }
 
   virtual Representation representation() const;
 
   bool IsUnboxedLoad() const;
 
   bool IsPotentialUnboxedLoad() const;
 
   void set_recognized_kind(MethodRecognizer::Kind kind) {
     recognized_kind_ = kind;
   }
@@ skipping 33 matching lines @@
   const bool immutable_;
 
   MethodRecognizer::Kind recognized_kind_;
 
   const Field* field_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadFieldInstr);
 };
 
 
-class StoreVMFieldInstr : public TemplateDefinition<2> {
- public:
-  StoreVMFieldInstr(Value* dest,
-                    intptr_t offset_in_bytes,
-                    Value* value,
-                    const AbstractType& type)
-      : offset_in_bytes_(offset_in_bytes), type_(type) {
-    ASSERT(type.IsZoneHandle());  // May be null if field is not an instance.
-    SetInputAt(kValuePos, value);
-    SetInputAt(kObjectPos, dest);
-  }
-
-  enum {
-    kValuePos = 0,
-    kObjectPos = 1
-  };
-
-  DECLARE_INSTRUCTION(StoreVMField)
-  virtual CompileType* ComputeInitialType() const;
-
-  Value* value() const { return inputs_[kValuePos]; }
-  Value* dest() const { return inputs_[kObjectPos]; }
-  intptr_t offset_in_bytes() const { return offset_in_bytes_; }
-  const AbstractType& type() const { return type_; }
-
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
-
-  virtual bool CanDeoptimize() const { return false; }
-
-  virtual EffectSet Effects() const { return EffectSet::None(); }
-
-  virtual bool MayThrow() const { return false; }
-
- private:
-  const intptr_t offset_in_bytes_;
-  const AbstractType& type_;
-
-  DISALLOW_COPY_AND_ASSIGN(StoreVMFieldInstr);
-};
-
-
 class InstantiateTypeInstr : public TemplateDefinition<1> {
  public:
   InstantiateTypeInstr(intptr_t token_pos,
                        const AbstractType& type,
                        const Class& instantiator_class,
                        Value* instantiator)
       : token_pos_(token_pos),
         type_(type),
         instantiator_class_(instantiator_class) {
     ASSERT(type.IsZoneHandle());
@@ skipping 2850 matching lines @@
   ForwardInstructionIterator* current_iterator_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_