IR cleanup: pass deopt id as constructor argument instead of doing deopt_id_ assignment.

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 582 matching lines @@
   DECLARE_INSTRUCTION_BACKEND()                                                \
 
 class Instruction : public ZoneAllocated {
  public:
 #define DECLARE_TAG(type) k##type,
   enum Tag {
     FOR_EACH_INSTRUCTION(DECLARE_TAG)
   };
 #undef DECLARE_TAG
 
-  Instruction()
-      : deopt_id_(Isolate::kNoDeoptId),
+  explicit Instruction(intptr_t deopt_id = Isolate::kNoDeoptId)
+      : deopt_id_(deopt_id),
         lifetime_position_(-1),
         previous_(NULL),
         next_(NULL),
         env_(NULL),
         locs_(NULL),
         place_id_(kNoPlaceId) { }
 
   virtual ~Instruction() { }
 
   virtual Tag tag() const = 0;
@@ skipping 229 matching lines @@
   // Fetch deopt id without checking if this computation can deoptimize.
   intptr_t GetDeoptId() const {
     return deopt_id_;
   }
 
  private:
   friend class FlowGraphPrinter;
   friend class Definition;  // Needed for InsertBefore, InsertAfter.
   friend class CallSiteInliner;
 
-  // Classes that set or read deopt_id_.
-  friend class UnboxIntegerInstr;
-  friend class UnboxDoubleInstr;
-  friend class UnboxFloat32x4Instr;
-  friend class UnboxFloat64x2Instr;
-  friend class UnboxInt32x4Instr;
-  friend class BinaryDoubleOpInstr;
-  friend class BinaryFloat32x4OpInstr;
-  friend class Float32x4ZeroInstr;
-  friend class Float32x4SplatInstr;
-  friend class Simd32x4ShuffleInstr;
-  friend class Simd32x4ShuffleMixInstr;
-  friend class Simd32x4GetSignMaskInstr;
-  friend class Float32x4ConstructorInstr;
-  friend class Float32x4ComparisonInstr;
-  friend class Float32x4MinMaxInstr;
-  friend class Float32x4ScaleInstr;
-  friend class Float32x4SqrtInstr;
-  friend class Float32x4ZeroArgInstr;
-  friend class Float32x4ClampInstr;
-  friend class Float32x4WithInstr;
-  friend class Float32x4ToInt32x4Instr;
-  friend class Simd64x2ShuffleInstr;
-  friend class Float64x2ZeroArgInstr;
-  friend class Float64x2OneArgInstr;
-  friend class Float32x4ToFloat64x2Instr;
-  friend class Float64x2ToFloat32x4Instr;
-  friend class Float64x2ZeroInstr;
-  friend class Float64x2SplatInstr;
-  friend class Float64x2ConstructorInstr;
-  friend class Int32x4ConstructorInstr;
-  friend class Int32x4BoolConstructorInstr;
-  friend class Int32x4GetFlagInstr;
-  friend class Int32x4SetFlagInstr;
-  friend class Int32x4SelectInstr;
-  friend class Int32x4ToFloat32x4Instr;
-  friend class BinaryInt32x4OpInstr;
-  friend class BinaryFloat64x2OpInstr;
-  friend class UnaryDoubleOpInstr;
-  friend class MathUnaryInstr;
-  friend class MathMinMaxInstr;
-  friend class CheckClassInstr;
-  friend class CheckClassIdInstr;
-  friend class GuardFieldInstr;
-  friend class CheckSmiInstr;
-  friend class CheckArrayBoundInstr;
-  friend class CheckEitherNonSmiInstr;
+  // deopt_id_ write access.
+  friend class ComparisonInstr;
   friend class LICM;
   friend class Scheduler;
-  friend class DoubleToSmiInstr;
-  friend class DoubleToDoubleInstr;
-  friend class DoubleToFloatInstr;
-  friend class FloatToDoubleInstr;
-  friend class InvokeMathCFunctionInstr;
-  friend class MergedMathInstr;
-  friend class FlowGraphOptimizer;
-  friend class LoadIndexedInstr;
-  friend class StoreIndexedInstr;
-  friend class StoreInstanceFieldInstr;
-  friend class ComparisonInstr;
-  friend class TargetEntryInstr;
-  friend class JoinEntryInstr;
-  friend class InstanceOfInstr;
-  friend class PolymorphicInstanceCallInstr;
-  friend class SmiToDoubleInstr;
-  friend class MintToDoubleInstr;
-  friend class DoubleToIntegerInstr;
+  friend class BlockEntryInstr;
   friend class BranchSimplifier;
-  friend class BlockEntryInstr;
-  friend class RelationalOpInstr;
-  friend class EqualityCompareInstr;
-  friend class TestCidsInstr;
-  friend class UnboxIntNInstr;
-  friend class UnboxInt32Instr;
-  friend class UnboxUint32Instr;
-  friend class UnboxedIntConverterInstr;
-  friend class UnaryIntegerOpInstr;
-  friend class BinaryIntegerOpInstr;
-  friend class DeoptimizeInstr;
-
-  // deopt_id_ access.
-  friend class InstanceCallInstr;
-  friend class StaticCallInstr;
-  friend class GotoInstr;
-  friend class ReturnInstr;
-  friend class BranchInstr;
-  friend class AssertAssignableInstr;
-  friend class TestSmiInstr;
-  friend class IfThenElseInstr;
-  friend class StrictCompareInstr;
-  friend class ThrowInstr;
-  friend class ReThrowInstr;
-  friend class AssertBooleanInstr;
-  friend class CurrentContextInstr;
-  friend class ClosureCallInstr;
-  friend class StringInterpolateInstr;
-  friend class CreateArrayInstr;
-  friend class InstantiateTypeInstr;
-  friend class InstantiateTypeArgumentsInstr;
-  friend class InitStaticFieldInstr;
-  friend class CloneContextInstr;
-  friend class CheckStackOverflowInstr;
 
   virtual void RawSetInputAt(intptr_t i, Value* value) = 0;
 
   enum {
     kNoPlaceId = -1
   };
 
   intptr_t deopt_id_;
   intptr_t lifetime_position_;  // Position used by register allocator.
   Instruction* previous_;
   Instruction* next_;
   Environment* env_;
   LocationSummary* locs_;
   intptr_t place_id_;
 
   DISALLOW_COPY_AND_ASSIGN(Instruction);
 };
 
 
 template<intptr_t N>
 class TemplateInstruction: public Instruction {
  public:
-  TemplateInstruction<N>() : 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]; }
 
  protected:
   EmbeddedArray<Value*, N> inputs_;
 
  private:
   virtual void RawSetInputAt(intptr_t i, Value* value) {
     inputs_[i] = value;
@@ skipping 232 matching lines @@
   void set_block_id(intptr_t block_id) { block_id_ = block_id; }
 
   // For all instruction in this block: Remove all inputs (including in the
   // environment) from their definition's use lists for all instructions.
   void ClearAllInstructions();
 
   DEFINE_INSTRUCTION_TYPE_CHECK(BlockEntry)
 
  protected:
   BlockEntryInstr(intptr_t block_id, intptr_t try_index)
-      : block_id_(block_id),
+      : Instruction(Isolate::Current()->GetNextDeoptId()),
+        block_id_(block_id),
         try_index_(try_index),
         preorder_number_(-1),
         postorder_number_(-1),
         dominator_(NULL),
         dominated_blocks_(1),
         last_instruction_(NULL),
         parallel_move_(NULL),
         loop_info_(NULL) {
-    deopt_id_ = Isolate::Current()->GetNextDeoptId();
   }
 
  private:
   virtual void RawSetInputAt(intptr_t i, Value* value) { UNREACHABLE(); }
 
   virtual void ClearPredecessors() = 0;
   virtual void AddPredecessor(BlockEntryInstr* predecessor) = 0;
 
   void set_dominator(BlockEntryInstr* instr) { dominator_ = instr; }
 
@@ skipping 370 matching lines @@
   COMPILE_ASSERT((kAliased & kNotAliased) == 0);
   COMPILE_ASSERT((kAllocationSinkingCandidate & kNotAliased) != 0);
 
   intptr_t value_;
 };
 
 
 // Abstract super-class of all instructions that define a value (Bind, Phi).
 class Definition : public Instruction {
  public:
-  Definition();
+  explicit Definition(intptr_t deopt_id = Isolate::kNoDeoptId);
 
   // Overridden by definitions that have pushed arguments.
   virtual intptr_t ArgumentCount() const { return 0; }
 
   // Overridden by definitions that have call counts.
   virtual intptr_t CallCount() const {
     UNREACHABLE();
     return -1;
   }
 
@@ skipping 186 matching lines @@
 inline void Value::BindToEnvironment(Definition* def) {
   RemoveFromUseList();
   set_definition(def);
   def->AddEnvUse(this);
 }
 
 
 template<intptr_t N>
 class TemplateDefinition : public Definition {
  public:
-  TemplateDefinition<N>() : 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]; }
 
  protected:
   EmbeddedArray<Value*, N> inputs_;
 
  private:
   friend class BranchInstr;
   friend class IfThenElseInstr;
@@ skipping 191 matching lines @@
 
 
 inline Definition* Instruction::ArgumentAt(intptr_t index) const {
   return PushArgumentAt(index)->value()->definition();
 }
 
 
 class ReturnInstr : public TemplateInstruction<1> {
  public:
   ReturnInstr(intptr_t token_pos, Value* value)
-      : token_pos_(token_pos) {
-    deopt_id_ = 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]; }
 
@@ skipping 11 matching lines @@
 
  private:
   const intptr_t token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(ReturnInstr);
 };
 
 
 class ThrowInstr : public TemplateInstruction<0> {
  public:
-  explicit ThrowInstr(intptr_t token_pos) : token_pos_(token_pos) {
-    deopt_id_ = Isolate::Current()->GetNextDeoptId();
+  explicit ThrowInstr(intptr_t token_pos)
+      : 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> {
  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)
-      : token_pos_(token_pos), catch_try_index_(catch_try_index) {
-    deopt_id_ = 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> {
  public:
   explicit GotoInstr(JoinEntryInstr* entry)
-    : successor_(entry),
+    : TemplateInstruction<0>(Isolate::Current()->GetNextDeoptId()),
+      successor_(entry),
       edge_weight_(0.0),
       parallel_move_(NULL) {
-    deopt_id_ = Isolate::Current()->GetNextDeoptId();
   }
 
   DECLARE_INSTRUCTION(Goto)
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   JoinEntryInstr* successor() const { return successor_; }
   void set_successor(JoinEntryInstr* successor) { successor_ = successor; }
   virtual intptr_t SuccessorCount() const;
   virtual BlockEntryInstr* SuccessorAt(intptr_t index) const;
@@ skipping 66 matching lines @@
   }
 
   // Operation class id is computed from collected ICData.
   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(); }
+
   DEFINE_INSTRUCTION_TYPE_CHECK(Comparison)
 
  protected:
   ComparisonInstr(intptr_t token_pos,
                   Token::Kind kind,
                   Value* left,
-                  Value* right)
-      : token_pos_(token_pos), kind_(kind), operation_cid_(kIllegalCid) {
+                  Value* right,
+                  intptr_t deopt_id = Isolate::kNoDeoptId)
+      : TemplateDefinition<2>(deopt_id),
+        token_pos_(token_pos),
+        kind_(kind),
+        operation_cid_(kIllegalCid) {
     SetInputAt(0, left);
     if (right != NULL) {
       SetInputAt(1, right);
     }
   }
 
  private:
   const intptr_t token_pos_;
   Token::Kind kind_;
   intptr_t operation_cid_;  // Set by optimizer.
 
   DISALLOW_COPY_AND_ASSIGN(ComparisonInstr);
 };
 
 
 class BranchInstr : public Instruction {
  public:
   explicit BranchInstr(ComparisonInstr* comparison)
-      : comparison_(comparison),
+      : Instruction(Isolate::Current()->GetNextDeoptId()),
+        comparison_(comparison),
         is_checked_(false),
         constrained_type_(NULL),
         constant_target_(NULL) {
-    deopt_id_ = Isolate::Current()->GetNextDeoptId();
     ASSERT(comparison->env() == NULL);
     for (intptr_t i = comparison->InputCount() - 1; i >= 0; --i) {
       comparison->InputAt(i)->set_instruction(this);
     }
   }
 
   DECLARE_INSTRUCTION(Branch)
 
   virtual intptr_t ArgumentCount() const {
     return comparison()->ArgumentCount();
@@ skipping 111 matching lines @@
   virtual bool MayThrow() const { return false; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(StoreContextInstr);
 };
 
 
 class DeoptimizeInstr : public TemplateInstruction<0> {
  public:
   DeoptimizeInstr(ICData::DeoptReasonId deopt_reason, intptr_t deopt_id)
-      : deopt_reason_(deopt_reason) {
-    deopt_id_ = 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 {
@@ skipping 139 matching lines @@
 };
 
 
 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)
-      : token_pos_(token_pos),
+                        const String& dst_name,
+                        intptr_t deopt_id)
+      : TemplateDefinition<3>(deopt_id),
+        token_pos_(token_pos),
         dst_type_(AbstractType::ZoneHandle(dst_type.raw())),
         dst_name_(dst_name) {
-    deopt_id_ = Isolate::Current()->GetNextDeoptId();
     ASSERT(!dst_type.IsNull());
     ASSERT(!dst_name.IsNull());
     SetInputAt(0, value);
     SetInputAt(1, instantiator);
     SetInputAt(2, instantiator_type_arguments);
   }
 
   DECLARE_INSTRUCTION(AssertAssignable)
   virtual CompileType* ComputeInitialType() const;
   virtual bool RecomputeType();
@@ skipping 33 matching lines @@
   AbstractType& dst_type_;
   const String& dst_name_;
 
   DISALLOW_COPY_AND_ASSIGN(AssertAssignableInstr);
 };
 
 
 class AssertBooleanInstr : public TemplateDefinition<1> {
  public:
   AssertBooleanInstr(intptr_t token_pos, Value* value)
-      : token_pos_(token_pos) {
-    deopt_id_ = 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;
@@ skipping 13 matching lines @@
   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> {
  public:
-  CurrentContextInstr() {
-    deopt_id_ = Isolate::Current()->GetNextDeoptId();
+  CurrentContextInstr()
+      : 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> {
  public:
   ClosureCallInstr(Value* function,
                    ClosureCallNode* node,
                    ZoneGrowableArray<PushArgumentInstr*>* arguments)
-      : ast_node_(*node),
+      : TemplateDefinition<1>(Isolate::Current()->GetNextDeoptId()),
+        ast_node_(*node),
         arguments_(arguments) {
-    deopt_id_ = Isolate::Current()->GetNextDeoptId();
     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 {
@@ skipping 21 matching lines @@
 
 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)
-      : ic_data_(NULL),
+      : 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) {
-    deopt_id_ = Isolate::Current()->GetNextDeoptId();
     ic_data_ = GetICData(ic_data_array);
     ASSERT(function_name.IsNotTemporaryScopedHandle());
     ASSERT(!arguments->is_empty());
     ASSERT(argument_names.IsZoneHandle() || argument_names.InVMHeap());
     ASSERT(Token::IsBinaryOperator(token_kind) ||
            Token::IsEqualityOperator(token_kind) ||
            Token::IsRelationalOperator(token_kind) ||
            Token::IsPrefixOperator(token_kind) ||
            Token::IsIndexOperator(token_kind) ||
            Token::IsTypeTestOperator(token_kind) ||
@@ skipping 52 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(InstanceCallInstr);
 };
 
 
 class PolymorphicInstanceCallInstr : public TemplateDefinition<0> {
  public:
   PolymorphicInstanceCallInstr(InstanceCallInstr* instance_call,
                                const ICData& ic_data,
                                bool with_checks)
-      : instance_call_(instance_call),
+      : 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);
-    deopt_id_ = instance_call->deopt_id();
   }
 
   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(); }
 
   virtual intptr_t ArgumentCount() const {
     return instance_call()->ArgumentCount();
   }
   virtual PushArgumentInstr* PushArgumentAt(intptr_t index) const {
@@ skipping 36 matching lines @@
                      bool needs_number_check);
 
   DECLARE_INSTRUCTION(StrictCompare)
 
   virtual ComparisonInstr* CopyWithNewOperands(Value* left, Value* right);
 
   virtual CompileType ComputeType() const;
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
-  virtual bool CanBecomeDeoptimizationTarget() const {
-    // StrictCompare can be merged into Branch and thus needs an environment.
-    return true;
-  }
-
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
   virtual void EmitBranchCode(FlowGraphCompiler* compiler,
                               BranchInstr* branch);
 
   virtual Condition EmitComparisonCode(FlowGraphCompiler* compiler,
                                        BranchLabels labels);
 
@@ skipping 15 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(StrictCompareInstr);
 };
 
 
 // Comparison instruction that is equivalent to the (left & right) == 0
 // comparison pattern.
 class TestSmiInstr : public ComparisonInstr {
  public:
   TestSmiInstr(intptr_t token_pos, Token::Kind kind, Value* left, Value* right)
       : ComparisonInstr(token_pos, kind, left, right) {
-    deopt_id_ = Isolate::Current()->GetNextDeoptId();
     ASSERT(kind == Token::kEQ || kind == Token::kNE);
   }
 
   DECLARE_INSTRUCTION(TestSmi);
 
   virtual ComparisonInstr* CopyWithNewOperands(Value* left, Value* right);
 
   virtual CompileType ComputeType() const;
 
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual bool CanBecomeDeoptimizationTarget() const {
-    // TestSmi can be merged into Branch and thus needs an environment.
-    return true;
-  }
-
-  virtual intptr_t DeoptimizationTarget() const {
-    return GetDeoptId();
-  }
-
   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);
@@ skipping 10 matching lines @@
 // a result or deoptimizes.
 // TODO(srdjan): Modify ComparisonInstr to allow 1 or 2 arguments, since
 // TestCidInstr needs only one argument
 class TestCidsInstr : public ComparisonInstr {
  public:
   TestCidsInstr(intptr_t token_pos,
                 Token::Kind kind,
                 Value* value,
                 const ZoneGrowableArray<intptr_t>& cid_results,
                 intptr_t deopt_id)
-      : ComparisonInstr(token_pos, kind, value, NULL),
+      : ComparisonInstr(token_pos, kind, value, NULL, deopt_id),
         cid_results_(cid_results) {
     ASSERT((kind == Token::kIS) || (kind == Token::kISNOT));
     set_operation_cid(kObjectCid);
-    deopt_id_ = deopt_id;
   }
 
   virtual intptr_t InputCount() const { return 1; }
 
   const ZoneGrowableArray<intptr_t>& cid_results() const {
     return cid_results_;
   }
 
   DECLARE_INSTRUCTION(TestCids);
 
   virtual ComparisonInstr* CopyWithNewOperands(Value* left, Value* right);
 
   virtual CompileType ComputeType() const;
 
   virtual bool CanDeoptimize() const {
-    return deopt_id_ != Isolate::kNoDeoptId;
-  }
-
-  virtual bool CanBecomeDeoptimizationTarget() const {
-    // TestCid can be merged into Branch and thus needs an environment.
-    return true;
-  }
-
-  virtual intptr_t DeoptimizationTarget() const {
-    return GetDeoptId();
+    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(); }
 
@@ skipping 16 matching lines @@
 
 
 class EqualityCompareInstr : public ComparisonInstr {
  public:
   EqualityCompareInstr(intptr_t token_pos,
                        Token::Kind kind,
                        Value* left,
                        Value* right,
                        intptr_t cid,
                        intptr_t deopt_id)
-      : ComparisonInstr(token_pos, kind, left, right) {
+      : ComparisonInstr(token_pos, kind, left, right, deopt_id) {
     ASSERT(Token::IsEqualityOperator(kind));
     set_operation_cid(cid);
-    deopt_id_ = deopt_id;  // Override generated deopt-id.
   }
 
   DECLARE_INSTRUCTION(EqualityCompare)
 
   virtual ComparisonInstr* CopyWithNewOperands(Value* left, Value* right);
 
   virtual CompileType ComputeType() const;
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual bool CanBecomeDeoptimizationTarget() const {
-    // EqualityCompare can be merged into Branch and thus needs an environment.
-    return true;
-  }
-
   virtual void EmitBranchCode(FlowGraphCompiler* compiler,
                               BranchInstr* branch);
 
   virtual Condition EmitComparisonCode(FlowGraphCompiler* compiler,
                                        BranchLabels labels);
 
-  virtual intptr_t DeoptimizationTarget() const {
-    return GetDeoptId();
-  }
-
   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,
                     Value* right,
                     intptr_t cid,
                     intptr_t deopt_id)
-      : ComparisonInstr(token_pos, kind, left, right) {
+      : ComparisonInstr(token_pos, kind, left, right, deopt_id) {
     ASSERT(Token::IsRelationalOperator(kind));
     set_operation_cid(cid);
-    deopt_id_ = deopt_id;  // Override generated deopt-id.
   }
 
   DECLARE_INSTRUCTION(RelationalOp)
 
   virtual ComparisonInstr* CopyWithNewOperands(Value* left, Value* right);
 
   virtual CompileType ComputeType() const;
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
-  virtual bool CanBecomeDeoptimizationTarget() const {
-    // RelationalOp can be merged into Branch and thus needs an environment.
-    return true;
-  }
-
   virtual void EmitBranchCode(FlowGraphCompiler* compiler,
                               BranchInstr* branch);
 
   virtual Condition EmitComparisonCode(FlowGraphCompiler* compiler,
                                        BranchLabels labels);
 
-  virtual intptr_t DeoptimizationTarget() const {
-    return GetDeoptId();
-  }
-
   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,
                   Value* if_true,
                   Value* if_false)
-      : comparison_(comparison),
+      : Definition(Isolate::Current()->GetNextDeoptId()),
+        comparison_(comparison),
         if_true_(Smi::Cast(if_true->BoundConstant()).Value()),
         if_false_(Smi::Cast(if_false->BoundConstant()).Value()) {
-    deopt_id_ = Isolate::Current()->GetNextDeoptId();
     // Adjust uses at the comparison.
     ASSERT(comparison->env() == NULL);
     for (intptr_t i = comparison->InputCount() - 1; i >= 0; --i) {
       comparison->InputAt(i)->set_instruction(this);
     }
   }
 
   // Returns true if this combination of comparison and values flowing on
   // the true and false paths is supported on the current platform.
   static bool Supports(ComparisonInstr* comparison, Value* v1, Value* v2);
@@ skipping 57 matching lines @@
 };
 
 
 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)
-      : ic_data_(NULL),
+      : 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()) {
-    deopt_id_ = Isolate::Current()->GetNextDeoptId();
     ic_data_ = GetICData(ic_data_array);
     ASSERT(function.IsZoneHandle());
     ASSERT(argument_names.IsZoneHandle() ||  argument_names.InVMHeap());
   }
 
   // ICData for static calls carries call count.
   const ICData* ic_data() const { return ic_data_; }
   bool HasICData() const {
     return (ic_data() != NULL) && !ic_data()->IsNull();
   }
@@ skipping 385 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(StoreInstanceFieldInstr);
 };
 
 
 class GuardFieldInstr : public TemplateInstruction<1> {
  public:
   GuardFieldInstr(Value* value,
                   const Field& field,
                   intptr_t deopt_id)
-    : field_(field) {
-    deopt_id_ = 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; }
@@ skipping 127 matching lines @@
 
 
 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)
-      : index_scale_(index_scale),
+      : TemplateDefinition<2>(deopt_id),
+        index_scale_(index_scale),
         class_id_(class_id),
         token_pos_(token_pos) {
     SetInputAt(0, array);
     SetInputAt(1, index);
-    deopt_id_ = deopt_id;
   }
 
   intptr_t token_pos() const { return token_pos_; }
 
   DECLARE_INSTRUCTION(LoadIndexed)
   virtual CompileType ComputeType() const;
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0 || idx == 1);
     // The array may be tagged or untagged (for external arrays).
     if (idx == 0) return kNoRepresentation;
     return kTagged;
   }
 
   bool IsExternal() const {
     return array()->definition()->representation() == kUntagged;
   }
 
   Value* array() const { return inputs_[0]; }
   Value* index() const { return inputs_[1]; }
   intptr_t index_scale() const { return index_scale_; }
   intptr_t class_id() const { return class_id_; }
 
   virtual bool CanDeoptimize() const {
-    return deopt_id_ != Isolate::kNoDeoptId;
+    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; }
@@ skipping 71 matching lines @@
  private:
   const intptr_t cid_;
 
   DISALLOW_COPY_AND_ASSIGN(StringToCharCodeInstr);
 };
 
 
 class StringInterpolateInstr : public TemplateDefinition<1> {
  public:
   StringInterpolateInstr(Value* value, intptr_t token_pos)
-      : token_pos_(token_pos), function_(Function::Handle()) {
-    deopt_id_ = 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; }
@@ skipping 16 matching lines @@
 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)
-      : emit_store_barrier_(emit_store_barrier),
+      : 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);
-    deopt_id_ = deopt_id;
   }
 
   DECLARE_INSTRUCTION(StoreIndexed)
 
   enum {
     kArrayPos = 0,
     kIndexPos = 1,
     kValuePos = 2
   };
 
@@ skipping 13 matching lines @@
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const;
 
   bool IsExternal() const {
     return array()->definition()->representation() == kUntagged;
   }
 
   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 deopt_id_;
+    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_;
@@ skipping 30 matching lines @@
 
 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)
-      : token_pos_(token_pos),
+      : 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);
-    deopt_id_ = deopt_id;
   }
 
   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_; }
@@ skipping 159 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(MaterializeObjectInstr);
 };
 
 
 class CreateArrayInstr : public TemplateDefinition<2> {
  public:
   CreateArrayInstr(intptr_t token_pos,
                    Value* element_type,
                    Value* num_elements)
-      : token_pos_(token_pos), identity_(AliasIdentity::Unknown())  {
-    deopt_id_ = 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)
@@ skipping 183 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(LoadFieldInstr);
 };
 
 
 class InstantiateTypeInstr : public TemplateDefinition<1> {
  public:
   InstantiateTypeInstr(intptr_t token_pos,
                        const AbstractType& type,
                        const Class& instantiator_class,
                        Value* instantiator)
-      : token_pos_(token_pos),
+      : TemplateDefinition<1>(Isolate::Current()->GetNextDeoptId()),
+        token_pos_(token_pos),
         type_(type),
         instantiator_class_(instantiator_class) {
-    deopt_id_ = Isolate::Current()->GetNextDeoptId();
     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_; }
@@ skipping 15 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(InstantiateTypeInstr);
 };
 
 
 class InstantiateTypeArgumentsInstr : public TemplateDefinition<1> {
  public:
   InstantiateTypeArgumentsInstr(intptr_t token_pos,
                                 const TypeArguments& type_arguments,
                                 const Class& instantiator_class,
                                 Value* instantiator)
-      : token_pos_(token_pos),
+      : TemplateDefinition<1>(Isolate::Current()->GetNextDeoptId()),
+        token_pos_(token_pos),
         type_arguments_(type_arguments),
         instantiator_class_(instantiator_class) {
-    deopt_id_ = Isolate::Current()->GetNextDeoptId();
     ASSERT(type_arguments.IsZoneHandle());
     SetInputAt(0, instantiator);
   }
 
   DECLARE_INSTRUCTION(InstantiateTypeArguments)
 
   Value* instantiator() const { return inputs_[0]; }
   const TypeArguments& type_arguments() const {
     return type_arguments_;
   }
@@ skipping 44 matching lines @@
   const intptr_t token_pos_;
   const intptr_t num_context_variables_;
 
   DISALLOW_COPY_AND_ASSIGN(AllocateContextInstr);
 };
 
 
 class InitStaticFieldInstr : public TemplateInstruction<1> {
  public:
   InitStaticFieldInstr(Value* input, const Field& field)
-      : field_(field) {
-    deopt_id_ = 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; }
@@ skipping 33 matching lines @@
   const intptr_t token_pos_;
   const intptr_t num_context_variables_;
 
   DISALLOW_COPY_AND_ASSIGN(AllocateUninitializedContextInstr);
 };
 
 
 class CloneContextInstr : public TemplateDefinition<1> {
  public:
   CloneContextInstr(intptr_t token_pos, Value* context_value)
-      : token_pos_(token_pos) {
-    deopt_id_ = 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> {
  public:
   CheckEitherNonSmiInstr(Value* left, Value* right, intptr_t deopt_id)
-      : licm_hoisted_(false) {
+      : TemplateInstruction<2>(deopt_id), licm_hoisted_(false) {
     SetInputAt(0, left);
     SetInputAt(1, right);
-    // Override generated deopt-id.
-    deopt_id_ = deopt_id;
   }
 
   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; }
@@ skipping 200 matching lines @@
 
  private:
   bool is_smi_;
 
   DISALLOW_COPY_AND_ASSIGN(BoxIntegerInstr);
 };
 
 
 class UnboxDoubleInstr : public TemplateDefinition<1> {
  public:
-  UnboxDoubleInstr(Value* value, intptr_t deopt_id) {
+  UnboxDoubleInstr(Value* value, intptr_t deopt_id)
+      : TemplateDefinition<1>(deopt_id) {
     SetInputAt(0, value);
-    deopt_id_ = deopt_id;
   }
 
   Value* value() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const {
     return (value()->Type()->ToCid() != kDoubleCid)
         && (value()->Type()->ToCid() != kSmiCid);
   }
 
   virtual Representation representation() const {
@@ skipping 12 matching lines @@
 
   Definition* Canonicalize(FlowGraph* flow_graph);
 
  private:
   DISALLOW_COPY_AND_ASSIGN(UnboxDoubleInstr);
 };
 
 
 class UnboxFloat32x4Instr : public TemplateDefinition<1> {
  public:
-  UnboxFloat32x4Instr(Value* value, intptr_t deopt_id) {
+  UnboxFloat32x4Instr(Value* value, intptr_t deopt_id)
+      : TemplateDefinition<1>(deopt_id) {
     SetInputAt(0, value);
-    deopt_id_ = deopt_id;
   }
 
   Value* value() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const {
     return (value()->Type()->ToCid() != kFloat32x4Cid);
   }
 
   virtual Representation representation() const {
     return kUnboxedFloat32x4;
@@ skipping 11 matching lines @@
 
   Definition* Canonicalize(FlowGraph* flow_graph);
 
  private:
   DISALLOW_COPY_AND_ASSIGN(UnboxFloat32x4Instr);
 };
 
 
 class UnboxFloat64x2Instr : public TemplateDefinition<1> {
  public:
-  UnboxFloat64x2Instr(Value* value, intptr_t deopt_id) {
+  UnboxFloat64x2Instr(Value* value, intptr_t deopt_id)
+      : TemplateDefinition<1>(deopt_id) {
     SetInputAt(0, value);
-    deopt_id_ = deopt_id;
   }
 
   Value* value() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const {
     return (value()->Type()->ToCid() != kFloat64x2Cid);
   }
 
   virtual Representation representation() const {
     return kUnboxedFloat64x2;
@@ skipping 11 matching lines @@
 
   Definition* Canonicalize(FlowGraph* flow_graph);
 
  private:
   DISALLOW_COPY_AND_ASSIGN(UnboxFloat64x2Instr);
 };
 
 
 class UnboxInt32x4Instr : public TemplateDefinition<1> {
  public:
-  UnboxInt32x4Instr(Value* value, intptr_t deopt_id) {
+  UnboxInt32x4Instr(Value* value, intptr_t deopt_id)
+      : TemplateDefinition<1>(deopt_id) {
     SetInputAt(0, value);
-    deopt_id_ = deopt_id;
   }
 
   Value* value() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const {
     return (value()->Type()->ToCid() != kInt32x4Cid);
   }
 
   virtual Representation representation() const {
     return kUnboxedInt32x4;
@@ skipping 11 matching lines @@
 
   Definition* Canonicalize(FlowGraph* flow_graph);
 
  private:
   DISALLOW_COPY_AND_ASSIGN(UnboxInt32x4Instr);
 };
 
 
 class UnboxIntegerInstr : public TemplateDefinition<1> {
  public:
-  UnboxIntegerInstr(Value* value, intptr_t deopt_id) {
+  UnboxIntegerInstr(Value* value, intptr_t deopt_id)
+      : TemplateDefinition<1>(deopt_id) {
     SetInputAt(0, value);
-    deopt_id_ = deopt_id;
   }
 
   Value* value() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const {
     return (value()->Type()->ToCid() != kSmiCid)
         && (value()->Type()->ToCid() != kMintCid);
   }
 
   virtual Representation representation() const {
     return kUnboxedMint;
   }
 
-  intptr_t deopt_id() const { return deopt_id_; }
+  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; }
@@ skipping 10 matching lines @@
 class MathUnaryInstr : public TemplateDefinition<1> {
  public:
   enum MathUnaryKind {
     kIllegal,
     kSin,
     kCos,
     kSqrt,
     kDoubleSquare,
   };
   MathUnaryInstr(MathUnaryKind kind, Value* value, intptr_t deopt_id)
-      : kind_(kind) {
+      : TemplateDefinition<1>(deopt_id), kind_(kind) {
     SetInputAt(0, value);
-    deopt_id_ = deopt_id;
   }
 
   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 deopt_id_;
+    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();
@@ skipping 13 matching lines @@
 
 
 // Represents Math's static min and max functions.
 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)
-      : op_kind_(op_kind), result_cid_(result_cid) {
+      : 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);
-    deopt_id_ = deopt_id;
   }
 
   MethodRecognizer::Kind op_kind() const { return op_kind_; }
 
   Value* left() const { return inputs_[0]; }
   Value* right() const { return inputs_[1]; }
 
   intptr_t result_cid() const { return result_cid_; }
 
   virtual bool CanDeoptimize() const { return false; }
@@ skipping 10 matching lines @@
     if (result_cid() == kSmiCid) {
       return kTagged;
     }
     ASSERT(result_cid() == kDoubleCid);
     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 deopt_id_;
+    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> {
  public:
   BinaryDoubleOpInstr(Token::Kind op_kind,
                       Value* left,
                       Value* right,
                       intptr_t deopt_id,
                       intptr_t token_pos)
-      : op_kind_(op_kind), token_pos_(token_pos) {
+      : TemplateDefinition<2>(deopt_id),
+        op_kind_(op_kind),
+        token_pos_(token_pos) {
     SetInputAt(0, left);
     SetInputAt(1, right);
-    // Overriden generated deopt_id.
-    deopt_id_ = deopt_id;
   }
 
   Value* left() const { return inputs_[0]; }
   Value* right() const { return inputs_[1]; }
 
   Token::Kind op_kind() const { return op_kind_; }
 
   virtual intptr_t token_pos() const { return token_pos_; }
 
   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) || (idx == 1));
     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 deopt_id_;
+    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(); }
@@ skipping 10 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(BinaryDoubleOpInstr);
 };
 
 
 class BinaryFloat32x4OpInstr : public TemplateDefinition<2> {
  public:
   BinaryFloat32x4OpInstr(Token::Kind op_kind,
                          Value* left,
                          Value* right,
                          intptr_t deopt_id)
-      : op_kind_(op_kind) {
+      : TemplateDefinition<2>(deopt_id), op_kind_(op_kind) {
     SetInputAt(0, left);
     SetInputAt(1, right);
-    deopt_id_ = deopt_id;
   }
 
   Value* left() const { return inputs_[0]; }
   Value* right() const { return inputs_[1]; }
 
   Token::Kind op_kind() const { return op_kind_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Representation representation() const {
     return kUnboxedFloat32x4;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     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 deopt_id_;
+    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> {
  public:
   Simd32x4ShuffleInstr(MethodRecognizer::Kind op_kind, Value* value,
                        intptr_t mask,
                        intptr_t deopt_id)
-      : op_kind_(op_kind), mask_(mask) {
+      : TemplateDefinition<1>(deopt_id), op_kind_(op_kind), mask_(mask) {
     SetInputAt(0, value);
-    deopt_id_ = deopt_id;
   }
 
   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 22 matching lines @@
         (op_kind_ == MethodRecognizer::kFloat32x4Shuffle)) {
       return kUnboxedFloat32x4;
     }
     ASSERT((op_kind_ == MethodRecognizer::kInt32x4Shuffle));
     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 deopt_id_;
+    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> {
  public:
   Simd32x4ShuffleMixInstr(MethodRecognizer::Kind op_kind, Value* xy,
                            Value* zw, intptr_t mask, intptr_t deopt_id)
-      : op_kind_(op_kind), mask_(mask) {
+      : TemplateDefinition<2>(deopt_id), op_kind_(op_kind), mask_(mask) {
     SetInputAt(0, xy);
     SetInputAt(1, zw);
-    deopt_id_ = deopt_id;
   }
 
   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_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
@@ skipping 13 matching lines @@
     if (op_kind() == MethodRecognizer::kInt32x4ShuffleMix) {
       return kUnboxedInt32x4;
     }
     ASSERT(op_kind() == MethodRecognizer::kFloat32x4ShuffleMix);
     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 deopt_id_;
+    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> {
  public:
-  Float32x4ConstructorInstr(Value* value0, Value* value1, Value* value2,
-                            Value* value3, intptr_t deopt_id) {
+  Float32x4ConstructorInstr(Value* value0,
+                            Value* value1,
+                            Value* value2,
+                            Value* value3,
+                            intptr_t deopt_id)
+      : TemplateDefinition<4>(deopt_id) {
     SetInputAt(0, value0);
     SetInputAt(1, value1);
     SetInputAt(2, value2);
     SetInputAt(3, value3);
-    deopt_id_ = deopt_id;
   }
 
   Value* value0() const { return inputs_[0]; }
   Value* value1() const { return inputs_[1]; }
   Value* value2() const { return inputs_[2]; }
   Value* value3() const { return inputs_[3]; }
 
   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 && idx < 4);
     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 deopt_id_;
+    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> {
  public:
-  Float32x4SplatInstr(Value* value, intptr_t deopt_id) {
+  Float32x4SplatInstr(Value* value, intptr_t deopt_id)
+      : TemplateDefinition<1>(deopt_id) {
     SetInputAt(0, value);
-    deopt_id_ = deopt_id;
   }
 
   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 deopt_id_;
+    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> {
  public:
-  explicit Float32x4ZeroInstr(intptr_t deopt_id) {
-    deopt_id_ = deopt_id;
-  }
-
-  Value* value() const { return inputs_[0]; }
-
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
+  Float32x4ZeroInstr() { }
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Representation representation() const {
     return kUnboxedFloat32x4;
   }
 
-  virtual Representation RequiredInputRepresentation(intptr_t idx) const {
-    UNIMPLEMENTED();
-    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 deopt_id_;
-  }
-
   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> {
  public:
-  Float32x4ComparisonInstr(MethodRecognizer::Kind op_kind, Value* left,
-                           Value* right, intptr_t deopt_id)
-      : op_kind_(op_kind) {
+  Float32x4ComparisonInstr(MethodRecognizer::Kind op_kind,
+                           Value* left,
+                           Value* right,
+                           intptr_t deopt_id)
+      : TemplateDefinition<2>(deopt_id), op_kind_(op_kind) {
     SetInputAt(0, left);
     SetInputAt(1, right);
-    deopt_id_ = deopt_id;
   }
 
   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;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Representation representation() const {
     return kUnboxedInt32x4;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     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 deopt_id_;
+    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> {
  public:
-  Float32x4MinMaxInstr(MethodRecognizer::Kind op_kind, Value* left,
-                       Value* right, intptr_t deopt_id)
-      : op_kind_(op_kind) {
+  Float32x4MinMaxInstr(MethodRecognizer::Kind op_kind,
+                       Value* left,
+                       Value* right,
+                       intptr_t deopt_id)
+      : TemplateDefinition<2>(deopt_id), op_kind_(op_kind) {
     SetInputAt(0, left);
     SetInputAt(1, right);
-    deopt_id_ = deopt_id;
   }
 
   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;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Representation representation() const {
     return kUnboxedFloat32x4;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     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 deopt_id_;
+    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> {
  public:
-  Float32x4ScaleInstr(MethodRecognizer::Kind op_kind, Value* left,
-                      Value* right, intptr_t deopt_id)
-      : op_kind_(op_kind) {
+  Float32x4ScaleInstr(MethodRecognizer::Kind op_kind,
+                      Value* left,
+                      Value* right,
+                      intptr_t deopt_id)
+      : TemplateDefinition<2>(deopt_id), op_kind_(op_kind) {
     SetInputAt(0, left);
     SetInputAt(1, right);
-    deopt_id_ = deopt_id;
   }
 
   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;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Representation representation() const {
     return kUnboxedFloat32x4;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     if (idx == 0) {
       return kUnboxedDouble;
     }
     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 deopt_id_;
+    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> {
  public:
-  Float32x4SqrtInstr(MethodRecognizer::Kind op_kind, Value* left,
-                     intptr_t deopt_id) : op_kind_(op_kind) {
+  Float32x4SqrtInstr(MethodRecognizer::Kind op_kind,
+                     Value* left,
+                     intptr_t deopt_id)
+      : TemplateDefinition<1>(deopt_id), op_kind_(op_kind) {
     SetInputAt(0, left);
-    deopt_id_ = deopt_id;
   }
 
   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 deopt_id_;
+    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> {
  public:
-  Float32x4ZeroArgInstr(MethodRecognizer::Kind op_kind, Value* left,
-                        intptr_t deopt_id) : op_kind_(op_kind) {
+  Float32x4ZeroArgInstr(MethodRecognizer::Kind op_kind,
+                        Value* left,
+                        intptr_t deopt_id)
+      : TemplateDefinition<1>(deopt_id),
+        op_kind_(op_kind) {
     SetInputAt(0, left);
-    deopt_id_ = deopt_id;
   }
 
   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 deopt_id_;
+    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> {
  public:
-  Float32x4ClampInstr(Value* left, Value* lower, Value* upper,
-                      intptr_t deopt_id) {
+  Float32x4ClampInstr(Value* left,
+                      Value* lower,
+                      Value* upper,
+                      intptr_t deopt_id)
+      : TemplateDefinition<3>(deopt_id) {
     SetInputAt(0, left);
     SetInputAt(1, lower);
     SetInputAt(2, upper);
-    deopt_id_ = deopt_id;
   }
 
   Value* left() const { return inputs_[0]; }
   Value* lower() const { return inputs_[1]; }
   Value* upper() const { return inputs_[2]; }
 
   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) || (idx == 1) || (idx == 2));
     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 deopt_id_;
+    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> {
  public:
-  Float32x4WithInstr(MethodRecognizer::Kind op_kind, Value* left,
-                     Value* replacement, intptr_t deopt_id)
-      : op_kind_(op_kind) {
+  Float32x4WithInstr(MethodRecognizer::Kind op_kind,
+                     Value* left,
+                     Value* replacement,
+                     intptr_t deopt_id)
+      : TemplateDefinition<2>(deopt_id),
+        op_kind_(op_kind) {
     SetInputAt(0, replacement);
     SetInputAt(1, left);
-    deopt_id_ = deopt_id;
   }
 
   Value* left() const { return inputs_[1]; }
   Value* replacement() 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) || (idx == 1));
     if (idx == 0) {
       return kUnboxedDouble;
     }
     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 deopt_id_;
+    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> {
  public:
-  Simd64x2ShuffleInstr(MethodRecognizer::Kind op_kind, Value* value,
+  Simd64x2ShuffleInstr(MethodRecognizer::Kind op_kind,
+                       Value* value,
                        intptr_t mask,
                        intptr_t deopt_id)
-      : op_kind_(op_kind), mask_(mask) {
+      : TemplateDefinition<1>(deopt_id), op_kind_(op_kind), mask_(mask) {
     SetInputAt(0, value);
-    deopt_id_ = deopt_id;
   }
 
   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 14 matching lines @@
         (op_kind_ == MethodRecognizer::kFloat64x2GetY)) {
       return kUnboxedFloat64x2;
     }
     UNIMPLEMENTED();
     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 deopt_id_;
+    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> {
  public:
-  Float32x4ToInt32x4Instr(Value* left, intptr_t deopt_id) {
+  Float32x4ToInt32x4Instr(Value* left, intptr_t deopt_id)
+      : TemplateDefinition<1>(deopt_id) {
     SetInputAt(0, left);
-    deopt_id_ = deopt_id;
   }
 
   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 deopt_id_;
+    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> {
  public:
-  Float32x4ToFloat64x2Instr(Value* left, intptr_t deopt_id) {
+  Float32x4ToFloat64x2Instr(Value* left, intptr_t deopt_id)
+      : TemplateDefinition<1>(deopt_id) {
     SetInputAt(0, left);
-    deopt_id_ = deopt_id;
   }
 
   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 deopt_id_;
+    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> {
  public:
-  Float64x2ToFloat32x4Instr(Value* left, intptr_t deopt_id) {
+  Float64x2ToFloat32x4Instr(Value* left, intptr_t deopt_id)
+      : TemplateDefinition<1>(deopt_id) {
     SetInputAt(0, left);
-    deopt_id_ = deopt_id;
   }
 
   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 deopt_id_;
+    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> {
  public:
-  Float64x2ConstructorInstr(Value* value0, Value* value1, intptr_t deopt_id) {
+  Float64x2ConstructorInstr(Value* value0, Value* value1, intptr_t deopt_id)
+      : TemplateDefinition<2>(deopt_id) {
     SetInputAt(0, value0);
     SetInputAt(1, value1);
-    deopt_id_ = deopt_id;
   }
 
   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 deopt_id_;
+    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> {
  public:
-  Float64x2SplatInstr(Value* value, intptr_t deopt_id) {
+  Float64x2SplatInstr(Value* value, intptr_t deopt_id)
+      : TemplateDefinition<1>(deopt_id) {
     SetInputAt(0, value);
-    deopt_id_ = deopt_id;
   }
 
   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 deopt_id_;
+    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> {
  public:
-  explicit Float64x2ZeroInstr(intptr_t deopt_id) {
-    deopt_id_ = deopt_id;
-  }
-
-  virtual void PrintOperandsTo(BufferFormatter* f) const;
+  Float64x2ZeroInstr() { }
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Representation representation() const {
     return kUnboxedFloat64x2;
   }
 
-  virtual Representation RequiredInputRepresentation(intptr_t idx) const {
-    UNIMPLEMENTED();
-    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 deopt_id_;
-  }
-
   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> {
  public:
-  Float64x2ZeroArgInstr(MethodRecognizer::Kind op_kind, Value* left,
-                        intptr_t deopt_id) : op_kind_(op_kind) {
+  Float64x2ZeroArgInstr(MethodRecognizer::Kind op_kind,
+                        Value* left,
+                        intptr_t deopt_id)
+      : TemplateDefinition<1>(deopt_id), op_kind_(op_kind) {
     SetInputAt(0, left);
-    deopt_id_ = deopt_id;
   }
 
   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 {
     if (op_kind() == MethodRecognizer::kFloat64x2GetSignMask) {
       // Smi.
       return kTagged;
     }
     return kUnboxedFloat64x2;
   }
 
   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 deopt_id_;
+    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> {
  public:
-  Float64x2OneArgInstr(MethodRecognizer::Kind op_kind, Value* left,
-                       Value* right, intptr_t deopt_id) : op_kind_(op_kind) {
+  Float64x2OneArgInstr(MethodRecognizer::Kind op_kind,
+                       Value* left,
+                       Value* right,
+                       intptr_t deopt_id)
+      : TemplateDefinition<2>(deopt_id), op_kind_(op_kind) {
     SetInputAt(0, left);
     SetInputAt(1, right);
-    deopt_id_ = deopt_id;
   }
 
   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;
 
   virtual bool CanDeoptimize() const { return false; }
@@ skipping 11 matching lines @@
         (op_kind() == MethodRecognizer::kFloat64x2WithY) ||
         (op_kind() == MethodRecognizer::kFloat64x2Scale)) {
       return kUnboxedDouble;
     }
     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 deopt_id_;
+    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> {
  public:
-  Int32x4ConstructorInstr(Value* value0, Value* value1, Value* value2,
-                          Value* value3, intptr_t deopt_id) {
+  Int32x4ConstructorInstr(Value* value0,
+                          Value* value1,
+                          Value* value2,
+                          Value* value3,
+                          intptr_t deopt_id)
+      : TemplateDefinition<4>(deopt_id) {
     SetInputAt(0, value0);
     SetInputAt(1, value1);
     SetInputAt(2, value2);
     SetInputAt(3, value3);
-    deopt_id_ = deopt_id;
   }
 
   Value* value0() const { return inputs_[0]; }
   Value* value1() const { return inputs_[1]; }
   Value* value2() const { return inputs_[2]; }
   Value* value3() const { return inputs_[3]; }
 
   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) && (idx < 4));
     return kUnboxedUint32;
   }
 
   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 deopt_id_;
+    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> {
  public:
-  Int32x4BoolConstructorInstr(Value* value0, Value* value1, Value* value2,
-                              Value* value3, intptr_t deopt_id) {
+  Int32x4BoolConstructorInstr(Value* value0,
+                              Value* value1,
+                              Value* value2,
+                              Value* value3,
+                              intptr_t deopt_id)
+      : TemplateDefinition<4>(deopt_id) {
     SetInputAt(0, value0);
     SetInputAt(1, value1);
     SetInputAt(2, value2);
     SetInputAt(3, value3);
-    deopt_id_ = deopt_id;
   }
 
   Value* value0() const { return inputs_[0]; }
   Value* value1() const { return inputs_[1]; }
   Value* value2() const { return inputs_[2]; }
   Value* value3() const { return inputs_[3]; }
 
   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) && (idx < 4));
     return kTagged;
   }
 
   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 deopt_id_;
+    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> {
  public:
-  Int32x4GetFlagInstr(MethodRecognizer::Kind op_kind, Value* value,
-                       intptr_t deopt_id)
-      : op_kind_(op_kind) {
+  Int32x4GetFlagInstr(MethodRecognizer::Kind op_kind,
+                      Value* value,
+                      intptr_t deopt_id)
+      : TemplateDefinition<1>(deopt_id), op_kind_(op_kind) {
     SetInputAt(0, value);
-    deopt_id_ = deopt_id;
   }
 
   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 deopt_id_;
+    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> {
  public:
-  Simd32x4GetSignMaskInstr(MethodRecognizer::Kind op_kind, Value* value,
-                           intptr_t deopt_id) : op_kind_(op_kind) {
+  Simd32x4GetSignMaskInstr(MethodRecognizer::Kind op_kind,
+                           Value* value,
+                           intptr_t deopt_id)
+      : TemplateDefinition<1>(deopt_id), op_kind_(op_kind) {
     SetInputAt(0, value);
-    deopt_id_ = deopt_id;
   }
 
   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);
     if (op_kind_ == MethodRecognizer::kFloat32x4GetSignMask) {
       return kUnboxedFloat32x4;
     }
     ASSERT(op_kind_ == MethodRecognizer::kInt32x4GetSignMask);
     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 deopt_id_;
+    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> {
  public:
-  Int32x4SelectInstr(Value* mask, Value* trueValue, Value* falseValue,
-                      intptr_t deopt_id) {
+  Int32x4SelectInstr(Value* mask,
+                     Value* trueValue,
+                     Value* falseValue,
+                     intptr_t deopt_id)
+      : TemplateDefinition<3>(deopt_id) {
     SetInputAt(0, mask);
     SetInputAt(1, trueValue);
     SetInputAt(2, falseValue);
-    deopt_id_ = deopt_id;
   }
 
   Value* mask() const { return inputs_[0]; }
   Value* trueValue() const { return inputs_[1]; }
   Value* falseValue() const { return inputs_[2]; }
 
   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) || (idx == 1) || (idx == 2));
     if (idx == 0) {
       return kUnboxedInt32x4;
     }
     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 deopt_id_;
+    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> {
  public:
-  Int32x4SetFlagInstr(MethodRecognizer::Kind op_kind, Value* value,
-                       Value* flagValue, intptr_t deopt_id)
-      : op_kind_(op_kind) {
+  Int32x4SetFlagInstr(MethodRecognizer::Kind op_kind,
+                      Value* value,
+                      Value* flagValue,
+                      intptr_t deopt_id)
+      : TemplateDefinition<2>(deopt_id), op_kind_(op_kind) {
     SetInputAt(0, value);
     SetInputAt(1, flagValue);
-    deopt_id_ = deopt_id;
   }
 
   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;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Representation representation() const {
       return kUnboxedInt32x4;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     if (idx == 1) {
       return kTagged;
     }
     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 deopt_id_;
+    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> {
  public:
-  Int32x4ToFloat32x4Instr(Value* left, intptr_t deopt_id) {
+  Int32x4ToFloat32x4Instr(Value* left, intptr_t deopt_id)
+      : TemplateDefinition<1>(deopt_id) {
     SetInputAt(0, left);
-    deopt_id_ = deopt_id;
   }
 
   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 deopt_id_;
+    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> {
  public:
   BinaryInt32x4OpInstr(Token::Kind op_kind,
                         Value* left,
                         Value* right,
                         intptr_t deopt_id)
-      : op_kind_(op_kind) {
+      : TemplateDefinition<2>(deopt_id), op_kind_(op_kind) {
     SetInputAt(0, left);
     SetInputAt(1, right);
-    deopt_id_ = deopt_id;
   }
 
   Value* left() const { return inputs_[0]; }
   Value* right() const { return inputs_[1]; }
 
   Token::Kind op_kind() const { return op_kind_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual Representation representation() const {
     return kUnboxedInt32x4;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     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 deopt_id_;
+    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> {
  public:
   BinaryFloat64x2OpInstr(Token::Kind op_kind,
                          Value* left,
                          Value* right,
                          intptr_t deopt_id)
-      : op_kind_(op_kind) {
+      : TemplateDefinition<2>(deopt_id), op_kind_(op_kind) {
     SetInputAt(0, left);
     SetInputAt(1, right);
-    deopt_id_ = deopt_id;
   }
 
   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; }
 
   virtual Representation representation() const {
     return kUnboxedFloat64x2;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     return kUnboxedFloat64x2;
   }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   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 deopt_id_;
+    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> {
  public:
   UnaryIntegerOpInstr(Token::Kind op_kind,
                       Value* value,
                       intptr_t 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);
-    // Override generated deopt-id.
-    deopt_id_ = deopt_id;
   }
 
   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 deopt_id_;
+    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_;
@@ skipping 76 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(UnaryMintOpInstr);
 };
 
 
 class BinaryIntegerOpInstr : public TemplateDefinition<2> {
  public:
   BinaryIntegerOpInstr(Token::Kind op_kind,
                        Value* left,
                        Value* right,
                        intptr_t deopt_id)
-      : op_kind_(op_kind),
+      : TemplateDefinition<2>(deopt_id),
+        op_kind_(op_kind),
         can_overflow_(true),
         is_truncating_(false) {
     SetInputAt(0, left);
     SetInputAt(1, right);
-    // Override generated deopt-id.
-    deopt_id_ = deopt_id;
   }
 
   static BinaryIntegerOpInstr* Make(Representation representation,
                                     Token::Kind op_kind,
                                     Value* left,
                                     Value* right,
                                     intptr_t deopt_id,
                                     bool can_overflow,
                                     bool is_truncating,
                                     Range* range);
@@ skipping 39 matching lines @@
 
       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 deopt_id_; }
+  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,
@@ skipping 216 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(ShiftMintOpInstr);
 };
 
 
 // Handles only NEGATE.
 class UnaryDoubleOpInstr : public TemplateDefinition<1> {
  public:
   UnaryDoubleOpInstr(Token::Kind op_kind,
                      Value* value,
                      intptr_t deopt_id)
-      : op_kind_(op_kind) {
+      : TemplateDefinition<1>(deopt_id), op_kind_(op_kind) {
     ASSERT(op_kind == Token::kNEGATE);
     SetInputAt(0, value);
-    // Overriden generated deopt_id.
-    deopt_id_ = deopt_id;
   }
 
   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 deopt_id_;
+    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> {
  public:
   CheckStackOverflowInstr(intptr_t token_pos, intptr_t loop_depth)
-      : token_pos_(token_pos), loop_depth_(loop_depth) {
-    deopt_id_ = 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; }
 
@@ skipping 77 matching lines @@
   virtual bool MayThrow() const { return false; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(Int32ToDoubleInstr);
 };
 
 
 class MintToDoubleInstr : public TemplateDefinition<1> {
  public:
   MintToDoubleInstr(Value* value, intptr_t deopt_id)
-      : deopt_id_(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 deopt_id_;
+    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:
-  const intptr_t deopt_id_;
-
   DISALLOW_COPY_AND_ASSIGN(MintToDoubleInstr);
 };
 
 
 class DoubleToIntegerInstr : public TemplateDefinition<1> {
  public:
   DoubleToIntegerInstr(Value* value, InstanceCallInstr* instance_call)
-      : instance_call_(instance_call) {
+      : TemplateDefinition<1>(instance_call->deopt_id()),
+        instance_call_(instance_call) {
     SetInputAt(0, value);
-    deopt_id_ = instance_call->deopt_id();
   }
 
   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> {
  public:
-  DoubleToSmiInstr(Value* value, intptr_t deopt_id) {
+  DoubleToSmiInstr(Value* value, intptr_t deopt_id)
+      : TemplateDefinition<1>(deopt_id) {
     SetInputAt(0, value);
-    // Override generated deopt-id.
-    deopt_id_ = deopt_id;
   }
 
   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 deopt_id_; }
+  virtual intptr_t DeoptimizationTarget() const { return GetDeoptId(); }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
   virtual bool MayThrow() const { return false; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DoubleToSmiInstr);
 };
 
 
 class DoubleToDoubleInstr : public TemplateDefinition<1> {
  public:
   DoubleToDoubleInstr(Value* value,
                       MethodRecognizer::Kind recognized_kind,
                       intptr_t deopt_id)
-    : recognized_kind_(recognized_kind) {
+    : TemplateDefinition<1>(deopt_id),
+      recognized_kind_(recognized_kind) {
     SetInputAt(0, value);
-    // Override generated deopt-id.
-    deopt_id_ = deopt_id;
   }
 
   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 deopt_id_; }
+  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> {
  public:
-  DoubleToFloatInstr(Value* value, intptr_t deopt_id) {
+  DoubleToFloatInstr(Value* value, intptr_t deopt_id)
+      : TemplateDefinition<1>(deopt_id) {
     SetInputAt(0, value);
-    // Override generated deopt-id.
-    deopt_id_ = deopt_id;
   }
 
   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 deopt_id_; }
+  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> {
  public:
-  FloatToDoubleInstr(Value* value, intptr_t deopt_id) {
+  FloatToDoubleInstr(Value* value, intptr_t deopt_id)
+      : TemplateDefinition<1>(deopt_id) {
     SetInputAt(0, value);
-    // Override generated deopt-id.
-    deopt_id_ = deopt_id;
   }
 
   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 deopt_id_; }
+  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 Definition {
  public:
   InvokeMathCFunctionInstr(ZoneGrowableArray<Value*>* inputs,
-                           intptr_t original_deopt_id,
+                           intptr_t deopt_id,
                            MethodRecognizer::Kind recognized_kind,
                            intptr_t token_pos);
 
   static intptr_t ArgumentCountFor(MethodRecognizer::Kind recognized_kind_);
 
   const RuntimeEntry& TargetFunction() const;
 
   MethodRecognizer::Kind recognized_kind() const { return recognized_kind_; }
 
   virtual intptr_t token_pos() const { return token_pos_; }
 
   DECLARE_INSTRUCTION(InvokeMathCFunction)
   virtual CompileType ComputeType() 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((0 <= idx) && (idx < InputCount()));
     return kUnboxedDouble;
   }
 
-  virtual intptr_t DeoptimizationTarget() const { return deopt_id_; }
+  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; }
@@ skipping 143 matching lines @@
     if (kind_ == kTruncDivMod) {
       return kTagged;
     } else if (kind_ == kSinCos) {
       return kUnboxedDouble;
     } else {
       UNIMPLEMENTED();
       return kTagged;
     }
   }
 
-  virtual intptr_t DeoptimizationTarget() const { return deopt_id_; }
+  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();
   }
@@ skipping 62 matching lines @@
   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> {
  public:
-  CheckSmiInstr(Value* value, intptr_t original_deopt_id, intptr_t token_pos)
-      : token_pos_(token_pos), licm_hoisted_(false) {
+  CheckSmiInstr(Value* value, intptr_t deopt_id, intptr_t token_pos)
+      : TemplateInstruction<1>(deopt_id),
+        token_pos_(token_pos),
+        licm_hoisted_(false) {
     SetInputAt(0, value);
-    deopt_id_ = original_deopt_id;
   }
 
   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; }
@@ skipping 12 matching lines @@
  private:
   const intptr_t token_pos_;
   bool licm_hoisted_;
 
   DISALLOW_COPY_AND_ASSIGN(CheckSmiInstr);
 };
 
 
 class CheckClassIdInstr : public TemplateInstruction<1> {
  public:
-  CheckClassIdInstr(Value* value, intptr_t cid, intptr_t deopt_id) : cid_(cid) {
+  CheckClassIdInstr(Value* value, intptr_t cid, intptr_t deopt_id)
+      : TemplateInstruction<1>(deopt_id), cid_(cid) {
     SetInputAt(0, value);
-    // Override generated deopt-id.
-    deopt_id_ = deopt_id;
   }
 
   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; }
@@ skipping 12 matching lines @@
  private:
   intptr_t cid_;
 
   DISALLOW_COPY_AND_ASSIGN(CheckClassIdInstr);
 };
 
 
 class CheckArrayBoundInstr : public TemplateInstruction<2> {
  public:
   CheckArrayBoundInstr(Value* length, Value* index, intptr_t deopt_id)
-      : generalized_(false), licm_hoisted_(false) {
+      : TemplateInstruction<2>(deopt_id),
+        generalized_(false),
+        licm_hoisted_(false) {
     SetInputAt(kLengthPos, length);
     SetInputAt(kIndexPos, index);
-    // Override generated deopt-id.
-    deopt_id_ = deopt_id;
   }
 
   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; }
@@ skipping 105 matching lines @@
  private:
   DISALLOW_COPY_AND_ASSIGN(BoxInt32Instr);
 };
 
 
 class UnboxIntNInstr : public TemplateDefinition<1> {
  public:
   UnboxIntNInstr(Representation representation,
                  Value* value,
                  intptr_t deopt_id)
-      : representation_(representation),
+      : TemplateDefinition<1>(deopt_id),
+        representation_(representation),
         is_truncating_(representation == kUnboxedUint32) {
     SetInputAt(0, value);
-    deopt_id_ = deopt_id;
   }
 
   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_;
   }
@@ skipping 63 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(UnboxInt32Instr);
 };
 
 
 class UnboxedIntConverterInstr : public TemplateDefinition<1> {
  public:
   UnboxedIntConverterInstr(Representation from,
                            Representation to,
                            Value* value,
                            intptr_t deopt_id)
-      : from_representation_(from),
+      : 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));
     ASSERT((to != kUnboxedInt32) || (deopt_id != Isolate::kNoDeoptId));
     SetInputAt(0, value);
-    deopt_id_ = deopt_id;
   }
 
   Value* value() const { return inputs_[0]; }
 
   Representation from() const { return from_representation_; }
   Representation to() const { return to_representation_; }
   bool is_truncating() const { return is_truncating_; }
 
   void mark_truncating() { is_truncating_ = true; }
 
@@ skipping 270 matching lines @@
       Isolate* isolate, bool opt) const {                                     \
     UNIMPLEMENTED();                                                          \
     return NULL;                                                              \
   }                                                                           \
   void Name::EmitNativeCode(FlowGraphCompiler* compiler) { UNIMPLEMENTED(); }
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_