Use isolate when allocation Zone objects and handles: focus on FlowGraphOptimizer, next inliner.

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.
 
 #include "vm/flow_graph_inliner.h"
 
 #include "vm/block_scheduler.h"
 #include "vm/compiler.h"
 #include "vm/flags.h"
 #include "vm/flow_graph.h"
@@ skipping 69 matching lines @@
   while (env != NULL) {
     if (code.raw() == env->code().raw()) {
       return true;
     }
     env = env->outer();
   }
   return false;
 }
 
 
-// Helper to create a parameter stub from an actual argument.
-static Definition* CreateParameterStub(intptr_t i,
-                                       Value* argument,
-                                       FlowGraph* graph) {
-  ConstantInstr* constant = argument->definition()->AsConstant();
-  if (constant != NULL) {
-    return new ConstantInstr(constant->value());
-  } else {
-    return new ParameterInstr(i, graph->graph_entry());
-  }
-}
-
-
 // Helper to get the default value of a formal parameter.
 static ConstantInstr* GetDefaultValue(intptr_t i,
                                       const ParsedFunction& parsed_function) {
   return new ConstantInstr(Object::ZoneHandle(
       parsed_function.default_parameter_values().At(i)));
 }
 
 
 // Pair of an argument name and its value.
 struct NamedArgument {
@@ skipping 326 matching lines @@
 
  private:
   bool CheckInlinedDuplicate(const Function& target);
   bool CheckNonInlinedDuplicate(const Function& target);
 
   bool TryInliningPoly(intptr_t receiver_cid, const Function& target);
   bool TryInlineRecognizedMethod(intptr_t receiver_cid, const Function& target);
 
   TargetEntryInstr* BuildDecisionGraph();
 
+  Isolate* isolate() const;
+
   CallSiteInliner* const owner_;
   PolymorphicInstanceCallInstr* const call_;
   const intptr_t num_variants_;
   GrowableArray<CidTarget> variants_;
 
   GrowableArray<CidTarget> inlined_variants_;
   GrowableArray<CidTarget> non_inlined_variants_;
   GrowableArray<BlockEntryInstr*> inlined_entries_;
   InlineExitCollector* exit_collector_;
 
   const Function& caller_function_;
 };
 
 
 class CallSiteInliner : public ValueObject {
  public:
   explicit CallSiteInliner(FlowGraph* flow_graph)
       : caller_graph_(flow_graph),
         inlined_(false),
         initial_size_(flow_graph->InstructionCount()),
         inlined_size_(0),
         inlining_depth_(1),
         collected_call_sites_(NULL),
         inlining_call_sites_(NULL),
         function_cache_(),
         inlined_info_() { }
 
   FlowGraph* caller_graph() const { return caller_graph_; }
 
+  Isolate* isolate() const { return caller_graph_->isolate(); }
+
   // Inlining heuristics based on Cooper et al. 2008.
   bool ShouldWeInline(const Function& callee,
                       intptr_t instr_count,
                       intptr_t call_site_count,
                       intptr_t const_arg_count) {
     if (inlined_size_ > FLAG_inlining_caller_size_threshold) {
       // Prevent methods becoming humongous and thus slow to compile.
       return false;
     }
     if (instr_count > FLAG_inlining_callee_size_threshold) {
@@ skipping 59 matching lines @@
     inlining_call_sites_ = NULL;
   }
 
   bool inlined() const { return inlined_; }
 
   double GrowthFactor() const {
     return static_cast<double>(inlined_size_) /
         static_cast<double>(initial_size_);
   }
 
+  // Helper to create a parameter stub from an actual argument.
+  Definition* CreateParameterStub(intptr_t i,
+                                  Value* argument,
+                                  FlowGraph* graph) {
+    ConstantInstr* constant = argument->definition()->AsConstant();
+    if (constant != NULL) {
+      return new(isolate()) ConstantInstr(constant->value());
+    } else {
+      return new(isolate()) ParameterInstr(i, graph->graph_entry());
+    }
+  }
+
   bool TryInlining(const Function& function,
                    const Array& argument_names,
                    InlinedCallData* call_data) {
     TRACE_INLINING(OS::Print("  => %s (deopt count %d)\n",
                              function.ToCString(),
                              function.deoptimization_counter()));
 
     // TODO(fschneider): Enable inlining inside try-blocks.
     if (call_data->call->GetBlock()->try_index() !=
         CatchClauseNode::kInvalidTryIndex) {
@@ skipping 45 matching lines @@
     // Abort if this is a recursive occurrence.
     Definition* call = call_data->call;
     if (!FLAG_inline_recursive && IsCallRecursive(unoptimized_code, call)) {
       function.set_is_inlinable(false);
       TRACE_INLINING(OS::Print("     Bailout: recursive function\n"));
       PRINT_INLINING_TREE("Recursive function",
           &call_data->caller, &function, call_data->call);
       return false;
     }
 
-    Isolate* isolate = Isolate::Current();
     // Save and clear deopt id.
-    const intptr_t prev_deopt_id = isolate->deopt_id();
-    isolate->set_deopt_id(0);
+    const intptr_t prev_deopt_id = isolate()->deopt_id();
+    isolate()->set_deopt_id(0);
     // Install bailout jump.
     LongJumpScope jump;
     if (setjmp(*jump.Set()) == 0) {
       // Parse the callee function.
       bool in_cache;
       ParsedFunction* parsed_function;
       {
         TimerScope timer(FLAG_compiler_stats,
                          &CompilerStats::graphinliner_parse_timer,
-                         isolate);
+                         isolate());
         parsed_function = GetParsedFunction(function, &in_cache);
       }
 
       // Load IC data for the callee.
       Array& ic_data_array = Array::Handle();
 
       // IsInlineable above checked HasCode. Creating a Handle for the code
       // should have kept GC from detaching, but let's assert just to make sure.
       ASSERT(function.HasCode());
       ic_data_array = unoptimized_code.ExtractTypeFeedbackArray();
 
       // Build the callee graph.
       InlineExitCollector* exit_collector =
-          new InlineExitCollector(caller_graph_, call);
+          new(isolate()) InlineExitCollector(caller_graph_, call);
       FlowGraphBuilder builder(parsed_function,
                                ic_data_array,
                                exit_collector,
                                Isolate::kNoDeoptId,
                                true);
       builder.SetInitialBlockId(caller_graph_->max_block_id());
       FlowGraph* callee_graph;
       {
         TimerScope timer(FLAG_compiler_stats,
                          &CompilerStats::graphinliner_build_timer,
-                         isolate);
+                         isolate());
         callee_graph = builder.BuildGraph();
       }
 
       // The parameter stubs are a copy of the actual arguments providing
       // concrete information about the values, for example constant values,
       // without linking between the caller and callee graphs.
       // TODO(zerny): Put more information in the stubs, eg, type information.
       ZoneGrowableArray<Definition*>* param_stubs =
-          new ZoneGrowableArray<Definition*>(function.NumParameters());
+          new(isolate()) ZoneGrowableArray<Definition*>(
+              function.NumParameters());
 
       // Create a parameter stub for each fixed positional parameter.
       for (intptr_t i = 0; i < function.num_fixed_parameters(); ++i) {
         param_stubs->Add(CreateParameterStub(i, (*arguments)[i], callee_graph));
       }
 
       // If the callee has optional parameters, rebuild the argument and stub
       // arrays so that actual arguments are in one-to-one with the formal
       // parameters.
       if (function.HasOptionalParameters()) {
@@ skipping 14 matching lines @@
       // After treating optional parameters the actual/formal count must match.
       ASSERT(arguments->length() == function.NumParameters());
       ASSERT(param_stubs->length() == callee_graph->parameter_count());
 
       BlockScheduler block_scheduler(callee_graph);
       block_scheduler.AssignEdgeWeights();
 
       {
         TimerScope timer(FLAG_compiler_stats,
                          &CompilerStats::graphinliner_ssa_timer,
-                         isolate);
+                         isolate());
         // Compute SSA on the callee graph, catching bailouts.
         callee_graph->ComputeSSA(caller_graph_->max_virtual_register_number(),
                                  param_stubs);
         DEBUG_ASSERT(callee_graph->VerifyUseLists());
       }
 
       {
         TimerScope timer(FLAG_compiler_stats,
                          &CompilerStats::graphinliner_opt_timer,
-                         isolate);
+                         isolate());
         // TODO(zerny): Do more optimization passes on the callee graph.
         FlowGraphOptimizer optimizer(callee_graph);
         optimizer.ApplyICData();
         DEBUG_ASSERT(callee_graph->VerifyUseLists());
 
         // Optimize (a << b) & c patterns, merge instructions. Must occur before
         // 'SelectRepresentations' which inserts conversion nodes.
         optimizer.TryOptimizePatterns();
         DEBUG_ASSERT(callee_graph->VerifyUseLists());
       }
@@ skipping 21 matching lines @@
       function.set_optimized_call_site_count(call_site_count);
 
       // Use heuristics do decide if this call should be inlined.
       if (!ShouldWeInline(function, size, call_site_count, constants_count)) {
         // If size is larger than all thresholds, don't consider it again.
         if ((size > FLAG_inlining_size_threshold) &&
             (call_site_count > FLAG_inlining_callee_call_sites_threshold) &&
             (size > FLAG_inlining_constant_arguments_size_threshold)) {
           function.set_is_inlinable(false);
         }
-        isolate->set_deopt_id(prev_deopt_id);
+        isolate()->set_deopt_id(prev_deopt_id);
         TRACE_INLINING(OS::Print("     Bailout: heuristics with "
                                  "code size:  %" Pd ", "
                                  "call sites: %" Pd ", "
                                  "const args: %" Pd "\n",
                                  size,
                                  call_site_count,
                                  constants_count));
         PRINT_INLINING_TREE("Heuristic fail",
             &call_data->caller, &function, call_data->call);
         return false;
@@ skipping 13 matching lines @@
       }
 
       // Add the function to the cache.
       if (!in_cache) {
         function_cache_.Add(parsed_function);
       }
 
       // Build succeeded so we restore the bailout jump.
       inlined_ = true;
       inlined_size_ += size;
-      isolate->set_deopt_id(prev_deopt_id);
+      isolate()->set_deopt_id(prev_deopt_id);
 
       call_data->callee_graph = callee_graph;
       call_data->parameter_stubs = param_stubs;
       call_data->exit_collector = exit_collector;
 
       // When inlined, we add the guarded fields of the callee to the caller's
       // list of guarded fields.
       for (intptr_t i = 0; i < callee_graph->guarded_fields()->length(); ++i) {
         FlowGraph::AddToGuardedFields(caller_graph_->guarded_fields(),
                                       (*callee_graph->guarded_fields())[i]);
       }
 
       // We allocate a ZoneHandle for the unoptimized code so that it cannot be
       // disconnected from its function during the rest of compilation.
       Code::ZoneHandle(unoptimized_code.raw());
       TRACE_INLINING(OS::Print("     Success\n"));
       PRINT_INLINING_TREE(NULL,
           &call_data->caller, &function, call);
       return true;
     } else {
       Error& error = Error::Handle();
-      error = isolate->object_store()->sticky_error();
-      isolate->object_store()->clear_sticky_error();
-      isolate->set_deopt_id(prev_deopt_id);
+      error = isolate()->object_store()->sticky_error();
+      isolate()->object_store()->clear_sticky_error();
+      isolate()->set_deopt_id(prev_deopt_id);
       TRACE_INLINING(OS::Print("     Bailout: %s\n", error.ToErrorCString()));
       PRINT_INLINING_TREE("Bailout",
           &call_data->caller, &function, call);
       return false;
     }
   }
 
   void PrintInlinedInfo(const Function& top) {
     if (inlined_info_.length() > 0) {
       OS::Print("Inlining into: '%s' growth: %f (%" Pd " -> %" Pd ")\n",
@@ skipping 117 matching lines @@
   ParsedFunction* GetParsedFunction(const Function& function, bool* in_cache) {
     // TODO(zerny): Use a hash map for the cache.
     for (intptr_t i = 0; i < function_cache_.length(); ++i) {
       ParsedFunction* parsed_function = function_cache_[i];
       if (parsed_function->function().raw() == function.raw()) {
         *in_cache = true;
         return parsed_function;
       }
     }
     *in_cache = false;
-    ParsedFunction* parsed_function = new ParsedFunction(function);
+    ParsedFunction* parsed_function = new(isolate()) ParsedFunction(function);
     Parser::ParseFunction(parsed_function);
     parsed_function->AllocateVariables();
     return parsed_function;
   }
 
   // Include special handling for List. factory: inlining it is not helpful
   // if the incoming argument is a non-constant value.
   // TODO(srdjan): Fix inlining of List. factory.
   void InlineStaticCalls() {
     const GrowableArray<CallSites::StaticCallInfo>& call_info =
@@ skipping 133 matching lines @@
       }
       ASSERT(function.NumOptionalPositionalParameters() ==
              (param_count - fixed_param_count));
       // For each optional positional parameter without an actual, add its
       // default value.
       for (intptr_t i = arg_count; i < param_count; ++i) {
         const Object& object =
             Object::ZoneHandle(
                 parsed_function.default_parameter_values().At(
                     i - fixed_param_count));
-        ConstantInstr* constant = new ConstantInstr(object);
+        ConstantInstr* constant = new(isolate()) ConstantInstr(object);
         arguments->Add(NULL);
         param_stubs->Add(constant);
       }
       return true;
     }
 
     ASSERT(function.HasOptionalNamedParameters());
 
     // Passed arguments must match fixed parameters plus named arguments.
     intptr_t argument_names_count =
@@ skipping 64 matching lines @@
 PolymorphicInliner::PolymorphicInliner(CallSiteInliner* owner,
                                        PolymorphicInstanceCallInstr* call,
                                        const Function& caller_function)
     : owner_(owner),
       call_(call),
       num_variants_(call->ic_data().NumberOfChecks()),
       variants_(num_variants_),
       inlined_variants_(num_variants_),
       non_inlined_variants_(num_variants_),
       inlined_entries_(num_variants_),
-      exit_collector_(new InlineExitCollector(owner->caller_graph(), call)),
+      exit_collector_(new(isolate())
+          InlineExitCollector(owner->caller_graph(), call)),
       caller_function_(caller_function) {
 }
 
 
+Isolate* PolymorphicInliner::isolate() const {
+  return owner_->caller_graph()->isolate();
+}
+
+
 // Inlined bodies are shared if two different class ids have the same
 // inlined target.  This sharing is represented by using three different
 // types of entries in the inlined_entries_ array:
 //
 //   * GraphEntry: the inlined body is not shared.
 //
 //   * TargetEntry: the inlined body is shared and this is the first variant.
 //
 //   * JoinEntry: the inlined body is shared and this is a subsequent variant.
 bool PolymorphicInliner::CheckInlinedDuplicate(const Function& target) {
   for (intptr_t i = 0; i < inlined_variants_.length(); ++i) {
     if ((target.raw() == inlined_variants_[i].target->raw()) &&
         !MethodRecognizer::PolymorphicTarget(target)) {
       // The call target is shared with a previous inlined variant.  Share
       // the graph.  This requires a join block at the entry, and edge-split
       // form requires a target for each branch.
       //
       // Represent the sharing by recording a fresh target for the first
       // variant and the shared join for all later variants.
       if (inlined_entries_[i]->IsGraphEntry()) {
         // Convert the old target entry to a new join entry.
         TargetEntryInstr* old_target =
             inlined_entries_[i]->AsGraphEntry()->normal_entry();
         // Unuse all inputs in the the old graph entry since it is not part of
         // the graph anymore. A new target be created instead.
         inlined_entries_[i]->AsGraphEntry()->UnuseAllInputs();
 
-        JoinEntryInstr* new_join = BranchSimplifier::ToJoinEntry(old_target);
+        JoinEntryInstr* new_join =
+            BranchSimplifier::ToJoinEntry(isolate(), 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(owner_->caller_graph()->allocate_block_id(),
                                  old_target->try_index());
-        new_target->InheritDeoptTarget(new_join);
-        GotoInstr* new_goto = new GotoInstr(new_join);
-        new_goto->InheritDeoptTarget(new_join);
+        new_target->InheritDeoptTarget(isolate(), new_join);
+        GotoInstr* new_goto = new(isolate()) GotoInstr(new_join);
+        new_goto->InheritDeoptTarget(isolate(), 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.
       BlockEntryInstr* join =
@@ skipping 43 matching lines @@
   FlowGraph* callee_graph = call_data.callee_graph;
   call_data.exit_collector->PrepareGraphs(callee_graph);
   inlined_entries_.Add(callee_graph->graph_entry());
   exit_collector_->Union(call_data.exit_collector);
 
   // Replace parameter stubs and constants.  Replace the receiver argument
   // with a redefinition to prevent code from the inlined body from being
   // hoisted above the inlined entry.
   ASSERT(arguments.length() > 0);
   Value* actual = arguments[0];
-  RedefinitionInstr* redefinition = new RedefinitionInstr(actual->Copy());
+  RedefinitionInstr* redefinition = new(isolate())
+      RedefinitionInstr(actual->Copy(isolate()));
   redefinition->set_ssa_temp_index(
       owner_->caller_graph()->alloc_ssa_temp_index());
   redefinition->InsertAfter(callee_graph->graph_entry()->normal_entry());
   Definition* stub = (*call_data.parameter_stubs)[0];
   stub->ReplaceUsesWith(redefinition);
 
   for (intptr_t i = 1; i < arguments.length(); ++i) {
     actual = arguments[i];
     if (actual != NULL) {
       stub = (*call_data.parameter_stubs)[i];
@@ skipping 27 matching lines @@
 bool PolymorphicInliner::TryInlineRecognizedMethod(intptr_t receiver_cid,
                                                    const Function& target) {
   FlowGraphOptimizer optimizer(owner_->caller_graph());
   TargetEntryInstr* entry;
   Definition* last;
   // Replace the receiver argument with a redefinition to prevent code from
   // the inlined body from being hoisted above the inlined entry.
   GrowableArray<Definition*> arguments(call_->ArgumentCount());
   Definition* receiver = call_->ArgumentAt(0);
     RedefinitionInstr* redefinition =
-        new RedefinitionInstr(new Value(receiver));
+        new(isolate()) RedefinitionInstr(new(isolate()) Value(receiver));
     redefinition->set_ssa_temp_index(
         owner_->caller_graph()->alloc_ssa_temp_index());
   if (optimizer.TryInlineRecognizedMethod(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 InlineExitCollector(owner_->caller_graph(), call_);
+        new(isolate()) InlineExitCollector(owner_->caller_graph(), call_);
 
     ReturnInstr* result =
-        new ReturnInstr(call_->instance_call()->token_pos(),
-                        new Value(last));
+        new(isolate()) ReturnInstr(call_->instance_call()->token_pos(),
+            new(isolate()) Value(last));
     owner_->caller_graph()->AppendTo(
         last,
         result,
         call_->env(),  // Return can become deoptimization target.
         FlowGraph::kEffect);
     entry->set_last_instruction(result);
     exit_collector->AddExit(result);
     GraphEntryInstr* graph_entry =
-        new GraphEntryInstr(NULL,  // No parsed function.
-                            entry,
-                            Isolate::kNoDeoptId);  // No OSR id.
+        new(isolate()) GraphEntryInstr(NULL,  // No parsed function.
+                                       entry,
+                                       Isolate::kNoDeoptId);  // No OSR id.
     // 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() {
   // Start with a fresh target entry.
   TargetEntryInstr* entry =
-      new TargetEntryInstr(owner_->caller_graph()->allocate_block_id(),
-                           call_->GetBlock()->try_index());
-  entry->InheritDeoptTarget(call_);
+      new(isolate()) TargetEntryInstr(
+          owner_->caller_graph()->allocate_block_id(),
+          call_->GetBlock()->try_index());
+  entry->InheritDeoptTarget(isolate(), 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.
   TargetEntryInstr* current_block = entry;
   Instruction* cursor = entry;
 
   Definition* receiver = call_->ArgumentAt(0);
   // There are at least two variants including non-inlined ones, so we have
   // at least one branch on the class id.
-  LoadClassIdInstr* load_cid = new LoadClassIdInstr(new Value(receiver));
+  LoadClassIdInstr* load_cid =
+      new(isolate()) LoadClassIdInstr(new(isolate()) Value(receiver));
   load_cid->set_ssa_temp_index(owner_->caller_graph()->alloc_ssa_temp_index());
   cursor = AppendInstruction(cursor, load_cid);
   for (intptr_t i = 0; i < inlined_variants_.length(); ++i) {
     // 1. Guard the body with a class id check.
     if ((i == (inlined_variants_.length() - 1)) &&
         non_inlined_variants_.is_empty()) {
       // If it is the last variant use a check class or check smi
       // instruction which can deoptimize, followed unconditionally by the
       // body.  Check a redefinition of the receiver, to prevent the check
       // from being hoisted.
       RedefinitionInstr* redefinition =
-          new RedefinitionInstr(new Value(receiver));
+          new(isolate()) RedefinitionInstr(new(isolate()) Value(receiver));
       redefinition->set_ssa_temp_index(
           owner_->caller_graph()->alloc_ssa_temp_index());
       cursor = AppendInstruction(cursor, redefinition);
       if (inlined_variants_[i].cid == kSmiCid) {
         CheckSmiInstr* check_smi =
             new CheckSmiInstr(new Value(redefinition),
                               call_->deopt_id(),
                               call_->token_pos());
-        check_smi->InheritDeoptTarget(call_);
+        check_smi->InheritDeoptTarget(isolate(), call_);
         cursor = AppendInstruction(cursor, check_smi);
       } else {
         const ICData& old_checks = call_->ic_data();
         const ICData& new_checks = ICData::ZoneHandle(
             ICData::New(Function::Handle(old_checks.owner()),
                         String::Handle(old_checks.target_name()),
                         Array::Handle(old_checks.arguments_descriptor()),
                         old_checks.deopt_id(),
                         1));  // Number of args tested.
         new_checks.AddReceiverCheck(inlined_variants_[i].cid,
                                     *inlined_variants_[i].target);
         CheckClassInstr* check_class =
             new CheckClassInstr(new Value(redefinition),
                                 call_->deopt_id(),
                                 new_checks,
                                 call_->token_pos());
-        check_class->InheritDeoptTarget(call_);
+        check_class->InheritDeoptTarget(isolate(), call_);
         cursor = AppendInstruction(cursor, check_class);
       }
       // The next instruction is the first instruction of the inlined body.
       // Handle the two possible cases (unshared and shared subsequent
       // predecessors) separately.
       BlockEntryInstr* callee_entry = inlined_entries_[i];
       if (callee_entry->IsGraphEntry()) {
         // Unshared.  Graft the normal entry on after the check class
         // instruction.
         TargetEntryInstr* target =
@@ skipping 12 matching lines @@
           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);
-        goto_join->InheritDeoptTarget(join);
+        goto_join->InheritDeoptTarget(isolate(), 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(inlined_variants_[i].cid));
       ConstantInstr* cid_constant = new ConstantInstr(cid);
       cid_constant->set_ssa_temp_index(
           owner_->caller_graph()->alloc_ssa_temp_index());
       StrictCompareInstr* compare =
           new StrictCompareInstr(call_->instance_call()->token_pos(),
                                  Token::kEQ_STRICT,
                                  new Value(load_cid),
                                  new Value(cid_constant),
                                  false);  // No number check.
       BranchInstr* branch = new BranchInstr(compare);
-      branch->InheritDeoptTarget(call_);
+      branch->InheritDeoptTarget(isolate(), call_);
       AppendInstruction(AppendInstruction(cursor, cid_constant), 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).
       BlockEntryInstr* callee_entry = inlined_entries_[i];
       TargetEntryInstr* true_target = NULL;
       if (callee_entry->IsGraphEntry()) {
@@ skipping 11 matching lines @@
       } 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(owner_->caller_graph()->allocate_block_id(),
                                  call_->GetBlock()->try_index());
-        true_target->InheritDeoptTarget(join);
+        true_target->InheritDeoptTarget(isolate(), join);
         GotoInstr* goto_join = new GotoInstr(join);
-        goto_join->InheritDeoptTarget(join);
+        goto_join->InheritDeoptTarget(isolate(), 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(owner_->caller_graph()->allocate_block_id(),
                                call_->GetBlock()->try_index());
-      false_target->InheritDeoptTarget(call_);
+      false_target->InheritDeoptTarget(isolate(), call_);
       *branch->false_successor_address() = false_target;
       current_block->AddDominatedBlock(false_target);
       cursor = current_block = false_target;
     }
   }
 
   // Handle any non-inlined variants.
   if (!non_inlined_variants_.is_empty()) {
     // Move push arguments of the call.
     for (intptr_t i = 0; i < call_->ArgumentCount(); ++i) {
@@ skipping 14 matching lines @@
       new_checks.AddReceiverCheck(non_inlined_variants_[i].cid,
                                   *non_inlined_variants_[i].target,
                                   non_inlined_variants_[i].count);
     }
     PolymorphicInstanceCallInstr* fallback_call =
         new PolymorphicInstanceCallInstr(call_->instance_call(),
                                          new_checks,
                                          true);  // With checks.
     fallback_call->set_ssa_temp_index(
         owner_->caller_graph()->alloc_ssa_temp_index());
-    fallback_call->InheritDeoptTarget(call_);
+    fallback_call->InheritDeoptTarget(isolate(), call_);
     ReturnInstr* fallback_return =
         new ReturnInstr(call_->instance_call()->token_pos(),
                         new Value(fallback_call));
-    fallback_return->InheritDeoptTargetAfter(call_);
+    fallback_return->InheritDeoptTargetAfter(isolate(), 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);
       push->ReplaceUsesWith(push->value()->definition());
       push->RemoveFromGraph();
@@ skipping 107 matching lines @@
         OS::Print("After Inlining of %s\n", flow_graph_->
                   parsed_function().function().ToFullyQualifiedCString());
         FlowGraphPrinter printer(*flow_graph_);
         printer.PrintBlocks();
       }
     }
   }
 }
 
 }  // namespace dart