Revert "Shuffle around deopt id allocation to give the flow graph builder a chance to record other …

runtime/vm/flow_graph_builder.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/flow_graph_builder.h"
 
 #include "lib/invocation_mirror.h"
 #include "vm/ast_printer.h"
 #include "vm/bit_vector.h"
 #include "vm/compiler.h"
@@ skipping 155 matching lines @@
 
 
 intptr_t FlowGraphBuilder::context_level() const {
   return (nesting_stack() == NULL) ? 0 : nesting_stack()->ContextLevel();
 }
 
 
 JoinEntryInstr* NestedStatement::BreakTargetFor(SourceLabel* label) {
   if (label != label_) return NULL;
   if (break_target_ == NULL) {
-    break_target_ = new (owner()->zone()) JoinEntryInstr(
-        owner()->AllocateBlockId(), try_index(), owner()->GetNextDeoptId());
+    break_target_ = new (owner()->zone())
+        JoinEntryInstr(owner()->AllocateBlockId(), try_index());
   }
   return break_target_;
 }
 
 
 JoinEntryInstr* NestedStatement::ContinueTargetFor(SourceLabel* label) {
   return NULL;
 }
 
 
@@ skipping 51 matching lines @@
   virtual JoinEntryInstr* ContinueTargetFor(SourceLabel* label);
 
  private:
   JoinEntryInstr* continue_target_;
 };
 
 
 JoinEntryInstr* NestedLoop::ContinueTargetFor(SourceLabel* label) {
   if (label != this->label()) return NULL;
   if (continue_target_ == NULL) {
-    continue_target_ = new (owner()->zone()) JoinEntryInstr(
-        owner()->AllocateBlockId(), try_index(), owner()->GetNextDeoptId());
+    continue_target_ = new (owner()->zone())
+        JoinEntryInstr(owner()->AllocateBlockId(), try_index());
   }
   return continue_target_;
 }
 
 
 // A nested switch which can be the target of a break if labeled, and whose
 // cases can be the targets of continues.
 class NestedSwitch : public NestedStatement {
  public:
   NestedSwitch(FlowGraphBuilder* owner, SwitchNode* node);
@@ skipping 21 matching lines @@
 }
 
 
 JoinEntryInstr* NestedSwitch::ContinueTargetFor(SourceLabel* label) {
   // Allocate a join for a case clause that matches the label.  This block
   // is not necessarily targeted by a continue, but we always use a join in
   // the graph anyway.
   for (intptr_t i = 0; i < case_labels_.length(); ++i) {
     if (label != case_labels_[i]) continue;
     if (case_targets_[i] == NULL) {
-      case_targets_[i] = new (owner()->zone()) JoinEntryInstr(
-          owner()->AllocateBlockId(), try_index(), owner()->GetNextDeoptId());
+      case_targets_[i] = new (owner()->zone())
+          JoinEntryInstr(owner()->AllocateBlockId(), try_index());
     }
     return case_targets_[i];
   }
   return NULL;
 }
 
 
 FlowGraphBuilder::FlowGraphBuilder(
     const ParsedFunction& parsed_function,
     const ZoneGrowableArray<const ICData*>& ic_data_array,
@@ skipping 131 matching lines @@
   if (num_exits == 1) {
     ReturnAt(0)->UnuseAllInputs();
     *exit_block = ExitBlockAt(0);
     *last_instruction = LastInstructionAt(0);
     return call_->HasUses() ? ValueAt(0)->definition() : NULL;
   } else {
     ASSERT(num_exits > 1);
     // Create a join of the returns.
     intptr_t join_id = caller_graph_->max_block_id() + 1;
     caller_graph_->set_max_block_id(join_id);
-    JoinEntryInstr* join = new (Z)
-        JoinEntryInstr(join_id, try_index, Thread::Current()->GetNextDeoptId());
+    JoinEntryInstr* join = new (Z) JoinEntryInstr(join_id, try_index);
 
     // The dominator set of the join is the intersection of the dominator
     // sets of all the predecessors.  If we keep the dominator sets ordered
     // by height in the dominator tree, we can also get the immediate
     // dominator of the join node from the intersection.
     //
     // block_dominators is the dominator set for each block, ordered from
     // the immediate dominator to the root of the dominator tree.  This is
     // the order we collect them in (adding at the end).
     //
     // join_dominators is the join's dominators ordered from the root of the
     // dominator tree to the immediate dominator.  This order supports
     // removing during intersection by truncating the list.
     GrowableArray<BlockEntryInstr*> block_dominators;
     GrowableArray<BlockEntryInstr*> join_dominators;
     for (intptr_t i = 0; i < num_exits; ++i) {
       // Add the control-flow edge.
-      GotoInstr* goto_instr =
-          new (Z) GotoInstr(join, Thread::Current()->GetNextDeoptId());
+      GotoInstr* goto_instr = new (Z) GotoInstr(join);
       goto_instr->InheritDeoptTarget(zone(), ReturnAt(i));
       LastInstructionAt(i)->LinkTo(goto_instr);
       ExitBlockAt(i)->set_last_instruction(LastInstructionAt(i)->next());
       join->predecessors_.Add(ExitBlockAt(i));
 
       // Collect the block's dominators.
       block_dominators.Clear();
       BlockEntryInstr* dominator = ExitBlockAt(i)->dominator();
       while (dominator != NULL) {
         block_dominators.Add(dominator);
@@ skipping 65 matching lines @@
   Instruction* callee_last_instruction = NULL;
 
   if (exits_.length() == 0) {
     // Handle the case when there are no normal return exits from the callee
     // (i.e. the callee unconditionally throws) by inserting an artificial
     // branch (true === true).
     // The true successor is the inlined body, the false successor
     // goes to the rest of the caller graph. It is removed as unreachable code
     // by the constant propagation.
     TargetEntryInstr* false_block = new (Z) TargetEntryInstr(
-        caller_graph_->allocate_block_id(), call_block->try_index(),
-        Thread::Current()->GetNextDeoptId());
+        caller_graph_->allocate_block_id(), call_block->try_index());
     false_block->InheritDeoptTargetAfter(caller_graph_, call_, NULL);
     false_block->LinkTo(call_->next());
     call_block->ReplaceAsPredecessorWith(false_block);
 
     ConstantInstr* true_const = caller_graph_->GetConstant(Bool::True());
-    BranchInstr* branch = new (Z)
-        BranchInstr(new (Z) StrictCompareInstr(
-                        TokenPosition::kNoSource, Token::kEQ_STRICT,
-                        new (Z) Value(true_const), new (Z) Value(true_const),
-                        false, Thread::Current()->GetNextDeoptId()),
-                    Thread::Current()->GetNextDeoptId());  // No number check.
+    BranchInstr* branch = new (Z) BranchInstr(new (Z) StrictCompareInstr(
+        TokenPosition::kNoSource, Token::kEQ_STRICT, new (Z) Value(true_const),
+        new (Z) Value(true_const),
+        false));  // No number check.
     branch->InheritDeoptTarget(zone(), call_);
     *branch->true_successor_address() = callee_entry;
     *branch->false_successor_address() = false_block;
 
     call_->previous()->AppendInstruction(branch);
     call_block->set_last_instruction(branch);
 
     // Replace uses of the return value with null to maintain valid
     // SSA form - even though the rest of the caller is unreachable.
     call_->ReplaceUsesWith(caller_graph_->constant_null());
@@ skipping 123 matching lines @@
     entry_ = exit_ = instruction;
   } else {
     exit()->LinkTo(instruction);
     exit_ = instruction;
   }
 }
 
 
 void EffectGraphVisitor::AddReturnExit(TokenPosition token_pos, Value* value) {
   ASSERT(is_open());
-  ReturnInstr* return_instr =
-      new (Z) ReturnInstr(token_pos, value, owner()->GetNextDeoptId());
+  ReturnInstr* return_instr = new (Z) ReturnInstr(token_pos, value);
   AddInstruction(return_instr);
   InlineExitCollector* exit_collector = owner()->exit_collector();
   if (exit_collector != NULL) {
     exit_collector->AddExit(return_instr);
   }
   CloseFragment();
 }
 
 
 void EffectGraphVisitor::Goto(JoinEntryInstr* join) {
   ASSERT(is_open());
   if (is_empty()) {
-    entry_ = new (Z) GotoInstr(join, owner()->GetNextDeoptId());
+    entry_ = new (Z) GotoInstr(join);
   } else {
     exit()->Goto(join);
   }
   CloseFragment();
 }
 
 
 // Appends a graph fragment to a block entry instruction.  Returns the entry
 // instruction if the fragment was empty or else the exit of the fragment if
 // it was non-empty (so NULL if the fragment is closed).
@@ skipping 28 matching lines @@
 
   BlockEntryInstr* false_entry = test_fragment.CreateFalseSuccessor();
   Instruction* false_exit = AppendFragment(false_entry, false_fragment);
 
   // 3. Add a join or select one (or neither) of the arms as exit.
   if (true_exit == NULL) {
     exit_ = false_exit;  // May be NULL.
   } else if (false_exit == NULL) {
     exit_ = true_exit;
   } else {
-    JoinEntryInstr* join =
-        new (Z) JoinEntryInstr(owner()->AllocateBlockId(), owner()->try_index(),
-                               owner()->GetNextDeoptId());
+    JoinEntryInstr* join = new (Z)
+        JoinEntryInstr(owner()->AllocateBlockId(), owner()->try_index());
     true_exit->Goto(join);
     false_exit->Goto(join);
     exit_ = join;
   }
 }
 
 
 void EffectGraphVisitor::TieLoop(
     TokenPosition token_pos,
     const TestGraphVisitor& test_fragment,
     const EffectGraphVisitor& body_fragment,
     const EffectGraphVisitor& test_preamble_fragment) {
   // We have: a test graph fragment with zero, one, or two available exits;
   // and an effect graph fragment with zero or one available exits.  We want
   // to append the 'while loop' consisting of the test graph fragment as
   // condition and the effect graph fragment as body.
   ASSERT(is_open());
 
   // 1. Connect the body to the test if it is reachable, and if so record
   // its exit (if any).
   BlockEntryInstr* body_entry = test_fragment.CreateTrueSuccessor();
   Instruction* body_exit = AppendFragment(body_entry, body_fragment);
 
   // 2. Connect the test to this graph, including the body if reachable and
   // using a fresh join node if the body is reachable and has an open exit.
   if (body_exit == NULL) {
     Append(test_preamble_fragment);
     Append(test_fragment);
   } else {
-    JoinEntryInstr* join =
-        new (Z) JoinEntryInstr(owner()->AllocateBlockId(), owner()->try_index(),
-                               owner()->GetNextDeoptId());
-    CheckStackOverflowInstr* check = new (Z) CheckStackOverflowInstr(
-        token_pos, owner()->loop_depth(), owner()->GetNextDeoptId());
+    JoinEntryInstr* join = new (Z)
+        JoinEntryInstr(owner()->AllocateBlockId(), owner()->try_index());
+    CheckStackOverflowInstr* check =
+        new (Z) CheckStackOverflowInstr(token_pos, owner()->loop_depth());
     join->LinkTo(check);
     if (!test_preamble_fragment.is_empty()) {
       check->LinkTo(test_preamble_fragment.entry());
       test_preamble_fragment.exit()->LinkTo(test_fragment.entry());
     } else {
       check->LinkTo(test_fragment.entry());
     }
     Goto(join);
     body_exit->Goto(join);
   }
@@ skipping 113 matching lines @@
       *owner()->parsed_function().current_context_var(), token_pos);
 }
 
 
 void TestGraphVisitor::ConnectBranchesTo(
     const GrowableArray<TargetEntryInstr**>& branches,
     JoinEntryInstr* join) const {
   ASSERT(!branches.is_empty());
   for (intptr_t i = 0; i < branches.length(); i++) {
     TargetEntryInstr* target = new (Z)
-        TargetEntryInstr(owner()->AllocateBlockId(), owner()->try_index(),
-                         owner()->GetNextDeoptId());
+        TargetEntryInstr(owner()->AllocateBlockId(), owner()->try_index());
     *(branches[i]) = target;
     target->Goto(join);
   }
 }
 
 
 void TestGraphVisitor::IfTrueGoto(JoinEntryInstr* join) const {
   ConnectBranchesTo(true_successor_addresses_, join);
 }
 
 
 void TestGraphVisitor::IfFalseGoto(JoinEntryInstr* join) const {
   ConnectBranchesTo(false_successor_addresses_, join);
 }
 
 
 BlockEntryInstr* TestGraphVisitor::CreateSuccessorFor(
     const GrowableArray<TargetEntryInstr**>& branches) const {
   ASSERT(!branches.is_empty());
 
   if (branches.length() == 1) {
     TargetEntryInstr* target = new (Z)
-        TargetEntryInstr(owner()->AllocateBlockId(), owner()->try_index(),
-                         owner()->GetNextDeoptId());
+        TargetEntryInstr(owner()->AllocateBlockId(), owner()->try_index());
     *(branches[0]) = target;
     return target;
   }
 
   JoinEntryInstr* join =
-      new (Z) JoinEntryInstr(owner()->AllocateBlockId(), owner()->try_index(),
-                             owner()->GetNextDeoptId());
+      new (Z) JoinEntryInstr(owner()->AllocateBlockId(), owner()->try_index());
   ConnectBranchesTo(branches, join);
   return join;
 }
 
 
 BlockEntryInstr* TestGraphVisitor::CreateTrueSuccessor() const {
   return CreateSuccessorFor(true_successor_addresses_);
 }
 
 
 BlockEntryInstr* TestGraphVisitor::CreateFalseSuccessor() const {
   return CreateSuccessorFor(false_successor_addresses_);
 }
 
 
 void TestGraphVisitor::ReturnValue(Value* value) {
   Isolate* isolate = Isolate::Current();
   if (isolate->type_checks() || isolate->asserts()) {
-    value = Bind(new (Z) AssertBooleanInstr(condition_token_pos(), value,
-                                            owner()->GetNextDeoptId()));
+    value = Bind(new (Z) AssertBooleanInstr(condition_token_pos(), value));
   }
   Value* constant_true = Bind(new (Z) ConstantInstr(Bool::True()));
   StrictCompareInstr* comp = new (Z) StrictCompareInstr(
-      condition_token_pos(), Token::kEQ_STRICT, value, constant_true, false,
-      owner()->GetNextDeoptId());  // No number check.
-  BranchInstr* branch = new (Z) BranchInstr(comp, owner()->GetNextDeoptId());
+      condition_token_pos(), Token::kEQ_STRICT, value, constant_true,
+      false);  // No number check.
+  BranchInstr* branch = new (Z) BranchInstr(comp);
   AddInstruction(branch);
   CloseFragment();
 
   true_successor_addresses_.Add(branch->true_successor_address());
   false_successor_addresses_.Add(branch->false_successor_address());
 }
 
 
 void TestGraphVisitor::MergeBranchWithStrictCompare(StrictCompareInstr* comp) {
-  BranchInstr* branch = new (Z) BranchInstr(comp, owner()->GetNextDeoptId());
+  BranchInstr* branch = new (Z) BranchInstr(comp);
   AddInstruction(branch);
   CloseFragment();
   true_successor_addresses_.Add(branch->true_successor_address());
   false_successor_addresses_.Add(branch->false_successor_address());
 }
 
 
 void TestGraphVisitor::MergeBranchWithNegate(BooleanNegateInstr* neg) {
   ASSERT(!Isolate::Current()->type_checks());
   Value* constant_true = Bind(new (Z) ConstantInstr(Bool::True()));
   StrictCompareInstr* comp = new (Z) StrictCompareInstr(
       condition_token_pos(), Token::kNE_STRICT, neg->value(), constant_true,
-      false, owner()->GetNextDeoptId());  // No number check.
-  BranchInstr* branch = new (Z) BranchInstr(comp, owner()->GetNextDeoptId());
+      false);  // No number check.
+  BranchInstr* branch = new (Z) BranchInstr(comp);
   AddInstruction(branch);
   CloseFragment();
   true_successor_addresses_.Add(branch->true_successor_address());
   false_successor_addresses_.Add(branch->false_successor_address());
 }
 
 
 void TestGraphVisitor::ReturnDefinition(Definition* definition) {
   StrictCompareInstr* comp = definition->AsStrictCompare();
   if (comp != NULL) {
@@ skipping 113 matching lines @@
 
   if (FLAG_causal_async_stacks &&
       (function.IsAsyncClosure() || function.IsAsyncGenClosure())) {
     // We are returning from an asynchronous closure. Before we do that, be
     // sure to clear the thread's asynchronous stack trace.
     const Function& async_clear_thread_stack_trace = Function::ZoneHandle(
         Z, isolate()->object_store()->async_clear_thread_stack_trace());
     ZoneGrowableArray<PushArgumentInstr*>* no_arguments =
         new (Z) ZoneGrowableArray<PushArgumentInstr*>(0);
     const int kTypeArgsLen = 0;
-    StaticCallInstr* call_async_clear_thread_stack_trace = new (Z)
-        StaticCallInstr(node->token_pos().ToSynthetic(),
-                        async_clear_thread_stack_trace, kTypeArgsLen,
-                        Object::null_array(), no_arguments,
-                        owner()->ic_data_array(), owner()->GetNextDeoptId());
+    StaticCallInstr* call_async_clear_thread_stack_trace =
+        new (Z) StaticCallInstr(node->token_pos().ToSynthetic(),
+                                async_clear_thread_stack_trace, kTypeArgsLen,
+                                Object::null_array(), no_arguments,
+                                owner()->ic_data_array());
     Do(call_async_clear_thread_stack_trace);
   }
 
   // Async functions contain two types of return statements:
   // 1) Returns that should complete the completer once all finally blocks have
   //    been inlined (call: :async_completer.complete(return_value)). These
   //    returns end up returning null in the end.
   // 2) "Continuation" returns that should not complete the completer but return
   //    the value.
   //
@@ skipping 14 matching lines @@
     Value* returned_value = Bind(BuildLoadExprTemp(node->token_pos()));
     arguments->Add(PushArgument(returned_value));
     // Call a helper function to complete the completer. The debugger
     // uses the helper function to know when to step-out.
     const Function& complete_on_async_return = Function::ZoneHandle(
         Z, isolate()->object_store()->complete_on_async_return());
     ASSERT(!complete_on_async_return.IsNull());
     const int kTypeArgsLen = 0;
     StaticCallInstr* call = new (Z) StaticCallInstr(
         node->token_pos().ToSynthetic(), complete_on_async_return, kTypeArgsLen,
-        Object::null_array(), arguments, owner()->ic_data_array(),
-        owner()->GetNextDeoptId());
+        Object::null_array(), arguments, owner()->ic_data_array());
     Do(call);
 
     // Rebind the return value for the actual return call to be null.
     return_value = BuildNullValue(node->token_pos());
   }
 
   intptr_t current_context_level = owner()->context_level();
   ASSERT(current_context_level >= 0);
   if (HasContextScope()) {
     UnchainContexts(current_context_level);
   }
 
   AddReturnExit(node->token_pos(), return_value);
 
   if ((function.IsAsyncClosure() || function.IsSyncGenClosure() ||
        function.IsAsyncGenClosure()) &&
       (node->return_type() == ReturnNode::kContinuationTarget)) {
-    JoinEntryInstr* const join =
-        new (Z) JoinEntryInstr(owner()->AllocateBlockId(), owner()->try_index(),
-                               owner()->GetNextDeoptId());
+    JoinEntryInstr* const join = new (Z)
+        JoinEntryInstr(owner()->AllocateBlockId(), owner()->try_index());
     owner()->await_joins()->Add(join);
     exit_ = join;
   }
 }
 
 
 // <Expression> ::= Literal { literal: Instance }
 void EffectGraphVisitor::VisitLiteralNode(LiteralNode* node) {
   ReturnDefinition(new (Z) ConstantInstr(node->literal(), node->token_pos()));
 }
@@ skipping 22 matching lines @@
   } else {
     instantiator_type_arguments = BuildInstantiatorTypeArguments(token_pos);
   }
   Value* function_type_arguments = NULL;
   if (type.IsInstantiated(kFunctions)) {
     function_type_arguments = BuildNullValue(token_pos);
   } else {
     function_type_arguments = BuildFunctionTypeArguments(token_pos);
   }
   ReturnDefinition(new (Z) InstantiateTypeInstr(
-      token_pos, type, instantiator_type_arguments, function_type_arguments,
-      owner()->GetNextDeoptId()));
+      token_pos, type, instantiator_type_arguments, function_type_arguments));
 }
 
 
 // Returns true if the type check can be skipped, for example, if the
 // destination type is dynamic or if the compile type of the value is a subtype
 // of the destination type.
 bool EffectGraphVisitor::CanSkipTypeCheck(TokenPosition token_pos,
                                           Value* value,
                                           const AbstractType& dst_type,
                                           const String& dst_name) {
@@ skipping 69 matching lines @@
   if ((node->kind() == Token::kAND) || (node->kind() == Token::kOR)) {
     // See ValueGraphVisitor::VisitBinaryOpNode.
     TestGraphVisitor for_left(owner(), node->left()->token_pos());
     node->left()->Visit(&for_left);
     EffectGraphVisitor empty(owner());
     Isolate* isolate = Isolate::Current();
     if (isolate->type_checks() || isolate->asserts()) {
       ValueGraphVisitor for_right(owner());
       node->right()->Visit(&for_right);
       Value* right_value = for_right.value();
-      for_right.Do(new (Z) AssertBooleanInstr(
-          node->right()->token_pos(), right_value, owner()->GetNextDeoptId()));
+      for_right.Do(
+          new (Z) AssertBooleanInstr(node->right()->token_pos(), right_value));
       if (node->kind() == Token::kAND) {
         Join(for_left, for_right, empty);
       } else {
         Join(for_left, empty, for_right);
       }
     } else {
       EffectGraphVisitor for_right(owner());
       node->right()->Visit(&for_right);
       if (node->kind() == Token::kAND) {
         Join(for_left, for_right, empty);
@@ skipping 14 matching lines @@
   Append(for_right_value);
   PushArgumentInstr* push_right = PushArgument(for_right_value.value());
 
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new (Z) ZoneGrowableArray<PushArgumentInstr*>(2);
   arguments->Add(push_left);
   arguments->Add(push_right);
   const String& name = Symbols::Token(node->kind());
   const intptr_t kTypeArgsLen = 0;
   const intptr_t kNumArgsChecked = 2;
-  InstanceCallInstr* call = new (Z)
-      InstanceCallInstr(node->token_pos(), name, node->kind(), arguments,
-                        kTypeArgsLen, Object::null_array(), kNumArgsChecked,
-                        owner()->ic_data_array(), owner()->GetNextDeoptId());
+  InstanceCallInstr* call = new (Z) InstanceCallInstr(
+      node->token_pos(), name, node->kind(), arguments, kTypeArgsLen,
+      Object::null_array(), kNumArgsChecked, owner()->ic_data_array());
   ReturnDefinition(call);
 }
 
 
 // Special handling for AND/OR.
 void ValueGraphVisitor::VisitBinaryOpNode(BinaryOpNode* node) {
   // Operators "&&" and "||" cannot be overloaded therefore do not call
   // operator.
   if ((node->kind() == Token::kAND) || (node->kind() == Token::kOR)) {
     // Implement short-circuit logic: do not evaluate right if evaluation
     // of left is sufficient.
     // AND:  left ? right === true : false;
     // OR:   left ? true : right === true;
 
     TestGraphVisitor for_test(owner(), node->left()->token_pos());
     node->left()->Visit(&for_test);
 
     ValueGraphVisitor for_right(owner());
     node->right()->Visit(&for_right);
     Value* right_value = for_right.value();
     Isolate* isolate = Isolate::Current();
     if (isolate->type_checks() || isolate->asserts()) {
-      right_value = for_right.Bind(new (Z) AssertBooleanInstr(
-          node->right()->token_pos(), right_value, owner()->GetNextDeoptId()));
+      right_value = for_right.Bind(
+          new (Z) AssertBooleanInstr(node->right()->token_pos(), right_value));
     }
     Value* constant_true = for_right.Bind(new (Z) ConstantInstr(Bool::True()));
     Value* compare = for_right.Bind(new (Z) StrictCompareInstr(
-        node->token_pos(), Token::kEQ_STRICT, right_value, constant_true, false,
-        owner()->GetNextDeoptId()));  // No number check.
+        node->token_pos(), Token::kEQ_STRICT, right_value, constant_true,
+        false));  // No number check.
     for_right.Do(BuildStoreExprTemp(compare, node->token_pos()));
 
     if (node->kind() == Token::kAND) {
       ValueGraphVisitor for_false(owner());
       Value* constant_false =
           for_false.Bind(new (Z) ConstantInstr(Bool::False()));
       for_false.Do(BuildStoreExprTemp(constant_false, node->token_pos()));
       Join(for_test, for_right, for_false);
     } else {
       ASSERT(node->kind() == Token::kOR);
@@ skipping 115 matching lines @@
     arguments->Add(push_left);
     Value* type_const = Bind(new (Z) ConstantInstr(type));
     arguments->Add(PushArgument(type_const));
     const intptr_t kTypeArgsLen = 0;
     const intptr_t kNumArgsChecked = 2;
     Definition* result = new (Z) InstanceCallInstr(
         node->token_pos(),
         Library::PrivateCoreLibName(Symbols::_simpleInstanceOf()), node->kind(),
         arguments, kTypeArgsLen,
         Object::null_array(),  // No argument names.
-        kNumArgsChecked, owner()->ic_data_array(), owner()->GetNextDeoptId());
+        kNumArgsChecked, owner()->ic_data_array());
     if (negate_result) {
       result = new (Z) BooleanNegateInstr(Bind(result));
     }
     ReturnDefinition(result);
     return;
   }
 
   PushArgumentInstr* push_instantiator_type_args =
       PushInstantiatorTypeArguments(type, node->token_pos());
   PushArgumentInstr* push_function_type_args =
       PushFunctionTypeArguments(type, node->token_pos());
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new (Z) ZoneGrowableArray<PushArgumentInstr*>(4);
   arguments->Add(push_left);
   arguments->Add(push_instantiator_type_args);
   arguments->Add(push_function_type_args);
   Value* type_const = Bind(new (Z) ConstantInstr(type));
   arguments->Add(PushArgument(type_const));
   const intptr_t kTypeArgsLen = 0;
   const intptr_t kNumArgsChecked = 1;
   Definition* result = new (Z) InstanceCallInstr(
       node->token_pos(), Library::PrivateCoreLibName(Symbols::_instanceOf()),
       node->kind(), arguments, kTypeArgsLen,
       Object::null_array(),  // No argument names.
-      kNumArgsChecked, owner()->ic_data_array(), owner()->GetNextDeoptId());
+      kNumArgsChecked, owner()->ic_data_array());
   if (negate_result) {
     result = new (Z) BooleanNegateInstr(Bind(result));
   }
   ReturnDefinition(result);
 }
 
 
 void EffectGraphVisitor::BuildTypeCast(ComparisonNode* node) {
   ASSERT(Token::IsTypeCastOperator(node->kind()));
   ASSERT(!node->right()->AsTypeNode()->type().IsNull());
@@ skipping 18 matching lines @@
   arguments->Add(push_instantiator_type_args);
   arguments->Add(push_function_type_args);
   Value* type_arg = Bind(new (Z) ConstantInstr(type));
   arguments->Add(PushArgument(type_arg));
   const int kTypeArgsLen = 0;
   const intptr_t kNumArgsChecked = 1;
   InstanceCallInstr* call = new (Z) InstanceCallInstr(
       node->token_pos(), Library::PrivateCoreLibName(Symbols::_as()),
       node->kind(), arguments, kTypeArgsLen,
       Object::null_array(),  // No argument names.
-      kNumArgsChecked, owner()->ic_data_array(), owner()->GetNextDeoptId());
+      kNumArgsChecked, owner()->ic_data_array());
   ReturnDefinition(call);
 }
 
 
 StrictCompareInstr* EffectGraphVisitor::BuildStrictCompare(
     AstNode* left,
     AstNode* right,
     Token::Kind kind,
     TokenPosition token_pos) {
   ValueGraphVisitor for_left_value(owner());
   left->Visit(&for_left_value);
   Append(for_left_value);
   ValueGraphVisitor for_right_value(owner());
   right->Visit(&for_right_value);
   Append(for_right_value);
   StrictCompareInstr* comp = new (Z) StrictCompareInstr(
-      token_pos, kind, for_left_value.value(), for_right_value.value(), true,
-      owner()->GetNextDeoptId());  // Number check.
+      token_pos, kind, for_left_value.value(), for_right_value.value(),
+      true);  // Number check.
   return comp;
 }
 
 
 // <Expression> :: Comparison { kind:  Token::Kind
 //                              left:  <Expression>
 //                              right: <Expression> }
 void EffectGraphVisitor::VisitComparisonNode(ComparisonNode* node) {
   if (Token::IsTypeTestOperator(node->kind())) {
     BuildTypeTest(node);
@@ skipping 35 matching lines @@
     arguments->Add(push_left);
 
     ValueGraphVisitor for_right_value(owner());
     node->right()->Visit(&for_right_value);
     Append(for_right_value);
     PushArgumentInstr* push_right = PushArgument(for_right_value.value());
     arguments->Add(push_right);
 
     const intptr_t kTypeArgsLen = 0;
     const intptr_t kNumArgsChecked = 2;
-    Definition* result = new (Z) InstanceCallInstr(
-        node->token_pos(), Symbols::EqualOperator(),
-        Token::kEQ,  // Result is negated later for kNE.
-        arguments, kTypeArgsLen, Object::null_array(), kNumArgsChecked,
-        owner()->ic_data_array(), owner()->GetNextDeoptId());
+    Definition* result = new (Z)
+        InstanceCallInstr(node->token_pos(), Symbols::EqualOperator(),
+                          Token::kEQ,  // Result is negated later for kNE.
+                          arguments, kTypeArgsLen, Object::null_array(),
+                          kNumArgsChecked, owner()->ic_data_array());
     if (node->kind() == Token::kNE) {
       Isolate* isolate = Isolate::Current();
       if (isolate->type_checks() || isolate->asserts()) {
         Value* value = Bind(result);
-        result = new (Z) AssertBooleanInstr(node->token_pos(), value,
-                                            owner()->GetNextDeoptId());
+        result = new (Z) AssertBooleanInstr(node->token_pos(), value);
       }
       Value* value = Bind(result);
       result = new (Z) BooleanNegateInstr(value);
     }
     ReturnDefinition(result);
     return;
   }
 
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new (Z) ZoneGrowableArray<PushArgumentInstr*>(2);
 
   ValueGraphVisitor for_left_value(owner());
   node->left()->Visit(&for_left_value);
   Append(for_left_value);
   PushArgumentInstr* push_left = PushArgument(for_left_value.value());
   arguments->Add(push_left);
 
   ValueGraphVisitor for_right_value(owner());
   node->right()->Visit(&for_right_value);
   Append(for_right_value);
   PushArgumentInstr* push_right = PushArgument(for_right_value.value());
   arguments->Add(push_right);
 
   ASSERT(Token::IsRelationalOperator(node->kind()));
   const intptr_t kTypeArgsLen = 0;
   InstanceCallInstr* comp = new (Z) InstanceCallInstr(
       node->token_pos(), Symbols::Token(node->kind()), node->kind(), arguments,
-      kTypeArgsLen, Object::null_array(), 2, owner()->ic_data_array(),
-      owner()->GetNextDeoptId());
+      kTypeArgsLen, Object::null_array(), 2, owner()->ic_data_array());
   ReturnDefinition(comp);
 }
 
 
 void EffectGraphVisitor::VisitUnaryOpNode(UnaryOpNode* node) {
   // "!" cannot be overloaded, therefore do not call operator.
   if (node->kind() == Token::kNOT) {
     ValueGraphVisitor for_value(owner());
     node->operand()->Visit(&for_value);
     Append(for_value);
     Value* value = for_value.value();
     Isolate* isolate = Isolate::Current();
     if (isolate->type_checks() || isolate->asserts()) {
-      value = Bind(new (Z) AssertBooleanInstr(
-          node->operand()->token_pos(), value, owner()->GetNextDeoptId()));
+      value =
+          Bind(new (Z) AssertBooleanInstr(node->operand()->token_pos(), value));
     }
     BooleanNegateInstr* negate = new (Z) BooleanNegateInstr(value);
     ReturnDefinition(negate);
     return;
   }
 
   ValueGraphVisitor for_value(owner());
   node->operand()->Visit(&for_value);
   Append(for_value);
   PushArgumentInstr* push_value = PushArgument(for_value.value());
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new (Z) ZoneGrowableArray<PushArgumentInstr*>(1);
   arguments->Add(push_value);
   const intptr_t kTypeArgsLen = 0;
   InstanceCallInstr* call = new (Z) InstanceCallInstr(
       node->token_pos(), Symbols::Token(node->kind()), node->kind(), arguments,
-      kTypeArgsLen, Object::null_array(), 1, owner()->ic_data_array(),
-      owner()->GetNextDeoptId());
+      kTypeArgsLen, Object::null_array(), 1, owner()->ic_data_array());
   ReturnDefinition(call);
 }
 
 
 void EffectGraphVisitor::VisitConditionalExprNode(ConditionalExprNode* node) {
   TestGraphVisitor for_test(owner(), node->condition()->token_pos());
   node->condition()->Visit(&for_test);
 
   // Translate the subexpressions for their effects.
   EffectGraphVisitor for_true(owner());
@@ skipping 77 matching lines @@
 //
 // Note: The specification of switch/case is under discussion and may change
 // drastically.
 void EffectGraphVisitor::VisitCaseNode(CaseNode* node) {
   const intptr_t len = node->case_expressions()->length();
   // Create case statements instructions.
   EffectGraphVisitor for_case_statements(owner());
   // Compute the start of the statements fragment.
   JoinEntryInstr* statement_start = NULL;
   if (node->label() == NULL) {
-    statement_start =
-        new (Z) JoinEntryInstr(owner()->AllocateBlockId(), owner()->try_index(),
-                               owner()->GetNextDeoptId());
+    statement_start = new (Z)
+        JoinEntryInstr(owner()->AllocateBlockId(), owner()->try_index());
   } else {
     // The case nodes are nested inside a SequenceNode that is the body of a
     // SwitchNode.  The SwitchNode on the nesting stack contains the
     // continue labels for all the case clauses.
     statement_start =
         owner()->nesting_stack()->outer()->ContinueTargetFor(node->label());
   }
   ASSERT(statement_start != NULL);
   node->statements()->Visit(&for_case_statements);
   Instruction* statement_exit =
@@ skipping 31 matching lines @@
   // node contains default.
   if (len > 0) {
     ASSERT(next_target != NULL);
     if (node->contains_default()) {
       // True and false go to statement start.
       next_target->Goto(statement_start);
       exit_instruction = statement_exit;
     } else {
       if (statement_exit != NULL) {
         JoinEntryInstr* join = new (Z)
-            JoinEntryInstr(owner()->AllocateBlockId(), owner()->try_index(),
-                           owner()->GetNextDeoptId());
+            JoinEntryInstr(owner()->AllocateBlockId(), owner()->try_index());
         statement_exit->Goto(join);
         next_target->Goto(join);
         exit_instruction = join;
       } else {
         exit_instruction = next_target;
       }
     }
   } else {
     // A CaseNode without case expressions must contain default.
     ASSERT(node->contains_default());
@@ skipping 62 matching lines @@
   // Traverse the body first in order to generate continue and break labels.
   EffectGraphVisitor for_body(owner());
   node->body()->Visit(&for_body);
 
   TestGraphVisitor for_test(owner(), node->condition()->token_pos());
   node->condition()->Visit(&for_test);
   ASSERT(is_open());
 
   // Tie do-while loop (test is after the body).
   JoinEntryInstr* body_entry_join =
-      new (Z) JoinEntryInstr(owner()->AllocateBlockId(), owner()->try_index(),
-                             owner()->GetNextDeoptId());
+      new (Z) JoinEntryInstr(owner()->AllocateBlockId(), owner()->try_index());
   Goto(body_entry_join);
   Instruction* body_exit = AppendFragment(body_entry_join, for_body);
 
   JoinEntryInstr* join = nested_loop.continue_target();
   if ((body_exit != NULL) || (join != NULL)) {
     if (join == NULL) {
       join = new (Z)
-          JoinEntryInstr(owner()->AllocateBlockId(), owner()->try_index(),
-                         owner()->GetNextDeoptId());
+          JoinEntryInstr(owner()->AllocateBlockId(), owner()->try_index());
     }
-    CheckStackOverflowInstr* check = new (Z) CheckStackOverflowInstr(
-        node->token_pos(), owner()->loop_depth(), owner()->GetNextDeoptId());
+    CheckStackOverflowInstr* check = new (Z)
+        CheckStackOverflowInstr(node->token_pos(), owner()->loop_depth());
     join->LinkTo(check);
     check->LinkTo(for_test.entry());
     if (body_exit != NULL) {
       body_exit->Goto(join);
     }
   }
 
   for_test.IfTrueGoto(body_entry_join);
   join = nested_loop.break_target();
   if (join == NULL) {
@@ skipping 27 matching lines @@
   // Compose body to set any jump labels.
   EffectGraphVisitor for_body(owner());
   node->body()->Visit(&for_body);
 
   EffectGraphVisitor for_increment(owner());
   node->increment()->Visit(&for_increment);
 
   // Join the loop body and increment and then tie the loop.
   JoinEntryInstr* continue_join = nested_loop.continue_target();
   if ((continue_join != NULL) || for_body.is_open()) {
-    JoinEntryInstr* loop_entry =
-        new (Z) JoinEntryInstr(owner()->AllocateBlockId(), owner()->try_index(),
-                               owner()->GetNextDeoptId());
+    JoinEntryInstr* loop_entry = new (Z)
+        JoinEntryInstr(owner()->AllocateBlockId(), owner()->try_index());
     if (continue_join != NULL) {
       if (for_body.is_open()) for_body.Goto(continue_join);
       Instruction* current = AppendFragment(continue_join, for_increment);
       current->Goto(loop_entry);
     } else {
       for_body.Append(for_increment);
       for_body.Goto(loop_entry);
     }
     Goto(loop_entry);
     exit_ = loop_entry;
     // Note: the stack overflow check happens on the back branch that jumps
     // to the increment instruction. The token position for the overflow
     // check must match the position of the increment expression, so that
     // the context level (if any) matches the that of the increment
     // expression.
     AddInstruction(new (Z) CheckStackOverflowInstr(
-        node->increment()->token_pos(), owner()->loop_depth(),
-        owner()->GetNextDeoptId()));
+        node->increment()->token_pos(), owner()->loop_depth()));
   }
 
   if (node->condition() == NULL) {
     // Endless loop, no test.
     Append(for_body);
     exit_ = nested_loop.break_target();  // May be NULL.
   } else {
     EffectGraphVisitor for_test_preamble(owner());
     if (node->condition_preamble() != NULL) {
       node->condition_preamble()->Visit(&for_test_preamble);
@@ skipping 174 matching lines @@
 }
 
 
 void EffectGraphVisitor::VisitArrayNode(ArrayNode* node) {
   const TypeArguments& type_args =
       TypeArguments::ZoneHandle(Z, node->type().arguments());
   Value* element_type =
       BuildInstantiatedTypeArguments(node->token_pos(), type_args);
   Value* num_elements =
       Bind(new (Z) ConstantInstr(Smi::ZoneHandle(Z, Smi::New(node->length()))));
-  CreateArrayInstr* create = new (Z) CreateArrayInstr(
-      node->token_pos(), element_type, num_elements, owner()->GetNextDeoptId());
+  CreateArrayInstr* create =
+      new (Z) CreateArrayInstr(node->token_pos(), element_type, num_elements);
   Value* array_val = Bind(create);
 
   {
     LocalVariable* tmp_var = EnterTempLocalScope(array_val);
     const intptr_t class_id = kArrayCid;
     const intptr_t deopt_id = Thread::kNoDeoptId;
     for (int i = 0; i < node->length(); ++i) {
       Value* array = Bind(new (Z) LoadLocalInstr(*tmp_var, node->token_pos()));
       Value* index = Bind(new (Z) ConstantInstr(Smi::ZoneHandle(Z, Smi::New(i)),
                                                 node->token_pos()));
@@ skipping 29 matching lines @@
     const int kTypeArgsLen = 0;
     const int kNumberOfArguments = 1;
     const Array& kNoArgumentNames = Object::null_array();
     const Class& cls =
         Class::Handle(Library::LookupCoreClass(Symbols::StringBase()));
     ASSERT(!cls.IsNull());
     const Function& function = Function::ZoneHandle(
         Z, Resolver::ResolveStatic(
                cls, Library::PrivateCoreLibName(Symbols::InterpolateSingle()),
                kTypeArgsLen, kNumberOfArguments, kNoArgumentNames));
-    StaticCallInstr* call = new (Z) StaticCallInstr(
-        node->token_pos(), function, kTypeArgsLen, kNoArgumentNames, values,
-        owner()->ic_data_array(), owner()->GetNextDeoptId());
+    StaticCallInstr* call = new (Z)
+        StaticCallInstr(node->token_pos(), function, kTypeArgsLen,
+                        kNoArgumentNames, values, owner()->ic_data_array());
     ReturnDefinition(call);
     return;
   }
   arguments->Visit(&for_argument);
   Append(for_argument);
-  StringInterpolateInstr* instr = new (Z) StringInterpolateInstr(
-      for_argument.value(), node->token_pos(), owner()->GetNextDeoptId());
+  StringInterpolateInstr* instr =
+      new (Z) StringInterpolateInstr(for_argument.value(), node->token_pos());
   ReturnDefinition(instr);
 }
 
 
 void EffectGraphVisitor::VisitClosureNode(ClosureNode* node) {
   const Function& function = node->function();
   if (function.IsImplicitStaticClosureFunction()) {
     const Instance& closure =
         Instance::ZoneHandle(Z, function.ImplicitStaticClosure());
     ReturnDefinition(new (Z) ConstantInstr(closure));
@@ skipping 201 matching lines @@
     BuildPushTypeArguments(*node->arguments(), arguments);
     ValueGraphVisitor for_receiver(owner());
     node->receiver()->Visit(&for_receiver);
     Append(for_receiver);
     PushArgumentInstr* push_receiver = PushArgument(for_receiver.value());
     arguments->Add(push_receiver);
     BuildPushArguments(*node->arguments(), arguments);
     InstanceCallInstr* call = new (Z) InstanceCallInstr(
         node->token_pos(), node->function_name(), Token::kILLEGAL, arguments,
         node->arguments()->type_args_len(), node->arguments()->names(), 1,
-        owner()->ic_data_array(), owner()->GetNextDeoptId());
+        owner()->ic_data_array());
     ReturnDefinition(call);
   }
 }
 
 
 // <Expression> ::= StaticCall { function: Function
 //                               arguments: <ArgumentList> }
 void EffectGraphVisitor::VisitStaticCallNode(StaticCallNode* node) {
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new (Z) ZoneGrowableArray<PushArgumentInstr*>(
           node->arguments()->LengthWithTypeArgs());
   BuildPushTypeArguments(*node->arguments(), arguments);
   BuildPushArguments(*node->arguments(), arguments);
   StaticCallInstr* call = new (Z) StaticCallInstr(
       node->token_pos(), node->function(), node->arguments()->type_args_len(),
-      node->arguments()->names(), arguments, owner()->ic_data_array(),
-      owner()->GetNextDeoptId());
+      node->arguments()->names(), arguments, owner()->ic_data_array());
   if (node->function().recognized_kind() != MethodRecognizer::kUnknown) {
     call->set_result_cid(MethodRecognizer::ResultCid(node->function()));
   }
   ReturnDefinition(call);
 }
 
 
 void EffectGraphVisitor::BuildClosureCall(ClosureCallNode* node,
                                           bool result_needed) {
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
@@ skipping 13 matching lines @@
   arguments->Add(push_closure);
   BuildPushArguments(*node->arguments(), arguments);
 
   closure_val = Bind(new (Z) LoadLocalInstr(*tmp_var, node->token_pos()));
   LoadFieldInstr* function_load = new (Z) LoadFieldInstr(
       closure_val, Closure::function_offset(),
       AbstractType::ZoneHandle(Z, AbstractType::null()), node->token_pos());
   function_load->set_is_immutable(true);
   Value* function_val = Bind(function_load);
 
-  Definition* closure_call = new (Z) ClosureCallInstr(
-      function_val, node, arguments, owner()->GetNextDeoptId());
+  Definition* closure_call =
+      new (Z) ClosureCallInstr(function_val, node, arguments);
   if (result_needed) {
     Value* result = Bind(closure_call);
     Do(new (Z) StoreLocalInstr(*tmp_var, result, ST(node->token_pos())));
   } else {
     Do(closure_call);
   }
   ReturnDefinition(ExitTempLocalScope(closure_value));
 }
 
 
 void EffectGraphVisitor::VisitClosureCallNode(ClosureCallNode* node) {
   BuildClosureCall(node, false);
 }
 
 
 void ValueGraphVisitor::VisitClosureCallNode(ClosureCallNode* node) {
   BuildClosureCall(node, true);
 }
 
 
 void EffectGraphVisitor::VisitInitStaticFieldNode(InitStaticFieldNode* node) {
   Value* field = Bind(
       new (Z) ConstantInstr(Field::ZoneHandle(Z, node->field().Original())));
-  AddInstruction(new (Z) InitStaticFieldInstr(field, node->field(),
-                                              owner()->GetNextDeoptId()));
+  AddInstruction(new (Z) InitStaticFieldInstr(field, node->field()));
 }
 
 
 void EffectGraphVisitor::VisitCloneContextNode(CloneContextNode* node) {
   Value* context = Bind(BuildCurrentContext(node->token_pos()));
-  Value* clone = Bind(new (Z) CloneContextInstr(node->token_pos(), context,
-                                                owner()->GetNextDeoptId()));
+  Value* clone = Bind(new (Z) CloneContextInstr(node->token_pos(), context));
   Do(BuildStoreContext(clone, node->token_pos()));
 }
 
 
 Value* EffectGraphVisitor::BuildObjectAllocation(ConstructorCallNode* node) {
   const Class& cls = Class::ZoneHandle(Z, node->constructor().Owner());
   const bool cls_is_parameterized = cls.NumTypeArguments() > 0;
 
   ZoneGrowableArray<PushArgumentInstr*>* allocate_arguments = new (Z)
       ZoneGrowableArray<PushArgumentInstr*>(cls_is_parameterized ? 1 : 0);
@@ skipping 13 matching lines @@
 
 void EffectGraphVisitor::BuildConstructorCall(
     ConstructorCallNode* node,
     PushArgumentInstr* push_alloc_value) {
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new (Z) ZoneGrowableArray<PushArgumentInstr*>(2);
   arguments->Add(push_alloc_value);
 
   BuildPushArguments(*node->arguments(), arguments);
   const intptr_t kTypeArgsLen = 0;
-  Do(new (Z)
-         StaticCallInstr(node->token_pos(), node->constructor(), kTypeArgsLen,
-                         node->arguments()->names(), arguments,
-                         owner()->ic_data_array(), owner()->GetNextDeoptId()));
+  Do(new (Z) StaticCallInstr(node->token_pos(), node->constructor(),
+                             kTypeArgsLen, node->arguments()->names(),
+                             arguments, owner()->ic_data_array()));
 }
 
 
 static intptr_t GetResultCidOfListFactory(ConstructorCallNode* node) {
   const Function& function = node->constructor();
   const Class& function_class = Class::Handle(function.Owner());
 
   if ((function_class.library() != Library::CoreLibrary()) &&
       (function_class.library() != Library::TypedDataLibrary())) {
     return kDynamicCid;
@@ skipping 18 matching lines @@
   if (node->constructor().IsFactory()) {
     ZoneGrowableArray<PushArgumentInstr*>* arguments =
         new (Z) ZoneGrowableArray<PushArgumentInstr*>();
     PushArgumentInstr* push_type_arguments =
         PushArgument(BuildInstantiatedTypeArguments(node->token_pos(),
                                                     node->type_arguments()));
     arguments->Add(push_type_arguments);
     ASSERT(arguments->length() == 1);
     BuildPushArguments(*node->arguments(), arguments);
     const int kTypeArgsLen = 0;
-    StaticCallInstr* call = new (Z)
-        StaticCallInstr(node->token_pos(), node->constructor(), kTypeArgsLen,
-                        node->arguments()->names(), arguments,
-                        owner()->ic_data_array(), owner()->GetNextDeoptId());
+    StaticCallInstr* call = new (Z) StaticCallInstr(
+        node->token_pos(), node->constructor(), kTypeArgsLen,
+        node->arguments()->names(), arguments, owner()->ic_data_array());
     const intptr_t result_cid = GetResultCidOfListFactory(node);
     if (result_cid != kDynamicCid) {
       call->set_result_cid(result_cid);
       call->set_is_known_list_constructor(true);
       // Recognized fixed length array factory must have two arguments:
       // (0) type-arguments, (1) length.
       ASSERT(!LoadFieldInstr::IsFixedLengthArrayCid(result_cid) ||
              arguments->length() == 2);
     } else if (node->constructor().recognized_kind() !=
                MethodRecognizer::kUnknown) {
@@ skipping 121 matching lines @@
     }
   }
   Value* function_type_args = NULL;
   if (type_arguments.IsInstantiated(kFunctions)) {
     function_type_args = BuildNullValue(token_pos);
   } else {
     function_type_args = BuildFunctionTypeArguments(token_pos);
   }
   return Bind(new (Z) InstantiateTypeArgumentsInstr(
       token_pos, type_arguments, instantiator_class, instantiator_type_args,
-      function_type_args, owner()->GetNextDeoptId()));
+      function_type_args));
 }
 
 
 void ValueGraphVisitor::VisitConstructorCallNode(ConstructorCallNode* node) {
   if (node->constructor().IsFactory()) {
     EffectGraphVisitor::VisitConstructorCallNode(node);
     return;
   }
 
   // t_n contains the allocated and initialized object.
@@ skipping 68 matching lines @@
     Do(BuildStoreExprTemp(for_receiver.value(), node->token_pos()));
     BuildInstanceGetterConditional(node);
   } else {
     PushArgumentInstr* push_receiver = PushArgument(for_receiver.value());
     ZoneGrowableArray<PushArgumentInstr*>* arguments =
         new (Z) ZoneGrowableArray<PushArgumentInstr*>(1);
     arguments->Add(push_receiver);
     const String& name =
         String::ZoneHandle(Z, Field::GetterSymbol(node->field_name()));
     const intptr_t kTypeArgsLen = 0;
-    InstanceCallInstr* call = new (Z)
-        InstanceCallInstr(node->token_pos(), name, Token::kGET, arguments,
-                          kTypeArgsLen, Object::null_array(), 1,
-                          owner()->ic_data_array(), owner()->GetNextDeoptId());
+    InstanceCallInstr* call = new (Z) InstanceCallInstr(
+        node->token_pos(), name, Token::kGET, arguments, kTypeArgsLen,
+        Object::null_array(), 1, owner()->ic_data_array());
     ReturnDefinition(call);
   }
 }
 
 
 void EffectGraphVisitor::BuildInstanceSetterArguments(
     InstanceSetterNode* node,
     ZoneGrowableArray<PushArgumentInstr*>* arguments,
     bool result_is_needed) {
   ValueGraphVisitor for_receiver(owner());
@@ skipping 41 matching lines @@
     Join(for_test, for_true, for_false);
     return;
   }
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new (Z) ZoneGrowableArray<PushArgumentInstr*>(2);
   BuildInstanceSetterArguments(node, arguments, kResultNotNeeded);
   const String& name =
       String::ZoneHandle(Z, Field::SetterSymbol(node->field_name()));
   const int kTypeArgsLen = 0;
   const intptr_t kNumArgsChecked = 1;  // Do not check value type.
-  InstanceCallInstr* call = new (Z)
-      InstanceCallInstr(token_pos, name, Token::kSET, arguments, kTypeArgsLen,
-                        Object::null_array(), kNumArgsChecked,
-                        owner()->ic_data_array(), owner()->GetNextDeoptId());
+  InstanceCallInstr* call = new (Z) InstanceCallInstr(
+      token_pos, name, Token::kSET, arguments, kTypeArgsLen,
+      Object::null_array(), kNumArgsChecked, owner()->ic_data_array());
   ReturnDefinition(call);
 }
 
 
 void ValueGraphVisitor::VisitInstanceSetterNode(InstanceSetterNode* node) {
   const TokenPosition token_pos = node->token_pos();
   if (node->is_conditional()) {
     ValueGraphVisitor for_receiver(owner());
     node->receiver()->Visit(&for_receiver);
     Append(for_receiver);
@@ skipping 24 matching lines @@
   }
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new (Z) ZoneGrowableArray<PushArgumentInstr*>(2);
   BuildInstanceSetterArguments(node, arguments, kResultNeeded);
   const String& name =
       String::ZoneHandle(Z, Field::SetterSymbol(node->field_name()));
   const intptr_t kTypeArgsLen = 0;
   const intptr_t kNumArgsChecked = 1;  // Do not check value type.
   Do(new (Z) InstanceCallInstr(token_pos, name, Token::kSET, arguments,
                                kTypeArgsLen, Object::null_array(),
-                               kNumArgsChecked, owner()->ic_data_array(),
-                               owner()->GetNextDeoptId()));
+                               kNumArgsChecked, owner()->ic_data_array()));
   ReturnDefinition(BuildLoadExprTemp(token_pos));
 }
 
 
 void EffectGraphVisitor::VisitStaticGetterNode(StaticGetterNode* node) {
   const String& getter_name =
       String::ZoneHandle(Z, Field::GetterSymbol(node->field_name()));
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new (Z) ZoneGrowableArray<PushArgumentInstr*>();
   Function& getter_function = Function::ZoneHandle(Z, Function::null());
@@ skipping 42 matching lines @@
           InvocationMirror::EncodeType(node->cls().IsTopLevel()
                                            ? InvocationMirror::kTopLevel
                                            : InvocationMirror::kStatic,
                                        InvocationMirror::kGetter));
       ReturnDefinition(call);
       return;
     }
   }
   ASSERT(!getter_function.IsNull());
   const intptr_t kTypeArgsLen = 0;
-  StaticCallInstr* call = new (Z) StaticCallInstr(
-      node->token_pos(), getter_function, kTypeArgsLen,
-      Object::null_array(),  // No names
-      arguments, owner()->ic_data_array(), owner()->GetNextDeoptId());
+  StaticCallInstr* call =
+      new (Z) StaticCallInstr(node->token_pos(), getter_function, kTypeArgsLen,
+                              Object::null_array(),  // No names
+                              arguments, owner()->ic_data_array());
   ReturnDefinition(call);
 }
 
 
 void EffectGraphVisitor::BuildStaticSetter(StaticSetterNode* node,
                                            bool result_is_needed) {
   const String& setter_name =
       String::ZoneHandle(Z, Field::SetterSymbol(node->field_name()));
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new (Z) ZoneGrowableArray<PushArgumentInstr*>(1);
@@ skipping 41 matching lines @@
     Value* value = NULL;
     if (result_is_needed) {
       value = Bind(BuildStoreExprTemp(for_value.value(), token_pos));
     } else {
       value = for_value.value();
     }
     arguments->Add(PushArgument(value));
     const intptr_t kTypeArgsLen = 0;
     call = new (Z) StaticCallInstr(token_pos, setter_function, kTypeArgsLen,
                                    Object::null_array(),  // No names.
-                                   arguments, owner()->ic_data_array(),
-                                   owner()->GetNextDeoptId());
+                                   arguments, owner()->ic_data_array());
   }
   if (result_is_needed) {
     Do(call);
     ReturnDefinition(BuildLoadExprTemp(token_pos));
   } else {
     ReturnDefinition(call);
   }
 }
 
 
@@ skipping 71 matching lines @@
     MethodRecognizer::Kind kind = MethodRecognizer::RecognizeKind(function);
     switch (kind) {
       case MethodRecognizer::kObjectEquals: {
         Value* receiver = Bind(BuildLoadThisVar(node->scope(), token_pos));
         LocalVariable* other_var =
             node->scope()->LookupVariable(Symbols::Other(),
                                           true);  // Test only.
         Value* other = Bind(new (Z) LoadLocalInstr(*other_var, token_pos));
         // Receiver is not a number because numbers override equality.
         const bool kNoNumberCheck = false;
-        StrictCompareInstr* compare = new (Z)
-            StrictCompareInstr(token_pos, Token::kEQ_STRICT, receiver, other,
-                               kNoNumberCheck, owner()->GetNextDeoptId());
+        StrictCompareInstr* compare = new (Z) StrictCompareInstr(
+            token_pos, Token::kEQ_STRICT, receiver, other, kNoNumberCheck);
         return ReturnDefinition(compare);
       }
       case MethodRecognizer::kStringBaseLength:
       case MethodRecognizer::kStringBaseIsEmpty: {
         // Treat length loads as mutable (i.e. affected by side effects) to
         // avoid hoisting them since we can't hoist the preceding class-check.
         // This is because of externalization of strings that affects their
         // class-id.
         LoadFieldInstr* load = BuildNativeGetter(
             node, MethodRecognizer::kStringBaseLength, String::length_offset(),
             Type::ZoneHandle(Z, Type::SmiType()), kSmiCid);
         load->set_is_immutable(!FLAG_support_externalizable_strings);
         if (kind == MethodRecognizer::kStringBaseLength) {
           return ReturnDefinition(load);
         }
         ASSERT(kind == MethodRecognizer::kStringBaseIsEmpty);
         Value* zero_val =
             Bind(new (Z) ConstantInstr(Smi::ZoneHandle(Z, Smi::New(0))));
         Value* load_val = Bind(load);
-        StrictCompareInstr* compare = new (Z) StrictCompareInstr(
-            token_pos, Token::kEQ_STRICT, load_val, zero_val, false,
-            owner()->GetNextDeoptId());  // No number check.
+        StrictCompareInstr* compare = new (Z)
+            StrictCompareInstr(token_pos, Token::kEQ_STRICT, load_val, zero_val,
+                               false);  // No number check.
         return ReturnDefinition(compare);
       }
       case MethodRecognizer::kGrowableArrayLength:
       case MethodRecognizer::kObjectArrayLength:
       case MethodRecognizer::kImmutableArrayLength:
       case MethodRecognizer::kTypedDataLength: {
         LoadFieldInstr* load =
             BuildNativeGetter(node, kind, OffsetForLengthGetter(kind),
                               Type::ZoneHandle(Z, Type::SmiType()), kSmiCid);
         load->set_is_immutable(kind != MethodRecognizer::kGrowableArrayLength);
@@ skipping 22 matching lines @@
       }
       case MethodRecognizer::kObjectArrayAllocate: {
         LocalVariable* type_args_parameter = node->scope()->LookupVariable(
             Symbols::TypeArgumentsParameter(), true);
         Value* element_type =
             Bind(new (Z) LoadLocalInstr(*type_args_parameter, token_pos));
         LocalVariable* length_parameter =
             node->scope()->LookupVariable(Symbols::Length(), true);
         Value* length =
             Bind(new (Z) LoadLocalInstr(*length_parameter, token_pos));
-        CreateArrayInstr* create_array = new CreateArrayInstr(
-            token_pos, element_type, length, owner()->GetNextDeoptId());
+        CreateArrayInstr* create_array =
+            new CreateArrayInstr(token_pos, element_type, length);
         return ReturnDefinition(create_array);
       }
       case MethodRecognizer::kBigint_getDigits: {
         return ReturnDefinition(BuildNativeGetter(
             node, kind, Bigint::digits_offset(), Object::dynamic_type(),
             kTypedDataUint32ArrayCid));
       }
       case MethodRecognizer::kBigint_getUsed: {
         return ReturnDefinition(
             BuildNativeGetter(node, kind, Bigint::used_offset(),
@@ skipping 269 matching lines @@
   ValueGraphVisitor for_index(owner());
   node->index_expr()->Visit(&for_index);
   Append(for_index);
   arguments->Add(PushArgument(for_index.value()));
 
   const intptr_t kTypeArgsLen = 0;
   if (super_function != NULL) {
     // Generate static call to super operator.
     StaticCallInstr* load = new (Z) StaticCallInstr(
         node->token_pos(), *super_function, kTypeArgsLen, Object::null_array(),
-        arguments, owner()->ic_data_array(), owner()->GetNextDeoptId());
+        arguments, owner()->ic_data_array());
     ReturnDefinition(load);
   } else {
     // Generate dynamic call to index operator.
     const intptr_t checked_argument_count = 1;
     InstanceCallInstr* load = new (Z) InstanceCallInstr(
         node->token_pos(), Symbols::IndexToken(), Token::kINDEX, arguments,
         kTypeArgsLen, Object::null_array(), checked_argument_count,
-        owner()->ic_data_array(), owner()->GetNextDeoptId());
+        owner()->ic_data_array());
     ReturnDefinition(load);
   }
 }
 
 
 Definition* EffectGraphVisitor::BuildStoreIndexedValues(StoreIndexedNode* node,
                                                         bool result_is_needed) {
   Function* super_function = NULL;
   const TokenPosition token_pos = node->token_pos();
   if (node->IsSuperStore()) {
@@ skipping 45 matching lines @@
     value = for_value.value();
   }
   arguments->Add(PushArgument(value));
 
   const intptr_t kTypeArgsLen = 0;
   if (super_function != NULL) {
     // Generate static call to super operator []=.
 
     StaticCallInstr* store = new (Z) StaticCallInstr(
         token_pos, *super_function, kTypeArgsLen, Object::null_array(),
-        arguments, owner()->ic_data_array(), owner()->GetNextDeoptId());
+        arguments, owner()->ic_data_array());
     if (result_is_needed) {
       Do(store);
       return BuildLoadExprTemp(token_pos);
     } else {
       return store;
     }
   } else {
     // Generate dynamic call to operator []=.
     const intptr_t checked_argument_count = 2;  // Do not check for value type.
     InstanceCallInstr* store = new (Z) InstanceCallInstr(
         token_pos, Symbols::AssignIndexToken(), Token::kASSIGN_INDEX, arguments,
         kTypeArgsLen, Object::null_array(), checked_argument_count,
-        owner()->ic_data_array(), owner()->GetNextDeoptId());
+        owner()->ic_data_array());
     if (result_is_needed) {
       Do(store);
       return BuildLoadExprTemp(token_pos);
     } else {
       return store;
     }
   }
 }
 
 
@@ skipping 150 matching lines @@
     // Setup arguments for _asyncSetThreadStackTrace.
     ZoneGrowableArray<PushArgumentInstr*>* arguments =
         new (Z) ZoneGrowableArray<PushArgumentInstr*>(1);
     arguments->Add(PushArgument(async_stack_trace_value));
 
     const Function& async_set_thread_stack_trace = Function::ZoneHandle(
         Z, isolate()->object_store()->async_set_thread_stack_trace());
     ASSERT(!async_set_thread_stack_trace.IsNull());
     // Call _asyncSetThreadStackTrace
     const intptr_t kTypeArgsLen = 0;
-    StaticCallInstr* call_async_set_thread_stack_trace = new (Z)
-        StaticCallInstr(node->token_pos().ToSynthetic(),
-                        async_set_thread_stack_trace, kTypeArgsLen,
-                        Object::null_array(), arguments,
-                        owner()->ic_data_array(), owner()->GetNextDeoptId());
+    StaticCallInstr* call_async_set_thread_stack_trace =
+        new (Z) StaticCallInstr(node->token_pos().ToSynthetic(),
+                                async_set_thread_stack_trace, kTypeArgsLen,
+                                Object::null_array(), arguments,
+                                owner()->ic_data_array());
     Do(call_async_set_thread_stack_trace);
   }
 
 
   if (FLAG_support_debugger && is_top_level_sequence &&
       function.is_debuggable()) {
     // Place a debug check at method entry to ensure breaking on a method always
     // happens, even if there are no assignments/calls/runtimecalls in the first
     // basic block. Place this check at the last parameter to ensure parameters
     // are in scope in the debugger at method entry.
@@ skipping 13 matching lines @@
         new (Z) DebugStepCheckInstr(check_pos, RawPcDescriptors::kRuntimeCall));
   }
 
   // This check may be deleted if the generated code is leaf.
   // Native functions don't need a stack check at entry.
   if (is_top_level_sequence && !function.is_native()) {
     // Always allocate CheckOverflowInstr so that deopt-ids match regardless
     // if we inline or not.
     if (!function.IsImplicitGetterFunction() &&
         !function.IsImplicitSetterFunction()) {
-      CheckStackOverflowInstr* check = new (Z) CheckStackOverflowInstr(
-          node->token_pos(), 0, owner()->GetNextDeoptId());
+      CheckStackOverflowInstr* check =
+          new (Z) CheckStackOverflowInstr(node->token_pos(), 0);
       // If we are inlining don't actually attach the stack check. We must still
       // create the stack check in order to allocate a deopt id.
       if (!owner()->IsInlining()) {
         AddInstruction(check);
       }
     }
   }
 
   if (Isolate::Current()->type_checks() && is_top_level_sequence) {
     const int num_params = function.NumParameters();
@@ skipping 19 matching lines @@
   }
 
   // Continuation part:
   // If this node sequence is the body of a function with continuations,
   // leave room for a preamble.
   // The preamble is generated after visiting the body.
   GotoInstr* preamble_start = NULL;
   if (is_top_level_sequence &&
       (function.IsAsyncClosure() || function.IsSyncGenClosure() ||
        function.IsAsyncGenClosure())) {
-    JoinEntryInstr* preamble_end =
-        new (Z) JoinEntryInstr(owner()->AllocateBlockId(), owner()->try_index(),
-                               owner()->GetNextDeoptId());
+    JoinEntryInstr* preamble_end = new (Z)
+        JoinEntryInstr(owner()->AllocateBlockId(), owner()->try_index());
     ASSERT(exit() != NULL);
     exit()->Goto(preamble_end);
     ASSERT(exit()->next()->IsGoto());
     preamble_start = exit()->next()->AsGoto();
     ASSERT(preamble_start->IsGoto());
     exit_ = preamble_end;
   }
 
   intptr_t i = 0;
   while (is_open() && (i < node->length())) {
@@ skipping 121 matching lines @@
   owner()->set_try_index(try_handler_index);
 
   // Preserve current context into local variable ':saved_try_context_var'.
   BuildSaveContext(node->context_var(), ST(node->token_pos()));
 
   EffectGraphVisitor for_try(owner());
   node->try_block()->Visit(&for_try);
 
   if (for_try.is_open()) {
     JoinEntryInstr* after_try = new (Z)
-        JoinEntryInstr(owner()->AllocateBlockId(), original_handler_index,
-                       owner()->GetNextDeoptId());
+        JoinEntryInstr(owner()->AllocateBlockId(), original_handler_index);
     for_try.Goto(after_try);
     for_try.exit_ = after_try;
   }
 
-  JoinEntryInstr* try_entry = new (Z) JoinEntryInstr(
-      owner()->AllocateBlockId(), try_handler_index, owner()->GetNextDeoptId());
+  JoinEntryInstr* try_entry =
+      new (Z) JoinEntryInstr(owner()->AllocateBlockId(), try_handler_index);
 
   Goto(try_entry);
   AppendFragment(try_entry, for_try);
   exit_ = for_try.exit_;
 
   // We are done generating code for the try block.
   owner()->set_try_index(original_handler_index);
 
   // If there is a finally block, it is the handler for code in the catch
   // block.
@@ skipping 19 matching lines @@
       catch_block->token_pos(), (node->token_pos() == TokenPosition::kNoSource),
       owner()->AllocateBlockId(), catch_handler_index, owner()->graph_entry(),
       catch_block->handler_types(), try_handler_index,
       catch_block->exception_var(), catch_block->stacktrace_var(),
       catch_block->needs_stacktrace(), Thread::Current()->GetNextDeoptId());
   owner()->AddCatchEntry(catch_entry);
   AppendFragment(catch_entry, for_catch);
 
   if (for_catch.is_open()) {
     JoinEntryInstr* join = new (Z)
-        JoinEntryInstr(owner()->AllocateBlockId(), original_handler_index,
-                       owner()->GetNextDeoptId());
+        JoinEntryInstr(owner()->AllocateBlockId(), original_handler_index);
     for_catch.Goto(join);
     if (is_open()) Goto(join);
     exit_ = join;
   }
 
   if (finally_block != NULL) {
     ASSERT(node->rethrow_clause() != NULL);
     // Create a handler for the code in the catch block, containing the
     // code in the finally block.
     owner()->set_try_index(original_handler_index);
     EffectGraphVisitor for_finally(owner());
     for_finally.BuildRestoreContext(catch_block->context_var(),
                                     finally_block->token_pos());
 
     node->rethrow_clause()->Visit(&for_finally);
     if (for_finally.is_open()) {
       // Rethrow the exception.  Manually build the graph for rethrow.
       Value* exception = for_finally.Bind(for_finally.BuildLoadLocal(
           catch_block->rethrow_exception_var(), finally_block->token_pos()));
       for_finally.PushArgument(exception);
       Value* stacktrace = for_finally.Bind(for_finally.BuildLoadLocal(
           catch_block->rethrow_stacktrace_var(), finally_block->token_pos()));
       for_finally.PushArgument(stacktrace);
       for_finally.AddInstruction(
-          new (Z) ReThrowInstr(catch_block->token_pos(), catch_handler_index,
-                               owner()->GetNextDeoptId()));
+          new (Z) ReThrowInstr(catch_block->token_pos(), catch_handler_index));
       for_finally.CloseFragment();
     }
     ASSERT(!for_finally.is_open());
 
     const Array& types = Array::ZoneHandle(Z, Array::New(1, Heap::kOld));
     types.SetAt(0, Object::dynamic_type());
     CatchBlockEntryInstr* finally_entry = new (Z) CatchBlockEntryInstr(
         finally_block->token_pos(),
         true,  // this is not a catch block from user code.
         owner()->AllocateBlockId(), original_handler_index,
@@ skipping 42 matching lines @@
     const Class& object_class =
         Class::ZoneHandle(Z, isolate()->object_store()->object_class());
     no_such_method_func = Resolver::ResolveDynamicForReceiverClass(
         object_class, Symbols::NoSuchMethod(), args_desc);
   }
   // We are guaranteed to find noSuchMethod of class Object.
   ASSERT(!no_such_method_func.IsNull());
   ZoneGrowableArray<PushArgumentInstr*>* push_arguments =
       new (Z) ZoneGrowableArray<PushArgumentInstr*>(2);
   BuildPushArguments(*args, push_arguments);
-  return new (Z) StaticCallInstr(
-      args_pos, no_such_method_func, kTypeArgsLen, Object::null_array(),
-      push_arguments, owner()->ic_data_array(), owner()->GetNextDeoptId());
+  return new (Z) StaticCallInstr(args_pos, no_such_method_func, kTypeArgsLen,
+                                 Object::null_array(), push_arguments,
+                                 owner()->ic_data_array());
 }
 
 
 StaticCallInstr* EffectGraphVisitor::BuildThrowNoSuchMethodError(
     TokenPosition token_pos,
     const Class& function_class,
     const String& function_name,
     ArgumentListNode* function_arguments,
     int invocation_type) {
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
@@ skipping 45 matching lines @@
       Class::Handle(Z, core_lib.LookupClass(Symbols::NoSuchMethodError()));
   ASSERT(!cls.IsNull());
   const intptr_t kTypeArgsLen = 0;
   const Function& func = Function::ZoneHandle(
       Z, Resolver::ResolveStatic(
              cls, Library::PrivateCoreLibName(Symbols::ThrowNew()),
              kTypeArgsLen, arguments->length(), Object::null_array()));
   ASSERT(!func.IsNull());
   return new (Z) StaticCallInstr(token_pos, func, kTypeArgsLen,
                                  Object::null_array(),  // No names.
-                                 arguments, owner()->ic_data_array(),
-                                 owner()->GetNextDeoptId());
+                                 arguments, owner()->ic_data_array());
 }
 
 
 void EffectGraphVisitor::BuildThrowNode(ThrowNode* node) {
   if (FLAG_support_debugger) {
     if (node->exception()->IsLiteralNode() ||
         node->exception()->IsLoadLocalNode() ||
         node->exception()->IsLoadStaticFieldNode() ||
         node->exception()->IsClosureNode()) {
       AddInstruction(new (Z) DebugStepCheckInstr(
           node->token_pos(), RawPcDescriptors::kRuntimeCall));
     }
   }
   ValueGraphVisitor for_exception(owner());
   node->exception()->Visit(&for_exception);
   Append(for_exception);
   PushArgument(for_exception.value());
   Instruction* instr = NULL;
   if (node->stacktrace() == NULL) {
-    instr = new (Z) ThrowInstr(node->token_pos(), owner()->GetNextDeoptId());
+    instr = new (Z) ThrowInstr(node->token_pos());
   } else {
     ValueGraphVisitor for_stack_trace(owner());
     node->stacktrace()->Visit(&for_stack_trace);
     Append(for_stack_trace);
     PushArgument(for_stack_trace.value());
-    instr = new (Z) ReThrowInstr(node->token_pos(), owner()->catch_try_index(),
-                                 owner()->GetNextDeoptId());
+    instr = new (Z) ReThrowInstr(node->token_pos(), owner()->catch_try_index());
   }
   AddInstruction(instr);
 }
 
 
 void EffectGraphVisitor::VisitThrowNode(ThrowNode* node) {
   BuildThrowNode(node);
   CloseFragment();
 }
 
@@ skipping 19 matching lines @@
     owner()->set_try_index(outer_try_index);
   }
 
   // Note: do not restore the saved_try_context here since the inlined
   // code is not reached via an exception handler, therefore the context is
   // always properly set on entry. In other words, the inlined finally clause is
   // never the target of a long jump that would find an uninitialized current
   // context variable.
 
   JoinEntryInstr* finally_entry =
-      new (Z) JoinEntryInstr(owner()->AllocateBlockId(), owner()->try_index(),
-                             owner()->GetNextDeoptId());
+      new (Z) JoinEntryInstr(owner()->AllocateBlockId(), owner()->try_index());
   EffectGraphVisitor for_finally_block(owner());
   for_finally_block.AdjustContextLevel(node->finally_block()->scope());
   node->finally_block()->Visit(&for_finally_block);
 
   if (try_index >= 0) {
     owner()->set_try_index(try_index);
   }
 
   if (for_finally_block.is_open()) {
-    JoinEntryInstr* after_finally =
-        new (Z) JoinEntryInstr(owner()->AllocateBlockId(), owner()->try_index(),
-                               owner()->GetNextDeoptId());
+    JoinEntryInstr* after_finally = new (Z)
+        JoinEntryInstr(owner()->AllocateBlockId(), owner()->try_index());
     for_finally_block.Goto(after_finally);
     for_finally_block.exit_ = after_finally;
   }
 
   Goto(finally_entry);
   AppendFragment(finally_entry, for_finally_block);
   exit_ = for_finally_block.exit_;
 }
 
 
 void EffectGraphVisitor::VisitStopNode(StopNode* node) {
   AddInstruction(new (Z) StopInstr(node->message()));
 }
 
 
 FlowGraph* FlowGraphBuilder::BuildGraph() {
   VMTagScope tagScope(thread(), VMTag::kCompileFlowGraphBuilderTagId,
                       FLAG_profile_vm);
   if (FLAG_support_ast_printer && FLAG_print_ast &&
       FlowGraphPrinter::ShouldPrint(parsed_function().function())) {
     // Print the function ast before IL generation.
     AstPrinter ast_printer;
     ast_printer.PrintFunctionNodes(parsed_function());
   }
   if (FLAG_support_ast_printer && FLAG_print_scopes &&
       FlowGraphPrinter::ShouldPrint(parsed_function().function())) {
     AstPrinter ast_printer;
     ast_printer.PrintFunctionScope(parsed_function());
   }
-  TargetEntryInstr* normal_entry = new (Z) TargetEntryInstr(
-      AllocateBlockId(), CatchClauseNode::kInvalidTryIndex, GetNextDeoptId());
+  TargetEntryInstr* normal_entry = new (Z)
+      TargetEntryInstr(AllocateBlockId(), CatchClauseNode::kInvalidTryIndex);
   graph_entry_ =
       new (Z) GraphEntryInstr(parsed_function(), normal_entry, osr_id_);
   EffectGraphVisitor for_effect(this);
   parsed_function().node_sequence()->Visit(&for_effect);
   AppendFragment(normal_entry, for_effect);
   // Check that the graph is properly terminated.
   ASSERT(!for_effect.is_open());
 
   // When compiling for OSR, use a depth first search to prune instructions
   // unreachable from the OSR entry. Catch entries are always considered
@@ skipping 38 matching lines @@
   ASSERT(type.HasResolvedTypeClass());
   const Class& type_class = Class::Handle(type.type_class());
   // Bail if the type has any type parameters.
   if (type_class.IsGeneric()) return false;
 
   // Finally a simple class for instance of checking.
   return true;
 }
 
 }  // namespace dart