Thread/Isolate refactoring: new(Isolate) -> new(Zone)

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 1313 matching lines @@
       // 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(isolate(), old_target);
+            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(owner_->caller_graph()->allocate_block_id(),
                                  old_target->try_index());
-        new_target->InheritDeoptTarget(isolate(), new_join);
+        new_target->InheritDeoptTarget(zone(), new_join);
         GotoInstr* new_goto = new(Z) GotoInstr(new_join);
-        new_goto->InheritDeoptTarget(isolate(), new_join);
+        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.
       BlockEntryInstr* join =
@@ skipping 43 matching lines @@
   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(Z)
-      RedefinitionInstr(actual->Copy(isolate()));
+      RedefinitionInstr(actual->Copy(Z));
   redefinition->set_ssa_temp_index(
       owner_->caller_graph()->alloc_ssa_temp_index());
   redefinition->UpdateType(CompileType::FromCid(receiver_cid));
   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) {
@@ skipping 94 matching lines @@
 // 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(Z) TargetEntryInstr(
           owner_->caller_graph()->allocate_block_id(),
           call_->GetBlock()->try_index());
-  entry->InheritDeoptTarget(isolate(), call_);
+  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.
   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(Z) LoadClassIdInstr(new(Z) 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 id instruction which can
       // deoptimize, followed unconditionally by the body.
       RedefinitionInstr* cid_redefinition =
           new RedefinitionInstr(new(Z) Value(load_cid));
       cid_redefinition->set_ssa_temp_index(
           owner_->caller_graph()->alloc_ssa_temp_index());
       cursor = AppendInstruction(cursor, cid_redefinition);
       CheckClassIdInstr* check_class_id = new(Z) CheckClassIdInstr(
           new(Z) Value(cid_redefinition),
           inlined_variants_[i].cid,
           call_->deopt_id());
-      check_class_id->InheritDeoptTarget(isolate(), call_);
+      check_class_id->InheritDeoptTarget(zone(), call_);
       cursor = AppendInstruction(cursor, check_class_id);
 
       // 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(isolate(), join);
+        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(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(isolate(), call_);
+      branch->InheritDeoptTarget(zone(), 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(isolate(), join);
+        true_target->InheritDeoptTarget(zone(), join);
         GotoInstr* goto_join = new GotoInstr(join);
-        goto_join->InheritDeoptTarget(isolate(), join);
+        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(owner_->caller_graph()->allocate_block_id(),
                                call_->GetBlock()->try_index());
-      false_target->InheritDeoptTarget(isolate(), call_);
+      false_target->InheritDeoptTarget(zone(), 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(isolate(), call_);
+    fallback_call->InheritDeoptTarget(zone(), call_);
     ReturnInstr* fallback_return =
         new ReturnInstr(call_->instance_call()->token_pos(),
                         new Value(fallback_call));
     fallback_return->InheritDeoptTargetAfter(
         owner_->caller_graph(),
         call_,
         fallback_call);
     AppendInstruction(AppendInstruction(cursor, fallback_call),
                       fallback_return);
     exit_collector_->AddExit(fallback_return);
@@ skipping 173 matching lines @@
 intptr_t FlowGraphInliner::NextInlineId(const Function& function,
                                         intptr_t parent_id) {
   const intptr_t id = inline_id_to_function_->length();
   inline_id_to_function_->Add(&function);
   caller_inline_id_->Add(parent_id);
   return id;
 }
 
 
 }  // namespace dart