Reapply "Shuffle around deopt id allocation...

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 RUNTIME_VM_INTERMEDIATE_LANGUAGE_H_
 #define RUNTIME_VM_INTERMEDIATE_LANGUAGE_H_
 
 #include "vm/allocation.h"
 #include "vm/ast.h"
 #include "vm/growable_array.h"
@@ skipping 1244 matching lines @@
   intptr_t offset() const { return offset_; }
   void set_offset(intptr_t offset) { offset_ = offset; }
 
   // 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)
-      : Instruction(Thread::Current()->GetNextDeoptId()),
+  BlockEntryInstr(intptr_t block_id, intptr_t try_index, intptr_t deopt_id)
+      : Instruction(deopt_id),
         block_id_(block_id),
         try_index_(try_index),
         preorder_number_(-1),
         postorder_number_(-1),
         dominator_(NULL),
         dominated_blocks_(1),
         last_instruction_(NULL),
         offset_(-1),
         parallel_move_(NULL),
         loop_info_(NULL) {}
@@ skipping 158 matching lines @@
   intptr_t entry_count_;
   intptr_t spill_slot_count_;
   intptr_t fixed_slot_count_;  // For try-catch in optimized code.
 
   DISALLOW_COPY_AND_ASSIGN(GraphEntryInstr);
 };
 
 
 class JoinEntryInstr : public BlockEntryInstr {
  public:
-  JoinEntryInstr(intptr_t block_id, intptr_t try_index)
-      : BlockEntryInstr(block_id, try_index),
+  JoinEntryInstr(intptr_t block_id, intptr_t try_index, intptr_t deopt_id)
+      : BlockEntryInstr(block_id, try_index, deopt_id),
         predecessors_(2),  // Two is the assumed to be the common case.
         phis_(NULL) {}
 
   DECLARE_INSTRUCTION(JoinEntry)
 
   virtual intptr_t PredecessorCount() const { return predecessors_.length(); }
   virtual BlockEntryInstr* PredecessorAt(intptr_t index) const {
     return predecessors_[index];
   }
 
@@ skipping 48 matching lines @@
   PhiInstr* Current() const { return (*phis_)[index_]; }
 
  private:
   ZoneGrowableArray<PhiInstr*>* phis_;
   intptr_t index_;
 };
 
 
 class TargetEntryInstr : public BlockEntryInstr {
  public:
-  TargetEntryInstr(intptr_t block_id, intptr_t try_index)
-      : BlockEntryInstr(block_id, try_index),
+  TargetEntryInstr(intptr_t block_id, intptr_t try_index, intptr_t deopt_id)
+      : BlockEntryInstr(block_id, try_index, deopt_id),
         predecessor_(NULL),
         edge_weight_(0.0) {}
 
   DECLARE_INSTRUCTION(TargetEntry)
 
   double edge_weight() const { return edge_weight_; }
   void set_edge_weight(double weight) { edge_weight_ = weight; }
   void adjust_edge_weight(double scale_factor) { edge_weight_ *= scale_factor; }
 
   virtual intptr_t PredecessorCount() const {
@@ skipping 19 matching lines @@
   double edge_weight_;
 
   DISALLOW_COPY_AND_ASSIGN(TargetEntryInstr);
 };
 
 
 class IndirectEntryInstr : public JoinEntryInstr {
  public:
   IndirectEntryInstr(intptr_t block_id,
                      intptr_t indirect_id,
-                     intptr_t try_index)
-      : JoinEntryInstr(block_id, try_index), indirect_id_(indirect_id) {}
+                     intptr_t try_index,
+                     intptr_t deopt_id)
+      : JoinEntryInstr(block_id, try_index, deopt_id),
+        indirect_id_(indirect_id) {}
 
   DECLARE_INSTRUCTION(IndirectEntry)
 
   intptr_t indirect_id() const { return indirect_id_; }
 
   PRINT_TO_SUPPORT
 
  private:
   const intptr_t indirect_id_;
 };
 
 
 class CatchBlockEntryInstr : public BlockEntryInstr {
  public:
   CatchBlockEntryInstr(TokenPosition handler_token_pos,
                        bool is_generated,
                        intptr_t block_id,
                        intptr_t try_index,
                        GraphEntryInstr* graph_entry,
                        const Array& handler_types,
                        intptr_t catch_try_index,
                        const LocalVariable& exception_var,
                        const LocalVariable& stacktrace_var,
                        bool needs_stacktrace,
                        intptr_t deopt_id,
                        bool should_restore_closure_context = false)
-      : BlockEntryInstr(block_id, try_index),
+      : BlockEntryInstr(block_id, try_index, deopt_id),
         graph_entry_(graph_entry),
         predecessor_(NULL),
         catch_handler_types_(Array::ZoneHandle(handler_types.raw())),
         catch_try_index_(catch_try_index),
         exception_var_(exception_var),
         stacktrace_var_(stacktrace_var),
         needs_stacktrace_(needs_stacktrace),
         should_restore_closure_context_(should_restore_closure_context),
         handler_token_pos_(handler_token_pos),
-        is_generated_(is_generated) {
-    deopt_id_ = deopt_id;
-  }
+        is_generated_(is_generated) {}
 
   DECLARE_INSTRUCTION(CatchBlockEntry)
 
   virtual intptr_t PredecessorCount() const {
     return (predecessor_ == NULL) ? 0 : 1;
   }
   virtual BlockEntryInstr* PredecessorAt(intptr_t index) const {
     ASSERT((index == 0) && (predecessor_ != NULL));
     return predecessor_;
   }
@@ skipping 494 matching lines @@
 };
 
 
 inline Definition* Instruction::ArgumentAt(intptr_t index) const {
   return PushArgumentAt(index)->value()->definition();
 }
 
 
 class ReturnInstr : public TemplateInstruction<1, NoThrow> {
  public:
-  ReturnInstr(TokenPosition token_pos, Value* value)
-      : TemplateInstruction(Thread::Current()->GetNextDeoptId()),
-        token_pos_(token_pos) {
+  ReturnInstr(TokenPosition token_pos, Value* value, intptr_t deopt_id)
+      : TemplateInstruction(deopt_id), token_pos_(token_pos) {
     SetInputAt(0, value);
   }
 
   DECLARE_INSTRUCTION(Return)
 
   virtual TokenPosition token_pos() const { return token_pos_; }
   Value* value() const { return inputs_[0]; }
 
   virtual bool CanBecomeDeoptimizationTarget() const {
     // Return instruction might turn into a Goto instruction after inlining.
     // Every Goto must have an environment.
     return true;
   }
 
   virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
  private:
   const TokenPosition token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(ReturnInstr);
 };
 
 
 class ThrowInstr : public TemplateInstruction<0, Throws> {
  public:
-  explicit ThrowInstr(TokenPosition token_pos)
-      : TemplateInstruction(Thread::Current()->GetNextDeoptId()),
-        token_pos_(token_pos) {}
+  explicit ThrowInstr(TokenPosition token_pos, intptr_t deopt_id)
+      : TemplateInstruction(deopt_id), token_pos_(token_pos) {}
 
   DECLARE_INSTRUCTION(Throw)
 
   virtual intptr_t ArgumentCount() const { return 1; }
 
   virtual TokenPosition token_pos() const { return token_pos_; }
 
   virtual bool ComputeCanDeoptimize() const { return true; }
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
  private:
   const TokenPosition token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(ThrowInstr);
 };
 
 
 class ReThrowInstr : public TemplateInstruction<0, Throws> {
  public:
   // 'catch_try_index' can be CatchClauseNode::kInvalidTryIndex if the
   // rethrow has been artificially generated by the parser.
-  ReThrowInstr(TokenPosition token_pos, intptr_t catch_try_index)
-      : TemplateInstruction(Thread::Current()->GetNextDeoptId()),
+  ReThrowInstr(TokenPosition token_pos,
+               intptr_t catch_try_index,
+               intptr_t deopt_id)
+      : TemplateInstruction(deopt_id),
         token_pos_(token_pos),
         catch_try_index_(catch_try_index) {}
 
   DECLARE_INSTRUCTION(ReThrow)
 
   virtual intptr_t ArgumentCount() const { return 2; }
 
   virtual TokenPosition token_pos() const { return token_pos_; }
   intptr_t catch_try_index() const { return catch_try_index_; }
 
@@ skipping 29 matching lines @@
 
  private:
   const char* message_;
 
   DISALLOW_COPY_AND_ASSIGN(StopInstr);
 };
 
 
 class GotoInstr : public TemplateInstruction<0, NoThrow> {
  public:
-  explicit GotoInstr(JoinEntryInstr* entry)
-      : TemplateInstruction(Thread::Current()->GetNextDeoptId()),
+  explicit GotoInstr(JoinEntryInstr* entry, intptr_t deopt_id)
+      : TemplateInstruction(deopt_id),
         block_(NULL),
         successor_(entry),
         edge_weight_(0.0),
         parallel_move_(NULL) {}
 
   DECLARE_INSTRUCTION(Goto)
 
   BlockEntryInstr* block() const { return block_; }
   void set_block(BlockEntryInstr* block) { block_ = block; }
 
@@ skipping 192 matching lines @@
  protected:
   EmbeddedArray<Value*, N> inputs_;
 
  private:
   virtual void RawSetInputAt(intptr_t i, Value* value) { inputs_[i] = value; }
 };
 
 
 class BranchInstr : public Instruction {
  public:
-  explicit BranchInstr(ComparisonInstr* comparison)
-      : Instruction(Thread::Current()->GetNextDeoptId()),
-        comparison_(comparison),
-        constant_target_(NULL) {
+  explicit BranchInstr(ComparisonInstr* comparison, intptr_t deopt_id)
+      : Instruction(deopt_id), comparison_(comparison), constant_target_(NULL) {
     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 258 matching lines @@
   const TokenPosition token_pos_;
   AbstractType& dst_type_;
   const String& dst_name_;
 
   DISALLOW_COPY_AND_ASSIGN(AssertAssignableInstr);
 };
 
 
 class AssertBooleanInstr : public TemplateDefinition<1, Throws, Pure> {
  public:
-  AssertBooleanInstr(TokenPosition token_pos, Value* value)
-      : TemplateDefinition(Thread::Current()->GetNextDeoptId()),
-        token_pos_(token_pos) {
+  AssertBooleanInstr(TokenPosition token_pos, Value* value, intptr_t deopt_id)
+      : TemplateDefinition(deopt_id), token_pos_(token_pos) {
     SetInputAt(0, value);
   }
 
   DECLARE_INSTRUCTION(AssertBoolean)
   virtual CompileType ComputeType() const;
 
   virtual TokenPosition token_pos() const { return token_pos_; }
   Value* value() const { return inputs_[0]; }
 
   virtual bool ComputeCanDeoptimize() const { return true; }
 
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
 
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
   PRINT_OPERANDS_TO_SUPPORT
 
  private:
   const TokenPosition token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(AssertBooleanInstr);
 };
 
 
 // Denotes the current context, normally held in a register.  This is
 // a computation, not a value, because it's mutable.
 class CurrentContextInstr : public TemplateDefinition<0, NoThrow> {
  public:
-  CurrentContextInstr()
-      : TemplateDefinition(Thread::Current()->GetNextDeoptId()) {}
+  explicit CurrentContextInstr(intptr_t deopt_id)
+      : TemplateDefinition(deopt_id) {}
 
   DECLARE_INSTRUCTION(CurrentContext)
   virtual CompileType ComputeType() const;
 
   virtual bool ComputeCanDeoptimize() 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; }
 
@@ skipping 62 matching lines @@
   TokenPosition token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(TemplateDartCall);
 };
 
 
 class ClosureCallInstr : public TemplateDartCall<1> {
  public:
   ClosureCallInstr(Value* function,
                    ClosureCallNode* node,
-                   ZoneGrowableArray<PushArgumentInstr*>* arguments)
-      : TemplateDartCall(Thread::Current()->GetNextDeoptId(),
+                   ZoneGrowableArray<PushArgumentInstr*>* arguments,
+                   intptr_t deopt_id)
+      : TemplateDartCall(deopt_id,
                          node->arguments()->type_args_len(),
                          node->arguments()->names(),
                          arguments,
                          node->token_pos()) {
     ASSERT(!arguments->is_empty());
     SetInputAt(0, function);
   }
 
   ClosureCallInstr(Value* function,
                    ZoneGrowableArray<PushArgumentInstr*>* arguments,
                    intptr_t type_args_len,
                    const Array& argument_names,
-                   TokenPosition token_pos)
-      : TemplateDartCall(Thread::Current()->GetNextDeoptId(),
+                   TokenPosition token_pos,
+                   intptr_t deopt_id)
+      : TemplateDartCall(deopt_id,
                          type_args_len,
                          argument_names,
                          arguments,
                          token_pos) {
     ASSERT(!arguments->is_empty());
     SetInputAt(0, function);
   }
 
   DECLARE_INSTRUCTION(ClosureCall)
 
@@ skipping 13 matching lines @@
 
 class InstanceCallInstr : public TemplateDartCall<0> {
  public:
   InstanceCallInstr(TokenPosition token_pos,
                     const String& function_name,
                     Token::Kind token_kind,
                     ZoneGrowableArray<PushArgumentInstr*>* arguments,
                     intptr_t type_args_len,
                     const Array& argument_names,
                     intptr_t checked_argument_count,
-                    const ZoneGrowableArray<const ICData*>& ic_data_array)
-      : TemplateDartCall(Thread::Current()->GetNextDeoptId(),
+                    const ZoneGrowableArray<const ICData*>& ic_data_array,
+                    intptr_t deopt_id)
+      : TemplateDartCall(deopt_id,
                          type_args_len,
                          argument_names,
                          arguments,
                          token_pos),
         ic_data_(NULL),
         function_name_(function_name),
         token_kind_(token_kind),
         checked_argument_count_(checked_argument_count),
         has_unique_selector_(false) {
     ic_data_ = GetICData(ic_data_array);
@@ skipping 137 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(PolymorphicInstanceCallInstr);
 };
 
 
 class StrictCompareInstr : public TemplateComparison<2, NoThrow, Pure> {
  public:
   StrictCompareInstr(TokenPosition token_pos,
                      Token::Kind kind,
                      Value* left,
                      Value* right,
-                     bool needs_number_check);
+                     bool needs_number_check,
+                     intptr_t deopt_id);
 
   DECLARE_INSTRUCTION(StrictCompare)
 
   virtual ComparisonInstr* CopyWithNewOperands(Value* left, Value* right);
 
   virtual CompileType ComputeType() const;
 
   virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual Definition* Canonicalize(FlowGraph* flow_graph);
@@ skipping 191 matching lines @@
 
  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)
-      : Definition(Thread::Current()->GetNextDeoptId()),
+  IfThenElseInstr(ComparisonInstr* comparison,
+                  Value* if_true,
+                  Value* if_false,
+                  intptr_t deopt_id)
+      : Definition(deopt_id),
         comparison_(comparison),
         if_true_(Smi::Cast(if_true->BoundConstant()).Value()),
         if_false_(Smi::Cast(if_false->BoundConstant()).Value()) {
     // 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);
     }
   }
 
@@ skipping 61 matching lines @@
 };
 
 
 class StaticCallInstr : public TemplateDartCall<0> {
  public:
   StaticCallInstr(TokenPosition token_pos,
                   const Function& function,
                   intptr_t type_args_len,
                   const Array& argument_names,
                   ZoneGrowableArray<PushArgumentInstr*>* arguments,
-                  const ZoneGrowableArray<const ICData*>& ic_data_array)
-      : TemplateDartCall(Thread::Current()->GetNextDeoptId(),
+                  const ZoneGrowableArray<const ICData*>& ic_data_array,
+                  intptr_t deopt_id)
+      : TemplateDartCall(deopt_id,
                          type_args_len,
                          argument_names,
                          arguments,
                          token_pos),
         ic_data_(NULL),
         call_count_(0),
         function_(function),
         result_cid_(kDynamicCid),
         is_known_list_constructor_(false),
         identity_(AliasIdentity::Unknown()) {
@@ skipping 699 matching lines @@
 
  private:
   const intptr_t cid_;
 
   DISALLOW_COPY_AND_ASSIGN(StringToCharCodeInstr);
 };
 
 
 class StringInterpolateInstr : public TemplateDefinition<1, Throws> {
  public:
-  StringInterpolateInstr(Value* value, TokenPosition token_pos)
-      : TemplateDefinition(Thread::Current()->GetNextDeoptId()),
+  StringInterpolateInstr(Value* value,
+                         TokenPosition token_pos,
+                         intptr_t deopt_id)
+      : TemplateDefinition(deopt_id),
         token_pos_(token_pos),
         function_(Function::ZoneHandle()) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
   virtual TokenPosition token_pos() const { return token_pos_; }
 
   virtual CompileType ComputeType() const;
   // Issues a static call to Dart code which calls toString on objects.
@@ skipping 314 matching lines @@
   bool registers_remapped_;
 
   DISALLOW_COPY_AND_ASSIGN(MaterializeObjectInstr);
 };
 
 
 class CreateArrayInstr : public TemplateDefinition<2, Throws> {
  public:
   CreateArrayInstr(TokenPosition token_pos,
                    Value* element_type,
-                   Value* num_elements)
-      : TemplateDefinition(Thread::Current()->GetNextDeoptId()),
+                   Value* num_elements,
+                   intptr_t deopt_id)
+      : TemplateDefinition(deopt_id),
         token_pos_(token_pos),
         identity_(AliasIdentity::Unknown()) {
     SetInputAt(kElementTypePos, element_type);
     SetInputAt(kLengthPos, num_elements);
   }
 
   enum { kElementTypePos = 0, kLengthPos = 1 };
 
   DECLARE_INSTRUCTION(CreateArray)
   virtual CompileType ComputeType() const;
@@ skipping 187 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(LoadFieldInstr);
 };
 
 
 class InstantiateTypeInstr : public TemplateDefinition<2, Throws> {
  public:
   InstantiateTypeInstr(TokenPosition token_pos,
                        const AbstractType& type,
                        Value* instantiator_type_arguments,
-                       Value* function_type_arguments)
-      : TemplateDefinition(Thread::Current()->GetNextDeoptId()),
-        token_pos_(token_pos),
-        type_(type) {
+                       Value* function_type_arguments,
+                       intptr_t deopt_id)
+      : TemplateDefinition(deopt_id), token_pos_(token_pos), type_(type) {
     ASSERT(type.IsZoneHandle() || type.IsReadOnlyHandle());
     SetInputAt(0, instantiator_type_arguments);
     SetInputAt(1, function_type_arguments);
   }
 
   DECLARE_INSTRUCTION(InstantiateType)
 
   Value* instantiator_type_arguments() const { return inputs_[0]; }
   Value* function_type_arguments() const { return inputs_[1]; }
   const AbstractType& type() const { return type_; }
@@ skipping 12 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(InstantiateTypeInstr);
 };
 
 
 class InstantiateTypeArgumentsInstr : public TemplateDefinition<2, Throws> {
  public:
   InstantiateTypeArgumentsInstr(TokenPosition token_pos,
                                 const TypeArguments& type_arguments,
                                 const Class& instantiator_class,
                                 Value* instantiator_type_arguments,
-                                Value* function_type_arguments)
-      : TemplateDefinition(Thread::Current()->GetNextDeoptId()),
+                                Value* function_type_arguments,
+                                intptr_t deopt_id)
+      : TemplateDefinition(deopt_id),
         token_pos_(token_pos),
         type_arguments_(type_arguments),
         instantiator_class_(instantiator_class) {
     ASSERT(type_arguments.IsZoneHandle());
     SetInputAt(0, instantiator_type_arguments);
     SetInputAt(1, function_type_arguments);
   }
 
   DECLARE_INSTRUCTION(InstantiateTypeArguments)
 
@@ skipping 40 matching lines @@
  private:
   const TokenPosition token_pos_;
   const intptr_t num_context_variables_;
 
   DISALLOW_COPY_AND_ASSIGN(AllocateContextInstr);
 };
 
 
 class InitStaticFieldInstr : public TemplateInstruction<1, Throws> {
  public:
-  InitStaticFieldInstr(Value* input, const Field& field)
-      : TemplateInstruction(Thread::Current()->GetNextDeoptId()),
-        field_(field) {
+  InitStaticFieldInstr(Value* input, const Field& field, intptr_t deopt_id)
+      : TemplateInstruction(deopt_id), field_(field) {
     SetInputAt(0, input);
     CheckField(field);
   }
 
   virtual TokenPosition token_pos() const { return field_.token_pos(); }
   const Field& field() const { return field_; }
 
   DECLARE_INSTRUCTION(InitStaticField)
 
   virtual bool ComputeCanDeoptimize() const { return true; }
   virtual EffectSet Effects() const { return EffectSet::All(); }
   virtual Instruction* Canonicalize(FlowGraph* flow_graph);
 
  private:
   const Field& field_;
 
   DISALLOW_COPY_AND_ASSIGN(InitStaticFieldInstr);
 };
 
 
 class CloneContextInstr : public TemplateDefinition<1, NoThrow> {
  public:
-  CloneContextInstr(TokenPosition token_pos, Value* context_value)
-      : TemplateDefinition(Thread::Current()->GetNextDeoptId()),
-        token_pos_(token_pos) {
+  CloneContextInstr(TokenPosition token_pos,
+                    Value* context_value,
+                    intptr_t deopt_id)
+      : TemplateDefinition(deopt_id), token_pos_(token_pos) {
     SetInputAt(0, context_value);
   }
 
   virtual TokenPosition token_pos() const { return token_pos_; }
   Value* context_value() const { return inputs_[0]; }
 
   DECLARE_INSTRUCTION(CloneContext)
   virtual CompileType ComputeType() const;
 
   virtual bool ComputeCanDeoptimize() const { return true; }
@@ skipping 2514 matching lines @@
 
  private:
   const Token::Kind op_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(UnaryDoubleOpInstr);
 };
 
 
 class CheckStackOverflowInstr : public TemplateInstruction<0, NoThrow> {
  public:
-  CheckStackOverflowInstr(TokenPosition token_pos, intptr_t loop_depth)
-      : TemplateInstruction(Thread::Current()->GetNextDeoptId()),
+  CheckStackOverflowInstr(TokenPosition token_pos,
+                          intptr_t loop_depth,
+                          intptr_t deopt_id)
+      : TemplateInstruction(deopt_id),
         token_pos_(token_pos),
         loop_depth_(loop_depth) {}
 
   virtual TokenPosition 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 bool ComputeCanDeoptimize() const { return true; }
@@ skipping 952 matching lines @@
   LocationSummary* Name::MakeLocationSummary(Zone* zone, bool opt) const {     \
     UNIMPLEMENTED();                                                           \
     return NULL;                                                               \
   }                                                                            \
   void Name::EmitNativeCode(FlowGraphCompiler* compiler) { UNIMPLEMENTED(); }
 
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_INTERMEDIATE_LANGUAGE_H_