Use enums for the index of IL operands.

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 2201 matching lines @@
 
   TargetEntryInstr* constant_target_;
 
   DISALLOW_COPY_AND_ASSIGN(BranchInstr);
 };
 
 
 class StoreContextInstr : public TemplateInstruction<1> {
  public:
   explicit StoreContextInstr(Value* value) {
-    SetInputAt(0, value);
+    SetInputAt(kValuePos, value);
   }
 
+  enum {
+    kValuePos = 0
+  };
+
   DECLARE_INSTRUCTION(StoreContext)
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
-  Value* value() const { return inputs_[0]; }
+  Value* value() const { return inputs_[kValuePos]; }
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
   virtual bool MayThrow() const { return false; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(StoreContextInstr);
 };
@@ skipping 1172 matching lines @@
 
 
 class StoreInstanceFieldInstr : public TemplateDefinition<2> {
  public:
   StoreInstanceFieldInstr(const Field& field,
                           Value* instance,
                           Value* value,
                           StoreBarrierType emit_store_barrier)
       : field_(field),
         emit_store_barrier_(emit_store_barrier) {
-    SetInputAt(0, instance);
-    SetInputAt(1, value);
+    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_; }
 
-  Value* instance() const { return inputs_[0]; }
-  Value* value() const { return inputs_[1]; }
   bool ShouldEmitStoreBarrier() const {
     return value()->NeedsStoreBuffer()
         && (emit_store_barrier_ == kEmitStoreBarrier);
   }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   // Currently CSE/LICM don't operate on any instructions that can be affected
@@ skipping 84 matching lines @@
  private:
   DISALLOW_COPY_AND_ASSIGN(LoadStaticFieldInstr);
 };
 
 
 class StoreStaticFieldInstr : public TemplateDefinition<1> {
  public:
   StoreStaticFieldInstr(const Field& field, Value* value)
       : field_(field) {
     ASSERT(field.IsZoneHandle());
-    SetInputAt(0, value);
+    SetInputAt(kValuePos, value);
   }
 
+  enum {
+    kValuePos = 0
+  };
+
   DECLARE_INSTRUCTION(StoreStaticField)
   virtual CompileType* ComputeInitialType() const;
 
   const Field& field() const { return field_; }
-  Value* value() const { return inputs_[0]; }
+  Value* value() const { return inputs_[kValuePos]; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   // Currently CSE/LICM don't operate on any instructions that can be affected
   // by stores/loads. LoadOptimizer handles loads separately. Hence stores
   // are marked as having no side-effects.
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
@@ skipping 134 matching lines @@
   StoreIndexedInstr(Value* array,
                     Value* index,
                     Value* value,
                     StoreBarrierType emit_store_barrier,
                     intptr_t index_scale,
                     intptr_t class_id,
                     intptr_t deopt_id)
       : emit_store_barrier_(emit_store_barrier),
         index_scale_(index_scale),
         class_id_(class_id) {
-    SetInputAt(0, array);
-    SetInputAt(1, index);
-    SetInputAt(2, value);
+    SetInputAt(kArrayPos, array);
+    SetInputAt(kIndexPos, index);
+    SetInputAt(kValuePos, value);
     deopt_id_ = deopt_id;
   }
 
   DECLARE_INSTRUCTION(StoreIndexed)
 
-  Value* array() const { return inputs_[0]; }
-  Value* index() const { return inputs_[1]; }
-  Value* value() const { return inputs_[2]; }
+  enum {
+    kArrayPos = 0,
+    kIndexPos = 1,
+    kValuePos = 2
+  };
+
+  Value* array() const { return inputs_[kArrayPos]; }
+  Value* index() const { return inputs_[kIndexPos]; }
+  Value* value() const { return inputs_[kValuePos]; }
+
   intptr_t index_scale() const { return index_scale_; }
   intptr_t class_id() const { return class_id_; }
 
   bool ShouldEmitStoreBarrier() const {
     return value()->NeedsStoreBuffer()
         && (emit_store_barrier_ == kEmitStoreBarrier);
   }
 
   virtual bool CanDeoptimize() const { return false; }
 
@@ skipping 470 matching lines @@
 
 
 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(0, value);
-    SetInputAt(1, dest);
+    SetInputAt(kValuePos, value);
+    SetInputAt(kDestPos, dest);
   }
 
+  enum {
+    kValuePos = 0,
+    kDestPos = 1
+  };
+
   DECLARE_INSTRUCTION(StoreVMField)
   virtual CompileType* ComputeInitialType() const;
 
-  Value* value() const { return inputs_[0]; }
-  Value* dest() const { return inputs_[1]; }
+  Value* value() const { return inputs_[kValuePos]; }
+  Value* dest() const { return inputs_[kDestPos]; }
   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; }
@@ skipping 2640 matching lines @@
   ForwardInstructionIterator* current_iterator_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_