Reapply "Shuffle around deopt id allocation...

runtime/vm/flow_graph_inliner.cc

 // 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.
 #if !defined(DART_PRECOMPILED_RUNTIME)
 #include "vm/flow_graph_inliner.h"
 
 #include "vm/aot_optimizer.h"
 #include "vm/precompiler.h"
 #include "vm/block_scheduler.h"
 #include "vm/branch_optimizer.h"
@@ skipping 1462 matching lines @@
         inlined_entries_[i]->AsGraphEntry()->UnuseAllInputs();
 
         JoinEntryInstr* new_join =
             BranchSimplifier::ToJoinEntry(zone(), old_target);
         old_target->ReplaceAsPredecessorWith(new_join);
         for (intptr_t j = 0; j < old_target->dominated_blocks().length(); ++j) {
           BlockEntryInstr* block = old_target->dominated_blocks()[j];
           new_join->AddDominatedBlock(block);
         }
         // Create a new target with the join as unconditional successor.
-        TargetEntryInstr* new_target =
-            new TargetEntryInstr(AllocateBlockId(), old_target->try_index());
+        TargetEntryInstr* new_target = new TargetEntryInstr(
+            AllocateBlockId(), old_target->try_index(), Thread::kNoDeoptId);
         new_target->InheritDeoptTarget(zone(), new_join);
-        GotoInstr* new_goto = new (Z) GotoInstr(new_join);
+        GotoInstr* new_goto = new (Z) GotoInstr(new_join, Thread::kNoDeoptId);
         new_goto->InheritDeoptTarget(zone(), new_join);
         new_target->LinkTo(new_goto);
         new_target->set_last_instruction(new_goto);
         new_join->predecessors_.Add(new_target);
 
         // Record the new target for the first variant.
         inlined_entries_[i] = new_target;
       }
       ASSERT(inlined_entries_[i]->IsTargetEntry());
       // Record the shared join for this variant.
@@ skipping 118 matching lines @@
       owner_->caller_graph()->alloc_ssa_temp_index());
   if (FlowGraphInliner::TryInlineRecognizedMethod(
           owner_->caller_graph(), receiver_cid, target, call_, redefinition,
           call_->instance_call()->token_pos(),
           *call_->instance_call()->ic_data(), &entry, &last)) {
     // Create a graph fragment.
     redefinition->InsertAfter(entry);
     InlineExitCollector* exit_collector =
         new (Z) InlineExitCollector(owner_->caller_graph(), call_);
 
-    ReturnInstr* result = new (Z)
-        ReturnInstr(call_->instance_call()->token_pos(), new (Z) Value(last));
+    ReturnInstr* result =
+        new (Z) ReturnInstr(call_->instance_call()->token_pos(),
+                            new (Z) Value(last), Thread::kNoDeoptId);
     owner_->caller_graph()->AppendTo(
         last, result,
         call_->env(),  // Return can become deoptimization target.
         FlowGraph::kEffect);
     entry->set_last_instruction(result);
     exit_collector->AddExit(result);
     ParsedFunction* temp_parsed_function =
         new ParsedFunction(Thread::Current(), target);
     GraphEntryInstr* graph_entry = new (Z)
         GraphEntryInstr(*temp_parsed_function, entry, Compiler::kNoOSRDeoptId);
     // Update polymorphic inliner state.
     inlined_entries_.Add(graph_entry);
     exit_collector_->Union(exit_collector);
     return true;
   }
   return false;
 }
 
 
 // Build a DAG to dispatch to the inlined function bodies.  Load the class
 // id of the receiver and make explicit comparisons for each inlined body,
 // in frequency order.  If all variants are inlined, the entry to the last
 // inlined body is guarded by a CheckClassId instruction which can deopt.
 // If not all variants are inlined, we add a PolymorphicInstanceCall
 // instruction to handle the non-inlined variants.
 TargetEntryInstr* PolymorphicInliner::BuildDecisionGraph() {
   const intptr_t try_idx = call_->GetBlock()->try_index();
 
   // Start with a fresh target entry.
-  TargetEntryInstr* entry =
-      new (Z) TargetEntryInstr(AllocateBlockId(), try_idx);
+  TargetEntryInstr* entry = new (Z) TargetEntryInstr(
+      AllocateBlockId(), try_idx, Thread::Current()->GetNextDeoptId());
   entry->InheritDeoptTarget(zone(), call_);
 
   // This function uses a cursor (a pointer to the 'current' instruction) to
   // build the graph.  The next instruction will be inserted after the
   // cursor.
   BlockEntryInstr* current_block = entry;
   Instruction* cursor = entry;
 
   Definition* receiver = call_->ArgumentAt(0);
   // There are at least two variants including non-inlined ones, so we have
@@ skipping 44 matching lines @@
         for (intptr_t j = 0; j < target->dominated_blocks().length(); ++j) {
           BlockEntryInstr* block = target->dominated_blocks()[j];
           current_block->AddDominatedBlock(block);
         }
       } else if (callee_entry->IsJoinEntry()) {
         // Shared inlined body and this is a subsequent entry.  We have
         // already constructed a join and set its dominator.  Add a jump to
         // the join.
         JoinEntryInstr* join = callee_entry->AsJoinEntry();
         ASSERT(join->dominator() != NULL);
-        GotoInstr* goto_join = new GotoInstr(join);
+        GotoInstr* goto_join = new GotoInstr(join, Thread::kNoDeoptId);
         goto_join->InheritDeoptTarget(zone(), join);
         cursor->LinkTo(goto_join);
         current_block->set_last_instruction(goto_join);
       } else {
         // There is no possibility of a TargetEntry (the first entry to a
         // shared inlined body) because this is the last inlined entry.
         UNREACHABLE();
       }
       cursor = NULL;
     } else {
       // For all variants except the last, use a branch on the loaded class
       // id.
       const Smi& cid = Smi::ZoneHandle(Smi::New(variant.cid_start));
       ConstantInstr* cid_constant = owner_->caller_graph()->GetConstant(cid);
       BranchInstr* branch;
       BranchInstr* upper_limit_branch = NULL;
       BlockEntryInstr* cid_test_entry_block = current_block;
       if (test_is_range) {
         // Double branch for testing a range of Cids.  TODO(erikcorry): Make a
         // special instruction that uses subtraction and unsigned comparison to
         // do this with a single branch.
         const Smi& cid_end = Smi::ZoneHandle(Smi::New(variant.cid_end));
         ConstantInstr* cid_constant_end =
             owner_->caller_graph()->GetConstant(cid_end);
         RelationalOpInstr* compare_top = new RelationalOpInstr(
             call_->instance_call()->token_pos(), Token::kLTE,
             new Value(load_cid), new Value(cid_constant_end), kSmiCid,
             call_->deopt_id());
         BranchInstr* branch_top = upper_limit_branch =
-            new BranchInstr(compare_top);
+            new BranchInstr(compare_top, Thread::kNoDeoptId);
         branch_top->InheritDeoptTarget(zone(), call_);
         cursor = AppendInstruction(cursor, branch_top);
         current_block->set_last_instruction(branch_top);
 
-        TargetEntryInstr* below_target =
-            new TargetEntryInstr(AllocateBlockId(), try_idx);
+        TargetEntryInstr* below_target = new TargetEntryInstr(
+            AllocateBlockId(), try_idx, Thread::kNoDeoptId);
         below_target->InheritDeoptTarget(zone(), call_);
         current_block->AddDominatedBlock(below_target);
         cursor = current_block = below_target;
         *branch_top->true_successor_address() = below_target;
 
         RelationalOpInstr* compare_bottom = new RelationalOpInstr(
             call_->instance_call()->token_pos(), Token::kGTE,
             new Value(load_cid), new Value(cid_constant), kSmiCid,
             call_->deopt_id());
-        branch = new BranchInstr(compare_bottom);
+        branch = new BranchInstr(compare_bottom, Thread::kNoDeoptId);
       } else {
         StrictCompareInstr* compare = new StrictCompareInstr(
             call_->instance_call()->token_pos(), Token::kEQ_STRICT,
             new Value(load_cid), new Value(cid_constant),
-            false);  // No number check.
-        branch = new BranchInstr(compare);
+            /* number_check = */ false, Thread::kNoDeoptId);
+        branch = new BranchInstr(compare, Thread::kNoDeoptId);
       }
 
       branch->InheritDeoptTarget(zone(), call_);
       cursor = AppendInstruction(cursor, branch);
       current_block->set_last_instruction(branch);
       cursor = NULL;
 
       // 2. Handle a match by linking to the inlined body.  There are three
       // cases (unshared, shared first predecessor, and shared subsequent
       // predecessors).
@@ skipping 10 matching lines @@
         true_target = callee_entry->AsTargetEntry();
         BlockEntryInstr* join = true_target->last_instruction()->SuccessorAt(0);
         current_block->AddDominatedBlock(join);
       } else {
         // Shared inlined body and this is a subsequent entry.  We have
         // already constructed a join.  We need a fresh target that jumps to
         // the join.
         JoinEntryInstr* join = callee_entry->AsJoinEntry();
         ASSERT(join != NULL);
         ASSERT(join->dominator() != NULL);
-        true_target = new TargetEntryInstr(AllocateBlockId(), try_idx);
+        true_target = new TargetEntryInstr(AllocateBlockId(), try_idx,
+                                           Thread::kNoDeoptId);
         true_target->InheritDeoptTarget(zone(), join);
-        GotoInstr* goto_join = new GotoInstr(join);
+        GotoInstr* goto_join = new GotoInstr(join, Thread::kNoDeoptId);
         goto_join->InheritDeoptTarget(zone(), join);
         true_target->LinkTo(goto_join);
         true_target->set_last_instruction(goto_join);
       }
       *branch->true_successor_address() = true_target;
       current_block->AddDominatedBlock(true_target);
 
       // 3. Prepare to handle a match failure on the next iteration or the
       // fall-through code below for non-inlined variants.
 
       TargetEntryInstr* false_target =
-          new TargetEntryInstr(AllocateBlockId(), try_idx);
+          new TargetEntryInstr(AllocateBlockId(), try_idx, Thread::kNoDeoptId);
       false_target->InheritDeoptTarget(zone(), call_);
       *branch->false_successor_address() = false_target;
       cid_test_entry_block->AddDominatedBlock(false_target);
 
       cursor = current_block = false_target;
 
       if (test_is_range) {
         // If we tested against a range of Cids there are two different tests
         // that can go to the no-cid-match target.
-        JoinEntryInstr* join = new JoinEntryInstr(AllocateBlockId(), try_idx);
-        TargetEntryInstr* false_target2 =
-            new TargetEntryInstr(AllocateBlockId(), try_idx);
+        JoinEntryInstr* join =
+            new JoinEntryInstr(AllocateBlockId(), try_idx, Thread::kNoDeoptId);
+        TargetEntryInstr* false_target2 = new TargetEntryInstr(
+            AllocateBlockId(), try_idx, Thread::kNoDeoptId);
         *upper_limit_branch->false_successor_address() = false_target2;
         cid_test_entry_block->AddDominatedBlock(false_target2);
         cid_test_entry_block->AddDominatedBlock(join);
-        GotoInstr* goto_1 = new GotoInstr(join);
-        GotoInstr* goto_2 = new GotoInstr(join);
+        GotoInstr* goto_1 = new GotoInstr(join, Thread::kNoDeoptId);
+        GotoInstr* goto_2 = new GotoInstr(join, Thread::kNoDeoptId);
         false_target->LinkTo(goto_1);
         false_target2->LinkTo(goto_2);
         false_target->set_last_instruction(goto_1);
         false_target2->set_last_instruction(goto_2);
 
         join->InheritDeoptTarget(zone(), call_);
         false_target2->InheritDeoptTarget(zone(), call_);
         goto_1->InheritDeoptTarget(zone(), call_);
         goto_2->InheritDeoptTarget(zone(), call_);
 
@@ skipping 12 matching lines @@
       cursor->LinkTo(push);
       cursor = push;
     }
     PolymorphicInstanceCallInstr* fallback_call =
         new PolymorphicInstanceCallInstr(
             call_->instance_call(), *non_inlined_variants_, call_->complete());
     fallback_call->set_ssa_temp_index(
         owner_->caller_graph()->alloc_ssa_temp_index());
     fallback_call->InheritDeoptTarget(zone(), call_);
     fallback_call->set_total_call_count(call_->CallCount());
-    ReturnInstr* fallback_return = new ReturnInstr(
-        call_->instance_call()->token_pos(), new Value(fallback_call));
+    ReturnInstr* fallback_return =
+        new ReturnInstr(call_->instance_call()->token_pos(),
+                        new Value(fallback_call), Thread::kNoDeoptId);
     fallback_return->InheritDeoptTargetAfter(owner_->caller_graph(), call_,
                                              fallback_call);
     AppendInstruction(AppendInstruction(cursor, fallback_call),
                       fallback_return);
     exit_collector_->AddExit(fallback_return);
     cursor = NULL;
   } else {
     // Remove push arguments of the call.
     for (intptr_t i = 0; i < call_->ArgumentCount(); ++i) {
       PushArgumentInstr* push = call_->PushArgumentAt(i);
@@ skipping 355 matching lines @@
 static bool InlineGetIndexed(FlowGraph* flow_graph,
                              MethodRecognizer::Kind kind,
                              Instruction* call,
                              Definition* receiver,
                              TargetEntryInstr** entry,
                              Definition** last) {
   intptr_t array_cid = MethodRecognizer::MethodKindToReceiverCid(kind);
 
   Definition* array = receiver;
   Definition* index = call->ArgumentAt(1);
-  *entry = new (Z) TargetEntryInstr(flow_graph->allocate_block_id(),
-                                    call->GetBlock()->try_index());
+  *entry = new (Z)
+      TargetEntryInstr(flow_graph->allocate_block_id(),
+                       call->GetBlock()->try_index(), Thread::kNoDeoptId);
   (*entry)->InheritDeoptTarget(Z, call);
   Instruction* cursor = *entry;
 
   array_cid = PrepareInlineIndexedOp(flow_graph, call, array_cid, &array, index,
                                      &cursor);
 
   intptr_t deopt_id = Thread::kNoDeoptId;
   if ((array_cid == kTypedDataInt32ArrayCid) ||
       (array_cid == kTypedDataUint32ArrayCid)) {
     // Deoptimization may be needed if result does not always fit in a Smi.
@@ skipping 27 matching lines @@
                              TokenPosition token_pos,
                              const Cids* value_check,
                              TargetEntryInstr** entry,
                              Definition** last) {
   intptr_t array_cid = MethodRecognizer::MethodKindToReceiverCid(kind);
 
   Definition* array = receiver;
   Definition* index = call->ArgumentAt(1);
   Definition* stored_value = call->ArgumentAt(2);
 
-  *entry = new (Z) TargetEntryInstr(flow_graph->allocate_block_id(),
-                                    call->GetBlock()->try_index());
+  *entry = new (Z)
+      TargetEntryInstr(flow_graph->allocate_block_id(),
+                       call->GetBlock()->try_index(), Thread::kNoDeoptId);
   (*entry)->InheritDeoptTarget(Z, call);
   Instruction* cursor = *entry;
   if (flow_graph->isolate()->type_checks()) {
     // Only type check for the value. A type check for the index is not
     // needed here because we insert a deoptimizing smi-check for the case
     // the index is not a smi.
     const AbstractType& value_type =
         AbstractType::ZoneHandle(Z, target.ParameterTypeAt(2));
     Definition* type_args = NULL;
     switch (array_cid) {
@@ skipping 115 matching lines @@
                            Instruction* call,
                            Definition* receiver,
                            TargetEntryInstr** entry,
                            Definition** last) {
   if (!CanUnboxDouble()) {
     return false;
   }
   Definition* left = receiver;
   Definition* right = call->ArgumentAt(1);
 
-  *entry = new (Z) TargetEntryInstr(flow_graph->allocate_block_id(),
-                                    call->GetBlock()->try_index());
+  *entry = new (Z)
+      TargetEntryInstr(flow_graph->allocate_block_id(),
+                       call->GetBlock()->try_index(), Thread::kNoDeoptId);
   (*entry)->InheritDeoptTarget(Z, call);
   // Arguments are checked. No need for class check.
   BinaryDoubleOpInstr* double_bin_op = new (Z)
       BinaryDoubleOpInstr(op_kind, new (Z) Value(left), new (Z) Value(right),
                           call->deopt_id(), call->token_pos());
   flow_graph->AppendTo(*entry, double_bin_op, call->env(), FlowGraph::kValue);
   *last = double_bin_op;
 
   return true;
 }
 
 
 static bool InlineDoubleTestOp(FlowGraph* flow_graph,
                                Instruction* call,
                                Definition* receiver,
                                MethodRecognizer::Kind kind,
                                TargetEntryInstr** entry,
                                Definition** last) {
   if (!CanUnboxDouble()) {
     return false;
   }
 
-  *entry = new (Z) TargetEntryInstr(flow_graph->allocate_block_id(),
-                                    call->GetBlock()->try_index());
+  *entry = new (Z)
+      TargetEntryInstr(flow_graph->allocate_block_id(),
+                       call->GetBlock()->try_index(), Thread::kNoDeoptId);
   (*entry)->InheritDeoptTarget(Z, call);
   // Arguments are checked. No need for class check.
 
   DoubleTestOpInstr* double_test_op = new (Z) DoubleTestOpInstr(
       kind, new (Z) Value(receiver), call->deopt_id(), call->token_pos());
   flow_graph->AppendTo(*entry, double_test_op, call->env(), FlowGraph::kValue);
   *last = double_test_op;
 
   return true;
 }
 
 
 static bool InlineSmiBitAndFromSmi(FlowGraph* flow_graph,
                                    Instruction* call,
                                    Definition* receiver,
                                    TargetEntryInstr** entry,
                                    Definition** last) {
   Definition* left = receiver;
   Definition* right = call->ArgumentAt(1);
 
-  *entry = new (Z) TargetEntryInstr(flow_graph->allocate_block_id(),
-                                    call->GetBlock()->try_index());
+  *entry = new (Z)
+      TargetEntryInstr(flow_graph->allocate_block_id(),
+                       call->GetBlock()->try_index(), Thread::kNoDeoptId);
   (*entry)->InheritDeoptTarget(Z, call);
   // Right arguments is known to be smi: other._bitAndFromSmi(this);
   BinarySmiOpInstr* smi_op =
       new (Z) BinarySmiOpInstr(Token::kBIT_AND, new (Z) Value(left),
                                new (Z) Value(right), call->deopt_id());
   flow_graph->AppendTo(*entry, smi_op, call->env(), FlowGraph::kValue);
   *last = smi_op;
 
   return true;
 }
 
 
 static bool InlineGrowableArraySetter(FlowGraph* flow_graph,
                                       intptr_t offset,
                                       StoreBarrierType store_barrier_type,
                                       Instruction* call,
                                       Definition* receiver,
                                       TargetEntryInstr** entry,
                                       Definition** last) {
   Definition* array = receiver;
   Definition* value = call->ArgumentAt(1);
 
-  *entry = new (Z) TargetEntryInstr(flow_graph->allocate_block_id(),
-                                    call->GetBlock()->try_index());
+  *entry = new (Z)
+      TargetEntryInstr(flow_graph->allocate_block_id(),
+                       call->GetBlock()->try_index(), Thread::kNoDeoptId);
   (*entry)->InheritDeoptTarget(Z, call);
 
   // This is an internal method, no need to check argument types.
   StoreInstanceFieldInstr* store = new (Z) StoreInstanceFieldInstr(
       offset, new (Z) Value(array), new (Z) Value(value), store_barrier_type,
       call->token_pos());
   flow_graph->AppendTo(*entry, store, call->env(), FlowGraph::kEffect);
   *last = store;
 
   return true;
@@ skipping 64 matching lines @@
 static bool InlineByteArrayBaseLoad(FlowGraph* flow_graph,
                                     Instruction* call,
                                     Definition* receiver,
                                     intptr_t array_cid,
                                     intptr_t view_cid,
                                     TargetEntryInstr** entry,
                                     Definition** last) {
   ASSERT(array_cid != kIllegalCid);
   Definition* array = receiver;
   Definition* index = call->ArgumentAt(1);
-  *entry = new (Z) TargetEntryInstr(flow_graph->allocate_block_id(),
-                                    call->GetBlock()->try_index());
+  *entry = new (Z)
+      TargetEntryInstr(flow_graph->allocate_block_id(),
+                       call->GetBlock()->try_index(), Thread::kNoDeoptId);
   (*entry)->InheritDeoptTarget(Z, call);
   Instruction* cursor = *entry;
 
   PrepareInlineByteArrayBaseOp(flow_graph, call, array_cid, view_cid, &array,
                                index, &cursor);
 
   intptr_t deopt_id = Thread::kNoDeoptId;
   if ((array_cid == kTypedDataInt32ArrayCid) ||
       (array_cid == kTypedDataUint32ArrayCid)) {
     // Deoptimization may be needed if result does not always fit in a Smi.
@@ skipping 21 matching lines @@
                                      const Function& target,
                                      Instruction* call,
                                      Definition* receiver,
                                      intptr_t array_cid,
                                      intptr_t view_cid,
                                      TargetEntryInstr** entry,
                                      Definition** last) {
   ASSERT(array_cid != kIllegalCid);
   Definition* array = receiver;
   Definition* index = call->ArgumentAt(1);
-  *entry = new (Z) TargetEntryInstr(flow_graph->allocate_block_id(),
-                                    call->GetBlock()->try_index());
+  *entry = new (Z)
+      TargetEntryInstr(flow_graph->allocate_block_id(),
+                       call->GetBlock()->try_index(), Thread::kNoDeoptId);
   (*entry)->InheritDeoptTarget(Z, call);
   Instruction* cursor = *entry;
 
   PrepareInlineByteArrayBaseOp(flow_graph, call, array_cid, view_cid, &array,
                                index, &cursor);
 
   // Extract the instance call so we can use the function_name in the stored
   // value check ICData.
   InstanceCallInstr* i_call = NULL;
   if (call->IsPolymorphicInstanceCall()) {
@@ skipping 144 matching lines @@
                                    Definition* receiver,
                                    intptr_t cid,
                                    TargetEntryInstr** entry,
                                    Definition** last) {
   if ((cid != kOneByteStringCid) && (cid != kExternalOneByteStringCid)) {
     return false;
   }
   Definition* str = receiver;
   Definition* index = call->ArgumentAt(1);
 
-  *entry = new (Z) TargetEntryInstr(flow_graph->allocate_block_id(),
-                                    call->GetBlock()->try_index());
+  *entry = new (Z)
+      TargetEntryInstr(flow_graph->allocate_block_id(),
+                       call->GetBlock()->try_index(), Thread::kNoDeoptId);
   (*entry)->InheritDeoptTarget(Z, call);
 
   *last = PrepareInlineStringIndexOp(flow_graph, call, cid, str, index, *entry);
 
   OneByteStringFromCharCodeInstr* char_at =
       new (Z) OneByteStringFromCharCodeInstr(new (Z) Value(*last));
 
   flow_graph->AppendTo(*last, char_at, NULL, FlowGraph::kValue);
   *last = char_at;
 
   return true;
 }
 
 
 static bool InlineStringCodeUnitAt(FlowGraph* flow_graph,
                                    Instruction* call,
                                    Definition* receiver,
                                    intptr_t cid,
                                    TargetEntryInstr** entry,
                                    Definition** last) {
   ASSERT((cid == kOneByteStringCid) || (cid == kTwoByteStringCid) ||
          (cid == kExternalOneByteStringCid) ||
          (cid == kExternalTwoByteStringCid));
   Definition* str = receiver;
   Definition* index = call->ArgumentAt(1);
 
-  *entry = new (Z) TargetEntryInstr(flow_graph->allocate_block_id(),
-                                    call->GetBlock()->try_index());
+  *entry = new (Z)
+      TargetEntryInstr(flow_graph->allocate_block_id(),
+                       call->GetBlock()->try_index(), Thread::kNoDeoptId);
   (*entry)->InheritDeoptTarget(Z, call);
 
   *last = PrepareInlineStringIndexOp(flow_graph, call, cid, str, index, *entry);
 
   return true;
 }
 
 
 // Only used for monomorphic calls.
 bool FlowGraphInliner::TryReplaceInstanceCallWithInline(
@@ skipping 91 matching lines @@
 static bool InlineFloat32x4Method(FlowGraph* flow_graph,
                                   Instruction* call,
                                   Definition* receiver,
                                   MethodRecognizer::Kind kind,
                                   TargetEntryInstr** entry,
                                   Definition** last) {
   if (!ShouldInlineSimd()) {
     return false;
   }
 
-  *entry = new (Z) TargetEntryInstr(flow_graph->allocate_block_id(),
-                                    call->GetBlock()->try_index());
+  *entry = new (Z)
+      TargetEntryInstr(flow_graph->allocate_block_id(),
+                       call->GetBlock()->try_index(), Thread::kNoDeoptId);
   (*entry)->InheritDeoptTarget(Z, call);
   Instruction* cursor = *entry;
   switch (kind) {
     case MethodRecognizer::kFloat32x4ShuffleX:
     case MethodRecognizer::kFloat32x4ShuffleY:
     case MethodRecognizer::kFloat32x4ShuffleZ:
     case MethodRecognizer::kFloat32x4ShuffleW: {
       *last = new (Z) Simd32x4ShuffleInstr(kind, new (Z) Value(receiver),
                                            0,  // mask ignored.
                                            call->deopt_id());
@@ skipping 96 matching lines @@
 
 static bool InlineSimdShuffleMethod(FlowGraph* flow_graph,
                                     Instruction* call,
                                     Definition* receiver,
                                     MethodRecognizer::Kind kind,
                                     TargetEntryInstr** entry,
                                     Definition** last) {
   if (!ShouldInlineSimd()) {
     return false;
   }
-  *entry = new (Z) TargetEntryInstr(flow_graph->allocate_block_id(),
-                                    call->GetBlock()->try_index());
+  *entry = new (Z)
+      TargetEntryInstr(flow_graph->allocate_block_id(),
+                       call->GetBlock()->try_index(), Thread::kNoDeoptId);
   (*entry)->InheritDeoptTarget(Z, call);
   Instruction* cursor = *entry;
   Definition* mask_definition = call->ArgumentAt(1);
   intptr_t mask = 0;
   if (!CheckMask(mask_definition, &mask)) {
     return false;
   }
   *last = new (Z) Simd32x4ShuffleInstr(kind, new (Z) Value(call->ArgumentAt(0)),
                                        mask, call->deopt_id());
   flow_graph->AppendTo(
       cursor, *last,
       call->deopt_id() != Thread::kNoDeoptId ? call->env() : NULL,
       FlowGraph::kValue);
   return true;
 }
 
 
 static bool InlineSimdShuffleMixMethod(FlowGraph* flow_graph,
                                        Instruction* call,
                                        Definition* receiver,
                                        MethodRecognizer::Kind kind,
                                        TargetEntryInstr** entry,
                                        Definition** last) {
   if (!ShouldInlineSimd()) {
     return false;
   }
-  *entry = new (Z) TargetEntryInstr(flow_graph->allocate_block_id(),
-                                    call->GetBlock()->try_index());
+  *entry = new (Z)
+      TargetEntryInstr(flow_graph->allocate_block_id(),
+                       call->GetBlock()->try_index(), Thread::kNoDeoptId);
   (*entry)->InheritDeoptTarget(Z, call);
   Instruction* cursor = *entry;
   Definition* mask_definition = call->ArgumentAt(2);
   intptr_t mask = 0;
   if (!CheckMask(mask_definition, &mask)) {
     return false;
   }
   *last = new (Z) Simd32x4ShuffleMixInstr(kind, new (Z) Value(receiver),
                                           new (Z) Value(call->ArgumentAt(1)),
                                           mask, call->deopt_id());
   flow_graph->AppendTo(
       cursor, *last,
       call->deopt_id() != Thread::kNoDeoptId ? call->env() : NULL,
       FlowGraph::kValue);
   return true;
 }
 
 
 static bool InlineInt32x4Method(FlowGraph* flow_graph,
                                 Instruction* call,
                                 Definition* receiver,
                                 MethodRecognizer::Kind kind,
                                 TargetEntryInstr** entry,
                                 Definition** last) {
   if (!ShouldInlineSimd()) {
     return false;
   }
-  *entry = new (Z) TargetEntryInstr(flow_graph->allocate_block_id(),
-                                    call->GetBlock()->try_index());
+  *entry = new (Z)
+      TargetEntryInstr(flow_graph->allocate_block_id(),
+                       call->GetBlock()->try_index(), Thread::kNoDeoptId);
   (*entry)->InheritDeoptTarget(Z, call);
   Instruction* cursor = *entry;
   switch (kind) {
     case MethodRecognizer::kInt32x4GetFlagX:
     case MethodRecognizer::kInt32x4GetFlagY:
     case MethodRecognizer::kInt32x4GetFlagZ:
     case MethodRecognizer::kInt32x4GetFlagW: {
       *last = new (Z)
           Int32x4GetFlagInstr(kind, new (Z) Value(receiver), call->deopt_id());
       break;
@@ skipping 34 matching lines @@
 
 static bool InlineFloat64x2Method(FlowGraph* flow_graph,
                                   Instruction* call,
                                   Definition* receiver,
                                   MethodRecognizer::Kind kind,
                                   TargetEntryInstr** entry,
                                   Definition** last) {
   if (!ShouldInlineSimd()) {
     return false;
   }
-  *entry = new (Z) TargetEntryInstr(flow_graph->allocate_block_id(),
-                                    call->GetBlock()->try_index());
+  *entry = new (Z)
+      TargetEntryInstr(flow_graph->allocate_block_id(),
+                       call->GetBlock()->try_index(), Thread::kNoDeoptId);
   (*entry)->InheritDeoptTarget(Z, call);
   Instruction* cursor = *entry;
   switch (kind) {
     case MethodRecognizer::kFloat64x2GetX:
     case MethodRecognizer::kFloat64x2GetY: {
       *last = new (Z) Simd64x2ShuffleInstr(kind, new (Z) Value(receiver),
                                            0,  // mask is ignored.
                                            call->deopt_id());
       break;
     }
@@ skipping 29 matching lines @@
 
 
 static bool InlineSimdConstructor(FlowGraph* flow_graph,
                                   Instruction* call,
                                   MethodRecognizer::Kind kind,
                                   TargetEntryInstr** entry,
                                   Definition** last) {
   if (!ShouldInlineSimd()) {
     return false;
   }
-  *entry = new (Z) TargetEntryInstr(flow_graph->allocate_block_id(),
-                                    call->GetBlock()->try_index());
+  *entry = new (Z)
+      TargetEntryInstr(flow_graph->allocate_block_id(),
+                       call->GetBlock()->try_index(), Thread::kNoDeoptId);
   (*entry)->InheritDeoptTarget(Z, call);
   Instruction* cursor = *entry;
   switch (kind) {
     case MethodRecognizer::kFloat32x4Zero:
       *last = new (Z) Float32x4ZeroInstr();
       break;
     case MethodRecognizer::kFloat32x4Splat:
       *last = new (Z) Float32x4SplatInstr(new (Z) Value(call->ArgumentAt(1)),
                                           call->deopt_id());
       break;
@@ skipping 59 matching lines @@
 
 
 static bool InlineMathCFunction(FlowGraph* flow_graph,
                                 Instruction* call,
                                 MethodRecognizer::Kind kind,
                                 TargetEntryInstr** entry,
                                 Definition** last) {
   if (!CanUnboxDouble()) {
     return false;
   }
-  *entry = new (Z) TargetEntryInstr(flow_graph->allocate_block_id(),
-                                    call->GetBlock()->try_index());
+  *entry = new (Z)
+      TargetEntryInstr(flow_graph->allocate_block_id(),
+                       call->GetBlock()->try_index(), Thread::kNoDeoptId);
   (*entry)->InheritDeoptTarget(Z, call);
   Instruction* cursor = *entry;
 
   switch (kind) {
     case MethodRecognizer::kMathSqrt: {
       *last = new (Z)
           MathUnaryInstr(MathUnaryInstr::kSqrt,
                          new (Z) Value(call->ArgumentAt(0)), call->deopt_id());
       break;
     }
@@ skipping 340 matching lines @@
     case MethodRecognizer::kMathSin:
     case MethodRecognizer::kMathCos:
     case MethodRecognizer::kMathTan:
     case MethodRecognizer::kMathAsin:
     case MethodRecognizer::kMathAcos:
     case MethodRecognizer::kMathAtan:
     case MethodRecognizer::kMathAtan2:
       return InlineMathCFunction(flow_graph, call, kind, entry, last);
 
     case MethodRecognizer::kObjectConstructor: {
-      *entry = new (Z) TargetEntryInstr(flow_graph->allocate_block_id(),
-                                        call->GetBlock()->try_index());
+      *entry = new (Z)
+          TargetEntryInstr(flow_graph->allocate_block_id(),
+                           call->GetBlock()->try_index(), Thread::kNoDeoptId);
       (*entry)->InheritDeoptTarget(Z, call);
       ASSERT(!call->HasUses());
       *last = NULL;  // Empty body.
       return true;
     }
 
     case MethodRecognizer::kObjectArrayAllocate: {
       Value* num_elements = new (Z) Value(call->ArgumentAt(1));
       if (num_elements->BindsToConstant() &&
           num_elements->BoundConstant().IsSmi()) {
         intptr_t length = Smi::Cast(num_elements->BoundConstant()).Value();
         if (length >= 0 && length <= Array::kMaxElements) {
           Value* type = new (Z) Value(call->ArgumentAt(0));
           *entry = new (Z) TargetEntryInstr(flow_graph->allocate_block_id(),
-                                            call->GetBlock()->try_index());
+                                            call->GetBlock()->try_index(),
+                                            Thread::kNoDeoptId);
           (*entry)->InheritDeoptTarget(Z, call);
-          *last =
-              new (Z) CreateArrayInstr(call->token_pos(), type, num_elements);
+          *last = new (Z) CreateArrayInstr(call->token_pos(), type,

[rmacnak, 2017/05/24 22:59:34]

Actually it looks like we've just been neglecting to forward the deopt id here.

[Vyacheslav Egorov (Google), 2017/05/25 08:44:04]

Good catch! Sorry I missed it in the original review - my eyes failed to see
this in the avalanche of TargetEntryInstr.

We had a refactoring planned long ago that would have caught this: make deopt_id
and Environment* use the same slot in the instruction (because environment
already contains a deopt_id). Currently instruction has both, so one is
redundant.

In optimizing compiler we only need env and in unoptimizing we only need
deopt_id.

+                                           num_elements, call->deopt_id());
           flow_graph->AppendTo(
               *entry, *last,
               call->deopt_id() != Thread::kNoDeoptId ? call->env() : NULL,
               FlowGraph::kValue);
           return true;
         }
       }
       return false;
     }
 
     case MethodRecognizer::kObjectRuntimeType: {
       Type& type = Type::ZoneHandle(Z);
       if (RawObject::IsStringClassId(receiver_cid)) {
         type = Type::StringType();
       } else if (receiver_cid == kDoubleCid) {
         type = Type::Double();
       } else if (RawObject::IsIntegerClassId(receiver_cid)) {
         type = Type::IntType();
       } else if (receiver_cid != kClosureCid) {
         const Class& cls = Class::Handle(
             Z, flow_graph->isolate()->class_table()->At(receiver_cid));
         if (!cls.IsGeneric()) {
           type = cls.CanonicalType();
         }
       }
 
       if (!type.IsNull()) {
-        *entry = new (Z) TargetEntryInstr(flow_graph->allocate_block_id(),
-                                          call->GetBlock()->try_index());
+        *entry = new (Z)
+            TargetEntryInstr(flow_graph->allocate_block_id(),
+                             call->GetBlock()->try_index(), Thread::kNoDeoptId);
         (*entry)->InheritDeoptTarget(Z, call);
         *last = new (Z) ConstantInstr(type);
         flow_graph->AppendTo(
             *entry, *last,
             call->deopt_id() != Thread::kNoDeoptId ? call->env() : NULL,
             FlowGraph::kValue);
         return true;
       }
       return false;
     }
 
     case MethodRecognizer::kOneByteStringSetAt: {
       // This is an internal method, no need to check argument types nor
       // range.
-      *entry = new (Z) TargetEntryInstr(flow_graph->allocate_block_id(),
-                                        call->GetBlock()->try_index());
+      *entry = new (Z)
+          TargetEntryInstr(flow_graph->allocate_block_id(),
+                           call->GetBlock()->try_index(), Thread::kNoDeoptId);
       (*entry)->InheritDeoptTarget(Z, call);
       Definition* str = call->ArgumentAt(0);
       Definition* index = call->ArgumentAt(1);
       Definition* value = call->ArgumentAt(2);
       *last =
           new (Z) StoreIndexedInstr(new (Z) Value(str), new (Z) Value(index),
                                     new (Z) Value(value), kNoStoreBarrier,
                                     1,  // Index scale
                                     kOneByteStringCid, kAlignedAccess,
                                     call->deopt_id(), call->token_pos());
       flow_graph->AppendTo(
           *entry, *last,
           call->deopt_id() != Thread::kNoDeoptId ? call->env() : NULL,
           FlowGraph::kEffect);
       return true;
     }
 
     default:
       return false;
   }
 }
 
 
 }  // namespace dart
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)