Set instruction/use_index when adding an input to an IL instruction.

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 310 matching lines @@
   kUnboxedDouble,
   kUnboxedMint
 };
 
 
 // An embedded container with N elements of type T.  Used (with partial
 // specialization for N=0) because embedded arrays cannot have size 0.
 template<typename T, intptr_t N>
 class EmbeddedArray {
  public:
-  EmbeddedArray() {
-    for (intptr_t i = 0; i < N; i++) elements_[i] = NULL;
-  }
+  EmbeddedArray() : elements_() { }
 
   intptr_t length() const { return N; }
 
   const T& operator[](intptr_t i) const {
     ASSERT(i < length());
     return elements_[i];
   }
 
   T& operator[](intptr_t i) {
     ASSERT(i < length());
@@ skipping 151 matching lines @@
   virtual BlockEntryInstr* AsBlockEntry() { return NULL; }
 
   bool IsDefinition() { return (AsDefinition() != NULL); }
   virtual Definition* AsDefinition() { return NULL; }
 
   bool IsControl() { return (AsControl() != NULL); }
   virtual ControlInstruction* AsControl() { return NULL; }
 
   virtual intptr_t InputCount() const = 0;
   virtual Value* InputAt(intptr_t i) const = 0;
-  virtual void SetInputAt(intptr_t i, Value* value) = 0;
+  void SetInputAt(intptr_t i, Value* value) {
+    ASSERT(value != NULL);
+    value->set_instruction(this);
+    value->set_use_index(i);
+    RawSetInputAt(i, value);
+  }
 
   // Remove all inputs (including in the environment) from their
   // definition's use lists.
   void UnuseAllInputs();
 
   // Call instructions override this function and return the number of
   // pushed arguments.
   virtual intptr_t ArgumentCount() const = 0;
   virtual PushArgumentInstr* PushArgumentAt(intptr_t index) const {
     UNREACHABLE();
@@ skipping 177 matching lines @@
   friend class CheckSmiInstr;
   friend class CheckArrayBoundInstr;
   friend class CheckEitherNonSmiInstr;
   friend class LICM;
   friend class DoubleToSmiInstr;
   friend class DoubleToDoubleInstr;
   friend class InvokeMathCFunctionInstr;
   friend class FlowGraphOptimizer;
   friend class LoadIndexedInstr;
 
+  virtual void RawSetInputAt(intptr_t i, Value* value) = 0;
+
   intptr_t deopt_id_;
   intptr_t lifetime_position_;  // Position used by register allocator.
   Instruction* previous_;
   Instruction* next_;
   Environment* env_;
   intptr_t expr_id_;
 
   DISALLOW_COPY_AND_ASSIGN(Instruction);
 };
 
 
 template<intptr_t N>
 class TemplateInstruction: public Instruction {
  public:
   TemplateInstruction<N>() : locs_(NULL) { }
 
   virtual intptr_t InputCount() const { return N; }
   virtual Value* InputAt(intptr_t i) const { return inputs_[i]; }
-  virtual void SetInputAt(intptr_t i, Value* value) {
-    ASSERT(value != NULL);
-    inputs_[i] = value;
-  }
 
   virtual LocationSummary* locs() {
     if (locs_ == NULL) {
       locs_ = MakeLocationSummary();
     }
     return locs_;
   }
 
  protected:
   EmbeddedArray<Value*, N> inputs_;
 
  private:
+  virtual void RawSetInputAt(intptr_t i, Value* value) {
+    inputs_[i] = value;
+  }
+
   LocationSummary* locs_;
 };
 
 
 class MoveOperands : public ZoneAllocated {
  public:
   MoveOperands(Location dest, Location src) : dest_(dest), src_(src) { }
 
   Location src() const { return src_; }
   Location dest() const { return dest_; }
@@ skipping 161 matching lines @@
       GrowableArray<intptr_t>* parent,
       GrowableArray<BitVector*>* assigned_vars,
       intptr_t variable_count,
       intptr_t fixed_parameter_count);
 
   virtual intptr_t InputCount() const { return 0; }
   virtual Value* InputAt(intptr_t i) const {
     UNREACHABLE();
     return NULL;
   }
-  virtual void SetInputAt(intptr_t i, Value* value) { UNREACHABLE(); }
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return false; }
 
   intptr_t try_index() const { return try_index_; }
 
   BitVector* loop_info() const { return loop_info_; }
@@ skipping 16 matching lines @@
         try_index_(try_index),
         preorder_number_(-1),
         postorder_number_(-1),
         dominator_(NULL),
         dominated_blocks_(1),
         last_instruction_(NULL),
         parallel_move_(NULL),
         loop_info_(NULL) { }
 
  private:
+  virtual void RawSetInputAt(intptr_t i, Value* value) { UNREACHABLE(); }
+
   virtual void ClearPredecessors() = 0;
   virtual void AddPredecessor(BlockEntryInstr* predecessor) = 0;
 
   const intptr_t block_id_;
   const intptr_t try_index_;
   intptr_t preorder_number_;
   intptr_t postorder_number_;
   // Starting and ending lifetime positions for this block.  Used by
   // the linear scan register allocator.
   intptr_t start_pos_;
@@ skipping 373 matching lines @@
   UseKind use_kind_;
 
   Object& constant_value_;
 
   DISALLOW_COPY_AND_ASSIGN(Definition);
 };
 
 
 class PhiInstr : public Definition {
  public:
-  explicit PhiInstr(JoinEntryInstr* block, intptr_t num_inputs)
+  PhiInstr(JoinEntryInstr* block, intptr_t num_inputs)
     : block_(block),
       inputs_(num_inputs),
       is_alive_(false),
       representation_(kTagged),
       reaching_defs_(NULL) {
     for (intptr_t i = 0; i < num_inputs; ++i) {
       inputs_.Add(NULL);
     }
   }
 
   // Get the block entry for that instruction.
   virtual BlockEntryInstr* GetBlock() const { return block(); }
   JoinEntryInstr* block() const { return block_; }
 
   virtual CompileType* ComputeInitialType() const;
   virtual bool RecomputeType();
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   intptr_t InputCount() const { return inputs_.length(); }
 
   Value* InputAt(intptr_t i) const { return inputs_[i]; }
 
-  void SetInputAt(intptr_t i, Value* value) { inputs_[i] = value; }
-
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return false; }
 
   // Phi is alive if it reaches a non-environment use.
   bool is_alive() const { return is_alive_; }
   void mark_alive() { is_alive_ = true; }
 
   virtual Representation RequiredInputRepresentation(intptr_t i) const {
     return representation_;
@@ skipping 20 matching lines @@
 
   BitVector* reaching_defs() const {
     return reaching_defs_;
   }
 
   void set_reaching_defs(BitVector* reaching_defs) {
     reaching_defs_ = reaching_defs;
   }
 
  private:
-  friend class ConstantPropagator;  // Direct access to inputs_.
+  // Direct access to inputs_ in order to resize it due to unreachable
+  // predecessors.
+  friend class ConstantPropagator;

[Vyacheslav Egorov (Google), 2013/02/22 16:13:36]

Comment does not match implementation. ConstantPropagator seems to call
SetInputAt.

[Kevin Millikin (Google), 2013/02/25 11:08:07]

It uses friend access to call inputs_.Truncate(...) to resize inputs_.  Any
suggestion to make the comment more clear?

+
+  void RawSetInputAt(intptr_t i, Value* value) { inputs_[i] = value; }
 
   JoinEntryInstr* block_;
   GrowableArray<Value*> inputs_;
   bool is_alive_;
   Representation representation_;
 
   BitVector* reaching_defs_;
 
   DISALLOW_COPY_AND_ASSIGN(PhiInstr);
 };
 
 
 class ParameterInstr : public Definition {
  public:
-  explicit ParameterInstr(intptr_t index, GraphEntryInstr* block)
+  ParameterInstr(intptr_t index, GraphEntryInstr* block)
       : index_(index), block_(block) { }
 
   DECLARE_INSTRUCTION(Parameter)
 
   intptr_t index() const { return index_; }
 
   // Get the block entry for that instruction.
   virtual BlockEntryInstr* GetBlock() const { return block_; }
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   intptr_t InputCount() const { return 0; }
   Value* InputAt(intptr_t i) const {
     UNREACHABLE();
     return NULL;
   }
-  void SetInputAt(intptr_t i, Value* value) { UNREACHABLE(); }
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return false; }
 
   virtual intptr_t Hashcode() const {
     UNREACHABLE();
     return 0;
   }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual CompileType* ComputeInitialType() const;
 
  private:
+  virtual void RawSetInputAt(intptr_t i, Value* value) { UNREACHABLE(); }
+
   const intptr_t index_;
   GraphEntryInstr* block_;
 
   DISALLOW_COPY_AND_ASSIGN(ParameterInstr);
 };
 
 
 class PushArgumentInstr : public Definition {
  public:
-  explicit PushArgumentInstr(Value* value) : value_(value), locs_(NULL) {
-    ASSERT(value != NULL);
+  explicit PushArgumentInstr(Value* value) : locs_(NULL) {
+    SetInputAt(0, value);
     set_use_kind(kEffect);  // Override the default.
   }
 
   DECLARE_INSTRUCTION(PushArgument)
 
   intptr_t InputCount() const { return 1; }
   Value* InputAt(intptr_t i) const {
     ASSERT(i == 0);
     return value_;
   }
-  void SetInputAt(intptr_t i, Value* value) {
-    ASSERT(i == 0);
-    value_ = value;
-  }
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   virtual CompileType* ComputeInitialType() const;
 
   Value* value() const { return value_; }
 
   virtual LocationSummary* locs() {
     if (locs_ == NULL) {
       locs_ = MakeLocationSummary();
     }
     return locs_;
   }
 
   virtual intptr_t Hashcode() const {
     UNREACHABLE();
     return 0;
   }
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return false; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
  private:
+  virtual void RawSetInputAt(intptr_t i, Value* value) {
+    ASSERT(i == 0);
+    value_ = value;
+  }
+
   Value* value_;
   LocationSummary* locs_;
 
   DISALLOW_COPY_AND_ASSIGN(PushArgumentInstr);
 };
 
 
 inline Definition* Instruction::ArgumentAt(intptr_t index) const {
   return PushArgumentAt(index)->value()->definition();
 }
 
 
 class ReturnInstr : public TemplateInstruction<1> {
  public:
   ReturnInstr(intptr_t token_pos, Value* value)
       : token_pos_(token_pos) {
-    ASSERT(value != NULL);
-    inputs_[0] = value;
+    SetInputAt(0, value);
   }
 
   DECLARE_INSTRUCTION(Return)
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   intptr_t token_pos() const { return token_pos_; }
   Value* value() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const { return false; }
@@ skipping 117 matching lines @@
  private:
   TargetEntryInstr* true_successor_;
   TargetEntryInstr* false_successor_;
 
   DISALLOW_COPY_AND_ASSIGN(ControlInstruction);
 };
 
 
 class BranchInstr : public ControlInstruction {
  public:
-  explicit BranchInstr(ComparisonInstr* comparison, bool is_checked = false)
-      : comparison_(comparison), is_checked_(is_checked) { }
+  explicit BranchInstr(ComparisonInstr* comparison, bool is_checked = false);
 
   DECLARE_INSTRUCTION(Branch)
 
   virtual intptr_t ArgumentCount() const;
   intptr_t InputCount() const;
   Value* InputAt(intptr_t i) const;
-  void SetInputAt(intptr_t i, Value* value);
   virtual bool CanDeoptimize() const;
 
   virtual bool HasSideEffect() const;
 
   ComparisonInstr* comparison() const { return comparison_; }
   void SetComparison(ComparisonInstr* comp);
 
   bool is_checked() const { return is_checked_; }
 
   virtual LocationSummary* locs();
   virtual intptr_t DeoptimizationTarget() const;
   virtual Representation RequiredInputRepresentation(intptr_t i) const;
 
   // A misleadingly named function for use in template functions that also
   // replace definitions.  In this case, leave the branch intact and replace
   // its comparison with another comparison that has been removed from the
   // graph but still has uses properly linked into their definition's use
   // list.
   void ReplaceWith(ComparisonInstr* other,
                    ForwardInstructionIterator* ignored);
 
   virtual Instruction* Canonicalize(FlowGraphOptimizer* optimizer);
 
   virtual void PrintTo(BufferFormatter* f) const;
 
  private:
+  virtual void RawSetInputAt(intptr_t i, Value* value);
+
   ComparisonInstr* comparison_;
   const bool is_checked_;
 
   DISALLOW_COPY_AND_ASSIGN(BranchInstr);
 };
 
 
 class StoreContextInstr : public TemplateInstruction<1> {
  public:
   explicit StoreContextInstr(Value* value) {
-    ASSERT(value != NULL);
-    inputs_[0] = value;
+    SetInputAt(0, value);
   }
 
   DECLARE_INSTRUCTION(StoreContext);
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   Value* value() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return false; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(StoreContextInstr);
 };
 
 
 template<intptr_t N>
 class TemplateDefinition : public Definition {
  public:
   TemplateDefinition<N>() : locs_(NULL) { }
 
   virtual intptr_t InputCount() const { return N; }
   virtual Value* InputAt(intptr_t i) const { return inputs_[i]; }
-  virtual void SetInputAt(intptr_t i, Value* value) {
-    ASSERT(value != NULL);
-    inputs_[i] = value;
-  }
 
   // Returns a structure describing the location constraints required
   // to emit native code for this definition.
   LocationSummary* locs() {
     if (locs_ == NULL) {
       locs_ = MakeLocationSummary();
     }
     return locs_;
   }
 
  protected:
   EmbeddedArray<Value*, N> inputs_;
 
  private:
   friend class BranchInstr;
 
+  virtual void RawSetInputAt(intptr_t i, Value* value) {
+    inputs_[i] = value;
+  }
+
   LocationSummary* locs_;
 };
 
 
 class RangeBoundary : public ValueObject {
  public:
   enum Kind { kUnknown, kSymbol, kConstant };
 
   RangeBoundary() : kind_(kUnknown), value_(0), offset_(0) { }
 
@@ skipping 147 matching lines @@
  private:
   RangeBoundary min_;
   RangeBoundary max_;
 };
 
 
 class ConstraintInstr : public TemplateDefinition<2> {
  public:
   ConstraintInstr(Value* value, Range* constraint)
       : constraint_(constraint) {
-    inputs_[0] = value;
-    inputs_[1] = NULL;  // Dependency.
+    SetInputAt(0, value);
   }
 
   DECLARE_INSTRUCTION(Constraint)
 
   virtual intptr_t InputCount() const {
     return (inputs_[1] == NULL) ? 1 : 2;
   }
 
   virtual CompileType* ComputeInitialType() const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return false; }
 
   virtual bool AttributesEqual(Instruction* other) const {
     UNREACHABLE();
     return false;
   }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   Value* value() const { return inputs_[0]; }
   Range* constraint() const { return constraint_; }
 
   virtual void InferRange();
 
   void AddDependency(Definition* defn) {
     Value* val = new Value(defn);
-    val->set_use_index(1);
-    val->set_instruction(this);
     defn->AddInputUse(val);
-    set_dependency(val);
+    SetInputAt(1, val);
   }
 
  private:
   Value* dependency() {
     return inputs_[1];
   }
 
-  void set_dependency(Value* value) {
-    inputs_[1] = value;
-  }
-
   Range* constraint_;
 
   DISALLOW_COPY_AND_ASSIGN(ConstraintInstr);
 };
 
 
 class ConstantInstr : public TemplateDefinition<0> {
  public:
   explicit ConstantInstr(const Object& value)
       : value_(value) { }
@@ skipping 25 matching lines @@
  public:
   AssertAssignableInstr(intptr_t token_pos,
                         Value* value,
                         Value* instantiator,
                         Value* instantiator_type_arguments,
                         const AbstractType& dst_type,
                         const String& dst_name)
       : token_pos_(token_pos),
         dst_type_(AbstractType::ZoneHandle(dst_type.raw())),
         dst_name_(dst_name) {
-    ASSERT(value != NULL);
-    ASSERT(instantiator != NULL);
-    ASSERT(instantiator_type_arguments != NULL);
     ASSERT(!dst_type.IsNull());
     ASSERT(!dst_name.IsNull());
-    inputs_[0] = value;
-    inputs_[1] = instantiator;
-    inputs_[2] = instantiator_type_arguments;
+    SetInputAt(0, value);
+    SetInputAt(1, instantiator);
+    SetInputAt(2, instantiator_type_arguments);
   }
 
   DECLARE_INSTRUCTION(AssertAssignable)
   virtual CompileType* ComputeInitialType() const;
   virtual bool RecomputeType();
 
   Value* value() const { return inputs_[0]; }
   Value* instantiator() const { return inputs_[1]; }
   Value* instantiator_type_arguments() const { return inputs_[2]; }
 
@@ skipping 21 matching lines @@
   const String& dst_name_;
 
   DISALLOW_COPY_AND_ASSIGN(AssertAssignableInstr);
 };
 
 
 class AssertBooleanInstr : public TemplateDefinition<1> {
  public:
   AssertBooleanInstr(intptr_t token_pos, Value* value)
       : token_pos_(token_pos) {
-    ASSERT(value != NULL);
-    inputs_[0] = value;
+    SetInputAt(0, value);
   }
 
   DECLARE_INSTRUCTION(AssertBoolean)
   virtual CompileType* ComputeInitialType() const;
 
   intptr_t token_pos() const { return token_pos_; }
   Value* value() const { return inputs_[0]; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
@@ skipping 11 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(AssertBooleanInstr);
 };
 
 
 class ArgumentDefinitionTestInstr : public TemplateDefinition<1> {
  public:
   ArgumentDefinitionTestInstr(ArgumentDefinitionTestNode* node,
                               Value* saved_arguments_descriptor)
       : ast_node_(*node) {
-    ASSERT(saved_arguments_descriptor != NULL);
-    inputs_[0] = saved_arguments_descriptor;
+    SetInputAt(0, saved_arguments_descriptor);
   }
 
   DECLARE_INSTRUCTION(ArgumentDefinitionTest)
   virtual CompileType* ComputeInitialType() const;
 
   intptr_t token_pos() const { return ast_node_.token_pos(); }
   intptr_t formal_parameter_index() const {
     return ast_node_.formal_parameter_index();
   }
   const String& formal_parameter_name() const {
@@ skipping 171 matching lines @@
   const bool with_checks_;
 
   DISALLOW_COPY_AND_ASSIGN(PolymorphicInstanceCallInstr);
 };
 
 
 class ComparisonInstr : public TemplateDefinition<2> {
  public:
   ComparisonInstr(Token::Kind kind, Value* left, Value* right)
       : kind_(kind) {
-    ASSERT(left != NULL);
-    ASSERT(right != NULL);
-    inputs_[0] = left;
-    inputs_[1] = right;
+    SetInputAt(0, left);
+    SetInputAt(1, right);
   }
 
   Value* left() const { return inputs_[0]; }
   Value* right() const { return inputs_[1]; }
 
   virtual ComparisonInstr* AsComparison() { return this; }
 
   Token::Kind kind() const { return kind_; }
 
   virtual void EmitBranchCode(FlowGraphCompiler* compiler,
@@ skipping 13 matching lines @@
 inline intptr_t BranchInstr::InputCount() const {
   return comparison()->InputCount();
 }
 
 
 inline Value* BranchInstr::InputAt(intptr_t i) const {
   return comparison()->InputAt(i);
 }
 
 
-inline void BranchInstr::SetInputAt(intptr_t i, Value* value) {
-  comparison()->SetInputAt(i, value);
-}
-
-
 inline bool BranchInstr::CanDeoptimize() const {
   // Branches need a deoptimization info in checked mode if they
   // can throw a type check error.
   return comparison()->CanDeoptimize() || is_checked();
 }
 
 
 inline bool BranchInstr::HasSideEffect() const {
   return comparison()->HasSideEffect();
 }
@@ skipping 279 matching lines @@
 };
 
 
 class StoreLocalInstr : public TemplateDefinition<1> {
  public:
   StoreLocalInstr(const LocalVariable& local,
                   Value* value,
                   intptr_t context_level)
       : local_(local),
         context_level_(context_level) {
-    ASSERT(value != NULL);
-    inputs_[0] = value;
+    SetInputAt(0, value);
   }
 
   DECLARE_INSTRUCTION(StoreLocal)
   virtual CompileType* ComputeInitialType() const;
 
   const LocalVariable& local() const { return local_; }
   Value* value() const { return inputs_[0]; }
   intptr_t context_level() const { return context_level_; }
 
   virtual void RecordAssignedVars(BitVector* assigned_vars,
@@ skipping 48 matching lines @@
 };
 
 
 class StoreInstanceFieldInstr : public TemplateDefinition<2> {
  public:
   StoreInstanceFieldInstr(const Field& field,
                           Value* instance,
                           Value* value,
                           bool emit_store_barrier)
       : field_(field), emit_store_barrier_(emit_store_barrier) {
-    ASSERT(instance != NULL);
-    ASSERT(value != NULL);
-    inputs_[0] = instance;
-    inputs_[1] = value;
+    SetInputAt(0, instance);
+    SetInputAt(1, value);
   }
 
   DECLARE_INSTRUCTION(StoreInstanceField)
   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 {
@@ skipping 37 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(LoadStaticFieldInstr);
 };
 
 
 class StoreStaticFieldInstr : public TemplateDefinition<1> {
  public:
   StoreStaticFieldInstr(const Field& field, Value* value)
       : field_(field) {
     ASSERT(field.IsZoneHandle());
-    ASSERT(value != NULL);
-    inputs_[0] = value;
+    SetInputAt(0, value);
   }
 
   DECLARE_INSTRUCTION(StoreStaticField);
   virtual CompileType* ComputeInitialType() const;
 
   const Field& field() const { return field_; }
   Value* value() const { return inputs_[0]; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return true; }
 
  private:
   const Field& field_;
 
   DISALLOW_COPY_AND_ASSIGN(StoreStaticFieldInstr);
 };
 
 
 class LoadIndexedInstr : public TemplateDefinition<2> {
  public:
   LoadIndexedInstr(Value* array,
                    Value* index,
                    intptr_t index_scale,
                    intptr_t class_id,
                    intptr_t deopt_id)
       : index_scale_(index_scale), class_id_(class_id) {
-    ASSERT(array != NULL);
-    ASSERT(index != NULL);
-    inputs_[0] = array;
-    inputs_[1] = index;
+    SetInputAt(0, array);
+    SetInputAt(1, index);
     deopt_id_ = deopt_id;
   }
 
   DECLARE_INSTRUCTION(LoadIndexed)
   virtual CompileType* ComputeInitialType() const;
 
   Value* array() const { return inputs_[0]; }
   Value* index() const { return inputs_[1]; }
   intptr_t index_scale() const { return index_scale_; }
   intptr_t class_id() const { return class_id_; }
@@ skipping 15 matching lines @@
  private:
   const intptr_t index_scale_;
   const intptr_t class_id_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadIndexedInstr);
 };
 
 
 class StringFromCharCodeInstr : public TemplateDefinition<1> {
  public:
-  explicit StringFromCharCodeInstr(Value* char_code,
-                                   intptr_t cid) : cid_(cid) {
+  StringFromCharCodeInstr(Value* char_code, intptr_t cid) : cid_(cid) {
     ASSERT(char_code != NULL);
     ASSERT(char_code->definition()->IsLoadIndexed() &&
            (char_code->definition()->AsLoadIndexed()->class_id() ==
             kOneByteStringCid));
-    inputs_[0] = char_code;
+    SetInputAt(0, char_code);
   }
 
   DECLARE_INSTRUCTION(StringFromCharCode)
   virtual CompileType* ComputeInitialType() const;
 
   Value* char_code() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return false; }
@@ skipping 13 matching lines @@
  public:
   StoreIndexedInstr(Value* array,
                     Value* index,
                     Value* value,
                     bool emit_store_barrier,
                     intptr_t class_id,
                     intptr_t deopt_id)
       : emit_store_barrier_(emit_store_barrier),
         class_id_(class_id),
         deopt_id_(deopt_id) {
-    ASSERT(array != NULL);
-    ASSERT(index != NULL);
-    ASSERT(value != NULL);
-    inputs_[0] = array;
-    inputs_[1] = index;
-    inputs_[2] = value;
+    SetInputAt(0, array);
+    SetInputAt(1, index);
+    SetInputAt(2, value);
   }
 
   DECLARE_INSTRUCTION(StoreIndexed)
 
   Value* array() const { return inputs_[0]; }
   Value* index() const { return inputs_[1]; }
   Value* value() const { return inputs_[2]; }
   intptr_t class_id() const { return class_id_; }
 
   bool ShouldEmitStoreBarrier() const {
@@ skipping 18 matching lines @@
   const intptr_t deopt_id_;
 
   DISALLOW_COPY_AND_ASSIGN(StoreIndexedInstr);
 };
 
 
 // Note overrideable, built-in: value? false : true.
 class BooleanNegateInstr : public TemplateDefinition<1> {
  public:
   explicit BooleanNegateInstr(Value* value) {
-    ASSERT(value != NULL);
-    inputs_[0] = value;
+    SetInputAt(0, value);
   }
 
   DECLARE_INSTRUCTION(BooleanNegate)
   virtual CompileType* ComputeInitialType() const;
 
   Value* value() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return false; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BooleanNegateInstr);
 };
 
 
 class InstanceOfInstr : public TemplateDefinition<3> {
  public:
   InstanceOfInstr(intptr_t token_pos,
                   Value* value,
                   Value* instantiator,
                   Value* instantiator_type_arguments,
                   const AbstractType& type,
                   bool negate_result)
       : token_pos_(token_pos),
         type_(type),
         negate_result_(negate_result) {
-    ASSERT(value != NULL);
-    ASSERT(instantiator != NULL);
-    ASSERT(instantiator_type_arguments != NULL);
     ASSERT(!type.IsNull());
-    inputs_[0] = value;
-    inputs_[1] = instantiator;
-    inputs_[2] = instantiator_type_arguments;
+    SetInputAt(0, value);
+    SetInputAt(1, instantiator);
+    SetInputAt(2, instantiator_type_arguments);
   }
 
   DECLARE_INSTRUCTION(InstanceOf)
   virtual CompileType* ComputeInitialType() const;
 
   Value* value() const { return inputs_[0]; }
   Value* instantiator() const { return inputs_[1]; }
   Value* instantiator_type_arguments() const { return inputs_[2]; }
 
   bool negate_result() const { return negate_result_; }
@@ skipping 54 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(AllocateObjectInstr);
 };
 
 
 class AllocateObjectWithBoundsCheckInstr : public TemplateDefinition<2> {
  public:
   AllocateObjectWithBoundsCheckInstr(ConstructorCallNode* node,
                                      Value* type_arguments,
                                      Value* instantiator)
       : ast_node_(*node) {
-    ASSERT(type_arguments != NULL);
-    ASSERT(instantiator != NULL);
-    inputs_[0] = type_arguments;
-    inputs_[1] = instantiator;
+    SetInputAt(0, type_arguments);
+    SetInputAt(1, instantiator);
   }
 
   DECLARE_INSTRUCTION(AllocateObjectWithBoundsCheck)
 
   const Function& constructor() const { return ast_node_.constructor(); }
   intptr_t token_pos() const { return ast_node_.token_pos(); }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return true; }
 
   virtual bool HasSideEffect() const { return true; }
 
  private:
   const ConstructorCallNode& ast_node_;
 
   DISALLOW_COPY_AND_ASSIGN(AllocateObjectWithBoundsCheckInstr);
 };
 
 
 class CreateArrayInstr : public TemplateDefinition<1> {
  public:
   CreateArrayInstr(intptr_t token_pos,
                    intptr_t num_elements,
                    const AbstractType& type,
                    Value* element_type)
       : token_pos_(token_pos),
         num_elements_(num_elements),
         type_(type) {
-#if defined(DEBUG)
-    ASSERT(element_type != NULL);
     ASSERT(type_.IsZoneHandle());
     ASSERT(!type_.IsNull());
     ASSERT(type_.IsFinalized());
-#endif
-    inputs_[0] = element_type;
+    SetInputAt(0, element_type);
   }
 
   DECLARE_INSTRUCTION(CreateArray)
   virtual CompileType* ComputeInitialType() const;
 
   intptr_t num_elements() const { return num_elements_; }
 
   intptr_t token_pos() const { return token_pos_; }
   const AbstractType& type() const { return type_; }
   Value* element_type() const { return inputs_[0]; }
@@ skipping 52 matching lines @@
  public:
   LoadFieldInstr(Value* value,
                  intptr_t offset_in_bytes,
                  const AbstractType& type,
                  bool immutable = false)
       : offset_in_bytes_(offset_in_bytes),
         type_(type),
         result_cid_(kDynamicCid),
         immutable_(immutable),
         recognized_kind_(MethodRecognizer::kUnknown) {
-    ASSERT(value != NULL);
     ASSERT(type.IsZoneHandle());  // May be null if field is not an instance.
-    inputs_[0] = value;
+    SetInputAt(0, value);
   }
 
   DECLARE_INSTRUCTION(LoadField)
   virtual CompileType* ComputeInitialType() const;
 
   Value* value() 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; }
 
@@ skipping 35 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(value != NULL);
-    ASSERT(dest != NULL);
     ASSERT(type.IsZoneHandle());  // May be null if field is not an instance.
-    inputs_[0] = value;
-    inputs_[1] = dest;
+    SetInputAt(0, value);
+    SetInputAt(1, dest);
   }
 
   DECLARE_INSTRUCTION(StoreVMField)
   virtual CompileType* ComputeInitialType() const;
 
   Value* value() const { return inputs_[0]; }
   Value* dest() const { return inputs_[1]; }
   intptr_t offset_in_bytes() const { return offset_in_bytes_; }
   const AbstractType& type() const { return type_; }
 
@@ skipping 12 matching lines @@
 
 
 class InstantiateTypeArgumentsInstr : public TemplateDefinition<1> {
  public:
   InstantiateTypeArgumentsInstr(intptr_t token_pos,
                                 const AbstractTypeArguments& type_arguments,
                                 Value* instantiator)
       : token_pos_(token_pos),
         type_arguments_(type_arguments) {
     ASSERT(type_arguments.IsZoneHandle());
-    ASSERT(instantiator != NULL);
-    inputs_[0] = instantiator;
+    SetInputAt(0, instantiator);
   }
 
   DECLARE_INSTRUCTION(InstantiateTypeArguments)
 
   Value* instantiator() const { return inputs_[0]; }
   const AbstractTypeArguments& type_arguments() const {
     return type_arguments_;
   }
   intptr_t token_pos() const { return token_pos_; }
 
@@ skipping 12 matching lines @@
 
 
 class ExtractConstructorTypeArgumentsInstr : public TemplateDefinition<1> {
  public:
   ExtractConstructorTypeArgumentsInstr(
       intptr_t token_pos,
       const AbstractTypeArguments& type_arguments,
       Value* instantiator)
       : token_pos_(token_pos),
         type_arguments_(type_arguments) {
-    ASSERT(instantiator != NULL);
-    inputs_[0] = instantiator;
+    SetInputAt(0, instantiator);
   }
 
   DECLARE_INSTRUCTION(ExtractConstructorTypeArguments)
 
   Value* instantiator() const { return inputs_[0]; }
   const AbstractTypeArguments& type_arguments() const {
     return type_arguments_;
   }
   intptr_t token_pos() const { return token_pos_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return false; }
 
  private:
   const intptr_t token_pos_;
   const AbstractTypeArguments& type_arguments_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtractConstructorTypeArgumentsInstr);
 };
 
 
 class ExtractConstructorInstantiatorInstr : public TemplateDefinition<1> {
  public:
   ExtractConstructorInstantiatorInstr(ConstructorCallNode* ast_node,
                                       Value* instantiator)
       : ast_node_(*ast_node) {
-    ASSERT(instantiator != NULL);
-    inputs_[0] = instantiator;
+    SetInputAt(0, instantiator);
   }
 
   DECLARE_INSTRUCTION(ExtractConstructorInstantiator)
 
   Value* instantiator() const { return inputs_[0]; }
   const AbstractTypeArguments& type_arguments() const {
     return ast_node_.type_arguments();
   }
   const Function& constructor() const { return ast_node_.constructor(); }
   intptr_t token_pos() const { return ast_node_.token_pos(); }
@@ skipping 32 matching lines @@
   const intptr_t token_pos_;
   const intptr_t num_context_variables_;
 
   DISALLOW_COPY_AND_ASSIGN(AllocateContextInstr);
 };
 
 
 class ChainContextInstr : public TemplateInstruction<1> {
  public:
   explicit ChainContextInstr(Value* context_value) {
-    ASSERT(context_value != NULL);
-    inputs_[0] = context_value;
+    SetInputAt(0, context_value);
   }
 
   DECLARE_INSTRUCTION(ChainContext)
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   Value* context_value() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return true; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ChainContextInstr);
 };
 
 
 class CloneContextInstr : public TemplateDefinition<1> {
  public:
   CloneContextInstr(intptr_t token_pos, Value* context_value)
       : token_pos_(token_pos) {
-    ASSERT(context_value != NULL);
-    inputs_[0] = context_value;
+    SetInputAt(0, context_value);
   }
 
   intptr_t token_pos() const { return token_pos_; }
   Value* context_value() const { return inputs_[0]; }
 
   DECLARE_INSTRUCTION(CloneContext)
   virtual CompileType* ComputeInitialType() const;
 
   virtual bool CanDeoptimize() const { return true; }
 
@@ skipping 31 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(CatchEntryInstr);
 };
 
 
 class CheckEitherNonSmiInstr : public TemplateInstruction<2> {
  public:
   CheckEitherNonSmiInstr(Value* left,
                          Value* right,
                          InstanceCallInstr* instance_call) {
-    ASSERT(left != NULL);
-    ASSERT(right != NULL);
-    inputs_[0] = left;
-    inputs_[1] = right;
+    SetInputAt(0, left);
+    SetInputAt(1, right);
     deopt_id_ = instance_call->deopt_id();
   }
 
   DECLARE_INSTRUCTION(CheckEitherNonSmi)
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   virtual bool CanDeoptimize() const { return true; }
 
   virtual bool HasSideEffect() const { return false; }
@@ skipping 10 matching lines @@
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CheckEitherNonSmiInstr);
 };
 
 
 class BoxDoubleInstr : public TemplateDefinition<1> {
  public:
   BoxDoubleInstr(Value* value, InstanceCallInstr* instance_call)
       : token_pos_((instance_call != NULL) ? instance_call->token_pos() : 0) {
-    ASSERT(value != NULL);
-    inputs_[0] = value;
+    SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
   intptr_t token_pos() const { return token_pos_; }
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return false; }
 
@@ skipping 11 matching lines @@
  private:
   const intptr_t token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(BoxDoubleInstr);
 };
 
 
 class BoxIntegerInstr : public TemplateDefinition<1> {
  public:
   explicit BoxIntegerInstr(Value* value) {
-    ASSERT(value != NULL);
-    inputs_[0] = value;
+    SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return false; }
 
   virtual bool AffectedBySideEffect() const { return false; }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedMint;
   }
 
   DECLARE_INSTRUCTION(BoxInteger)
   virtual CompileType* ComputeInitialType() const;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BoxIntegerInstr);
 };
 
 
 class UnboxDoubleInstr : public TemplateDefinition<1> {
  public:
   UnboxDoubleInstr(Value* value, intptr_t deopt_id) {
-    ASSERT(value != NULL);
-    inputs_[0] = value;
+    SetInputAt(0, value);
     deopt_id_ = deopt_id;
   }
 
   Value* value() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const {
     return (value()->Type()->ToCid() != kDoubleCid)
         && (value()->Type()->ToCid() != kSmiCid);
   }
 
@@ skipping 10 matching lines @@
   virtual CompileType* ComputeInitialType() const;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(UnboxDoubleInstr);
 };
 
 
 class UnboxIntegerInstr : public TemplateDefinition<1> {
  public:
   UnboxIntegerInstr(Value* value, intptr_t deopt_id) {
-    ASSERT(value != NULL);
-    inputs_[0] = value;
+    SetInputAt(0, value);
     deopt_id_ = deopt_id;
   }
 
   Value* value() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const {
     return (value()->Type()->ToCid() != kSmiCid)
         && (value()->Type()->ToCid() != kMintCid);
   }
 
@@ skipping 12 matching lines @@
   DECLARE_INSTRUCTION(UnboxInteger)
 
  private:
   DISALLOW_COPY_AND_ASSIGN(UnboxIntegerInstr);
 };
 
 
 class MathSqrtInstr : public TemplateDefinition<1> {
  public:
   MathSqrtInstr(Value* value, StaticCallInstr* instance_call) {
-    ASSERT(value != NULL);
-    inputs_[0] = value;
+    SetInputAt(0, value);
     deopt_id_ = instance_call->deopt_id();
   }
 
   Value* value() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return false; }
 
   virtual bool AttributesEqual(Instruction* other) const {
@@ skipping 23 matching lines @@
 };
 
 
 class BinaryDoubleOpInstr : public TemplateDefinition<2> {
  public:
   BinaryDoubleOpInstr(Token::Kind op_kind,
                       Value* left,
                       Value* right,
                       InstanceCallInstr* instance_call)
       : op_kind_(op_kind) {
-    ASSERT(left != NULL);
-    ASSERT(right != NULL);
-    inputs_[0] = left;
-    inputs_[1] = right;
+    SetInputAt(0, left);
+    SetInputAt(1, right);
     deopt_id_ = instance_call->deopt_id();
   }
 
   Value* left() const { return inputs_[0]; }
   Value* right() const { return inputs_[1]; }
 
   Token::Kind op_kind() const { return op_kind_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
@@ skipping 35 matching lines @@
 
 
 class BinaryMintOpInstr : public TemplateDefinition<2> {
  public:
   BinaryMintOpInstr(Token::Kind op_kind,
                            Value* left,
                            Value* right,
                            InstanceCallInstr* instance_call)
       : op_kind_(op_kind),
         instance_call_(instance_call) {
-    ASSERT(left != NULL);
-    ASSERT(right != NULL);
-    inputs_[0] = left;
-    inputs_[1] = right;
+    SetInputAt(0, left);
+    SetInputAt(1, right);
     deopt_id_ = instance_call->deopt_id();
   }
 
   Value* left() const { return inputs_[0]; }
   Value* right() const { return inputs_[1]; }
 
   Token::Kind op_kind() const { return op_kind_; }
 
   InstanceCallInstr* instance_call() const { return instance_call_; }
 
@@ skipping 41 matching lines @@
 };
 
 
 class ShiftMintOpInstr : public TemplateDefinition<2> {
  public:
   ShiftMintOpInstr(Token::Kind op_kind,
                    Value* left,
                    Value* right,
                    InstanceCallInstr* instance_call)
       : op_kind_(op_kind) {
-    ASSERT(left != NULL);
-    ASSERT(right != NULL);
     ASSERT(op_kind == Token::kSHR || op_kind == Token::kSHL);
-    inputs_[0] = left;
-    inputs_[1] = right;
+    SetInputAt(0, left);
+    SetInputAt(1, right);
     deopt_id_ = instance_call->deopt_id();
   }
 
   Value* left() const { return inputs_[0]; }
   Value* right() const { return inputs_[1]; }
 
   Token::Kind op_kind() const { return op_kind_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
@@ skipping 32 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(ShiftMintOpInstr);
 };
 
 
 class UnaryMintOpInstr : public TemplateDefinition<1> {
  public:
   UnaryMintOpInstr(Token::Kind op_kind,
                           Value* value,
                           InstanceCallInstr* instance_call)
       : op_kind_(op_kind) {
-    ASSERT(value != NULL);
     ASSERT(op_kind == Token::kBIT_NOT);
-    inputs_[0] = value;
+    SetInputAt(0, value);
     deopt_id_ = instance_call->deopt_id();
   }
 
   Value* value() const { return inputs_[0]; }
 
   Token::Kind op_kind() const { return op_kind_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
@@ skipping 35 matching lines @@
 class BinarySmiOpInstr : public TemplateDefinition<2> {
  public:
   BinarySmiOpInstr(Token::Kind op_kind,
                    InstanceCallInstr* instance_call,
                    Value* left,
                    Value* right)
       : op_kind_(op_kind),
         instance_call_(instance_call),
         overflow_(true),
         is_truncating_(false) {
-    ASSERT(left != NULL);
-    ASSERT(right != NULL);
-    inputs_[0] = left;
-    inputs_[1] = right;
+    SetInputAt(0, left);
+    SetInputAt(1, right);
     deopt_id_ = instance_call->deopt_id();
   }
 
   Value* left() const { return inputs_[0]; }
   Value* right() const { return inputs_[1]; }
 
   Token::Kind op_kind() const { return op_kind_; }
 
   InstanceCallInstr* instance_call() const { return instance_call_; }
 
@@ skipping 42 matching lines @@
 
 
 // Handles both Smi operations: BIT_OR and NEGATE.
 class UnarySmiOpInstr : public TemplateDefinition<1> {
  public:
   UnarySmiOpInstr(Token::Kind op_kind,
                   InstanceCallInstr* instance_call,
                   Value* value)
       : op_kind_(op_kind) {
     ASSERT((op_kind == Token::kNEGATE) || (op_kind == Token::kBIT_NOT));
-    ASSERT(value != NULL);
-    inputs_[0] = value;
+    SetInputAt(0, value);
     deopt_id_ = instance_call->deopt_id();
   }
 
   Value* value() const { return inputs_[0]; }
   Token::Kind op_kind() const { return op_kind_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   DECLARE_INSTRUCTION(UnarySmiOp)
   virtual CompileType* ComputeInitialType() const;
@@ skipping 51 matching lines @@
   InstanceCallInstr* instance_call_;
 
   DISALLOW_COPY_AND_ASSIGN(SmiToDoubleInstr);
 };
 
 
 class DoubleToIntegerInstr : public TemplateDefinition<1> {
  public:
   DoubleToIntegerInstr(Value* value, InstanceCallInstr* instance_call)
       : instance_call_(instance_call) {
-    ASSERT(value != NULL);
-    inputs_[0] = value;
+    SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
   InstanceCallInstr* instance_call() const { return instance_call_; }
 
   DECLARE_INSTRUCTION(DoubleToInteger)
   virtual CompileType* ComputeInitialType() const;
 
   virtual intptr_t ArgumentCount() const { return 1; }
 
   virtual bool CanDeoptimize() const { return true; }
 
   virtual bool HasSideEffect() const { return false; }
 
  private:
   InstanceCallInstr* instance_call_;
 
   DISALLOW_COPY_AND_ASSIGN(DoubleToIntegerInstr);
 };
 
 
 // Similar to 'DoubleToIntegerInstr' but expects unboxed double as input
 // and creates a Smi.
 class DoubleToSmiInstr : public TemplateDefinition<1> {
  public:
   DoubleToSmiInstr(Value* value, InstanceCallInstr* instance_call) {
-    ASSERT(value != NULL);
-    inputs_[0] = value;
+    SetInputAt(0, value);
     deopt_id_ = instance_call->deopt_id();
   }
 
   Value* value() const { return inputs_[0]; }
 
   DECLARE_INSTRUCTION(DoubleToSmi)
   virtual CompileType* ComputeInitialType() const;
 
   virtual bool CanDeoptimize() const { return true; }
 
@@ skipping 10 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(DoubleToSmiInstr);
 };
 
 
 class DoubleToDoubleInstr : public TemplateDefinition<1> {
  public:
   DoubleToDoubleInstr(Value* value,
                       InstanceCallInstr* instance_call,
                       MethodRecognizer::Kind recognized_kind)
     : recognized_kind_(recognized_kind) {
-    ASSERT(value != NULL);
-    inputs_[0] = value;
+    SetInputAt(0, value);
     deopt_id_ = instance_call->deopt_id();
   }
 
   Value* value() const { return inputs_[0]; }
 
   MethodRecognizer::Kind recognized_kind() const { return recognized_kind_; }
 
   DECLARE_INSTRUCTION(DoubleToDouble)
   virtual CompileType* ComputeInitialType() const;
 
@@ skipping 16 matching lines @@
   const MethodRecognizer::Kind recognized_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(DoubleToDoubleInstr);
 };
 
 
 class InvokeMathCFunctionInstr : public Definition {
  public:
   InvokeMathCFunctionInstr(ZoneGrowableArray<Value*>* inputs,
                            InstanceCallInstr* instance_call,
-                           MethodRecognizer::Kind recognized_kind)
-    : inputs_(inputs), locs_(NULL), recognized_kind_(recognized_kind) {
-    ASSERT(inputs_->length() == ArgumentCountFor(recognized_kind_));
-    deopt_id_ = instance_call->deopt_id();
-  }
+                           MethodRecognizer::Kind recognized_kind);
 
   static intptr_t ArgumentCountFor(MethodRecognizer::Kind recognized_kind_);
 
   const RuntimeEntry& TargetFunction() const;
 
   MethodRecognizer::Kind recognized_kind() const { return recognized_kind_; }
 
   DECLARE_INSTRUCTION(InvokeMathCFunction)
   virtual CompileType* ComputeInitialType() const;
   virtual void PrintOperandsTo(BufferFormatter* f) const;
@@ skipping 14 matching lines @@
   virtual intptr_t DeoptimizationTarget() const { return deopt_id_; }
 
   virtual intptr_t InputCount() const {
     return inputs_->length();
   }
 
   virtual Value* InputAt(intptr_t i) const {
     return (*inputs_)[i];
   }
 
-  virtual void SetInputAt(intptr_t i, Value* value) {
-    ASSERT(value != NULL);
-    (*inputs_)[i] = value;
-  }
-
   // Returns a structure describing the location constraints required
   // to emit native code for this definition.
   LocationSummary* locs() {
     if (locs_ == NULL) {
       locs_ = MakeLocationSummary();
     }
     return locs_;
   }
 
  private:
+  virtual void RawSetInputAt(intptr_t i, Value* value) {
+    (*inputs_)[i] = value;
+  }
+
   ZoneGrowableArray<Value*>* inputs_;
 
   LocationSummary* locs_;
 
   const MethodRecognizer::Kind recognized_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(InvokeMathCFunctionInstr);
 };
 
 
@@ skipping 26 matching lines @@
  private:
   const ICData& unary_checks_;
 
   DISALLOW_COPY_AND_ASSIGN(CheckClassInstr);
 };
 
 
 class CheckSmiInstr : public TemplateInstruction<1> {
  public:
   CheckSmiInstr(Value* value, intptr_t original_deopt_id) {
-    ASSERT(value != NULL);
     ASSERT(original_deopt_id != Isolate::kNoDeoptId);
-    inputs_[0] = value;
+    SetInputAt(0, value);
     deopt_id_ = original_deopt_id;
   }
 
   DECLARE_INSTRUCTION(CheckSmi)
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   virtual bool CanDeoptimize() const { return true; }
 
   virtual bool HasSideEffect() const { return false; }
@@ skipping 11 matching lines @@
 };
 
 
 class CheckArrayBoundInstr : public TemplateInstruction<2> {
  public:
   CheckArrayBoundInstr(Value* length,
                        Value* index,
                        intptr_t array_type,
                        InstanceCallInstr* instance_call)
       : array_type_(array_type) {
-    ASSERT(length != NULL);
-    ASSERT(index != NULL);
-    inputs_[0] = length;
-    inputs_[1] = index;
+    SetInputAt(0, length);
+    SetInputAt(1, index);
     deopt_id_ = instance_call->deopt_id();
   }
 
   DECLARE_INSTRUCTION(CheckArrayBound)
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   virtual bool CanDeoptimize() const { return true; }
 
   virtual bool HasSideEffect() const { return false; }
@@ skipping 243 matching lines @@
   ForwardInstructionIterator* current_iterator_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_