Shuffle around deopt id allocation to give the flow graph builder a chance to record other data as they are allocated.

We'll use deopt-id -> context-level or deopt-id -> scope mappings to find what variables are in scope for the debugger and async stack trace machinery.

R=vegorov@google.com

Review-Url: https://codereview.chromium.org/2896903002 .

Author: rmacnak-google

runtime/vm/aot_optimizer.cc

@@ -710,7 +710,7 @@ bool AotOptimizer::TryReplaceWithEqualityOp(InstanceCallInstr* call,
         StrictCompareInstr* comp = new (Z)
             StrictCompareInstr(call->token_pos(), Token::kEQ_STRICT,
                                new (Z) Value(left), new (Z) Value(right),
-                               false);  // No number check.
+                               /* number_check = */ false, Thread::kNoDeoptId);
         ReplaceCall(call, comp);
         return true;
       }
@@ -1441,10 +1441,9 @@ void AotOptimizer::ReplaceWithInstanceOf(InstanceCallInstr* call) {
     ConstantInstr* cid =
         flow_graph()->GetConstant(Smi::Handle(Z, Smi::New(type_cid)));
 
-    StrictCompareInstr* check_cid =
-        new (Z) StrictCompareInstr(call->token_pos(), Token::kEQ_STRICT,
-                                   new (Z) Value(left_cid), new (Z) Value(cid),
-                                   false);  // No number check.
+    StrictCompareInstr* check_cid = new (Z) StrictCompareInstr(
+        call->token_pos(), Token::kEQ_STRICT, new (Z) Value(left_cid),
+        new (Z) Value(cid), /* number_check = */ false, Thread::kNoDeoptId);
     ReplaceCall(call, check_cid);
     return;
   }

runtime/vm/branch_optimizer.cc

@@ -65,8 +65,8 @@ JoinEntryInstr* BranchSimplifier::ToJoinEntry(Zone* zone,
   // Convert a target block into a join block.  Branches will be duplicated
   // so the former true and false targets become joins of the control flows
   // from all the duplicated branches.
-  JoinEntryInstr* join =
-      new (zone) JoinEntryInstr(target->block_id(), target->try_index());
+  JoinEntryInstr* join = new (zone) JoinEntryInstr(
+      target->block_id(), target->try_index(), Thread::kNoDeoptId);
   join->InheritDeoptTarget(zone, target);
   join->LinkTo(target->next());
   join->set_last_instruction(target->last_instruction());
@@ -82,7 +82,8 @@ BranchInstr* BranchSimplifier::CloneBranch(Zone* zone,
   ComparisonInstr* comparison = branch->comparison();
   ComparisonInstr* new_comparison =
       comparison->CopyWithNewOperands(new_left, new_right);
-  BranchInstr* new_branch = new (zone) BranchInstr(new_comparison);
+  BranchInstr* new_branch =
+      new (zone) BranchInstr(new_comparison, Thread::kNoDeoptId);
   return new_branch;
 }
 
@@ -183,20 +184,24 @@ void BranchSimplifier::Simplify(FlowGraph* flow_graph) {
 
         // Connect the branch to the true and false joins, via empty target
         // blocks.
-        TargetEntryInstr* true_target = new (zone) TargetEntryInstr(
-            flow_graph->max_block_id() + 1, block->try_index());
+        TargetEntryInstr* true_target =
+            new (zone) TargetEntryInstr(flow_graph->max_block_id() + 1,
+                                        block->try_index(), Thread::kNoDeoptId);
         true_target->InheritDeoptTarget(zone, join_true);
-        TargetEntryInstr* false_target = new (zone) TargetEntryInstr(
-            flow_graph->max_block_id() + 2, block->try_index());
+        TargetEntryInstr* false_target =
+            new (zone) TargetEntryInstr(flow_graph->max_block_id() + 2,
+                                        block->try_index(), Thread::kNoDeoptId);
         false_target->InheritDeoptTarget(zone, join_false);
         flow_graph->set_max_block_id(flow_graph->max_block_id() + 2);
         *new_branch->true_successor_address() = true_target;
         *new_branch->false_successor_address() = false_target;
-        GotoInstr* goto_true = new (zone) GotoInstr(join_true);
+        GotoInstr* goto_true =
+            new (zone) GotoInstr(join_true, Thread::kNoDeoptId);
         goto_true->InheritDeoptTarget(zone, join_true);
         true_target->LinkTo(goto_true);
         true_target->set_last_instruction(goto_true);
-        GotoInstr* goto_false = new (zone) GotoInstr(join_false);
+        GotoInstr* goto_false =
+            new (zone) GotoInstr(join_false, Thread::kNoDeoptId);
         goto_false->InheritDeoptTarget(zone, join_false);
         false_target->LinkTo(goto_false);
         false_target->set_last_instruction(goto_false);
@@ -295,8 +300,9 @@ void IfConverter::Simplify(FlowGraph* flow_graph) {
 
           ComparisonInstr* new_comparison = comparison->CopyWithNewOperands(
               comparison->left()->Copy(zone), comparison->right()->Copy(zone));
-          IfThenElseInstr* if_then_else = new (zone) IfThenElseInstr(
-              new_comparison, if_true->Copy(zone), if_false->Copy(zone));
+          IfThenElseInstr* if_then_else = new (zone)
+              IfThenElseInstr(new_comparison, if_true->Copy(zone),
+                              if_false->Copy(zone), Thread::kNoDeoptId);
           flow_graph->InsertBefore(branch, if_then_else, NULL,
                                    FlowGraph::kValue);
 

runtime/vm/constant_propagator.cc

@@ -1551,7 +1551,8 @@ void ConstantPropagator::EliminateRedundantBranches() {
         // Drop the comparison, which does not have side effects
         JoinEntryInstr* join = if_true->AsJoinEntry();
         if (join->phis() == NULL) {
-          GotoInstr* jump = new (Z) GotoInstr(if_true->AsJoinEntry());
+          GotoInstr* jump =
+              new (Z) GotoInstr(if_true->AsJoinEntry(), Thread::kNoDeoptId);
           jump->InheritDeoptTarget(Z, branch);
 
           Instruction* previous = branch->previous();
@@ -1694,16 +1695,16 @@ void ConstantPropagator::Transform() {
         ASSERT(reachable_->Contains(if_false->preorder_number()));
         ASSERT(if_false->parallel_move() == NULL);
         ASSERT(if_false->loop_info() == NULL);
-        join =
-            new (Z) JoinEntryInstr(if_false->block_id(), if_false->try_index());
+        join = new (Z) JoinEntryInstr(
+            if_false->block_id(), if_false->try_index(), Thread::kNoDeoptId);
         join->InheritDeoptTarget(Z, if_false);
         if_false->UnuseAllInputs();
         next = if_false->next();
       } else if (!reachable_->Contains(if_false->preorder_number())) {
         ASSERT(if_true->parallel_move() == NULL);
         ASSERT(if_true->loop_info() == NULL);
-        join =
-            new (Z) JoinEntryInstr(if_true->block_id(), if_true->try_index());
+        join = new (Z) JoinEntryInstr(if_true->block_id(), if_true->try_index(),
+                                      Thread::kNoDeoptId);
         join->InheritDeoptTarget(Z, if_true);
         if_true->UnuseAllInputs();
         next = if_true->next();
@@ -1714,7 +1715,7 @@ void ConstantPropagator::Transform() {
         // Drop the comparison, which does not have side effects as long
         // as it is a strict compare (the only one we can determine is
         // constant with the current analysis).
-        GotoInstr* jump = new (Z) GotoInstr(join);
+        GotoInstr* jump = new (Z) GotoInstr(join, Thread::kNoDeoptId);
         jump->InheritDeoptTarget(Z, branch);
 
         Instruction* previous = branch->previous();

runtime/vm/flow_graph.cc

@@ -1018,7 +1018,8 @@ void FlowGraph::Rename(GrowableArray<PhiInstr*>* live_phis,
     for (intptr_t i = parameter_count(); i < variable_count(); ++i) {
       if (i == CurrentContextEnvIndex()) {
         if (function().IsClosureFunction()) {
-          CurrentContextInstr* context = new CurrentContextInstr();
+          CurrentContextInstr* context =
+              new CurrentContextInstr(Thread::kNoDeoptId);
           context->set_ssa_temp_index(alloc_ssa_temp_index());  // New SSA temp.
           AddToInitialDefinitions(context);
           env.Add(context);