Reapply "Shuffle around deopt id allocation...

runtime/vm/branch_optimizer.cc

 // Copyright (c) 2016, 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/branch_optimizer.h"
 
 #include "vm/flow_graph.h"
 #include "vm/intermediate_language.h"
 
 namespace dart {
@@ skipping 47 matching lines @@
          PhiHasSingleUse(phi, left) && (block->next() == branch) &&
          (block->phis()->length() == 1);
 }
 
 
 JoinEntryInstr* BranchSimplifier::ToJoinEntry(Zone* zone,
                                               TargetEntryInstr* target) {
   // 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());
   target->UnuseAllInputs();
   return join;
 }
 
 
 BranchInstr* BranchSimplifier::CloneBranch(Zone* zone,
                                            BranchInstr* branch,
                                            Value* new_left,
                                            Value* new_right) {
   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;
 }
 
 
 void BranchSimplifier::Simplify(FlowGraph* flow_graph) {
   // Optimize some branches that test the value of a phi.  When it is safe
   // to do so, push the branch to each of the predecessor blocks.  This is
   // an optimization when (a) it can avoid materializing a boolean object at
   // the phi only to test its value, and (b) it can expose opportunities for
   // constant propagation and unreachable code elimination.  This
@@ skipping 80 matching lines @@
         old_goto->UnuseAllInputs();
 
         // Update the predecessor block.  We may have created another
         // instance of the pattern so add it to the worklist if necessary.
         BlockEntryInstr* branch_block = new_branch->GetBlock();
         branch_block->set_last_instruction(new_branch);
         if (branch_block->IsJoinEntry()) worklist.Add(branch_block);
 
         // 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);
       }
       // When all predecessors have been rewritten, the original block is
       // unreachable from the graph.
       phi->UnuseAllInputs();
       branch->UnuseAllInputs();
       block->UnuseAllInputs();
       ASSERT(!phi->HasUses());
@@ skipping 78 matching lines @@
 
         // Check if the platform supports efficient branchless IfThenElseInstr
         // for the given combination of comparison and values flowing from
         // false and true paths.
         if (IfThenElseInstr::Supports(comparison, v1, v2)) {
           Value* if_true = (pred1 == branch->true_successor()) ? v1 : v2;
           Value* if_false = (pred2 == branch->true_successor()) ? v1 : v2;
 
           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);
 
           phi->ReplaceUsesWith(if_then_else);
 
           // Connect IfThenElseInstr to the first instruction in the merge block
           // effectively eliminating diamond control flow.
           // Current block as well as pred1 and pred2 blocks are no longer in
           // the graph at this point.
           if_then_else->LinkTo(join->next());
@@ skipping 25 matching lines @@
   if (changed) {
     // We may have changed the block order and the dominator tree.
     flow_graph->DiscoverBlocks();
     GrowableArray<BitVector*> dominance_frontier;
     flow_graph->ComputeDominators(&dominance_frontier);
   }
 }
 
 
 }  // namespace dart