Revert "IR refactoring: reduce duplication related to MayThrow/AllowsCSE."

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 858 matching lines @@
   Instruction* previous_;
   Instruction* next_;
   Environment* env_;
   LocationSummary* locs_;
   intptr_t place_id_;
 
   DISALLOW_COPY_AND_ASSIGN(Instruction);
 };
 
 
-class PureInstruction : public Instruction {
+template<intptr_t N>
+class TemplateInstruction: public Instruction {
  public:
-  explicit PureInstruction(intptr_t deopt_id)
-      : Instruction(deopt_id) { }
-
-  virtual bool AllowsCSE() const { return true; }
-  virtual EffectSet Dependencies() const { return EffectSet::None(); }
-
-  virtual EffectSet Effects() const { return EffectSet::None(); }
-};
-
-
-// Types to be used as ThrowsTrait for TemplateInstruction/TemplateDefinition.
-struct Throws {
-  static const bool kCanThrow = true;
-};
-
-
-struct NoThrow {
-  static const bool kCanThrow = false;
-};
-
-
-// Types to be used as CSETrait for TemplateInstruction/TemplateDefinition.
-// Pure instructions are those that allow CSE and have no effects and
-// no dependencies.
-template<typename DefaultBase, typename PureBase>
-struct Pure {
-  typedef PureBase Base;
-};
-
-
-template<typename DefaultBase, typename PureBase>
-struct NoCSE {
-  typedef DefaultBase Base;
-};
-
-
-template<intptr_t N,
-         typename ThrowsTrait,
-         template<typename Default, typename Pure> class CSETrait = NoCSE>
-class TemplateInstruction: public CSETrait<Instruction, PureInstruction>::Base {
- public:
-  explicit TemplateInstruction(intptr_t deopt_id = Isolate::kNoDeoptId)
-      : CSETrait<Instruction, PureInstruction>::Base(deopt_id), inputs_() { }
+  explicit TemplateInstruction<N>(intptr_t deopt_id = Isolate::kNoDeoptId)
+      : Instruction(deopt_id), inputs_() { }
 
   virtual intptr_t InputCount() const { return N; }
   virtual Value* InputAt(intptr_t i) const { return inputs_[i]; }
 
-  virtual bool MayThrow() const { return ThrowsTrait::kCanThrow; }
-
  protected:
   EmbeddedArray<Value*, N> inputs_;
 
  private:
   virtual void RawSetInputAt(intptr_t i, Value* value) {
     inputs_[i] = value;
   }
 };
 
 
@@ skipping 48 matching lines @@
   }
 
  private:
   Location dest_;
   Location src_;
 
   DISALLOW_COPY_AND_ASSIGN(MoveOperands);
 };
 
 
-class ParallelMoveInstr : public TemplateInstruction<0, NoThrow> {
+class ParallelMoveInstr : public TemplateInstruction<0> {
  public:
   ParallelMoveInstr() : moves_(4) { }
 
   DECLARE_INSTRUCTION(ParallelMove)
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const {
@@ skipping 13 matching lines @@
   }
 
   MoveOperands* MoveOperandsAt(intptr_t index) const { return moves_[index]; }
 
   intptr_t NumMoves() const { return moves_.length(); }
 
   bool IsRedundant() const;
 
   virtual void PrintTo(BufferFormatter* f) const;
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   GrowableArray<MoveOperands*> moves_;   // Elements cannot be null.
 
   DISALLOW_COPY_AND_ASSIGN(ParallelMoveInstr);
 };
 
 
 // Basic block entries are administrative nodes.  There is a distinguished
 // graph entry with no predecessor.  Joins are the only nodes with multiple
 // predecessors.  Targets are all other basic block entries.  The types
@@ skipping 733 matching lines @@
 }
 
 
 inline void Value::BindToEnvironment(Definition* def) {
   RemoveFromUseList();
   set_definition(def);
   def->AddEnvUse(this);
 }
 
 
-class PureDefinition : public Definition {
+template<intptr_t N>
+class TemplateDefinition : public Definition {
  public:
-  explicit PureDefinition(intptr_t deopt_id)
-      : Definition(deopt_id) { }
-
-  virtual bool AllowsCSE() const { return true; }
-  virtual EffectSet Dependencies() const { return EffectSet::None(); }
-
-  virtual EffectSet Effects() const { return EffectSet::None(); }
-};
-
-
-template<intptr_t N,
-         typename ThrowsTrait,
-         template<typename Impure, typename Pure> class CSETrait = NoCSE>
-class TemplateDefinition : public CSETrait<Definition, PureDefinition>::Base {
- public:
-  explicit TemplateDefinition(intptr_t deopt_id = Isolate::kNoDeoptId)
-      : CSETrait<Definition, PureDefinition>::Base(deopt_id), inputs_() { }
+  explicit TemplateDefinition<N>(intptr_t deopt_id = Isolate::kNoDeoptId)
+      : Definition(deopt_id), inputs_() { }
 
   virtual intptr_t InputCount() const { return N; }
   virtual Value* InputAt(intptr_t i) const { return inputs_[i]; }
 
-  virtual bool MayThrow() const { return ThrowsTrait::kCanThrow; }
-
  protected:
   EmbeddedArray<Value*, N> inputs_;
 
  private:
   friend class BranchInstr;
   friend class IfThenElseInstr;
 
   virtual void RawSetInputAt(intptr_t i, Value* value) {
     inputs_[i] = value;
   }
@@ skipping 152 matching lines @@
   virtual void RawSetInputAt(intptr_t i, Value* value) { UNREACHABLE(); }
 
   const intptr_t index_;
   const Register base_reg_;
   BlockEntryInstr* block_;
 
   DISALLOW_COPY_AND_ASSIGN(ParameterInstr);
 };
 
 
-class PushArgumentInstr : public TemplateDefinition<1, NoThrow> {
+class PushArgumentInstr : public TemplateDefinition<1> {
  public:
   explicit PushArgumentInstr(Value* value) {
     SetInputAt(0, value);
   }
 
   DECLARE_INSTRUCTION(PushArgument)
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   virtual CompileType ComputeType() const;
 
   Value* value() const { return InputAt(0); }
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(PushArgumentInstr);
 };
 
 
 inline Definition* Instruction::ArgumentAt(intptr_t index) const {
   return PushArgumentAt(index)->value()->definition();
 }
 
 
-class ReturnInstr : public TemplateInstruction<1, NoThrow> {
+class ReturnInstr : public TemplateInstruction<1> {
  public:
   ReturnInstr(intptr_t token_pos, Value* value)
-      : TemplateInstruction(Isolate::Current()->GetNextDeoptId()),
+      : TemplateInstruction<1>(Isolate::Current()->GetNextDeoptId()),
         token_pos_(token_pos) {
     SetInputAt(0, value);
   }
 
   DECLARE_INSTRUCTION(Return)
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   virtual intptr_t token_pos() const { return token_pos_; }
   Value* value() const { return inputs_[0]; }
 
   virtual bool CanBecomeDeoptimizationTarget() const {
     // Return instruction might turn into a Goto instruction after inlining.
     // Every Goto must have an environment.
     return true;
   }
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   const intptr_t token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(ReturnInstr);
 };
 
 
-class ThrowInstr : public TemplateInstruction<0, Throws> {
+class ThrowInstr : public TemplateInstruction<0> {
  public:
   explicit ThrowInstr(intptr_t token_pos)
-      : TemplateInstruction(Isolate::Current()->GetNextDeoptId()),
+      : TemplateInstruction<0>(Isolate::Current()->GetNextDeoptId()),
         token_pos_(token_pos) {
   }
 
   DECLARE_INSTRUCTION(Throw)
 
   virtual intptr_t ArgumentCount() const { return 1; }
 
   virtual intptr_t token_pos() const { return token_pos_; }
 
   virtual bool CanDeoptimize() const { return true; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
+  virtual bool MayThrow() const { return true; }
+
  private:
   const intptr_t token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(ThrowInstr);
 };
 
 
-class ReThrowInstr : public TemplateInstruction<0, Throws> {
+class ReThrowInstr : public TemplateInstruction<0> {
  public:
   // 'catch_try_index' can be CatchClauseNode::kInvalidTryIndex if the
   // rethrow has been artifically generated by the parser.
   ReThrowInstr(intptr_t token_pos, intptr_t catch_try_index)
-      : TemplateInstruction(Isolate::Current()->GetNextDeoptId()),
+      : TemplateInstruction<0>(Isolate::Current()->GetNextDeoptId()),
         token_pos_(token_pos),
         catch_try_index_(catch_try_index) {
   }
 
   DECLARE_INSTRUCTION(ReThrow)
 
   virtual intptr_t ArgumentCount() const { return 2; }
 
   virtual intptr_t token_pos() const { return token_pos_; }
   intptr_t catch_try_index() const { return catch_try_index_; }
 
   virtual bool CanDeoptimize() const { return true; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
+  virtual bool MayThrow() const { return true; }
+
  private:
   const intptr_t token_pos_;
   const intptr_t catch_try_index_;
 
   DISALLOW_COPY_AND_ASSIGN(ReThrowInstr);
 };
 
 
-class GotoInstr : public TemplateInstruction<0, NoThrow> {
+class GotoInstr : public TemplateInstruction<0> {
  public:
   explicit GotoInstr(JoinEntryInstr* entry)
-    : TemplateInstruction(Isolate::Current()->GetNextDeoptId()),
+    : TemplateInstruction<0>(Isolate::Current()->GetNextDeoptId()),
       successor_(entry),
       edge_weight_(0.0),
       parallel_move_(NULL) {
   }
 
   DECLARE_INSTRUCTION(Goto)
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   JoinEntryInstr* successor() const { return successor_; }
@@ skipping 29 matching lines @@
 
   ParallelMoveInstr* GetParallelMove() {
     if (parallel_move_ == NULL) {
       parallel_move_ = new ParallelMoveInstr();
     }
     return parallel_move_;
   }
 
   virtual void PrintTo(BufferFormatter* f) const;
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   JoinEntryInstr* successor_;
   double edge_weight_;
 
   // Parallel move that will be used by linear scan register allocator to
   // connect live ranges at the end of the block and resolve phis.
   ParallelMoveInstr* parallel_move_;
 };
 
 
-class ComparisonInstr : public TemplateDefinition<2, NoThrow, Pure> {
+class ComparisonInstr : public TemplateDefinition<2> {
  public:
   Value* left() const { return inputs_[0]; }
   Value* right() const { return inputs_[1]; }
 
   virtual intptr_t token_pos() const { return token_pos_; }
   Token::Kind kind() const { return kind_; }
 
   virtual ComparisonInstr* CopyWithNewOperands(Value* left, Value* right) = 0;
 
   virtual void EmitBranchCode(FlowGraphCompiler* compiler,
@@ skipping 10 matching lines @@
   void set_operation_cid(intptr_t value) { operation_cid_ = value; }
   intptr_t operation_cid() const { return operation_cid_; }
 
   void NegateComparison() {
     kind_ = Token::NegateComparison(kind_);
   }
 
   virtual bool CanBecomeDeoptimizationTarget() const { return true; }
   virtual intptr_t DeoptimizationTarget() const { return GetDeoptId(); }
 
-  virtual bool AttributesEqual(Instruction* other) const {
-    ComparisonInstr* other_comparison = other->AsComparison();
-    return kind() == other_comparison->kind() &&
-        (operation_cid() == other_comparison->operation_cid());
-  }
-
   DEFINE_INSTRUCTION_TYPE_CHECK(Comparison)
 
  protected:
   ComparisonInstr(intptr_t token_pos,
                   Token::Kind kind,
                   Value* left,
                   Value* right,
                   intptr_t deopt_id = Isolate::kNoDeoptId)
-      : TemplateDefinition(deopt_id),
+      : TemplateDefinition<2>(deopt_id),
         token_pos_(token_pos),
         kind_(kind),
         operation_cid_(kIllegalCid) {
     SetInputAt(0, left);
     if (right != NULL) {
       SetInputAt(1, right);
     }
   }
 
  private:
@@ skipping 107 matching lines @@
   TargetEntryInstr* false_successor_;
   ComparisonInstr* comparison_;
   bool is_checked_;
   ConstrainedCompileType* constrained_type_;
   TargetEntryInstr* constant_target_;
 
   DISALLOW_COPY_AND_ASSIGN(BranchInstr);
 };
 
 
-class StoreContextInstr : public TemplateInstruction<1, NoThrow> {
+class StoreContextInstr : public TemplateInstruction<1> {
  public:
   explicit StoreContextInstr(Value* value) {
     SetInputAt(kValuePos, value);
   }
 
   enum {
     kValuePos = 0
   };
 
   DECLARE_INSTRUCTION(StoreContext)
 
   virtual intptr_t ArgumentCount() const { return 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);
 };
 
 
-class DeoptimizeInstr : public TemplateInstruction<0, NoThrow, Pure> {
+class DeoptimizeInstr : public TemplateInstruction<0> {
  public:
   DeoptimizeInstr(ICData::DeoptReasonId deopt_reason, intptr_t deopt_id)
-      : TemplateInstruction(deopt_id),
+      : TemplateInstruction<0>(deopt_id),
         deopt_reason_(deopt_reason) {
   }
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   virtual bool CanDeoptimize() const { return true; }
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const {
     return true;
   }
 
+  virtual bool MayThrow() const { return false; }
+
   DECLARE_INSTRUCTION(Deoptimize)
 
  private:
   const ICData::DeoptReasonId deopt_reason_;
 
   DISALLOW_COPY_AND_ASSIGN(DeoptimizeInstr);
 };
 
 
-class RedefinitionInstr : public TemplateDefinition<1, NoThrow> {
+class RedefinitionInstr : public TemplateDefinition<1> {
  public:
   explicit RedefinitionInstr(Value* value) {
     SetInputAt(0, value);
   }
 
   DECLARE_INSTRUCTION(Redefinition)
 
   Value* value() const { return inputs_[0]; }
 
   virtual CompileType ComputeType() const;
   virtual bool RecomputeType();
 
   virtual bool CanDeoptimize() const { return false; }
   virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(RedefinitionInstr);
 };
 
 
-class ConstraintInstr : public TemplateDefinition<1, NoThrow> {
+class ConstraintInstr : public TemplateDefinition<1> {
  public:
   ConstraintInstr(Value* value, Range* constraint)
       : constraint_(constraint),
         target_(NULL) {
     SetInputAt(0, value);
   }
 
   DECLARE_INSTRUCTION(Constraint)
 
   virtual CompileType ComputeType() const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
   virtual bool AttributesEqual(Instruction* other) const {
     UNREACHABLE();
     return false;
   }
 
+  virtual bool MayThrow() const { return false; }
+
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   Value* value() const { return inputs_[0]; }
   Range* constraint() const { return constraint_; }
 
   virtual void InferRange(RangeAnalysis* analysis, Range* range);
 
   // Constraints for branches have their target block stored in order
   // to find the the comparsion that generated the constraint:
   // target->predecessor->last_instruction->comparison.
   void set_target(TargetEntryInstr* target) {
     target_ = target;
   }
   TargetEntryInstr* target() const {
     return target_;
   }
 
  private:
   Range* constraint_;
   TargetEntryInstr* target_;
 
   DISALLOW_COPY_AND_ASSIGN(ConstraintInstr);
 };
 
 
-class ConstantInstr : public TemplateDefinition<0, NoThrow, Pure> {
+class ConstantInstr : public TemplateDefinition<0> {
  public:
   explicit ConstantInstr(const Object& value);
 
   DECLARE_INSTRUCTION(Constant)
   virtual CompileType ComputeType() const;
 
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
   const Object& value() const { return value_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual void InferRange(RangeAnalysis* analysis, Range* range);
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const;
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   const Object& value_;
 
   DISALLOW_COPY_AND_ASSIGN(ConstantInstr);
 };
 
 
 // Merged ConstantInstr -> UnboxedXXX into UnboxedConstantInstr.
 // TODO(srdjan): Implemented currently for doubles only, should implement
 // for other unboxing instructions.
@@ skipping 12 matching lines @@
   DECLARE_INSTRUCTION(UnboxedConstant)
 
  private:
   const Representation representation_;
   uword constant_address_;  // Either NULL or points to the untagged constant.
 
   DISALLOW_COPY_AND_ASSIGN(UnboxedConstantInstr);
 };
 
 
-class AssertAssignableInstr : public TemplateDefinition<3, Throws, Pure> {
+class AssertAssignableInstr : public TemplateDefinition<3> {
  public:
   AssertAssignableInstr(intptr_t token_pos,
                         Value* value,
                         Value* instantiator,
                         Value* instantiator_type_arguments,
                         const AbstractType& dst_type,
                         const String& dst_name,
                         intptr_t deopt_id)
-      : TemplateDefinition(deopt_id),
+      : TemplateDefinition<3>(deopt_id),
         token_pos_(token_pos),
         dst_type_(AbstractType::ZoneHandle(dst_type.raw())),
         dst_name_(dst_name) {
     ASSERT(!dst_type.IsNull());
     ASSERT(!dst_name.IsNull());
     SetInputAt(0, value);
     SetInputAt(1, instantiator);
     SetInputAt(2, instantiator_type_arguments);
   }
 
@@ skipping 17 matching lines @@
   virtual bool CanDeoptimize() const { return true; }
 
   virtual bool CanBecomeDeoptimizationTarget() const {
     // AssertAssignable instructions that are specialized by the optimizer
     // (e.g. replaced with CheckClass) need a deoptimization descriptor before.
     return true;
   }
 
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const;
 
+  virtual bool MayThrow() const { return true; }
+
  private:
   const intptr_t token_pos_;
   AbstractType& dst_type_;
   const String& dst_name_;
 
   DISALLOW_COPY_AND_ASSIGN(AssertAssignableInstr);
 };
 
 
-class AssertBooleanInstr : public TemplateDefinition<1, Throws, Pure> {
+class AssertBooleanInstr : public TemplateDefinition<1> {
  public:
   AssertBooleanInstr(intptr_t token_pos, Value* value)
-      : TemplateDefinition(Isolate::Current()->GetNextDeoptId()),
+      : TemplateDefinition<1>(Isolate::Current()->GetNextDeoptId()),
         token_pos_(token_pos) {
     SetInputAt(0, value);
   }
 
   DECLARE_INSTRUCTION(AssertBoolean)
   virtual CompileType ComputeType() const;
 
   virtual intptr_t token_pos() const { return token_pos_; }
   Value* value() const { return inputs_[0]; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return true; }
 
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
+  virtual bool MayThrow() const { return true; }
+
  private:
   const intptr_t token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(AssertBooleanInstr);
 };
 
 
 // Denotes the current context, normally held in a register.  This is
 // a computation, not a value, because it's mutable.
-class CurrentContextInstr : public TemplateDefinition<0, NoThrow> {
+class CurrentContextInstr : public TemplateDefinition<0> {
  public:
   CurrentContextInstr()
-      : TemplateDefinition(Isolate::Current()->GetNextDeoptId()) {
+      : TemplateDefinition<0>(Isolate::Current()->GetNextDeoptId()) {
   }
 
   DECLARE_INSTRUCTION(CurrentContext)
   virtual CompileType ComputeType() const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
   virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(CurrentContextInstr);
 };
 
 
-class ClosureCallInstr : public TemplateDefinition<1, Throws> {
+class ClosureCallInstr : public TemplateDefinition<1> {
  public:
   ClosureCallInstr(Value* function,
                    ClosureCallNode* node,
                    ZoneGrowableArray<PushArgumentInstr*>* arguments)
-      : TemplateDefinition(Isolate::Current()->GetNextDeoptId()),
+      : TemplateDefinition<1>(Isolate::Current()->GetNextDeoptId()),
         ast_node_(*node),
         arguments_(arguments) {
     SetInputAt(0, function);
   }
 
   DECLARE_INSTRUCTION(ClosureCall)
 
   const Array& argument_names() const { return ast_node_.arguments()->names(); }
   virtual intptr_t token_pos() const { return ast_node_.token_pos(); }
 
   virtual intptr_t ArgumentCount() const { return arguments_->length(); }
   virtual PushArgumentInstr* PushArgumentAt(intptr_t index) const {
     return (*arguments_)[index];
   }
 
   // TODO(kmillikin): implement exact call counts for closure calls.
   virtual intptr_t CallCount() const { return 1; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return true; }
 
   virtual EffectSet Effects() const { return EffectSet::All(); }
 
+  virtual bool MayThrow() const { return true; }
+
  private:
   const ClosureCallNode& ast_node_;
   ZoneGrowableArray<PushArgumentInstr*>* arguments_;
 
   DISALLOW_COPY_AND_ASSIGN(ClosureCallInstr);
 };
 
 
-class InstanceCallInstr : public TemplateDefinition<0, Throws> {
+class InstanceCallInstr : public TemplateDefinition<0> {
  public:
   InstanceCallInstr(intptr_t token_pos,
                     const String& function_name,
                     Token::Kind token_kind,
                     ZoneGrowableArray<PushArgumentInstr*>* arguments,
                     const Array& argument_names,
                     intptr_t checked_argument_count,
                     const ZoneGrowableArray<const ICData*>& ic_data_array)
-      : TemplateDefinition(Isolate::Current()->GetNextDeoptId()),
+      : TemplateDefinition<0>(Isolate::Current()->GetNextDeoptId()),
         ic_data_(NULL),
         token_pos_(token_pos),
         function_name_(function_name),
         token_kind_(token_kind),
         arguments_(arguments),
         argument_names_(argument_names),
         checked_argument_count_(checked_argument_count) {
     ic_data_ = GetICData(ic_data_array);
     ASSERT(function_name.IsNotTemporaryScopedHandle());
     ASSERT(!arguments->is_empty());
@@ skipping 35 matching lines @@
   virtual bool CanDeoptimize() const { return true; }
 
   virtual bool CanBecomeDeoptimizationTarget() const {
     // Instance calls that are specialized by the optimizer need a
     // deoptimization descriptor before the call.
     return true;
   }
 
   virtual EffectSet Effects() const { return EffectSet::All(); }
 
+  virtual bool MayThrow() const { return true; }
+
  protected:
   friend class FlowGraphOptimizer;
   void set_ic_data(ICData* value) { ic_data_ = value; }
 
  private:
   const ICData* ic_data_;
   const intptr_t token_pos_;
   const String& function_name_;
   const Token::Kind token_kind_;  // Binary op, unary op, kGET or kILLEGAL.
   ZoneGrowableArray<PushArgumentInstr*>* const arguments_;
   const Array& argument_names_;
   const intptr_t checked_argument_count_;
 
   DISALLOW_COPY_AND_ASSIGN(InstanceCallInstr);
 };
 
 
-class PolymorphicInstanceCallInstr : public TemplateDefinition<0, Throws> {
+class PolymorphicInstanceCallInstr : public TemplateDefinition<0> {
  public:
   PolymorphicInstanceCallInstr(InstanceCallInstr* instance_call,
                                const ICData& ic_data,
                                bool with_checks)
-      : TemplateDefinition(instance_call->deopt_id()),
+      : TemplateDefinition<0>(instance_call->deopt_id()),
         instance_call_(instance_call),
         ic_data_(ic_data),
         with_checks_(with_checks) {
     ASSERT(instance_call_ != NULL);
     ASSERT(ic_data.NumberOfChecks() > 0);
   }
 
   InstanceCallInstr* instance_call() const { return instance_call_; }
   bool with_checks() const { return with_checks_; }
   virtual intptr_t token_pos() const { return instance_call_->token_pos(); }
@@ skipping 14 matching lines @@
   DECLARE_INSTRUCTION(PolymorphicInstanceCall)
 
   const ICData& ic_data() const { return ic_data_; }
 
   virtual bool CanDeoptimize() const { return true; }
 
   virtual EffectSet Effects() const { return EffectSet::All(); }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
+  virtual bool MayThrow() const { return true; }
+
  private:
   InstanceCallInstr* instance_call_;
   const ICData& ic_data_;
   const bool with_checks_;
 
   DISALLOW_COPY_AND_ASSIGN(PolymorphicInstanceCallInstr);
 };
 
 
 class StrictCompareInstr : public ComparisonInstr {
@@ skipping 18 matching lines @@
 
   virtual void EmitBranchCode(FlowGraphCompiler* compiler,
                               BranchInstr* branch);
 
   virtual Condition EmitComparisonCode(FlowGraphCompiler* compiler,
                                        BranchLabels labels);
 
   bool needs_number_check() const { return needs_number_check_; }
   void set_needs_number_check(bool value) { needs_number_check_ = value; }
 
-  bool AttributesEqual(Instruction* other) const;
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
+  virtual bool AttributesEqual(Instruction* other) const;
+
+  virtual bool MayThrow() const { return false; }
 
  private:
   // True if the comparison must check for double, Mint or Bigint and
   // use value comparison instead.
   bool needs_number_check_;
 
   DISALLOW_COPY_AND_ASSIGN(StrictCompareInstr);
 };
 
 
@@ skipping 11 matching lines @@
   virtual ComparisonInstr* CopyWithNewOperands(Value* left, Value* right);
 
   virtual CompileType ComputeType() const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     return kTagged;
   }
 
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+
+  virtual bool MayThrow() const { return false; }
+
   virtual void EmitBranchCode(FlowGraphCompiler* compiler,
                               BranchInstr* branch);
 
   virtual Condition EmitComparisonCode(FlowGraphCompiler* compiler,
                                        BranchLabels labels);
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestSmiInstr);
 };
 
@@ skipping 28 matching lines @@
   virtual CompileType ComputeType() const;
 
   virtual bool CanDeoptimize() const {
     return GetDeoptId() != Isolate::kNoDeoptId;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     return kTagged;
   }
 
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
+
+  virtual bool MayThrow() const { return false; }
+
   virtual bool AttributesEqual(Instruction* other) const;
 
   virtual void EmitBranchCode(FlowGraphCompiler* compiler,
                               BranchInstr* branch);
 
   virtual Condition EmitComparisonCode(FlowGraphCompiler* compiler,
                                        BranchLabels labels);
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
@@ skipping 32 matching lines @@
   virtual Condition EmitComparisonCode(FlowGraphCompiler* compiler,
                                        BranchLabels labels);
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     if (operation_cid() == kDoubleCid) return kUnboxedDouble;
     if (operation_cid() == kMintCid) return kUnboxedMint;
     return kTagged;
   }
 
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+
+  virtual bool MayThrow() const { return false; }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(EqualityCompareInstr);
 };
 
 
 class RelationalOpInstr : public ComparisonInstr {
  public:
   RelationalOpInstr(intptr_t token_pos,
                     Token::Kind kind,
                     Value* left,
@@ skipping 21 matching lines @@
   virtual Condition EmitComparisonCode(FlowGraphCompiler* compiler,
                                        BranchLabels labels);
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     if (operation_cid() == kDoubleCid) return kUnboxedDouble;
     if (operation_cid() == kMintCid) return kUnboxedMint;
     return kTagged;
   }
 
+  virtual EffectSet Effects() const {
+    return EffectSet::None();
+  }
+
+  virtual bool MayThrow() const { return false; }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(RelationalOpInstr);
 };
 
 
 // TODO(vegorov): ComparisonInstr should be switched to use IfTheElseInstr for
 // materialization of true and false constants.
 class IfThenElseInstr : public Definition {
  public:
   IfThenElseInstr(ComparisonInstr* comparison,
@@ skipping 66 matching lines @@
   }
 
   ComparisonInstr* comparison_;
   const intptr_t if_true_;
   const intptr_t if_false_;
 
   DISALLOW_COPY_AND_ASSIGN(IfThenElseInstr);
 };
 
 
-class StaticCallInstr : public TemplateDefinition<0, Throws> {
+class StaticCallInstr : public TemplateDefinition<0> {
  public:
   StaticCallInstr(intptr_t token_pos,
                   const Function& function,
                   const Array& argument_names,
                   ZoneGrowableArray<PushArgumentInstr*>* arguments,
                   const ZoneGrowableArray<const ICData*>& ic_data_array)
-      : TemplateDefinition(Isolate::Current()->GetNextDeoptId()),
+      : TemplateDefinition<0>(Isolate::Current()->GetNextDeoptId()),
         ic_data_(NULL),
         token_pos_(token_pos),
         function_(function),
         argument_names_(argument_names),
         arguments_(arguments),
         result_cid_(kDynamicCid),
         is_known_list_constructor_(false),
         is_native_list_factory_(false),
         identity_(AliasIdentity::Unknown()) {
     ic_data_ = GetICData(ic_data_array);
@@ skipping 43 matching lines @@
 
   bool is_native_list_factory() const { return is_native_list_factory_; }
   void set_is_native_list_factory(bool value) {
     is_native_list_factory_ = value;
   }
 
   bool IsRecognizedFactory() const {
     return is_known_list_constructor() || is_native_list_factory();
   }
 
+  virtual bool MayThrow() const { return true; }
+
   virtual AliasIdentity Identity() const { return identity_; }
   virtual void SetIdentity(AliasIdentity identity) { identity_ = identity; }
 
  private:
   const ICData* ic_data_;
   const intptr_t token_pos_;
   const Function& function_;
   const Array& argument_names_;
   ZoneGrowableArray<PushArgumentInstr*>* arguments_;
   intptr_t result_cid_;  // For some library functions we know the result.
 
   // 'True' for recognized list constructors.
   bool is_known_list_constructor_;
   bool is_native_list_factory_;
 
   AliasIdentity identity_;
 
   DISALLOW_COPY_AND_ASSIGN(StaticCallInstr);
 };
 
 
-class LoadLocalInstr : public TemplateDefinition<0, NoThrow> {
+class LoadLocalInstr : public TemplateDefinition<0> {
  public:
   explicit LoadLocalInstr(const LocalVariable& local)
       : local_(local), is_last_(false) { }
 
   DECLARE_INSTRUCTION(LoadLocal)
   virtual CompileType ComputeType() const;
 
   const LocalVariable& local() const { return local_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const {
     UNREACHABLE();  // Eliminated by SSA construction.
     return EffectSet::None();
   }
 
   void mark_last() { is_last_ = true; }
   bool is_last() const { return is_last_; }
 
+  virtual bool MayThrow() const {
+    UNREACHABLE();
+    return false;
+  }
+
  private:
   const LocalVariable& local_;
   bool is_last_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadLocalInstr);
 };
 
 
-class PushTempInstr : public TemplateDefinition<1, NoThrow> {
+class PushTempInstr : public TemplateDefinition<1> {
  public:
   explicit PushTempInstr(Value* value) {
     SetInputAt(0, value);
   }
 
   DECLARE_INSTRUCTION(PushTemp)
 
   Value* value() const { return inputs_[0]; }
 
   virtual CompileType ComputeType() const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const {
     UNREACHABLE();  // Eliminated by SSA construction.
     return EffectSet::None();
   }
 
+  virtual bool MayThrow() const {
+    UNREACHABLE();
+    return false;
+  }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(PushTempInstr);
 };
 
 
 class DropTempsInstr : public Definition {
  public:
   explicit DropTempsInstr(intptr_t num_temps, Value* value = NULL)
       : num_temps_(num_temps), value_(NULL) {
     if (value != NULL) {
@@ skipping 34 matching lines @@
     value_ = value;
   }
 
   const intptr_t num_temps_;
   Value* value_;
 
   DISALLOW_COPY_AND_ASSIGN(DropTempsInstr);
 };
 
 
-class StoreLocalInstr : public TemplateDefinition<1, NoThrow> {
+class StoreLocalInstr : public TemplateDefinition<1> {
  public:
   StoreLocalInstr(const LocalVariable& local, Value* value)
       : local_(local), is_dead_(false), is_last_(false) {
     SetInputAt(0, value);
   }
 
   DECLARE_INSTRUCTION(StoreLocal)
   virtual CompileType* ComputeInitialType() const;
 
   const LocalVariable& local() const { return local_; }
   Value* value() const { return inputs_[0]; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   void mark_dead() { is_dead_ = true; }
   bool is_dead() const { return is_dead_; }
 
   void mark_last() { is_last_ = true; }
   bool is_last() const { return is_last_; }
 
   virtual EffectSet Effects() const {
     UNREACHABLE();  // Eliminated by SSA construction.
     return EffectSet::None();
   }
 
+  virtual bool MayThrow() const {
+    UNREACHABLE();
+    return false;
+  }
+
  private:
   const LocalVariable& local_;
   bool is_dead_;
   bool is_last_;
 
   DISALLOW_COPY_AND_ASSIGN(StoreLocalInstr);
 };
 
 
-class NativeCallInstr : public TemplateDefinition<0, Throws> {
+class NativeCallInstr : public TemplateDefinition<0> {
  public:
   explicit NativeCallInstr(NativeBodyNode* node)
       : ast_node_(*node) {}
 
   DECLARE_INSTRUCTION(NativeCall)
 
   virtual intptr_t token_pos() const { return ast_node_.token_pos(); }
 
   const Function& function() const { return ast_node_.function(); }
 
   const String& native_name() const {
     return ast_node_.native_c_function_name();
   }
 
   NativeFunction native_c_function() const {
     return ast_node_.native_c_function();
   }
 
   bool is_bootstrap_native() const {
     return ast_node_.is_bootstrap_native();
   }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const { return EffectSet::All(); }
 
+  virtual bool MayThrow() const {
+    UNREACHABLE();
+    return true;
+  }
+
  private:
   const NativeBodyNode& ast_node_;
 
   DISALLOW_COPY_AND_ASSIGN(NativeCallInstr);
 };
 
 
-class DebugStepCheckInstr : public TemplateInstruction<0, NoThrow> {
+class DebugStepCheckInstr : public TemplateInstruction<0> {
  public:
   DebugStepCheckInstr(intptr_t token_pos,
                       RawPcDescriptors::Kind stub_kind)
       : token_pos_(token_pos),
         stub_kind_(stub_kind) {
   }
 
   DECLARE_INSTRUCTION(DebugStepCheck)
 
   virtual intptr_t token_pos() const { return token_pos_; }
+  virtual bool MayThrow() const { return false; }
   virtual bool CanDeoptimize() const { return false; }
   virtual EffectSet Effects() const { return EffectSet::All(); }
   virtual intptr_t ArgumentCount() const { return 0; }
   virtual Instruction* Canonicalize(FlowGraph* flow_graph);
 
  private:
   const intptr_t token_pos_;
   const RawPcDescriptors::Kind stub_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(DebugStepCheckInstr);
 };
 
 
 enum StoreBarrierType {
   kNoStoreBarrier,
   kEmitStoreBarrier
 };
 
 
-class StoreInstanceFieldInstr : public TemplateDefinition<2, NoThrow> {
+class StoreInstanceFieldInstr : public TemplateDefinition<2> {
  public:
   StoreInstanceFieldInstr(const Field& field,
                           Value* instance,
                           Value* value,
                           StoreBarrierType emit_store_barrier,
                           intptr_t token_pos)
       : field_(field),
         offset_in_bytes_(field.Offset()),
         emit_store_barrier_(emit_store_barrier),
         token_pos_(token_pos),
@@ skipping 47 matching lines @@
   // May require a deoptimization target for input conversions.
   virtual intptr_t DeoptimizationTarget() const {
     return GetDeoptId();
   }
 
   // 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(); }
 
+  virtual bool MayThrow() const { return false; }
+
   bool IsUnboxedStore() const;
 
   bool IsPotentialUnboxedStore() const;
 
   virtual Representation RequiredInputRepresentation(intptr_t index) const;
 
  private:
   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 intptr_t token_pos_;
   bool is_initialization_;  // Marks stores in the constructor.
 
   DISALLOW_COPY_AND_ASSIGN(StoreInstanceFieldInstr);
 };
 
 
-class GuardFieldInstr : public TemplateInstruction<1, NoThrow, Pure> {
+class GuardFieldInstr : public TemplateInstruction<1> {
  public:
   GuardFieldInstr(Value* value,
                   const Field& field,
                   intptr_t deopt_id)
-    : TemplateInstruction(deopt_id),
+    : TemplateInstruction<1>(deopt_id),
       field_(field) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
   const Field& field() const { return field_; }
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   virtual bool CanDeoptimize() const { return true; }
   virtual bool CanBecomeDeoptimizationTarget() const {
     // Ensure that we record kDeopt PC descriptor in unoptimized code.
     return true;
   }
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
+
+  virtual bool MayThrow() const { return false; }
+
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
  private:
   const Field& field_;
 
   DISALLOW_COPY_AND_ASSIGN(GuardFieldInstr);
 };
 
 
 class GuardFieldClassInstr : public GuardFieldInstr {
@@ skipping 25 matching lines @@
 
   virtual Instruction* Canonicalize(FlowGraph* flow_graph);
 
   virtual bool AttributesEqual(Instruction* other) const;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(GuardFieldLengthInstr);
 };
 
 
-class LoadStaticFieldInstr : public TemplateDefinition<1, NoThrow> {
+class LoadStaticFieldInstr : public TemplateDefinition<1> {
  public:
   explicit LoadStaticFieldInstr(Value* field_value) {
     ASSERT(field_value->BindsToConstant());
     SetInputAt(0, field_value);
   }
 
   DECLARE_INSTRUCTION(LoadStaticField)
   virtual CompileType ComputeType() const;
 
   const Field& StaticField() const;
 
   Value* field_value() const { return inputs_[0]; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool AllowsCSE() const { return StaticField().is_final(); }
   virtual EffectSet Effects() const { return EffectSet::None(); }
   virtual EffectSet Dependencies() const;
   virtual bool AttributesEqual(Instruction* other) const;
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(LoadStaticFieldInstr);
 };
 
 
-class StoreStaticFieldInstr : public TemplateDefinition<1, NoThrow> {
+class StoreStaticFieldInstr : public TemplateDefinition<1> {
  public:
   StoreStaticFieldInstr(const Field& field, Value* value)
       : field_(field) {
     ASSERT(field.IsZoneHandle());
     SetInputAt(kValuePos, value);
   }
 
   enum {
     kValuePos = 0
   };
 
   DECLARE_INSTRUCTION(StoreStaticField)
   virtual CompileType* ComputeInitialType() const;
 
   const Field& field() const { return field_; }
   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(); }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   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_;
 
   DISALLOW_COPY_AND_ASSIGN(StoreStaticFieldInstr);
 };
 
 
-class LoadIndexedInstr : public TemplateDefinition<2, NoThrow> {
+class LoadIndexedInstr : public TemplateDefinition<2> {
  public:
   LoadIndexedInstr(Value* array,
                    Value* index,
                    intptr_t index_scale,
                    intptr_t class_id,
                    intptr_t deopt_id,
                    intptr_t token_pos)
-      : TemplateDefinition(deopt_id),
+      : TemplateDefinition<2>(deopt_id),
         index_scale_(index_scale),
         class_id_(class_id),
         token_pos_(token_pos) {
     SetInputAt(0, array);
     SetInputAt(1, index);
   }
 
   intptr_t token_pos() const { return token_pos_; }
 
   DECLARE_INSTRUCTION(LoadIndexed)
@@ skipping 19 matching lines @@
     return GetDeoptId() != Isolate::kNoDeoptId;
   }
 
   bool Typed32BitIsSmi() const {
     return kSmiBits >= 32;
   }
 
   virtual Representation representation() const;
   virtual void InferRange(RangeAnalysis* analysis, Range* range);
 
+  virtual bool AllowsCSE() const { return false; }
   virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const;
+  virtual bool AttributesEqual(Instruction* other) const;
+
+  virtual bool MayThrow() const { return false; }
 
  private:
   const intptr_t index_scale_;
   const intptr_t class_id_;
   const intptr_t token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadIndexedInstr);
 };
 
 
-class StringFromCharCodeInstr : public TemplateDefinition<1, NoThrow, Pure> {
+class StringFromCharCodeInstr : public TemplateDefinition<1> {
  public:
   StringFromCharCodeInstr(Value* char_code, intptr_t cid) : cid_(cid) {
     ASSERT(char_code != NULL);
     ASSERT(char_code->definition()->IsLoadIndexed());
     ASSERT(char_code->definition()->AsLoadIndexed()->class_id() ==
            kOneByteStringCid);
     SetInputAt(0, char_code);
   }
 
   DECLARE_INSTRUCTION(StringFromCharCode)
   virtual CompileType ComputeType() const;
 
   Value* char_code() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const { return false; }
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const {
     return other->AsStringFromCharCode()->cid_ == cid_;
   }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   const intptr_t cid_;
 
   DISALLOW_COPY_AND_ASSIGN(StringFromCharCodeInstr);
 };
 
 
-class StringToCharCodeInstr : public TemplateDefinition<1, NoThrow, Pure> {
+class StringToCharCodeInstr : public TemplateDefinition<1> {
  public:
   StringToCharCodeInstr(Value* str, intptr_t cid) : cid_(cid) {
     ASSERT(str != NULL);
     SetInputAt(0, str);
   }
 
   DECLARE_INSTRUCTION(StringToCharCode)
   virtual CompileType ComputeType() const;
 
   Value* str() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const { return false; }
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const {
     return other->AsStringToCharCode()->cid_ == cid_;
   }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   const intptr_t cid_;
 
   DISALLOW_COPY_AND_ASSIGN(StringToCharCodeInstr);
 };
 
 
-class StringInterpolateInstr : public TemplateDefinition<1, Throws> {
+class StringInterpolateInstr : public TemplateDefinition<1> {
  public:
   StringInterpolateInstr(Value* value, intptr_t token_pos)
-      : TemplateDefinition(Isolate::Current()->GetNextDeoptId()),
+      : TemplateDefinition<1>(Isolate::Current()->GetNextDeoptId()),
         token_pos_(token_pos),
         function_(Function::Handle()) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
   virtual intptr_t token_pos() const { return token_pos_; }
 
   virtual CompileType ComputeType() const;
   // Issues a static call to Dart code which calls toString on objects.
   virtual EffectSet Effects() const { return EffectSet::All(); }
   virtual bool CanDeoptimize() const { return true; }
+  virtual bool MayThrow() const { return true; }
 
   const Function& CallFunction() const;
 
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
   DECLARE_INSTRUCTION(StringInterpolate)
 
  private:
   const intptr_t token_pos_;
   Function& function_;
 
   DISALLOW_COPY_AND_ASSIGN(StringInterpolateInstr);
 };
 
 
-class StoreIndexedInstr : public TemplateDefinition<3, NoThrow> {
+class StoreIndexedInstr : public TemplateDefinition<3> {
  public:
   StoreIndexedInstr(Value* array,
                     Value* index,
                     Value* value,
                     StoreBarrierType emit_store_barrier,
                     intptr_t index_scale,
                     intptr_t class_id,
                     intptr_t deopt_id,
                     intptr_t token_pos)
-      : TemplateDefinition(deopt_id),
+      : TemplateDefinition<3>(deopt_id),
         emit_store_barrier_(emit_store_barrier),
         index_scale_(index_scale),
         class_id_(class_id),
         token_pos_(token_pos) {
     SetInputAt(kArrayPos, array);
     SetInputAt(kIndexPos, index);
     SetInputAt(kValuePos, value);
   }
 
   DECLARE_INSTRUCTION(StoreIndexed)
@@ skipping 25 matching lines @@
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   const StoreBarrierType emit_store_barrier_;
   const intptr_t index_scale_;
   const intptr_t class_id_;
   const intptr_t token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(StoreIndexedInstr);
 };
 
 
 // Note overrideable, built-in: value ? false : true.
-class BooleanNegateInstr : public TemplateDefinition<1, NoThrow> {
+class BooleanNegateInstr : public TemplateDefinition<1> {
  public:
   explicit BooleanNegateInstr(Value* value) {
     SetInputAt(0, value);
   }
 
   DECLARE_INSTRUCTION(BooleanNegate)
   virtual CompileType ComputeType() const;
 
   Value* value() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
+  virtual bool MayThrow() const { return false; }
+
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BooleanNegateInstr);
 };
 
 
-class InstanceOfInstr : public TemplateDefinition<3, Throws> {
+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,
                   intptr_t deopt_id)
-      : TemplateDefinition(deopt_id),
+      : TemplateDefinition<3>(deopt_id),
         token_pos_(token_pos),
         type_(type),
         negate_result_(negate_result) {
     ASSERT(!type.IsNull());
     SetInputAt(0, value);
     SetInputAt(1, instantiator);
     SetInputAt(2, instantiator_type_arguments);
   }
 
   DECLARE_INSTRUCTION(InstanceOf)
   virtual CompileType ComputeType() 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_; }
   const AbstractType& type() const { return type_; }
   virtual intptr_t token_pos() const { return token_pos_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return true; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
+  virtual bool MayThrow() const { return true; }
+
  private:
   const intptr_t token_pos_;
   Value* value_;
   Value* instantiator_;
   Value* type_arguments_;
   const AbstractType& type_;
   const bool negate_result_;
 
   DISALLOW_COPY_AND_ASSIGN(InstanceOfInstr);
 };
 
 
-class AllocateObjectInstr : public TemplateDefinition<0, NoThrow> {
+class AllocateObjectInstr : public TemplateDefinition<0> {
  public:
   AllocateObjectInstr(intptr_t token_pos,
                       const Class& cls,
                       ZoneGrowableArray<PushArgumentInstr*>* arguments)
       : token_pos_(token_pos),
         cls_(cls),
         arguments_(arguments),
         identity_(AliasIdentity::Unknown()),
         closure_function_(Function::ZoneHandle()) {
     // Either no arguments or one type-argument and one instantiator.
@@ skipping 15 matching lines @@
   void set_closure_function(const Function& function) {
     closure_function_ ^= function.raw();
   }
 
   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; }
+
   virtual AliasIdentity Identity() const { return identity_; }
   virtual void SetIdentity(AliasIdentity identity) { identity_ = identity; }
 
  private:
   const intptr_t token_pos_;
   const Class& cls_;
   ZoneGrowableArray<PushArgumentInstr*>* const arguments_;
   AliasIdentity identity_;
   Function& closure_function_;
 
@@ skipping 83 matching lines @@
   ZoneGrowableArray<Value*>* values_;
   Location* locations_;
 
   bool visited_for_liveness_;
   bool registers_remapped_;
 
   DISALLOW_COPY_AND_ASSIGN(MaterializeObjectInstr);
 };
 
 
-class CreateArrayInstr : public TemplateDefinition<2, Throws> {
+class CreateArrayInstr : public TemplateDefinition<2> {
  public:
   CreateArrayInstr(intptr_t token_pos,
                    Value* element_type,
                    Value* num_elements)
-      : TemplateDefinition(Isolate::Current()->GetNextDeoptId()),
+      : TemplateDefinition<2>(Isolate::Current()->GetNextDeoptId()),
         token_pos_(token_pos),
         identity_(AliasIdentity::Unknown())  {
     SetInputAt(kElementTypePos, element_type);
     SetInputAt(kLengthPos, num_elements);
   }
 
   enum {
     kElementTypePos = 0,
     kLengthPos = 1
   };
 
   DECLARE_INSTRUCTION(CreateArray)
   virtual CompileType ComputeType() const;
 
   virtual intptr_t token_pos() const { return token_pos_; }
   Value* element_type() const { return inputs_[kElementTypePos]; }
   Value* num_elements() const { return inputs_[kLengthPos]; }
 
   // Throw needs environment, which is created only if instruction can
   // deoptimize.
   virtual bool CanDeoptimize() const { return MayThrow(); }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
+  // OutOfMemoryError can be called.
+  virtual bool MayThrow() const { return true; }
+
   virtual AliasIdentity Identity() const { return identity_; }
   virtual void SetIdentity(AliasIdentity identity) { identity_ = identity; }
 
  private:
   const intptr_t token_pos_;
   AliasIdentity identity_;
 
   DISALLOW_COPY_AND_ASSIGN(CreateArrayInstr);
 };
 
 
-// Note: this instruction must not be moved without the indexed access that
-// depends on it (e.g. out of loops). GC may cause collect
-// the array while the external data-array is still accessed.
-// TODO(vegorov) enable LICMing this instruction by ensuring that array itself
-// is kept alive.
-class LoadUntaggedInstr : public TemplateDefinition<1, NoThrow> {
+class LoadUntaggedInstr : public TemplateDefinition<1> {
  public:
   LoadUntaggedInstr(Value* object, intptr_t offset) : offset_(offset) {
     SetInputAt(0, object);
   }
 
   virtual Representation representation() const {
     return kUntagged;
   }
   DECLARE_INSTRUCTION(LoadUntagged)
   virtual CompileType ComputeType() const;
 
   Value* object() const { return inputs_[0]; }
   intptr_t offset() const { return offset_; }
 
   virtual bool CanDeoptimize() const { return false; }
 
+  // This instruction must not be moved without the indexed access that
+  // depends on it (e.g. out of loops). GC may cause collect
+  // the array while the external data-array is still accessed.
+  virtual bool AllowsCSE() const { return false; }
   virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   intptr_t offset_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadUntaggedInstr);
 };
 
 
-class LoadClassIdInstr : public TemplateDefinition<1, NoThrow> {
+class LoadClassIdInstr : public TemplateDefinition<1> {
  public:
   explicit LoadClassIdInstr(Value* object) {
     SetInputAt(0, object);
   }
 
   virtual Representation representation() const {
     return kTagged;
   }
   DECLARE_INSTRUCTION(LoadClassId)
   virtual CompileType ComputeType() const;
 
   Value* object() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
   virtual EffectSet Dependencies() const {
     return EffectSet::Externalization();
   }
-  virtual EffectSet Effects() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(LoadClassIdInstr);
 };
 
 
-class LoadFieldInstr : public TemplateDefinition<1, NoThrow> {
+class LoadFieldInstr : public TemplateDefinition<1> {
  public:
   LoadFieldInstr(Value* instance,
                  intptr_t offset_in_bytes,
                  const AbstractType& type,
                  intptr_t token_pos)
       : offset_in_bytes_(offset_in_bytes),
         type_(type),
         result_cid_(kDynamicCid),
         immutable_(false),
         recognized_kind_(MethodRecognizer::kUnknown),
@@ skipping 60 matching lines @@
 
   static MethodRecognizer::Kind RecognizedKindFromArrayCid(intptr_t cid);
 
   static bool IsFixedLengthArrayCid(intptr_t cid);
 
   virtual bool AllowsCSE() const { return immutable_; }
   virtual EffectSet Effects() const { return EffectSet::None(); }
   virtual EffectSet Dependencies() const;
   virtual bool AttributesEqual(Instruction* other) const;
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   const intptr_t offset_in_bytes_;
   const AbstractType& type_;
   intptr_t result_cid_;
   bool immutable_;
 
   MethodRecognizer::Kind recognized_kind_;
   const Field* field_;
   const intptr_t token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadFieldInstr);
 };
 
 
-class InstantiateTypeInstr : public TemplateDefinition<1, Throws> {
+class InstantiateTypeInstr : public TemplateDefinition<1> {
  public:
   InstantiateTypeInstr(intptr_t token_pos,
                        const AbstractType& type,
                        const Class& instantiator_class,
                        Value* instantiator)
-      : TemplateDefinition(Isolate::Current()->GetNextDeoptId()),
+      : TemplateDefinition<1>(Isolate::Current()->GetNextDeoptId()),
         token_pos_(token_pos),
         type_(type),
         instantiator_class_(instantiator_class) {
     ASSERT(type.IsZoneHandle());
     SetInputAt(0, instantiator);
   }
 
   DECLARE_INSTRUCTION(InstantiateType)
 
   Value* instantiator() const { return inputs_[0]; }
   const AbstractType& type() const { return type_;
   }
   const Class& instantiator_class() const { return instantiator_class_; }
   virtual intptr_t token_pos() const { return token_pos_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return true; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
+  virtual bool MayThrow() const { return true; }
+
  private:
   const intptr_t token_pos_;
   const AbstractType& type_;
   const Class& instantiator_class_;
 
   DISALLOW_COPY_AND_ASSIGN(InstantiateTypeInstr);
 };
 
 
-class InstantiateTypeArgumentsInstr : public TemplateDefinition<1, Throws> {
+class InstantiateTypeArgumentsInstr : public TemplateDefinition<1> {
  public:
   InstantiateTypeArgumentsInstr(intptr_t token_pos,
                                 const TypeArguments& type_arguments,
                                 const Class& instantiator_class,
                                 Value* instantiator)
-      : TemplateDefinition(Isolate::Current()->GetNextDeoptId()),
+      : TemplateDefinition<1>(Isolate::Current()->GetNextDeoptId()),
         token_pos_(token_pos),
         type_arguments_(type_arguments),
         instantiator_class_(instantiator_class) {
     ASSERT(type_arguments.IsZoneHandle());
     SetInputAt(0, instantiator);
   }
 
   DECLARE_INSTRUCTION(InstantiateTypeArguments)
 
   Value* instantiator() const { return inputs_[0]; }
   const TypeArguments& type_arguments() const {
     return type_arguments_;
   }
   const Class& instantiator_class() const { return instantiator_class_; }
   virtual intptr_t token_pos() const { return token_pos_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return true; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
+  virtual bool MayThrow() const { return true; }
+
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
  private:
   const intptr_t token_pos_;
   const TypeArguments& type_arguments_;
   const Class& instantiator_class_;
 
   DISALLOW_COPY_AND_ASSIGN(InstantiateTypeArgumentsInstr);
 };
 
 
-class AllocateContextInstr : public TemplateDefinition<0, NoThrow> {
+class AllocateContextInstr : public TemplateDefinition<0> {
  public:
   AllocateContextInstr(intptr_t token_pos,
                        intptr_t num_context_variables)
       : token_pos_(token_pos),
         num_context_variables_(num_context_variables) {}
 
   DECLARE_INSTRUCTION(AllocateContext)
   virtual CompileType ComputeType() const;
 
   virtual intptr_t token_pos() const { return token_pos_; }
   intptr_t num_context_variables() const { return num_context_variables_; }
 
   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 token_pos_;
   const intptr_t num_context_variables_;
 
   DISALLOW_COPY_AND_ASSIGN(AllocateContextInstr);
 };
 
 
-class InitStaticFieldInstr : public TemplateInstruction<1, Throws> {
+class InitStaticFieldInstr : public TemplateInstruction<1> {
  public:
   InitStaticFieldInstr(Value* input, const Field& field)
-      : TemplateInstruction(Isolate::Current()->GetNextDeoptId()),
+      : TemplateInstruction<1>(Isolate::Current()->GetNextDeoptId()),
         field_(field) {
     SetInputAt(0, input);
   }
 
   virtual intptr_t token_pos() const { return field_.token_pos(); }
   const Field& field() const { return field_; }
 
   DECLARE_INSTRUCTION(InitStaticField)
 
   virtual intptr_t ArgumentCount() const { return 0; }
   virtual bool CanDeoptimize() const { return true; }
   virtual EffectSet Effects() const { return EffectSet::All(); }
+  virtual bool MayThrow() const { return true; }
   virtual Instruction* Canonicalize(FlowGraph* flow_graph);
 
  private:
   const Field& field_;
 
   DISALLOW_COPY_AND_ASSIGN(InitStaticFieldInstr);
 };
 
 
-class AllocateUninitializedContextInstr
-    : public TemplateDefinition<0, NoThrow> {
+class AllocateUninitializedContextInstr : public TemplateDefinition<0> {
  public:
   AllocateUninitializedContextInstr(intptr_t token_pos,
                                     intptr_t num_context_variables)
       : token_pos_(token_pos),
         num_context_variables_(num_context_variables) {}
 
   DECLARE_INSTRUCTION(AllocateUninitializedContext)
   virtual CompileType ComputeType() const;
 
   virtual intptr_t token_pos() const { return token_pos_; }
   intptr_t num_context_variables() const { return num_context_variables_; }
 
   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 token_pos_;
   const intptr_t num_context_variables_;
 
   DISALLOW_COPY_AND_ASSIGN(AllocateUninitializedContextInstr);
 };
 
 
-class CloneContextInstr : public TemplateDefinition<1, NoThrow> {
+class CloneContextInstr : public TemplateDefinition<1> {
  public:
   CloneContextInstr(intptr_t token_pos, Value* context_value)
-      : TemplateDefinition(Isolate::Current()->GetNextDeoptId()),
+      : TemplateDefinition<1>(Isolate::Current()->GetNextDeoptId()),
         token_pos_(token_pos) {
     SetInputAt(0, context_value);
   }
 
   virtual intptr_t token_pos() const { return token_pos_; }
   Value* context_value() const { return inputs_[0]; }
 
   DECLARE_INSTRUCTION(CloneContext)
   virtual CompileType ComputeType() const;
 
   virtual bool CanDeoptimize() const { return true; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   const intptr_t token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(CloneContextInstr);
 };
 
 
-class CheckEitherNonSmiInstr : public TemplateInstruction<2, NoThrow, Pure> {
+class CheckEitherNonSmiInstr : public TemplateInstruction<2> {
  public:
   CheckEitherNonSmiInstr(Value* left, Value* right, intptr_t deopt_id)
-      : TemplateInstruction(deopt_id), licm_hoisted_(false) {
+      : TemplateInstruction<2>(deopt_id), licm_hoisted_(false) {
     SetInputAt(0, left);
     SetInputAt(1, right);
   }
 
   Value* left() const { return inputs_[0]; }
   Value* right() const { return inputs_[1]; }
 
   DECLARE_INSTRUCTION(CheckEitherNonSmi)
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   virtual bool CanDeoptimize() const { return true; }
 
   virtual Instruction* Canonicalize(FlowGraph* flow_graph);
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
+  virtual bool MayThrow() const { return false; }
+
   void set_licm_hoisted(bool value) { licm_hoisted_ = value; }
 
  private:
   bool licm_hoisted_;
 
   DISALLOW_COPY_AND_ASSIGN(CheckEitherNonSmiInstr);
 };
 
 
-class BoxDoubleInstr : public TemplateDefinition<1, NoThrow, Pure> {
+class BoxDoubleInstr : public TemplateDefinition<1> {
  public:
   explicit BoxDoubleInstr(Value* value) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
   DECLARE_INSTRUCTION(BoxDouble)
   virtual CompileType ComputeType() const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual intptr_t DeoptimizationTarget() const {
     return Isolate::kNoDeoptId;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedDouble;
   }
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
+  virtual bool MayThrow() const { return false; }
+
   Definition* Canonicalize(FlowGraph* flow_graph);
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BoxDoubleInstr);
 };
 
 
-class BoxFloat32x4Instr : public TemplateDefinition<1, NoThrow, Pure> {
+class BoxFloat32x4Instr : public TemplateDefinition<1> {
  public:
   explicit BoxFloat32x4Instr(Value* value) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual intptr_t DeoptimizationTarget() const {
     return Isolate::kNoDeoptId;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedFloat32x4;
   }
 
   DECLARE_INSTRUCTION(BoxFloat32x4)
   virtual CompileType ComputeType() const;
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
+  virtual bool MayThrow() const { return false; }
+
   Definition* Canonicalize(FlowGraph* flow_graph);
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BoxFloat32x4Instr);
 };
 
 
-class BoxFloat64x2Instr : public TemplateDefinition<1, NoThrow, Pure> {
+class BoxFloat64x2Instr : public TemplateDefinition<1> {
  public:
   explicit BoxFloat64x2Instr(Value* value) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual intptr_t DeoptimizationTarget() const {
     return Isolate::kNoDeoptId;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedFloat64x2;
   }
 
   DECLARE_INSTRUCTION(BoxFloat64x2)
   virtual CompileType ComputeType() const;
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
+  virtual bool MayThrow() const { return false; }
+
   Definition* Canonicalize(FlowGraph* flow_graph);
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BoxFloat64x2Instr);
 };
 
 
 
-class BoxInt32x4Instr : public TemplateDefinition<1, NoThrow, Pure> {
+class BoxInt32x4Instr : public TemplateDefinition<1> {
  public:
   explicit BoxInt32x4Instr(Value* value) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual intptr_t DeoptimizationTarget() const {
     return Isolate::kNoDeoptId;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedInt32x4;
   }
 
   DECLARE_INSTRUCTION(BoxInt32x4)
   virtual CompileType ComputeType() const;
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
+  virtual bool MayThrow() const { return false; }
+
   Definition* Canonicalize(FlowGraph* flow_graph);
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BoxInt32x4Instr);
 };
 
 
-class BoxIntegerInstr : public TemplateDefinition<1, NoThrow, Pure> {
+class BoxIntegerInstr : public TemplateDefinition<1> {
  public:
   explicit BoxIntegerInstr(Value* value) : is_smi_(false) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
   bool is_smi() const { return is_smi_; }
   void set_is_smi(bool is_smi) { is_smi_ = is_smi; }
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual intptr_t DeoptimizationTarget() const {
     return Isolate::kNoDeoptId;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedMint;
   }
 
   DECLARE_INSTRUCTION(BoxInteger)
   virtual CompileType ComputeType() const;
   virtual bool RecomputeType();
 
   virtual void InferRange(RangeAnalysis* analysis, Range* range);
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
+  virtual bool MayThrow() const { return false; }
+
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
  private:
   bool is_smi_;
 
   DISALLOW_COPY_AND_ASSIGN(BoxIntegerInstr);
 };
 
 
-class UnboxDoubleInstr : public TemplateDefinition<1, NoThrow, Pure> {
+class UnboxDoubleInstr : public TemplateDefinition<1> {
  public:
   UnboxDoubleInstr(Value* value, intptr_t deopt_id)
-      : TemplateDefinition(deopt_id) {
+      : TemplateDefinition<1>(deopt_id) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const {
     return (value()->Type()->ToCid() != kDoubleCid)
         && (value()->Type()->ToCid() != kSmiCid);
   }
 
   virtual Representation representation() const {
     return kUnboxedDouble;
   }
 
   DECLARE_INSTRUCTION(UnboxDouble)
   virtual CompileType ComputeType() const;
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
+  virtual bool MayThrow() const { return false; }
+
   Definition* Canonicalize(FlowGraph* flow_graph);
 
  private:
   DISALLOW_COPY_AND_ASSIGN(UnboxDoubleInstr);
 };
 
 
-class UnboxFloat32x4Instr : public TemplateDefinition<1, NoThrow, Pure> {
+class UnboxFloat32x4Instr : public TemplateDefinition<1> {
  public:
   UnboxFloat32x4Instr(Value* value, intptr_t deopt_id)
-      : TemplateDefinition(deopt_id) {
+      : TemplateDefinition<1>(deopt_id) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const {
     return (value()->Type()->ToCid() != kFloat32x4Cid);
   }
 
   virtual Representation representation() const {
     return kUnboxedFloat32x4;
   }
 
   DECLARE_INSTRUCTION(UnboxFloat32x4)
   virtual CompileType ComputeType() const;
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
+  virtual bool MayThrow() const { return false; }
+
   Definition* Canonicalize(FlowGraph* flow_graph);
 
  private:
   DISALLOW_COPY_AND_ASSIGN(UnboxFloat32x4Instr);
 };
 
 
-class UnboxFloat64x2Instr : public TemplateDefinition<1, NoThrow, Pure> {
+class UnboxFloat64x2Instr : public TemplateDefinition<1> {
  public:
   UnboxFloat64x2Instr(Value* value, intptr_t deopt_id)
-      : TemplateDefinition(deopt_id) {
+      : TemplateDefinition<1>(deopt_id) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const {
     return (value()->Type()->ToCid() != kFloat64x2Cid);
   }
 
   virtual Representation representation() const {
     return kUnboxedFloat64x2;
   }
 
   DECLARE_INSTRUCTION(UnboxFloat64x2)
   virtual CompileType ComputeType() const;
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
+  virtual bool MayThrow() const { return false; }
+
   Definition* Canonicalize(FlowGraph* flow_graph);
 
  private:
   DISALLOW_COPY_AND_ASSIGN(UnboxFloat64x2Instr);
 };
 
 
-class UnboxInt32x4Instr : public TemplateDefinition<1, NoThrow, Pure> {
+class UnboxInt32x4Instr : public TemplateDefinition<1> {
  public:
   UnboxInt32x4Instr(Value* value, intptr_t deopt_id)
-      : TemplateDefinition(deopt_id) {
+      : TemplateDefinition<1>(deopt_id) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const {
     return (value()->Type()->ToCid() != kInt32x4Cid);
   }
 
   virtual Representation representation() const {
     return kUnboxedInt32x4;
   }
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
   DECLARE_INSTRUCTION(UnboxInt32x4)
   virtual CompileType ComputeType() const;
 
+  virtual bool MayThrow() const { return false; }
+
   Definition* Canonicalize(FlowGraph* flow_graph);
 
  private:
   DISALLOW_COPY_AND_ASSIGN(UnboxInt32x4Instr);
 };
 
 
-class UnboxIntegerInstr : public TemplateDefinition<1, NoThrow, Pure> {
+class UnboxIntegerInstr : public TemplateDefinition<1> {
  public:
   UnboxIntegerInstr(Value* value, intptr_t deopt_id)
-      : TemplateDefinition(deopt_id) {
+      : TemplateDefinition<1>(deopt_id) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const {
     return (value()->Type()->ToCid() != kSmiCid)
         && (value()->Type()->ToCid() != kMintCid);
   }
 
   virtual Representation representation() const {
     return kUnboxedMint;
   }
 
   intptr_t deopt_id() const { return GetDeoptId(); }
 
   virtual void InferRange(RangeAnalysis* analysis, Range* range);
 
   DECLARE_INSTRUCTION(UnboxInteger)
   virtual CompileType ComputeType() const;
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
+  virtual bool MayThrow() const { return false; }
+
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
  private:
   DISALLOW_COPY_AND_ASSIGN(UnboxIntegerInstr);
 };
 
 
-class MathUnaryInstr : public TemplateDefinition<1, NoThrow, Pure> {
+class MathUnaryInstr : public TemplateDefinition<1> {
  public:
   enum MathUnaryKind {
     kIllegal,
     kSin,
     kCos,
     kSqrt,
     kDoubleSquare,
   };
   MathUnaryInstr(MathUnaryKind kind, Value* value, intptr_t deopt_id)
-      : TemplateDefinition(deopt_id), kind_(kind) {
+      : TemplateDefinition<1>(deopt_id), kind_(kind) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
   MathUnaryKind kind() const { return kind_; }
   const RuntimeEntry& TargetFunction() const;
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Representation representation() const {
     return kUnboxedDouble;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedDouble;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   DECLARE_INSTRUCTION(MathUnary)
   virtual CompileType ComputeType() const;
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const {
     return kind() == other->AsMathUnary()->kind();
   }
 
+  virtual bool MayThrow() const { return false; }
+
   Definition* Canonicalize(FlowGraph* flow_graph);
 
   static const char* KindToCString(MathUnaryKind kind);
 
  private:
   const MathUnaryKind kind_;
 
   DISALLOW_COPY_AND_ASSIGN(MathUnaryInstr);
 };
 
 
 // Represents Math's static min and max functions.
-class MathMinMaxInstr : public TemplateDefinition<2, NoThrow, Pure> {
+class MathMinMaxInstr : public TemplateDefinition<2> {
  public:
   MathMinMaxInstr(MethodRecognizer::Kind op_kind,
                   Value* left_value,
                   Value* right_value,
                   intptr_t deopt_id,
                   intptr_t result_cid)
-      : TemplateDefinition(deopt_id),
+      : TemplateDefinition<2>(deopt_id),
         op_kind_(op_kind),
         result_cid_(result_cid) {
     ASSERT((result_cid == kSmiCid) || (result_cid == kDoubleCid));
     SetInputAt(0, left_value);
     SetInputAt(1, right_value);
   }
 
   MethodRecognizer::Kind op_kind() const { return op_kind_; }
 
   Value* left() const { return inputs_[0]; }
@@ skipping 20 matching lines @@
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   DECLARE_INSTRUCTION(MathMinMax)
   virtual CompileType ComputeType() const;
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const;
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   const MethodRecognizer::Kind op_kind_;
   const intptr_t result_cid_;
 
   DISALLOW_COPY_AND_ASSIGN(MathMinMaxInstr);
 };
 
 
-class BinaryDoubleOpInstr : public TemplateDefinition<2, NoThrow, Pure> {
+class BinaryDoubleOpInstr : public TemplateDefinition<2> {
  public:
   BinaryDoubleOpInstr(Token::Kind op_kind,
                       Value* left,
                       Value* right,
                       intptr_t deopt_id,
                       intptr_t token_pos)
-      : TemplateDefinition(deopt_id),
+      : TemplateDefinition<2>(deopt_id),
         op_kind_(op_kind),
         token_pos_(token_pos) {
     SetInputAt(0, left);
     SetInputAt(1, right);
   }
 
   Value* left() const { return inputs_[0]; }
   Value* right() const { return inputs_[1]; }
 
   Token::Kind op_kind() const { return op_kind_; }
@@ skipping 17 matching lines @@
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   DECLARE_INSTRUCTION(BinaryDoubleOp)
   virtual CompileType ComputeType() const;
 
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const {
     return op_kind() == other->AsBinaryDoubleOp()->op_kind();
   }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   const Token::Kind op_kind_;
   const intptr_t token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(BinaryDoubleOpInstr);
 };
 
 
-class BinaryFloat32x4OpInstr : public TemplateDefinition<2, NoThrow, Pure> {
+class BinaryFloat32x4OpInstr : public TemplateDefinition<2> {
  public:
   BinaryFloat32x4OpInstr(Token::Kind op_kind,
                          Value* left,
                          Value* right,
                          intptr_t deopt_id)
-      : TemplateDefinition(deopt_id), op_kind_(op_kind) {
+      : TemplateDefinition<2>(deopt_id), op_kind_(op_kind) {
     SetInputAt(0, left);
     SetInputAt(1, right);
   }
 
   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 11 matching lines @@
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   DECLARE_INSTRUCTION(BinaryFloat32x4Op)
   virtual CompileType ComputeType() const;
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const {
     return op_kind() == other->AsBinaryFloat32x4Op()->op_kind();
   }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   const Token::Kind op_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(BinaryFloat32x4OpInstr);
 };
 
 
-class Simd32x4ShuffleInstr : public TemplateDefinition<1, NoThrow, Pure> {
+class Simd32x4ShuffleInstr : public TemplateDefinition<1> {
  public:
   Simd32x4ShuffleInstr(MethodRecognizer::Kind op_kind, Value* value,
                        intptr_t mask,
                        intptr_t deopt_id)
-      : TemplateDefinition(deopt_id), op_kind_(op_kind), mask_(mask) {
+      : TemplateDefinition<1>(deopt_id), op_kind_(op_kind), mask_(mask) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
   MethodRecognizer::Kind op_kind() const { return op_kind_; }
 
   intptr_t mask() const { return mask_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
@@ skipping 29 matching lines @@
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   DECLARE_INSTRUCTION(Simd32x4Shuffle)
   virtual CompileType ComputeType() const;
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const {
     return (op_kind() == other->AsSimd32x4Shuffle()->op_kind()) &&
            (mask() == other->AsSimd32x4Shuffle()->mask());
   }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   const MethodRecognizer::Kind op_kind_;
   const intptr_t mask_;
 
   DISALLOW_COPY_AND_ASSIGN(Simd32x4ShuffleInstr);
 };
 
 
-class Simd32x4ShuffleMixInstr : public TemplateDefinition<2, NoThrow, Pure> {
+class Simd32x4ShuffleMixInstr : public TemplateDefinition<2> {
  public:
   Simd32x4ShuffleMixInstr(MethodRecognizer::Kind op_kind, Value* xy,
                            Value* zw, intptr_t mask, intptr_t deopt_id)
-      : TemplateDefinition(deopt_id), op_kind_(op_kind), mask_(mask) {
+      : TemplateDefinition<2>(deopt_id), op_kind_(op_kind), mask_(mask) {
     SetInputAt(0, xy);
     SetInputAt(1, zw);
   }
 
   Value* xy() const { return inputs_[0]; }
   Value* zw() const { return inputs_[1]; }
 
   MethodRecognizer::Kind op_kind() const { return op_kind_; }
 
   intptr_t mask() const { return mask_; }
@@ skipping 21 matching lines @@
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   DECLARE_INSTRUCTION(Simd32x4ShuffleMix)
   virtual CompileType ComputeType() const;
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const {
     return (op_kind() == other->AsSimd32x4ShuffleMix()->op_kind()) &&
            (mask() == other->AsSimd32x4ShuffleMix()->mask());
   }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   const MethodRecognizer::Kind op_kind_;
   const intptr_t mask_;
 
   DISALLOW_COPY_AND_ASSIGN(Simd32x4ShuffleMixInstr);
 };
 
 
-class Float32x4ConstructorInstr : public TemplateDefinition<4, NoThrow, Pure> {
+class Float32x4ConstructorInstr : public TemplateDefinition<4> {
  public:
   Float32x4ConstructorInstr(Value* value0,
                             Value* value1,
                             Value* value2,
                             Value* value3,
                             intptr_t deopt_id)
-      : TemplateDefinition(deopt_id) {
+      : TemplateDefinition<4>(deopt_id) {
     SetInputAt(0, value0);
     SetInputAt(1, value1);
     SetInputAt(2, value2);
     SetInputAt(3, value3);
   }
 
   Value* value0() const { return inputs_[0]; }
   Value* value1() const { return inputs_[1]; }
   Value* value2() const { return inputs_[2]; }
   Value* value3() const { return inputs_[3]; }
@@ skipping 13 matching lines @@
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   DECLARE_INSTRUCTION(Float32x4Constructor)
   virtual CompileType ComputeType() const;
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(Float32x4ConstructorInstr);
 };
 
 
-class Float32x4SplatInstr : public TemplateDefinition<1, NoThrow, Pure> {
+class Float32x4SplatInstr : public TemplateDefinition<1> {
  public:
   Float32x4SplatInstr(Value* value, intptr_t deopt_id)
-      : TemplateDefinition(deopt_id) {
+      : TemplateDefinition<1>(deopt_id) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Representation representation() const {
     return kUnboxedFloat32x4;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedDouble;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   DECLARE_INSTRUCTION(Float32x4Splat)
   virtual CompileType ComputeType() const;
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(Float32x4SplatInstr);
 };
 
 
 // TODO(vegorov) replace with UnboxedConstantInstr.
-class Float32x4ZeroInstr : public TemplateDefinition<0, NoThrow, Pure> {
+class Float32x4ZeroInstr : public TemplateDefinition<0> {
  public:
   Float32x4ZeroInstr() { }
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Representation representation() const {
     return kUnboxedFloat32x4;
   }
 
   DECLARE_INSTRUCTION(Float32x4Zero)
   virtual CompileType ComputeType() const;
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(Float32x4ZeroInstr);
 };
 
 
-class Float32x4ComparisonInstr : public TemplateDefinition<2, NoThrow, Pure> {
+class Float32x4ComparisonInstr : public TemplateDefinition<2> {
  public:
   Float32x4ComparisonInstr(MethodRecognizer::Kind op_kind,
                            Value* left,
                            Value* right,
                            intptr_t deopt_id)
-      : TemplateDefinition(deopt_id), op_kind_(op_kind) {
+      : TemplateDefinition<2>(deopt_id), op_kind_(op_kind) {
     SetInputAt(0, left);
     SetInputAt(1, right);
   }
 
   Value* left() const { return inputs_[0]; }
   Value* right() const { return inputs_[1]; }
 
   MethodRecognizer::Kind op_kind() const { return op_kind_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
@@ skipping 11 matching lines @@
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   DECLARE_INSTRUCTION(Float32x4Comparison)
   virtual CompileType ComputeType() const;
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const {
     return op_kind() == other->AsFloat32x4Comparison()->op_kind();
   }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   const MethodRecognizer::Kind op_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(Float32x4ComparisonInstr);
 };
 
 
-class Float32x4MinMaxInstr : public TemplateDefinition<2, NoThrow, Pure> {
+class Float32x4MinMaxInstr : public TemplateDefinition<2> {
  public:
   Float32x4MinMaxInstr(MethodRecognizer::Kind op_kind,
                        Value* left,
                        Value* right,
                        intptr_t deopt_id)
-      : TemplateDefinition(deopt_id), op_kind_(op_kind) {
+      : TemplateDefinition<2>(deopt_id), op_kind_(op_kind) {
     SetInputAt(0, left);
     SetInputAt(1, right);
   }
 
   Value* left() const { return inputs_[0]; }
   Value* right() const { return inputs_[1]; }
 
   MethodRecognizer::Kind op_kind() const { return op_kind_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
@@ skipping 11 matching lines @@
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   DECLARE_INSTRUCTION(Float32x4MinMax)
   virtual CompileType ComputeType() const;
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const {
     return op_kind() == other->AsFloat32x4MinMax()->op_kind();
   }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   const MethodRecognizer::Kind op_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(Float32x4MinMaxInstr);
 };
 
 
-class Float32x4ScaleInstr : public TemplateDefinition<2, NoThrow, Pure> {
+class Float32x4ScaleInstr : public TemplateDefinition<2> {
  public:
   Float32x4ScaleInstr(MethodRecognizer::Kind op_kind,
                       Value* left,
                       Value* right,
                       intptr_t deopt_id)
-      : TemplateDefinition(deopt_id), op_kind_(op_kind) {
+      : TemplateDefinition<2>(deopt_id), op_kind_(op_kind) {
     SetInputAt(0, left);
     SetInputAt(1, right);
   }
 
   Value* left() const { return inputs_[0]; }
   Value* right() const { return inputs_[1]; }
 
   MethodRecognizer::Kind op_kind() const { return op_kind_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
@@ skipping 14 matching lines @@
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   DECLARE_INSTRUCTION(Float32x4Scale)
   virtual CompileType ComputeType() const;
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const {
     return op_kind() == other->AsFloat32x4Scale()->op_kind();
   }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   const MethodRecognizer::Kind op_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(Float32x4ScaleInstr);
 };
 
 
-class Float32x4SqrtInstr : public TemplateDefinition<1, NoThrow, Pure> {
+class Float32x4SqrtInstr : public TemplateDefinition<1> {
  public:
   Float32x4SqrtInstr(MethodRecognizer::Kind op_kind,
                      Value* left,
                      intptr_t deopt_id)
-      : TemplateDefinition(deopt_id), op_kind_(op_kind) {
+      : TemplateDefinition<1>(deopt_id), op_kind_(op_kind) {
     SetInputAt(0, left);
   }
 
   Value* left() const { return inputs_[0]; }
 
   MethodRecognizer::Kind op_kind() const { return op_kind_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Representation representation() const {
     return kUnboxedFloat32x4;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedFloat32x4;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   DECLARE_INSTRUCTION(Float32x4Sqrt)
   virtual CompileType ComputeType() const;
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const {
     return op_kind() == other->AsFloat32x4Sqrt()->op_kind();
   }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   const MethodRecognizer::Kind op_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(Float32x4SqrtInstr);
 };
 
 
 // TODO(vegorov) rename to Unary to match naming convention for arithmetic.
-class Float32x4ZeroArgInstr : public TemplateDefinition<1, NoThrow, Pure> {
+class Float32x4ZeroArgInstr : public TemplateDefinition<1> {
  public:
   Float32x4ZeroArgInstr(MethodRecognizer::Kind op_kind,
                         Value* left,
                         intptr_t deopt_id)
-      : TemplateDefinition(deopt_id),
+      : TemplateDefinition<1>(deopt_id),
         op_kind_(op_kind) {
     SetInputAt(0, left);
   }
 
   Value* left() const { return inputs_[0]; }
 
   MethodRecognizer::Kind op_kind() const { return op_kind_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
@@ skipping 10 matching lines @@
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   DECLARE_INSTRUCTION(Float32x4ZeroArg)
   virtual CompileType ComputeType() const;
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const {
     return op_kind() == other->AsFloat32x4ZeroArg()->op_kind();
   }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   const MethodRecognizer::Kind op_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(Float32x4ZeroArgInstr);
 };
 
 
-class Float32x4ClampInstr : public TemplateDefinition<3, NoThrow, Pure> {
+class Float32x4ClampInstr : public TemplateDefinition<3> {
  public:
   Float32x4ClampInstr(Value* left,
                       Value* lower,
                       Value* upper,
                       intptr_t deopt_id)
-      : TemplateDefinition(deopt_id) {
+      : TemplateDefinition<3>(deopt_id) {
     SetInputAt(0, left);
     SetInputAt(1, lower);
     SetInputAt(2, upper);
   }
 
   Value* left() const { return inputs_[0]; }
   Value* lower() const { return inputs_[1]; }
   Value* upper() const { return inputs_[2]; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
@@ skipping 11 matching lines @@
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   DECLARE_INSTRUCTION(Float32x4Clamp)
   virtual CompileType ComputeType() const;
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(Float32x4ClampInstr);
 };
 
 
-class Float32x4WithInstr : public TemplateDefinition<2, NoThrow, Pure> {
+class Float32x4WithInstr : public TemplateDefinition<2> {
  public:
   Float32x4WithInstr(MethodRecognizer::Kind op_kind,
                      Value* left,
                      Value* replacement,
                      intptr_t deopt_id)
-      : TemplateDefinition(deopt_id),
+      : TemplateDefinition<2>(deopt_id),
         op_kind_(op_kind) {
     SetInputAt(0, replacement);
     SetInputAt(1, left);
   }
 
   Value* left() const { return inputs_[1]; }
   Value* replacement() const { return inputs_[0]; }
 
   MethodRecognizer::Kind op_kind() const { return op_kind_; }
 
@@ skipping 15 matching lines @@
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   DECLARE_INSTRUCTION(Float32x4With)
   virtual CompileType ComputeType() const;
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const {
     return op_kind() == other->AsFloat32x4With()->op_kind();
   }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   const MethodRecognizer::Kind op_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(Float32x4WithInstr);
 };
 
 
-class Simd64x2ShuffleInstr : public TemplateDefinition<1, NoThrow, Pure> {
+class Simd64x2ShuffleInstr : public TemplateDefinition<1> {
  public:
   Simd64x2ShuffleInstr(MethodRecognizer::Kind op_kind,
                        Value* value,
                        intptr_t mask,
                        intptr_t deopt_id)
-      : TemplateDefinition(deopt_id), op_kind_(op_kind), mask_(mask) {
+      : TemplateDefinition<1>(deopt_id), op_kind_(op_kind), mask_(mask) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
   MethodRecognizer::Kind op_kind() const { return op_kind_; }
 
   intptr_t mask() const { return mask_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
@@ skipping 21 matching lines @@
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   DECLARE_INSTRUCTION(Simd64x2Shuffle)
   virtual CompileType ComputeType() const;
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const {
     return (op_kind() == other->AsSimd64x2Shuffle()->op_kind()) &&
            (mask() == other->AsSimd64x2Shuffle()->mask());
   }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   const MethodRecognizer::Kind op_kind_;
   const intptr_t mask_;
 
   DISALLOW_COPY_AND_ASSIGN(Simd64x2ShuffleInstr);
 };
 
 
-class Float32x4ToInt32x4Instr : public TemplateDefinition<1, NoThrow, Pure> {
+class Float32x4ToInt32x4Instr : public TemplateDefinition<1> {
  public:
   Float32x4ToInt32x4Instr(Value* left, intptr_t deopt_id)
-      : TemplateDefinition(deopt_id) {
+      : TemplateDefinition<1>(deopt_id) {
     SetInputAt(0, left);
   }
 
   Value* left() const { return inputs_[0]; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Representation representation() const {
     return kUnboxedInt32x4;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedFloat32x4;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   DECLARE_INSTRUCTION(Float32x4ToInt32x4)
   virtual CompileType ComputeType() const;
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(Float32x4ToInt32x4Instr);
 };
 
 
-class Float32x4ToFloat64x2Instr : public TemplateDefinition<1, NoThrow, Pure> {
+class Float32x4ToFloat64x2Instr : public TemplateDefinition<1> {
  public:
   Float32x4ToFloat64x2Instr(Value* left, intptr_t deopt_id)
-      : TemplateDefinition(deopt_id) {
+      : TemplateDefinition<1>(deopt_id) {
     SetInputAt(0, left);
   }
 
   Value* left() const { return inputs_[0]; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Representation representation() const {
     return kUnboxedFloat64x2;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedFloat32x4;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   DECLARE_INSTRUCTION(Float32x4ToFloat64x2)
   virtual CompileType ComputeType() const;
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(Float32x4ToFloat64x2Instr);
 };
 
 
-class Float64x2ToFloat32x4Instr : public TemplateDefinition<1, NoThrow, Pure> {
+class Float64x2ToFloat32x4Instr : public TemplateDefinition<1> {
  public:
   Float64x2ToFloat32x4Instr(Value* left, intptr_t deopt_id)
-      : TemplateDefinition(deopt_id) {
+      : TemplateDefinition<1>(deopt_id) {
     SetInputAt(0, left);
   }
 
   Value* left() const { return inputs_[0]; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Representation representation() const {
     return kUnboxedFloat32x4;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedFloat64x2;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   DECLARE_INSTRUCTION(Float64x2ToFloat32x4)
   virtual CompileType ComputeType() const;
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(Float64x2ToFloat32x4Instr);
 };
 
 
-class Float64x2ConstructorInstr : public TemplateDefinition<2, NoThrow, Pure> {
+class Float64x2ConstructorInstr : public TemplateDefinition<2> {
  public:
   Float64x2ConstructorInstr(Value* value0, Value* value1, intptr_t deopt_id)
-      : TemplateDefinition(deopt_id) {
+      : TemplateDefinition<2>(deopt_id) {
     SetInputAt(0, value0);
     SetInputAt(1, value1);
   }
 
   Value* value0() const { return inputs_[0]; }
   Value* value1() const { return inputs_[1]; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Representation representation() const {
     return kUnboxedFloat64x2;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx >= 0 && idx < 2);
     return kUnboxedDouble;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   DECLARE_INSTRUCTION(Float64x2Constructor)
   virtual CompileType ComputeType() const;
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(Float64x2ConstructorInstr);
 };
 
 
-class Float64x2SplatInstr : public TemplateDefinition<1, NoThrow, Pure> {
+class Float64x2SplatInstr : public TemplateDefinition<1> {
  public:
   Float64x2SplatInstr(Value* value, intptr_t deopt_id)
-      : TemplateDefinition(deopt_id) {
+      : TemplateDefinition<1>(deopt_id) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Representation representation() const {
     return kUnboxedFloat64x2;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedDouble;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   DECLARE_INSTRUCTION(Float64x2Splat)
   virtual CompileType ComputeType() const;
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(Float64x2SplatInstr);
 };
 
 
-class Float64x2ZeroInstr : public TemplateDefinition<0, NoThrow, Pure> {
+class Float64x2ZeroInstr : public TemplateDefinition<0> {
  public:
   Float64x2ZeroInstr() { }
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Representation representation() const {
     return kUnboxedFloat64x2;
   }
 
   DECLARE_INSTRUCTION(Float64x2Zero)
   virtual CompileType ComputeType() const;
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(Float64x2ZeroInstr);
 };
 
 
 // TODO(vegorov) rename to Unary to match arithmetic instructions.
-class Float64x2ZeroArgInstr : public TemplateDefinition<1, NoThrow, Pure> {
+class Float64x2ZeroArgInstr : public TemplateDefinition<1> {
  public:
   Float64x2ZeroArgInstr(MethodRecognizer::Kind op_kind,
                         Value* left,
                         intptr_t deopt_id)
-      : TemplateDefinition(deopt_id), op_kind_(op_kind) {
+      : TemplateDefinition<1>(deopt_id), op_kind_(op_kind) {
     SetInputAt(0, left);
   }
 
   Value* left() const { return inputs_[0]; }
 
   MethodRecognizer::Kind op_kind() const { return op_kind_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
@@ skipping 13 matching lines @@
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   DECLARE_INSTRUCTION(Float64x2ZeroArg)
   virtual CompileType ComputeType() const;
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const {
     return op_kind() == other->AsFloat64x2ZeroArg()->op_kind();
   }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   const MethodRecognizer::Kind op_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(Float64x2ZeroArgInstr);
 };
 
 
-class Float64x2OneArgInstr : public TemplateDefinition<2, NoThrow, Pure> {
+class Float64x2OneArgInstr : public TemplateDefinition<2> {
  public:
   Float64x2OneArgInstr(MethodRecognizer::Kind op_kind,
                        Value* left,
                        Value* right,
                        intptr_t deopt_id)
-      : TemplateDefinition(deopt_id), op_kind_(op_kind) {
+      : TemplateDefinition<2>(deopt_id), op_kind_(op_kind) {
     SetInputAt(0, left);
     SetInputAt(1, right);
   }
 
   Value* left() const { return inputs_[0]; }
   Value* right() const { return inputs_[1]; }
 
   MethodRecognizer::Kind op_kind() const { return op_kind_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
@@ skipping 19 matching lines @@
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   DECLARE_INSTRUCTION(Float64x2OneArg)
   virtual CompileType ComputeType() const;
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const {
     return op_kind() == other->AsFloat64x2OneArg()->op_kind();
   }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   const MethodRecognizer::Kind op_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(Float64x2OneArgInstr);
 };
 
 
-class Int32x4ConstructorInstr : public TemplateDefinition<4, NoThrow, Pure> {
+class Int32x4ConstructorInstr : public TemplateDefinition<4> {
  public:
   Int32x4ConstructorInstr(Value* value0,
                           Value* value1,
                           Value* value2,
                           Value* value3,
                           intptr_t deopt_id)
-      : TemplateDefinition(deopt_id) {
+      : TemplateDefinition<4>(deopt_id) {
     SetInputAt(0, value0);
     SetInputAt(1, value1);
     SetInputAt(2, value2);
     SetInputAt(3, value3);
   }
 
   Value* value0() const { return inputs_[0]; }
   Value* value1() const { return inputs_[1]; }
   Value* value2() const { return inputs_[2]; }
   Value* value3() const { return inputs_[3]; }
@@ skipping 13 matching lines @@
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   DECLARE_INSTRUCTION(Int32x4Constructor)
   virtual CompileType ComputeType() const;
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(Int32x4ConstructorInstr);
 };
 
 
-class Int32x4BoolConstructorInstr
-    : public TemplateDefinition<4, NoThrow, Pure> {
+class Int32x4BoolConstructorInstr : public TemplateDefinition<4> {
  public:
   Int32x4BoolConstructorInstr(Value* value0,
                               Value* value1,
                               Value* value2,
                               Value* value3,
                               intptr_t deopt_id)
-      : TemplateDefinition(deopt_id) {
+      : TemplateDefinition<4>(deopt_id) {
     SetInputAt(0, value0);
     SetInputAt(1, value1);
     SetInputAt(2, value2);
     SetInputAt(3, value3);
   }
 
   Value* value0() const { return inputs_[0]; }
   Value* value1() const { return inputs_[1]; }
   Value* value2() const { return inputs_[2]; }
   Value* value3() const { return inputs_[3]; }
@@ skipping 13 matching lines @@
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   DECLARE_INSTRUCTION(Int32x4BoolConstructor)
   virtual CompileType ComputeType() const;
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(Int32x4BoolConstructorInstr);
 };
 
 
-class Int32x4GetFlagInstr : public TemplateDefinition<1, NoThrow, Pure> {
+class Int32x4GetFlagInstr : public TemplateDefinition<1> {
  public:
   Int32x4GetFlagInstr(MethodRecognizer::Kind op_kind,
                       Value* value,
                       intptr_t deopt_id)
-      : TemplateDefinition(deopt_id), op_kind_(op_kind) {
+      : TemplateDefinition<1>(deopt_id), op_kind_(op_kind) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
   MethodRecognizer::Kind op_kind() const { return op_kind_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Representation representation() const {
       return kTagged;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedInt32x4;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   DECLARE_INSTRUCTION(Int32x4GetFlag)
   virtual CompileType ComputeType() const;
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const {
     return op_kind() == other->AsInt32x4GetFlag()->op_kind();
   }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   const MethodRecognizer::Kind op_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(Int32x4GetFlagInstr);
 };
 
 
-class Simd32x4GetSignMaskInstr : public TemplateDefinition<1, NoThrow, Pure> {
+class Simd32x4GetSignMaskInstr : public TemplateDefinition<1> {
  public:
   Simd32x4GetSignMaskInstr(MethodRecognizer::Kind op_kind,
                            Value* value,
                            intptr_t deopt_id)
-      : TemplateDefinition(deopt_id), op_kind_(op_kind) {
+      : TemplateDefinition<1>(deopt_id), op_kind_(op_kind) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
   MethodRecognizer::Kind op_kind() const { return op_kind_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
@@ skipping 13 matching lines @@
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   DECLARE_INSTRUCTION(Simd32x4GetSignMask)
   virtual CompileType ComputeType() const;
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const {
     return other->AsSimd32x4GetSignMask()->op_kind() == op_kind();
   }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   const MethodRecognizer::Kind op_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(Simd32x4GetSignMaskInstr);
 };
 
 
-class Int32x4SelectInstr : public TemplateDefinition<3, NoThrow, Pure> {
+class Int32x4SelectInstr : public TemplateDefinition<3> {
  public:
   Int32x4SelectInstr(Value* mask,
                      Value* trueValue,
                      Value* falseValue,
                      intptr_t deopt_id)
-      : TemplateDefinition(deopt_id) {
+      : TemplateDefinition<3>(deopt_id) {
     SetInputAt(0, mask);
     SetInputAt(1, trueValue);
     SetInputAt(2, falseValue);
   }
 
   Value* mask() const { return inputs_[0]; }
   Value* trueValue() const { return inputs_[1]; }
   Value* falseValue() const { return inputs_[2]; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
@@ skipping 14 matching lines @@
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   DECLARE_INSTRUCTION(Int32x4Select)
   virtual CompileType ComputeType() const;
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(Int32x4SelectInstr);
 };
 
 
-class Int32x4SetFlagInstr : public TemplateDefinition<2, NoThrow, Pure> {
+class Int32x4SetFlagInstr : public TemplateDefinition<2> {
  public:
   Int32x4SetFlagInstr(MethodRecognizer::Kind op_kind,
                       Value* value,
                       Value* flagValue,
                       intptr_t deopt_id)
-      : TemplateDefinition(deopt_id), op_kind_(op_kind) {
+      : TemplateDefinition<2>(deopt_id), op_kind_(op_kind) {
     SetInputAt(0, value);
     SetInputAt(1, flagValue);
   }
 
   Value* value() const { return inputs_[0]; }
   Value* flagValue() const { return inputs_[1]; }
 
   MethodRecognizer::Kind op_kind() const { return op_kind_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
@@ skipping 14 matching lines @@
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   DECLARE_INSTRUCTION(Int32x4SetFlag)
   virtual CompileType ComputeType() const;
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const {
     return op_kind() == other->AsInt32x4SetFlag()->op_kind();
   }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   const MethodRecognizer::Kind op_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(Int32x4SetFlagInstr);
 };
 
 
-class Int32x4ToFloat32x4Instr : public TemplateDefinition<1, NoThrow, Pure> {
+class Int32x4ToFloat32x4Instr : public TemplateDefinition<1> {
  public:
   Int32x4ToFloat32x4Instr(Value* left, intptr_t deopt_id)
-      : TemplateDefinition(deopt_id) {
+      : TemplateDefinition<1>(deopt_id) {
     SetInputAt(0, left);
   }
 
   Value* left() const { return inputs_[0]; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Representation representation() const {
     return kUnboxedFloat32x4;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedInt32x4;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   DECLARE_INSTRUCTION(Int32x4ToFloat32x4)
   virtual CompileType ComputeType() const;
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(Int32x4ToFloat32x4Instr);
 };
 
 
-class BinaryInt32x4OpInstr : public TemplateDefinition<2, NoThrow, Pure> {
+class BinaryInt32x4OpInstr : public TemplateDefinition<2> {
  public:
   BinaryInt32x4OpInstr(Token::Kind op_kind,
                         Value* left,
                         Value* right,
                         intptr_t deopt_id)
-      : TemplateDefinition(deopt_id), op_kind_(op_kind) {
+      : TemplateDefinition<2>(deopt_id), op_kind_(op_kind) {
     SetInputAt(0, left);
     SetInputAt(1, right);
   }
 
   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 11 matching lines @@
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   DECLARE_INSTRUCTION(BinaryInt32x4Op)
   virtual CompileType ComputeType() const;
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const {
     return op_kind() == other->AsBinaryInt32x4Op()->op_kind();
   }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   const Token::Kind op_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(BinaryInt32x4OpInstr);
 };
 
 
-class BinaryFloat64x2OpInstr : public TemplateDefinition<2, NoThrow, Pure> {
+class BinaryFloat64x2OpInstr : public TemplateDefinition<2> {
  public:
   BinaryFloat64x2OpInstr(Token::Kind op_kind,
                          Value* left,
                          Value* right,
                          intptr_t deopt_id)
-      : TemplateDefinition(deopt_id), op_kind_(op_kind) {
+      : TemplateDefinition<2>(deopt_id), op_kind_(op_kind) {
     SetInputAt(0, left);
     SetInputAt(1, right);
   }
 
   Value* left() const { return inputs_[0]; }
   Value* right() const { return inputs_[1]; }
 
   Token::Kind op_kind() const { return op_kind_; }
 
   virtual bool CanDeoptimize() const { return false; }
@@ skipping 11 matching lines @@
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   DECLARE_INSTRUCTION(BinaryFloat64x2Op)
   virtual CompileType ComputeType() const;
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const {
+    ASSERT(other->IsBinaryFloat64x2Op());
     return op_kind() == other->AsBinaryFloat64x2Op()->op_kind();
   }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   const Token::Kind op_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(BinaryFloat64x2OpInstr);
 };
 
 
-class UnaryIntegerOpInstr : public TemplateDefinition<1, NoThrow, Pure> {
+class UnaryIntegerOpInstr : public TemplateDefinition<1> {
  public:
   UnaryIntegerOpInstr(Token::Kind op_kind,
                       Value* value,
                       intptr_t deopt_id)
-      : TemplateDefinition(deopt_id), op_kind_(op_kind) {
+      : TemplateDefinition<1>(deopt_id), op_kind_(op_kind) {
     ASSERT((op_kind == Token::kNEGATE) ||
            (op_kind == Token::kBIT_NOT));
     SetInputAt(0, value);
   }
 
   static UnaryIntegerOpInstr* Make(Representation representation,
                                    Token::Kind op_kind,
                                    Value* value,
                                    intptr_t deopt_id,
                                    Range* range);
 
   Value* value() const { return inputs_[0]; }
   Token::Kind op_kind() const { return op_kind_; }
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const {
     return other->AsUnaryIntegerOp()->op_kind() == op_kind();
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
+  virtual bool MayThrow() const { return false; }
+
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   DEFINE_INSTRUCTION_TYPE_CHECK(UnaryIntegerOp)
 
  private:
   const Token::Kind op_kind_;
 };
 
 
 // Handles both Smi operations: BIT_OR and NEGATE.
@@ skipping 66 matching lines @@
     return kUnboxedMint;
   }
 
   DECLARE_INSTRUCTION(UnaryMintOp)
 
  private:
   DISALLOW_COPY_AND_ASSIGN(UnaryMintOpInstr);
 };
 
 
-class BinaryIntegerOpInstr : public TemplateDefinition<2, NoThrow, Pure> {
+class BinaryIntegerOpInstr : public TemplateDefinition<2> {
  public:
   BinaryIntegerOpInstr(Token::Kind op_kind,
                        Value* left,
                        Value* right,
                        intptr_t deopt_id)
-      : TemplateDefinition(deopt_id),
+      : TemplateDefinition<2>(deopt_id),
         op_kind_(op_kind),
         can_overflow_(true),
         is_truncating_(false) {
     SetInputAt(0, left);
     SetInputAt(1, right);
   }
 
   static BinaryIntegerOpInstr* Make(Representation representation,
                                     Token::Kind op_kind,
                                     Value* left,
@@ skipping 39 matching lines @@
 
       case Token::kSHR:
       case Token::kSHL:
         // These instructions throw on negative shifts.
         return !CanDeoptimize();
 
       default:
         return false;
     }
   }
-
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const;
 
   virtual intptr_t DeoptimizationTarget() const { return GetDeoptId(); }
 
+  virtual bool MayThrow() const { return false; }
+
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   DEFINE_INSTRUCTION_TYPE_CHECK(BinaryIntegerOp)
 
  protected:
   void InferRangeHelper(const Range* left_range,
                         const Range* right_range,
                         Range* range);
 
  private:
@@ skipping 208 matching lines @@
   DECLARE_INSTRUCTION(ShiftMintOp)
 
  private:
   bool has_shift_count_check() const;
 
   DISALLOW_COPY_AND_ASSIGN(ShiftMintOpInstr);
 };
 
 
 // Handles only NEGATE.
-class UnaryDoubleOpInstr : public TemplateDefinition<1, NoThrow, Pure> {
+class UnaryDoubleOpInstr : public TemplateDefinition<1> {
  public:
   UnaryDoubleOpInstr(Token::Kind op_kind,
                      Value* value,
                      intptr_t deopt_id)
-      : TemplateDefinition(deopt_id), op_kind_(op_kind) {
+      : TemplateDefinition<1>(deopt_id), op_kind_(op_kind) {
     ASSERT(op_kind == Token::kNEGATE);
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
   Token::Kind op_kind() const { return op_kind_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   DECLARE_INSTRUCTION(UnaryDoubleOp)
   virtual CompileType ComputeType() const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   virtual Representation representation() const {
     return kUnboxedDouble;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedDouble;
   }
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   const Token::Kind op_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(UnaryDoubleOpInstr);
 };
 
 
-class CheckStackOverflowInstr : public TemplateInstruction<0, NoThrow> {
+class CheckStackOverflowInstr : public TemplateInstruction<0> {
  public:
   CheckStackOverflowInstr(intptr_t token_pos, intptr_t loop_depth)
-      : TemplateInstruction(Isolate::Current()->GetNextDeoptId()),
+      : TemplateInstruction<0>(Isolate::Current()->GetNextDeoptId()),
         token_pos_(token_pos),
         loop_depth_(loop_depth) {
   }
 
   virtual intptr_t token_pos() const { return token_pos_; }
   bool in_loop() const { return loop_depth_ > 0; }
   intptr_t loop_depth() const { return loop_depth_; }
 
   DECLARE_INSTRUCTION(CheckStackOverflow)
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   virtual bool CanDeoptimize() const { return true; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
+  virtual bool MayThrow() const { return false; }
+
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
  private:
   const intptr_t token_pos_;
   const intptr_t loop_depth_;
 
   DISALLOW_COPY_AND_ASSIGN(CheckStackOverflowInstr);
 };
 
 
 // TODO(vegorov): remove this instruction in favor of Int32ToDouble.
-class SmiToDoubleInstr : public TemplateDefinition<1, NoThrow, Pure> {
+class SmiToDoubleInstr : public TemplateDefinition<1> {
  public:
   SmiToDoubleInstr(Value* value, intptr_t token_pos)
       : token_pos_(token_pos) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
   virtual intptr_t token_pos() const { return token_pos_; }
 
   DECLARE_INSTRUCTION(SmiToDouble)
   virtual CompileType ComputeType() const;
 
   virtual Representation representation() const {
     return kUnboxedDouble;
   }
 
   virtual bool CanDeoptimize() const { return false; }
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   const intptr_t token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(SmiToDoubleInstr);
 };
 
 
-class Int32ToDoubleInstr : public TemplateDefinition<1, NoThrow, Pure> {
+class Int32ToDoubleInstr : public TemplateDefinition<1> {
  public:
   explicit Int32ToDoubleInstr(Value* value) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
   DECLARE_INSTRUCTION(Int32ToDouble)
   virtual CompileType ComputeType() const;
 
   virtual Representation RequiredInputRepresentation(intptr_t index) const {
     ASSERT(index == 0);
     return kUnboxedInt32;
   }
 
   virtual Representation representation() const {
     return kUnboxedDouble;
   }
 
   virtual bool CanDeoptimize() const { return false; }
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(Int32ToDoubleInstr);
 };
 
 
-class MintToDoubleInstr : public TemplateDefinition<1, NoThrow, Pure> {
+class MintToDoubleInstr : public TemplateDefinition<1> {
  public:
   MintToDoubleInstr(Value* value, intptr_t deopt_id)
-      : TemplateDefinition(deopt_id) {
+      : TemplateDefinition<1>(deopt_id) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
   DECLARE_INSTRUCTION(MintToDouble)
   virtual CompileType ComputeType() const;
 
   virtual Representation RequiredInputRepresentation(intptr_t index) const {
     ASSERT(index == 0);
     return kUnboxedMint;
   }
 
   virtual Representation representation() const {
     return kUnboxedDouble;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return GetDeoptId();
   }
 
   virtual bool CanDeoptimize() const { return false; }
+
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(MintToDoubleInstr);
 };
 
 
-class DoubleToIntegerInstr : public TemplateDefinition<1, Throws> {
+class DoubleToIntegerInstr : public TemplateDefinition<1> {
  public:
   DoubleToIntegerInstr(Value* value, InstanceCallInstr* instance_call)
-      : TemplateDefinition(instance_call->deopt_id()),
+      : TemplateDefinition<1>(instance_call->deopt_id()),
         instance_call_(instance_call) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
   InstanceCallInstr* instance_call() const { return instance_call_; }
 
   DECLARE_INSTRUCTION(DoubleToInteger)
   virtual CompileType ComputeType() const;
 
   virtual intptr_t ArgumentCount() const { return 1; }
 
   virtual bool CanDeoptimize() const { return true; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
+  virtual bool MayThrow() const { return true; }
+
  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, NoThrow, Pure> {
+class DoubleToSmiInstr : public TemplateDefinition<1> {
  public:
   DoubleToSmiInstr(Value* value, intptr_t deopt_id)
-      : TemplateDefinition(deopt_id) {
+      : TemplateDefinition<1>(deopt_id) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
   DECLARE_INSTRUCTION(DoubleToSmi)
   virtual CompileType ComputeType() const;
 
   virtual bool CanDeoptimize() const { return true; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedDouble;
   }
 
   virtual intptr_t DeoptimizationTarget() const { return GetDeoptId(); }
 
-  virtual bool AttributesEqual(Instruction* other) const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+
+  virtual bool MayThrow() const { return false; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DoubleToSmiInstr);
 };
 
 
-class DoubleToDoubleInstr : public TemplateDefinition<1, NoThrow, Pure> {
+class DoubleToDoubleInstr : public TemplateDefinition<1> {
  public:
   DoubleToDoubleInstr(Value* value,
                       MethodRecognizer::Kind recognized_kind,
                       intptr_t deopt_id)
-    : TemplateDefinition(deopt_id),
+    : TemplateDefinition<1>(deopt_id),
       recognized_kind_(recognized_kind) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
   MethodRecognizer::Kind recognized_kind() const { return recognized_kind_; }
 
   DECLARE_INSTRUCTION(DoubleToDouble)
   virtual CompileType ComputeType() const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Representation representation() const {
     return kUnboxedDouble;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedDouble;
   }
 
   virtual intptr_t DeoptimizationTarget() const { return GetDeoptId(); }
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const {
     return other->AsDoubleToDouble()->recognized_kind() == recognized_kind();
   }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   const MethodRecognizer::Kind recognized_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(DoubleToDoubleInstr);
 };
 
 
-class DoubleToFloatInstr: public TemplateDefinition<1, NoThrow, Pure> {
+class DoubleToFloatInstr: public TemplateDefinition<1> {
  public:
   DoubleToFloatInstr(Value* value, intptr_t deopt_id)
-      : TemplateDefinition(deopt_id) {
+      : TemplateDefinition<1>(deopt_id) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
   DECLARE_INSTRUCTION(DoubleToFloat)
 
   virtual CompileType ComputeType() const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Representation representation() const {
     // This works since double is the representation that the typed array
     // store expects.
     // TODO(fschneider): Change this to a genuine float representation once it
     // is supported.
     return kUnboxedDouble;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedDouble;
   }
 
   virtual intptr_t DeoptimizationTarget() const { return GetDeoptId(); }
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
+  virtual bool MayThrow() const { return false; }
+
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DoubleToFloatInstr);
 };
 
 
-class FloatToDoubleInstr: public TemplateDefinition<1, NoThrow, Pure> {
+class FloatToDoubleInstr: public TemplateDefinition<1> {
  public:
   FloatToDoubleInstr(Value* value, intptr_t deopt_id)
-      : TemplateDefinition(deopt_id) {
+      : TemplateDefinition<1>(deopt_id) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
   DECLARE_INSTRUCTION(FloatToDouble)
 
   virtual CompileType ComputeType() const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Representation representation() const {
     return kUnboxedDouble;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedDouble;
   }
 
   virtual intptr_t DeoptimizationTarget() const { return GetDeoptId(); }
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
+  virtual bool MayThrow() const { return false; }
+
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FloatToDoubleInstr);
 };
 
 
-class InvokeMathCFunctionInstr : public PureDefinition {
+class InvokeMathCFunctionInstr : public Definition {
  public:
   InvokeMathCFunctionInstr(ZoneGrowableArray<Value*>* inputs,
                            intptr_t deopt_id,
                            MethodRecognizer::Kind recognized_kind,
                            intptr_t token_pos);
 
   static intptr_t ArgumentCountFor(MethodRecognizer::Kind recognized_kind_);
 
   const RuntimeEntry& TargetFunction() const;
 
@@ skipping 19 matching lines @@
   virtual intptr_t DeoptimizationTarget() const { return GetDeoptId(); }
 
   virtual intptr_t InputCount() const {
     return inputs_->length();
   }
 
   virtual Value* InputAt(intptr_t i) const {
     return (*inputs_)[i];
   }
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const {
     InvokeMathCFunctionInstr* other_invoke = other->AsInvokeMathCFunction();
     return other_invoke->recognized_kind() == recognized_kind();
   }
 
   virtual bool MayThrow() const { return false; }
 
   static const intptr_t kSavedSpTempIndex = 0;
   static const intptr_t kObjectTempIndex = 1;
   static const intptr_t kDoubleTempIndex = 2;
 
  private:
   virtual void RawSetInputAt(intptr_t i, Value* value) {
     (*inputs_)[i] = value;
   }
 
   ZoneGrowableArray<Value*>* inputs_;
   const MethodRecognizer::Kind recognized_kind_;
   const intptr_t token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(InvokeMathCFunctionInstr);
 };
 
 
-class ExtractNthOutputInstr : public TemplateDefinition<1, NoThrow, Pure> {
+class ExtractNthOutputInstr : public TemplateDefinition<1> {
  public:
   // Extract the Nth output register from value.
   ExtractNthOutputInstr(Value* value,
                         intptr_t n,
                         Representation definition_rep,
                         intptr_t definition_cid)
       : index_(n),
         definition_rep_(definition_rep),
         definition_cid_(definition_cid) {
     SetInputAt(0, value);
@@ skipping 17 matching lines @@
     ASSERT(idx == 0);
     if (representation() == kTagged) {
       return kPairOfTagged;
     } else if (representation() == kUnboxedDouble) {
       return kPairOfUnboxedDouble;
     }
     UNREACHABLE();
     return definition_rep_;
   }
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const {
     ExtractNthOutputInstr* other_extract = other->AsExtractNthOutput();
     return (other_extract->representation() == representation()) &&
            (other_extract->index() == index());
   }
 
+  virtual bool MayThrow() const { return false; }
+
  private:
   const intptr_t index_;
   const Representation definition_rep_;
   const intptr_t definition_cid_;
   DISALLOW_COPY_AND_ASSIGN(ExtractNthOutputInstr);
 };
 
 
-class MergedMathInstr : public PureDefinition {
+class MergedMathInstr : public Definition {
  public:
   enum Kind {
     kTruncDivMod,
     kSinCos,
   };
 
   MergedMathInstr(ZoneGrowableArray<Value*>* inputs,
                   intptr_t original_deopt_id,
                   MergedMathInstr::Kind kind);
 
@@ skipping 53 matching lines @@
     } else {
       UNIMPLEMENTED();
       return kTagged;
     }
   }
 
   virtual intptr_t DeoptimizationTarget() const { return GetDeoptId(); }
 
   DECLARE_INSTRUCTION(MergedMath)
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const {
     MergedMathInstr* other_invoke = other->AsMergedMath();
     return other_invoke->kind() == kind();
   }
 
   virtual bool MayThrow() const { return false; }
 
   static const char* KindToCString(MergedMathInstr::Kind kind) {
     if (kind == kTruncDivMod) return "TruncDivMod";
     if (kind == kSinCos) return "SinCos";
     UNIMPLEMENTED();
     return "";
   }
 
  private:
   virtual void RawSetInputAt(intptr_t i, Value* value) {
     (*inputs_)[i] = value;
   }
   ZoneGrowableArray<Value*>* inputs_;
   MergedMathInstr::Kind kind_;
   DISALLOW_COPY_AND_ASSIGN(MergedMathInstr);
 };
 
 
-class CheckClassInstr : public TemplateInstruction<1, NoThrow> {
+class CheckClassInstr : public TemplateInstruction<1> {
  public:
   CheckClassInstr(Value* value,
                   intptr_t deopt_id,
                   const ICData& unary_checks,
                   intptr_t token_pos);
 
   DECLARE_INSTRUCTION(CheckClass)
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
@@ skipping 11 matching lines @@
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   bool IsNullCheck() const;
 
   bool IsDenseSwitch() const;
   intptr_t ComputeCidMask() const;
   static bool IsDenseMask(intptr_t mask);
 
   virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
   virtual EffectSet Dependencies() const;
-  virtual EffectSet Effects() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const;
 
+  virtual bool MayThrow() const { return false; }
+
   void set_licm_hoisted(bool value) { licm_hoisted_ = value; }
 
  private:
   const ICData& unary_checks_;
   GrowableArray<intptr_t> cids_;  // Sorted, lowest first.
   bool licm_hoisted_;
   const intptr_t token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(CheckClassInstr);
 };
 
 
-class CheckSmiInstr : public TemplateInstruction<1, NoThrow, Pure> {
+class CheckSmiInstr : public TemplateInstruction<1> {
  public:
   CheckSmiInstr(Value* value, intptr_t deopt_id, intptr_t token_pos)
-      : TemplateInstruction(deopt_id),
+      : TemplateInstruction<1>(deopt_id),
         token_pos_(token_pos),
         licm_hoisted_(false) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
   virtual intptr_t token_pos() const { return token_pos_; }
 
   DECLARE_INSTRUCTION(CheckSmi)
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   virtual bool CanDeoptimize() const { return true; }
 
   virtual Instruction* Canonicalize(FlowGraph* flow_graph);
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
+  virtual bool MayThrow() const { return false; }
+
   void set_licm_hoisted(bool value) { licm_hoisted_ = value; }
 
  private:
   const intptr_t token_pos_;
   bool licm_hoisted_;
 
   DISALLOW_COPY_AND_ASSIGN(CheckSmiInstr);
 };
 
 
-class CheckClassIdInstr : public TemplateInstruction<1, NoThrow> {
+class CheckClassIdInstr : public TemplateInstruction<1> {
  public:
   CheckClassIdInstr(Value* value, intptr_t cid, intptr_t deopt_id)
-      : TemplateInstruction(deopt_id), cid_(cid) {
+      : TemplateInstruction<1>(deopt_id), cid_(cid) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
   intptr_t cid() const { return cid_; }
 
   DECLARE_INSTRUCTION(CheckClassId)
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   virtual bool CanDeoptimize() const { return true; }
 
   virtual Instruction* Canonicalize(FlowGraph* flow_graph);
 
   virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
   virtual EffectSet Dependencies() const;
-  virtual EffectSet Effects() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
+  virtual bool MayThrow() const { return false; }
+
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
  private:
   intptr_t cid_;
 
   DISALLOW_COPY_AND_ASSIGN(CheckClassIdInstr);
 };
 
 
-class CheckArrayBoundInstr : public TemplateInstruction<2, NoThrow, Pure> {
+class CheckArrayBoundInstr : public TemplateInstruction<2> {
  public:
   CheckArrayBoundInstr(Value* length, Value* index, intptr_t deopt_id)
-      : TemplateInstruction(deopt_id),
+      : TemplateInstruction<2>(deopt_id),
         generalized_(false),
         licm_hoisted_(false) {
     SetInputAt(kLengthPos, length);
     SetInputAt(kIndexPos, index);
   }
 
   Value* length() const { return inputs_[kLengthPos]; }
   Value* index() const { return inputs_[kIndexPos]; }
 
   DECLARE_INSTRUCTION(CheckArrayBound)
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   virtual bool CanDeoptimize() const { return true; }
 
   bool IsRedundant(const RangeBoundary& length);
 
   void mark_generalized() {
     generalized_ = true;
   }
 
   virtual Instruction* Canonicalize(FlowGraph* flow_graph);
 
   // Returns the length offset for array and string types.
   static intptr_t LengthOffsetFor(intptr_t class_id);
 
   static bool IsFixedLengthArrayType(intptr_t class_id);
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
+  virtual bool MayThrow() const { return false; }
+
   void set_licm_hoisted(bool value) { licm_hoisted_ = value; }
 
   // Give a name to the location/input indices.
   enum {
     kLengthPos = 0,
     kIndexPos = 1
   };
 
  private:
   bool generalized_;
   bool licm_hoisted_;
 
   DISALLOW_COPY_AND_ASSIGN(CheckArrayBoundInstr);
 };
 
 
-class BoxIntNInstr : public TemplateDefinition<1, NoThrow, Pure> {
+class BoxIntNInstr : public TemplateDefinition<1> {
  public:
   BoxIntNInstr(Representation representation, Value* value)
       : from_representation_(representation) {
     SetInputAt(0, value);
   }
 
   Representation from_representation() const { return from_representation_; }
 
   Value* value() const { return inputs_[0]; }
   virtual bool ValueFitsSmi() const;
 
   virtual CompileType ComputeType() const;
   virtual bool RecomputeType();
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual intptr_t DeoptimizationTarget() const {
     return Isolate::kNoDeoptId;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return from_representation_;
   }
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const {
     return other->AsBoxIntN()->from_representation_ == from_representation_;
   }
 
+  virtual bool MayThrow() const { return false; }
+
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
   DEFINE_INSTRUCTION_TYPE_CHECK(BoxIntN)
   DECLARE_INSTRUCTION_BACKEND()
 
  private:
   const Representation from_representation_;
 
   DISALLOW_COPY_AND_ASSIGN(BoxIntNInstr);
 };
@@ skipping 18 matching lines @@
 
   virtual void InferRange(RangeAnalysis* analysis, Range* range);
 
   DECLARE_INSTRUCTION_NO_BACKEND(BoxInt32)
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BoxInt32Instr);
 };
 
 
-class UnboxIntNInstr : public TemplateDefinition<1, NoThrow, Pure> {
+class UnboxIntNInstr : public TemplateDefinition<1> {
  public:
   UnboxIntNInstr(Representation representation,
                  Value* value,
                  intptr_t deopt_id)
-      : TemplateDefinition(deopt_id),
+      : TemplateDefinition<1>(deopt_id),
         representation_(representation),
         is_truncating_(representation == kUnboxedUint32) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
 
   bool is_truncating() const { return is_truncating_; }
   void mark_truncating() { is_truncating_ = true; }
 
   virtual Representation representation() const {
     return representation_;
   }
 
   virtual CompileType ComputeType() const;
 
+  virtual bool AllowsCSE() const { return true; }
+  virtual EffectSet Effects() const { return EffectSet::None(); }
+  virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const {
     UnboxIntNInstr* other_unbox = other->AsUnboxIntN();
     return (other_unbox->representation_ == representation_) &&
         (other_unbox->is_truncating_ == is_truncating_);
   }
 
+  virtual bool MayThrow() const { return false; }
+
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   DEFINE_INSTRUCTION_TYPE_CHECK(UnboxIntN)
   DECLARE_INSTRUCTION_BACKEND()
 
  private:
   const Representation representation_;
   bool is_truncating_;
@@ skipping 33 matching lines @@
 
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
   DECLARE_INSTRUCTION_NO_BACKEND(UnboxInt32)
 
  private:
   DISALLOW_COPY_AND_ASSIGN(UnboxInt32Instr);
 };
 
 
-class UnboxedIntConverterInstr : public TemplateDefinition<1, NoThrow> {
+class UnboxedIntConverterInstr : public TemplateDefinition<1> {
  public:
   UnboxedIntConverterInstr(Representation from,
                            Representation to,
                            Value* value,
                            intptr_t deopt_id)
-      : TemplateDefinition(deopt_id),
+      : TemplateDefinition<1>(deopt_id),
         from_representation_(from),
         to_representation_(to),
         is_truncating_(to == kUnboxedUint32) {
     ASSERT(from != to);
     ASSERT((from == kUnboxedMint) ||
            (from == kUnboxedUint32) ||
            (from == kUnboxedInt32));
     ASSERT((to == kUnboxedMint) ||
            (to == kUnboxedUint32) ||
            (to == kUnboxedInt32));
@@ skipping 25 matching lines @@
   virtual EffectSet Effects() const { return EffectSet::None(); }
   virtual EffectSet Dependencies() const { return EffectSet::None(); }
   virtual bool AttributesEqual(Instruction* other) const {
     ASSERT(other->IsUnboxedIntConverter());
     UnboxedIntConverterInstr* converter = other->AsUnboxedIntConverter();
     return (converter->from() == from()) &&
         (converter->to() == to()) &&
         (converter->is_truncating() == is_truncating());
   }
 
+  virtual bool MayThrow() const { return false; }
+
   virtual void InferRange(RangeAnalysis* analysis, Range* range);
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   DECLARE_INSTRUCTION(UnboxedIntConverter);
 
  private:
   const Representation from_representation_;
   const Representation to_representation_;
   bool is_truncating_;
@@ skipping 235 matching lines @@
       Isolate* isolate, bool opt) const {                                     \
     UNIMPLEMENTED();                                                          \
     return NULL;                                                              \
   }                                                                           \
   void Name::EmitNativeCode(FlowGraphCompiler* compiler) { UNIMPLEMENTED(); }
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_