Turn definitions that do not produce results (e.g. Checks) into instructions.

runtime/vm/intermediate_language.h

 // Copyright (c) 2012, 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 368 matching lines @@
   }
 
   // Mutate assigned_vars to add the local variable index for all
   // frame-allocated locals assigned to by the instruction.
   virtual void RecordAssignedVars(BitVector* assigned_vars,
                                   intptr_t fixed_parameter_count);
 
   virtual const char* DebugName() const = 0;
 
   // Printing support.
-  virtual void PrintTo(BufferFormatter* f) const = 0;
-  virtual void PrintToVisualizer(BufferFormatter* f) const = 0;
+  virtual void PrintTo(BufferFormatter* f) const;
+  virtual void PrintOperandsTo(BufferFormatter* f) const;
+  virtual void PrintToVisualizer(BufferFormatter* f) const;
 
 #define INSTRUCTION_TYPE_CHECK(type)                                           \
   bool Is##type() { return (As##type() != NULL); }                             \
   virtual type##Instr* As##type() { return NULL; }
 FOR_EACH_INSTRUCTION(INSTRUCTION_TYPE_CHECK)
 #undef INSTRUCTION_TYPE_CHECK
 
   // Returns structure describing location constraints required
   // to emit native code for this instruction.
   virtual LocationSummary* locs() {
@@ skipping 34 matching lines @@
   }
 
   // Returns deoptimization id that corresponds to the deoptimization target
   // that input operands conversions inserted for this instruction can jump
   // to.
   virtual intptr_t DeoptimizationTarget() const {
     UNREACHABLE();
     return Isolate::kNoDeoptId;
   }
 
+  // Returns a replacement for the instruction or NULL if the instruction can
+  // be eliminated.  By default returns the this instruction which means no
+  // change.
+  virtual Instruction* Canonicalize();
+
+  // Insert this instruction before 'next'.
+  void InsertBefore(Instruction* next);
+
+  // Insert this instruction after 'prev'.
+  void InsertAfter(Instruction* prev);
+
+  // Returns true if the instruction is affected by side effects.
+  // Only instructions that are not affected by side effects can participate
+  // in redundancy elimination or loop invariant code motion.
+  // TODO(fschneider): Make this abstract and implement for all instructions
+  // instead of returning the safe default (true).
+  virtual bool AffectedBySideEffect() const { return true; }
+
+  // Get the block entry for this instruction.
+  virtual BlockEntryInstr* GetBlock() const;
+
   // Id for instructions used in CSE.
   intptr_t expr_id() const { return expr_id_; }
   void set_expr_id(intptr_t expr_id) { expr_id_ = expr_id; }
 
+  // Returns a hash code for use with hash maps.
+  virtual intptr_t Hashcode() const;
+
+  // Compares two instructions.  Returns true, iff:
+  // 1. They have the same tag.
+  // 2. All input operands are Equals.
+  // 3. They satisfy AttributesEqual.
+  bool Equals(Instruction* other) const;
+
+  // Compare attributes of a instructions (except input operands and tag).
+  // All instructions that participate in CSE have to override this function.
+  // This function can assume that the argument has the same type as this.
+  virtual bool AttributesEqual(Instruction* other) const {
+    UNREACHABLE();
+    return false;
+  }
+
  protected:
   // Fetch deopt id without checking if this computation can deoptimize.
   intptr_t GetDeoptId() const {
     return deopt_id_;
   }
 
  private:
   friend class Definition;  // Needed for InsertBefore, InsertAfter.
 
   // Classes that set deopt_id_.
@@ skipping 530 matching lines @@
 
   bool has_propagated_cid() const { return propagated_cid_ != kIllegalCid; }
   intptr_t propagated_cid() const { return propagated_cid_; }
 
   // May compute and set propagated cid.
   virtual intptr_t GetPropagatedCid();
 
   // Returns true if the propagated cid has changed.
   bool SetPropagatedCid(intptr_t cid);
 
-  // Returns true if the definition is affected by side effects.
-  // Only instructions that are not affected by side effects can participate
-  // in redundancy elimination or loop invariant code motion.
-  // TODO(fschneider): Make this abstract and implement for all definitions
-  // instead of returning the safe default (true).
-  virtual bool AffectedBySideEffect() const { return true; }
-
   Value* input_use_list() { return input_use_list_; }
   void set_input_use_list(Value* head) { input_use_list_ = head; }
 
   Value* env_use_list() { return env_use_list_; }
   void set_env_use_list(Value* head) { env_use_list_ = head; }
 
-  // Returns a replacement for the definition or NULL if the definition can
-  // be eliminated.  By default returns the definition (input parameter)
-  // which means no change.
-  virtual Definition* Canonicalize();
-
   // Replace uses of this definition with uses of other definition or value.
   // Precondition: use lists must be properly calculated.
   // Postcondition: use lists and use values are still valid.
   void ReplaceUsesWith(Definition* other);
 
   // Replace this definition and all uses with another definition.  If
   // replacing during iteration, pass the iterator so that the instruction
   // can be replaced without affecting iteration order, otherwise pass a
   // NULL iterator.
   void ReplaceWith(Definition* other, ForwardInstructionIterator* iterator);
 
-  // Insert this definition before 'next'.
-  void InsertBefore(Instruction* next);
-
-  // Insert this definition after 'prev'.
-  void InsertAfter(Instruction* prev);
-
-  // Compares two definitions.  Returns true, iff:
-  // 1. They have the same tag.
-  // 2. All input operands are Equals.
-  // 3. They satisfy AttributesEqual.
-  bool Equals(Definition* other) const;
-
-  // Compare attributes of a definition (except input operands and tag).
-  // All definition that participate in CSE have to override this function.
-  // This function can assume that the argument has the same type as this.
-  virtual bool AttributesEqual(Definition* other) const {
-    UNREACHABLE();
-    return false;
-  }
-
-  // Returns a hash code for use with hash maps.
-  virtual intptr_t Hashcode() const;
-
   virtual void RecordAssignedVars(BitVector* assigned_vars,
                                   intptr_t fixed_parameter_count);
 
-  // Get the block entry for that instruction.
-  virtual BlockEntryInstr* GetBlock() const;
-
   // Printing support. These functions are sometimes overridden for custom
   // formatting. Otherwise, it prints in the format "opcode(op1, op2, op3)".
   virtual void PrintTo(BufferFormatter* f) const;
   virtual void PrintOperandsTo(BufferFormatter* f) const;
   virtual void PrintToVisualizer(BufferFormatter* f) const;
 
+  // Definitions can be canonicalized only into definitions to ensure
+  // this check statically we override base Canonicalize with a Canonicalize
+  // returning Definition (return type is covariant).
+  virtual Definition* Canonicalize();
+
  private:
   intptr_t temp_index_;
   intptr_t ssa_temp_index_;
   // TODO(regis): GrowableArray<const AbstractType*> propagated_types_;
   // For now:
   AbstractType& propagated_type_;
   intptr_t propagated_cid_;
   Value* input_use_list_;
   Value* env_use_list_;
   UseKind use_kind_;
@@ skipping 198 matching lines @@
 
   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; }
 
   virtual bool HasSideEffect() const { return false; }
 
-  virtual void PrintTo(BufferFormatter* f) const;
-  virtual void PrintToVisualizer(BufferFormatter* f) const;
-
  private:
   const intptr_t token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(ReturnInstr);
 };
 
 
 class ThrowInstr : public TemplateInstruction<0> {
  public:
   explicit ThrowInstr(intptr_t token_pos) : token_pos_(token_pos) { }
 
   DECLARE_INSTRUCTION(Throw)
 
   virtual intptr_t ArgumentCount() const { return 1; }
 
   intptr_t token_pos() const { return token_pos_; }
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return true; }
 
-  virtual void PrintTo(BufferFormatter* f) const;
-  virtual void PrintToVisualizer(BufferFormatter* f) const;
-
  private:
   const intptr_t token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(ThrowInstr);
 };
 
 
 class ReThrowInstr : public TemplateInstruction<0> {
  public:
   explicit ReThrowInstr(intptr_t token_pos) : token_pos_(token_pos) { }
 
   DECLARE_INSTRUCTION(ReThrow)
 
   virtual intptr_t ArgumentCount() const { return 2; }
 
   intptr_t token_pos() const { return token_pos_; }
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return true; }
 
-  virtual void PrintTo(BufferFormatter* f) const;
-  virtual void PrintToVisualizer(BufferFormatter* f) const;
-
  private:
   const intptr_t token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(ReThrowInstr);
 };
 
 
 class GotoInstr : public TemplateInstruction<0> {
  public:
   explicit GotoInstr(JoinEntryInstr* entry)
@@ skipping 109 matching lines @@
   virtual void PrintTo(BufferFormatter* f) const;
   virtual void PrintToVisualizer(BufferFormatter* f) const;
 
  private:
   ComparisonInstr* comparison_;
 
   DISALLOW_COPY_AND_ASSIGN(BranchInstr);
 };
 
 
+class StoreContextInstr : public TemplateInstruction<1> {
+ public:
+  explicit StoreContextInstr(Value* value) {
+    ASSERT(value != NULL);
+    inputs_[0] = value;
+  }
+
+  DECLARE_INSTRUCTION(StoreContext);
+  virtual RawAbstractType* CompileType() const;
+
+  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;
@@ skipping 28 matching lines @@
   const Object& value() const { return value_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return false; }
 
   virtual intptr_t ResultCid() const;
 
-  virtual bool AttributesEqual(Definition* other) const;
+  virtual bool AttributesEqual(Instruction* other) const;
   virtual bool AffectedBySideEffect() const { return false; }
 
  private:
   const Object& value_;
 
   DISALLOW_COPY_AND_ASSIGN(ConstantInstr);
 };
 
 
 class AssertAssignableInstr : public TemplateDefinition<3> {
@@ skipping 143 matching lines @@
 
   virtual bool HasSideEffect() const { return false; }
 
   virtual intptr_t ResultCid() const { return kDynamicCid; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CurrentContextInstr);
 };
 
 
-class StoreContextInstr : public TemplateDefinition<1> {
- public:
-  explicit StoreContextInstr(Value* value) {
-    ASSERT(value != NULL);
-    inputs_[0] = value;
-  }
-
-  DECLARE_INSTRUCTION(StoreContext);
-  virtual RawAbstractType* CompileType() const;
-
-  Value* value() const { return inputs_[0]; }
-
-  virtual bool CanDeoptimize() const { return false; }
-
-  virtual bool HasSideEffect() const { return false; }
-
-  virtual intptr_t ResultCid() const { return kIllegalCid; }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(StoreContextInstr);
-};
-
-
 class ClosureCallInstr : public TemplateDefinition<0> {
  public:
   ClosureCallInstr(ClosureCallNode* node,
                    ZoneGrowableArray<PushArgumentInstr*>* arguments)
       : ast_node_(*node),
         arguments_(arguments) { }
 
   DECLARE_INSTRUCTION(ClosureCall)
   virtual RawAbstractType* CompileType() const;
 
@@ skipping 215 matching lines @@
 
   DECLARE_INSTRUCTION(StrictCompare)
   virtual RawAbstractType* CompileType() const;
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return false; }
 
-  virtual bool AttributesEqual(Definition* other) const;
+  virtual bool AttributesEqual(Instruction* other) const;
   virtual bool AffectedBySideEffect() const { return false; }
 
   virtual Definition* Canonicalize();
 
   virtual intptr_t ResultCid() const { return kBoolCid; }
 
   virtual void EmitBranchCode(FlowGraphCompiler* compiler,
                               BranchInstr* branch);
 
  private:
@@ skipping 341 matching lines @@
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return false; }
 
   virtual intptr_t ResultCid() const { return kDynamicCid; }
 
   virtual bool AffectedBySideEffect() const { return !field().is_final(); }
-  virtual bool AttributesEqual(Definition* other) const;
+  virtual bool AttributesEqual(Instruction* other) const;
 
  private:
   const Field& field_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadStaticFieldInstr);
 };
 
 
 class StoreStaticFieldInstr : public TemplateDefinition<1> {
  public:
@@ skipping 340 matching lines @@
   void set_result_cid(intptr_t value) { result_cid_ = value; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return false; }
 
   virtual intptr_t ResultCid() const { return result_cid_; }
 
-  virtual bool AttributesEqual(Definition* other) const;
+  virtual bool AttributesEqual(Instruction* other) const;
 
   virtual bool AffectedBySideEffect() const { return !immutable_; }
 
  private:
   const intptr_t offset_in_bytes_;
   const AbstractType& type_;
   intptr_t result_cid_;
   const bool immutable_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadFieldInstr);
@@ skipping 166 matching lines @@
   virtual intptr_t ResultCid() const { return kDynamicCid; }
 
  private:
   const intptr_t token_pos_;
   const intptr_t num_context_variables_;
 
   DISALLOW_COPY_AND_ASSIGN(AllocateContextInstr);
 };
 
 
-class ChainContextInstr : public TemplateDefinition<1> {
+class ChainContextInstr : public TemplateInstruction<1> {
  public:
   explicit ChainContextInstr(Value* context_value) {
     ASSERT(context_value != NULL);
     inputs_[0] = context_value;
   }
 
   DECLARE_INSTRUCTION(ChainContext)
   virtual RawAbstractType* CompileType() const;
 
+  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; }
 
-  virtual intptr_t ResultCid() const { return kIllegalCid; }
-
  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;
   }
 
   intptr_t token_pos() const { return token_pos_; }
   Value* context_value() const { return inputs_[0]; }
 
   DECLARE_INSTRUCTION(CloneContext)
   virtual RawAbstractType* CompileType() const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return false; }
 
-  virtual intptr_t ResultCid() const { return kIllegalCid; }
+  virtual intptr_t ResultCid() const { return kContextCid; }
 
  private:
   const intptr_t token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(CloneContextInstr);
 };
 
 
-class CatchEntryInstr : public TemplateDefinition<0> {
+class CatchEntryInstr : public TemplateInstruction<0> {
  public:
   CatchEntryInstr(const LocalVariable& exception_var,
                   const LocalVariable& stacktrace_var)
       : exception_var_(exception_var), stacktrace_var_(stacktrace_var) {}
 
   const LocalVariable& exception_var() const { return exception_var_; }
   const LocalVariable& stacktrace_var() const { return stacktrace_var_; }
 
   DECLARE_INSTRUCTION(CatchEntry)
   virtual RawAbstractType* CompileType() const;
 
+  virtual intptr_t ArgumentCount() const { return 0; }
+
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return true; }
 
-  virtual intptr_t ResultCid() const { return kIllegalCid; }
-
  private:
   const LocalVariable& exception_var_;
   const LocalVariable& stacktrace_var_;
 
   DISALLOW_COPY_AND_ASSIGN(CatchEntryInstr);
 };
 
 
-class CheckEitherNonSmiInstr : public TemplateDefinition<2> {
+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;
     deopt_id_ = instance_call->deopt_id();
   }
 
   DECLARE_INSTRUCTION(CheckEitherNonSmi)
   virtual RawAbstractType* CompileType() const;
 
+  virtual intptr_t ArgumentCount() const { return 0; }
+
   virtual bool CanDeoptimize() const { return true; }
 
   virtual bool HasSideEffect() const { return false; }
 
-  virtual intptr_t ResultCid() const { return kIllegalCid; }
-
-  virtual bool AttributesEqual(Definition* other) const { return true; }
+  virtual bool AttributesEqual(Instruction* other) const { return true; }
 
   virtual bool AffectedBySideEffect() const { return false; }
 
   Value* left() const { return inputs_[0]; }
 
   Value* right() const { return inputs_[1]; }
 
-  virtual Definition* Canonicalize();
+  virtual Instruction* Canonicalize();
 
  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;
   }
 
   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; }
 
   virtual bool AffectedBySideEffect() const { return false; }
-  virtual bool AttributesEqual(Definition* other) const { return true; }
+  virtual bool AttributesEqual(Instruction* other) const { return true; }
 
   virtual intptr_t ResultCid() const;
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedDouble;
   }
 
   DECLARE_INSTRUCTION(BoxDouble)
   virtual RawAbstractType* CompileType() const;
@@ skipping 23 matching lines @@
   virtual bool HasSideEffect() const { return false; }
 
   // The output is not an instance but when it is boxed it becomes double.
   virtual intptr_t ResultCid() const { return kDoubleCid; }
 
   virtual Representation representation() const {
     return kUnboxedDouble;
   }
 
   virtual bool AffectedBySideEffect() const { return false; }
-  virtual bool AttributesEqual(Definition* other) const { return true; }
+  virtual bool AttributesEqual(Instruction* other) const { return true; }
 
   DECLARE_INSTRUCTION(UnboxDouble)
   virtual RawAbstractType* CompileType() const;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(UnboxDoubleInstr);
 };
 
 
 class MathSqrtInstr : public TemplateDefinition<1> {
  public:
   MathSqrtInstr(Value* value, StaticCallInstr* instance_call) {
     ASSERT(value != NULL);
     inputs_[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(Definition* other) const {
+  virtual bool AttributesEqual(Instruction* other) const {
     return true;
   }
 
   // The output is not an instance but when it is boxed it becomes double.
   virtual intptr_t ResultCid() const { return kDoubleCid; }
 
   virtual Representation representation() const {
     return kUnboxedDouble;
   }
 
@@ skipping 36 matching lines @@
   Token::Kind op_kind() const { return op_kind_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return false; }
 
   virtual bool AffectedBySideEffect() const { return false; }
 
-  virtual bool AttributesEqual(Definition* other) const {
+  virtual bool AttributesEqual(Instruction* other) const {
     return op_kind() == other->AsUnboxedDoubleBinaryOp()->op_kind();
   }
 
   // The output is not an instance but when it is boxed it becomes double.
   virtual intptr_t ResultCid() const { return kDoubleCid; }
 
   virtual Representation representation() const {
     return kUnboxedDouble;
   }
 
@@ skipping 44 matching lines @@
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   DECLARE_INSTRUCTION(BinarySmiOp)
   virtual RawAbstractType* CompileType() const;
 
   virtual bool CanDeoptimize() const;
 
   virtual bool HasSideEffect() const { return false; }
 
   virtual bool AffectedBySideEffect() const { return false; }
-  virtual bool AttributesEqual(Definition* other) const;
+  virtual bool AttributesEqual(Instruction* other) const;
 
   virtual intptr_t ResultCid() const;
 
  private:
   const Token::Kind op_kind_;
   InstanceCallInstr* instance_call_;
 
   DISALLOW_COPY_AND_ASSIGN(BinarySmiOpInstr);
 };
 
@@ skipping 69 matching lines @@
   virtual intptr_t ResultCid() const { return kSmiCid; }
 
  private:
   const Token::Kind op_kind_;
   InstanceCallInstr* instance_call_;
 
   DISALLOW_COPY_AND_ASSIGN(UnarySmiOpInstr);
 };
 
 
-class CheckStackOverflowInstr : public TemplateDefinition<0> {
+class CheckStackOverflowInstr : public TemplateInstruction<0> {
  public:
   explicit CheckStackOverflowInstr(intptr_t token_pos)
       : token_pos_(token_pos) {}
 
   intptr_t token_pos() const { return token_pos_; }
 
   DECLARE_INSTRUCTION(CheckStackOverflow)
   virtual RawAbstractType* CompileType() const;
 
+  virtual intptr_t ArgumentCount() const { return 0; }
+
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return false; }
 
-  virtual intptr_t ResultCid() const { return kIllegalCid; }
-
  private:
   const intptr_t token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(CheckStackOverflowInstr);
 };
 
 
 class DoubleToDoubleInstr : public TemplateDefinition<1> {
  public:
   DoubleToDoubleInstr(Value* value, InstanceCallInstr* instance_call)
@@ skipping 40 matching lines @@
 
   virtual intptr_t ResultCid() const { return kDoubleCid; }
 
  private:
   InstanceCallInstr* instance_call_;
 
   DISALLOW_COPY_AND_ASSIGN(SmiToDoubleInstr);
 };
 
 
-class CheckClassInstr : public TemplateDefinition<1> {
+class CheckClassInstr : public TemplateInstruction<1> {
  public:
   CheckClassInstr(Value* value,
                   InstanceCallInstr* instance_call,
                   const ICData& unary_checks)
       : unary_checks_(unary_checks) {
     ASSERT(value != NULL);
     inputs_[0] = value;
     deopt_id_ = instance_call->deopt_id();
   }
 
   DECLARE_INSTRUCTION(CheckClass)
   virtual RawAbstractType* CompileType() const;
 
+  virtual intptr_t ArgumentCount() const { return 0; }
+
   virtual bool CanDeoptimize() const { return true; }
 
   virtual bool HasSideEffect() const { return false; }
 
-  virtual intptr_t ResultCid() const { return kIllegalCid; }
-
-  virtual bool AttributesEqual(Definition* other) const;
+  virtual bool AttributesEqual(Instruction* other) const;
 
   virtual bool AffectedBySideEffect() const { return false; }
 
   Value* value() const { return inputs_[0]; }
 
   const ICData& unary_checks() const { return unary_checks_; }
 
-  virtual Definition* Canonicalize();
+  virtual Instruction* Canonicalize();
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
  private:
   const ICData& unary_checks_;
 
   DISALLOW_COPY_AND_ASSIGN(CheckClassInstr);
 };
 
 
-class CheckSmiInstr : public TemplateDefinition<1> {
+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;
     deopt_id_ = original_deopt_id;
   }
 
   DECLARE_INSTRUCTION(CheckSmi)
   virtual RawAbstractType* CompileType() const;
 
+  virtual intptr_t ArgumentCount() const { return 0; }
+
   virtual bool CanDeoptimize() const { return true; }
 
   virtual bool HasSideEffect() const { return false; }
 
-  virtual intptr_t ResultCid() const { return kIllegalCid; }
-
-  virtual bool AttributesEqual(Definition* other) const { return true; }
+  virtual bool AttributesEqual(Instruction* other) const { return true; }
 
   virtual bool AffectedBySideEffect() const { return false; }
 
-  virtual Definition* Canonicalize();
+  virtual Instruction* Canonicalize();
 
   Value* value() const { return inputs_[0]; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CheckSmiInstr);
 };
 
 
-class CheckArrayBoundInstr : public TemplateDefinition<2> {
+class CheckArrayBoundInstr : public TemplateInstruction<2> {
  public:
   CheckArrayBoundInstr(Value* array,
                        Value* index,
                        intptr_t array_type,
                        InstanceCallInstr* instance_call)
       : array_type_(array_type) {
     ASSERT(array != NULL);
     ASSERT(index != NULL);
     inputs_[0] = array;
     inputs_[1] = index;
     deopt_id_ = instance_call->deopt_id();
   }
 
   DECLARE_INSTRUCTION(CheckArrayBound)
   virtual RawAbstractType* CompileType() const;
 
+  virtual intptr_t ArgumentCount() const { return 0; }
+
   virtual bool CanDeoptimize() const { return true; }
 
   virtual bool HasSideEffect() const { return false; }
 
-  virtual intptr_t ResultCid() const { return kIllegalCid; }
-
-  virtual bool AttributesEqual(Definition* other) const;
+  virtual bool AttributesEqual(Instruction* other) const;
 
   virtual bool AffectedBySideEffect() const { return false; }
 
   Value* array() const { return inputs_[0]; }
   Value* index() const { return inputs_[1]; }
 
   intptr_t array_type() const { return array_type_; }
 
  private:
   intptr_t array_type_;
@@ skipping 209 matching lines @@
   ForwardInstructionIterator* current_iterator_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_