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

runtime/vm/flow_graph_optimizer.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_optimizer.h"
 
 #include "vm/bit_vector.h"
 #include "vm/cha.h"
 #include "vm/cpu.h"
 #include "vm/dart_entry.h"
@@ skipping 1181 matching lines @@
     Definition** last) {
   intptr_t array_cid = MethodKindToCid(kind);
   ASSERT(array_cid != kIllegalCid);
 
   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)->InheritDeoptTarget(I, call);
+  (*entry)->InheritDeoptTarget(Z, call);
   Instruction* cursor = *entry;
   if (I->TypeChecksEnabled()) {
     // 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* instantiator = NULL;
     Definition* type_args = NULL;
     switch (array_cid) {
@@ skipping 461 matching lines @@
                                           Definition* receiver,
                                           TargetEntryInstr** entry,
                                           Definition** last) {
   intptr_t array_cid = MethodKindToCid(kind);
   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)->InheritDeoptTarget(I, call);
+  (*entry)->InheritDeoptTarget(Z, call);
   Instruction* cursor = *entry;
 
   array_cid = PrepareInlineIndexedOp(call,
                                      array_cid,
                                      &array,
                                      index,
                                      &cursor);
 
   intptr_t deopt_id = Isolate::kNoDeoptId;
   if ((array_cid == kTypedDataInt32ArrayCid) ||
@@ skipping 1036 matching lines @@
   // TODO(johnmccutchan): Handle external strings in PrepareInlineStringIndexOp.
   if (RawObject::IsExternalStringClassId(cid)) {
     return false;
   }
 
   Definition* str = call->ArgumentAt(0);
   Definition* index = call->ArgumentAt(1);
 
   *entry = new(Z) TargetEntryInstr(flow_graph()->allocate_block_id(),
                                    call->GetBlock()->try_index());
-  (*entry)->InheritDeoptTarget(I, call);
+  (*entry)->InheritDeoptTarget(Z, call);
 
   *last = PrepareInlineStringIndexOp(call, cid, str, index, *entry);
 
   return true;
 }
 
 
 bool FlowGraphOptimizer::InlineStringBaseCharAt(
     Instruction* call,
     intptr_t cid,
     TargetEntryInstr** entry,
     Definition** last) {
   // TODO(johnmccutchan): Handle external strings in PrepareInlineStringIndexOp.
   if (RawObject::IsExternalStringClassId(cid) || cid != kOneByteStringCid) {
     return false;
   }
   Definition* str = call->ArgumentAt(0);
   Definition* index = call->ArgumentAt(1);
 
   *entry = new(Z) TargetEntryInstr(flow_graph()->allocate_block_id(),
                                    call->GetBlock()->try_index());
-  (*entry)->InheritDeoptTarget(I, call);
+  (*entry)->InheritDeoptTarget(Z, call);
 
   *last = PrepareInlineStringIndexOp(call, cid, str, index, *entry);
 
   StringFromCharCodeInstr* char_at = new(Z) StringFromCharCodeInstr(
       new(Z) Value(*last), cid);
 
   flow_graph()->AppendTo(*last, char_at, NULL, FlowGraph::kValue);
   *last = char_at;
 
   return true;
 }
 
 
 bool FlowGraphOptimizer::InlineDoubleOp(
     Token::Kind op_kind,
     Instruction* call,
     TargetEntryInstr** entry,
     Definition** last) {
   Definition* left = call->ArgumentAt(0);
   Definition* right = call->ArgumentAt(1);
 
   *entry = new(Z) TargetEntryInstr(flow_graph()->allocate_block_id(),
                                    call->GetBlock()->try_index());
-  (*entry)->InheritDeoptTarget(I, call);
+  (*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;
@@ skipping 749 matching lines @@
                                                  intptr_t array_cid,
                                                  intptr_t view_cid,
                                                  const ICData& ic_data,
                                                  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)->InheritDeoptTarget(I, call);
+  (*entry)->InheritDeoptTarget(Z, call);
   Instruction* cursor = *entry;
 
   array_cid = PrepareInlineByteArrayBaseOp(call,
                                            array_cid,
                                            view_cid,
                                            &array,
                                            index,
                                            &cursor);
 
   intptr_t deopt_id = Isolate::kNoDeoptId;
@@ skipping 32 matching lines @@
                                                   intptr_t array_cid,
                                                   intptr_t view_cid,
                                                   const ICData& ic_data,
                                                   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)->InheritDeoptTarget(I, call);
+  (*entry)->InheritDeoptTarget(Z, call);
   Instruction* cursor = *entry;
 
   array_cid = PrepareInlineByteArrayBaseOp(call,
                                            array_cid,
                                            view_cid,
                                            &array,
                                            index,
                                            &cursor);
 
   // Extract the instance call so we can use the function_name in the stored
@@ skipping 1249 matching lines @@
           }
         }
       }
     }
     for (intptr_t j = 0; j < idefs->length(); ++j) {
       if (cdefs[j] != NULL && cdefs[j]->IsConstant()) {
         // TODO(fschneider): Use constants from the constant pool.
         Definition* old = (*idefs)[j];
         ConstantInstr* orig = cdefs[j]->AsConstant();
         ConstantInstr* copy =
-            new(flow_graph->isolate()) ConstantInstr(orig->value());
+            new(flow_graph->zone()) ConstantInstr(orig->value());
         copy->set_ssa_temp_index(flow_graph->alloc_ssa_temp_index());
         old->ReplaceUsesWith(copy);
         (*idefs)[j] = copy;
       }
     }
   }
 }
 
 
 LICM::LICM(FlowGraph* flow_graph) : flow_graph_(flow_graph) {
@@ skipping 730 matching lines @@
   return wrapped;
 }
 
 
 // Correspondence between places connected through outgoing phi moves on the
 // edge that targets join.
 class PhiPlaceMoves : public ZoneAllocated {
  public:
   // Record a move from the place with id |from| to the place with id |to| at
   // the given block.
-  void CreateOutgoingMove(Isolate* isolate,
+  void CreateOutgoingMove(Zone* zone,
                           BlockEntryInstr* block, intptr_t from, intptr_t to) {
     const intptr_t block_num = block->preorder_number();
     while (moves_.length() <= block_num) {
       moves_.Add(NULL);
     }
 
     if (moves_[block_num] == NULL) {
-      moves_[block_num] = new(isolate) ZoneGrowableArray<Move>(5);
+      moves_[block_num] = new(zone) ZoneGrowableArray<Move>(5);
     }
 
     moves_[block_num]->Add(Move(from, to));
   }
 
   class Move {
    public:
     Move(intptr_t from, intptr_t to) : from_(from), to_(to) { }
 
     intptr_t from() const { return from_; }
@@ skipping 547 matching lines @@
 
 
 // For each place that depends on a phi ensure that equivalent places
 // corresponding to phi input are numbered and record outgoing phi moves
 // for each block which establish correspondence between phi dependent place
 // and phi input's place that is flowing in.
 static PhiPlaceMoves* ComputePhiMoves(
     DirectChainedHashMap<PointerKeyValueTrait<Place> >* map,
     ZoneGrowableArray<Place*>* places) {
   Thread* thread = Thread::Current();
-  Isolate* isolate = thread->isolate();
   Zone* zone = thread->zone();
   PhiPlaceMoves* phi_moves = new(zone) PhiPlaceMoves();
 
   for (intptr_t i = 0; i < places->length(); i++) {
     Place* place = (*places)[i];
 
     if (IsPhiDependentPlace(place)) {
       PhiInstr* phi = place->instance()->AsPhi();
       BlockEntryInstr* block = phi->GetBlock();
 
       if (FLAG_trace_optimization) {
         ISL_Print("phi dependent place %s\n", place->ToCString());
       }
 
       Place input_place(*place);
       for (intptr_t j = 0; j < phi->InputCount(); j++) {
         input_place.set_instance(phi->InputAt(j)->definition());
 
         Place* result = map->Lookup(&input_place);
         if (result == NULL) {
           result = Place::Wrap(zone, input_place, places->length());
           map->Insert(result);
           places->Add(result);
           if (FLAG_trace_optimization) {
             ISL_Print("  adding place %s as %" Pd "\n",
                       result->ToCString(),
                       result->id());
           }
         }
-        phi_moves->CreateOutgoingMove(isolate,
+        phi_moves->CreateOutgoingMove(zone,
                                       block->PredecessorAt(j),
                                       result->id(),
                                       place->id());
       }
     }
   }
 
   return phi_moves;
 }
 
@@ skipping 1439 matching lines @@
       (right == NULL) ? NULL : right->definition()->AsConstant();
   return (phi != NULL) &&
       (constant != NULL) &&
       (phi->GetBlock() == block) &&
       PhiHasSingleUse(phi, left) &&
       (block->next() == branch) &&
       (block->phis()->length() == 1);
 }
 
 
-JoinEntryInstr* BranchSimplifier::ToJoinEntry(Isolate* isolate,
+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(isolate) JoinEntryInstr(target->block_id(), target->try_index());
-  join->InheritDeoptTarget(isolate, target);
+      new(zone) JoinEntryInstr(target->block_id(), target->try_index());
+  join->InheritDeoptTarget(zone, target);
   join->LinkTo(target->next());
   join->set_last_instruction(target->last_instruction());
   target->UnuseAllInputs();
   return join;
 }
 
 
-BranchInstr* BranchSimplifier::CloneBranch(Isolate* isolate,
+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(isolate) BranchInstr(new_comparison);
+  BranchInstr* new_branch = new(zone) BranchInstr(new_comparison);
   new_branch->set_is_checked(branch->is_checked());
   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
   // optimization is intended to run after inlining which creates
   // opportunities for optimization (a) and before constant folding which
   // can perform optimization (b).
 
   // Begin with a worklist of join blocks ending in branches.  They are
   // candidates for the pattern below.
-  Isolate* isolate = flow_graph->isolate();
+  Zone* zone = flow_graph->zone();
   const GrowableArray<BlockEntryInstr*>& postorder = flow_graph->postorder();
   GrowableArray<BlockEntryInstr*> worklist(postorder.length());
   for (BlockIterator it(postorder); !it.Done(); it.Advance()) {
     BlockEntryInstr* block = it.Current();
     if (block->IsJoinEntry() && block->last_instruction()->IsBranch()) {
       worklist.Add(block);
     }
   }
 
   // Rewrite until no more instance of the pattern exists.
@@ skipping 10 matching lines @@
       // predecessors.  Convert the true and false target blocks into join
       // blocks to join the control flows from all of the true
       // (respectively, false) targets of the copied branches.
       //
       // The converted join block will have no phis, so it cannot be another
       // instance of the pattern.  There is thus no need to add it to the
       // worklist.
       BranchInstr* branch = block->last_instruction()->AsBranch();
       ASSERT(branch != NULL);
       JoinEntryInstr* join_true =
-          ToJoinEntry(isolate, branch->true_successor());
+          ToJoinEntry(zone, branch->true_successor());
       JoinEntryInstr* join_false =
-          ToJoinEntry(isolate, branch->false_successor());
+          ToJoinEntry(zone, branch->false_successor());
 
       ComparisonInstr* comparison = branch->comparison();
       PhiInstr* phi = comparison->left()->definition()->AsPhi();
       ConstantInstr* constant = comparison->right()->definition()->AsConstant();
       ASSERT(constant != NULL);
       // Copy the constant and branch and push it to all the predecessors.
       for (intptr_t i = 0, count = block->PredecessorCount(); i < count; ++i) {
         GotoInstr* old_goto =
             block->PredecessorAt(i)->last_instruction()->AsGoto();
         ASSERT(old_goto != NULL);
 
         // Replace the goto in each predecessor with a rewritten branch,
         // rewritten to use the corresponding phi input instead of the phi.
-        Value* new_left = phi->InputAt(i)->Copy(isolate);
-        Value* new_right = new(isolate) Value(constant);
+        Value* new_left = phi->InputAt(i)->Copy(zone);
+        Value* new_right = new(zone) Value(constant);
         BranchInstr* new_branch =
-            CloneBranch(isolate, branch, new_left, new_right);
+            CloneBranch(zone, branch, new_left, new_right);
         if (branch->env() == NULL) {
-          new_branch->InheritDeoptTarget(isolate, old_goto);
+          new_branch->InheritDeoptTarget(zone, old_goto);
         } else {
           // Take the environment from the branch if it has one.
-          new_branch->InheritDeoptTarget(isolate, branch);
+          new_branch->InheritDeoptTarget(zone, branch);
           // InheritDeoptTarget gave the new branch's comparison the same
           // deopt id that it gave the new branch.  The id should be the
           // deopt id of the original comparison.
           new_branch->comparison()->SetDeoptId(*comparison);
           // The phi can be used in the branch's environment.  Rename such
           // uses.
           for (Environment::DeepIterator it(new_branch->env());
                !it.Done();
                it.Advance()) {
             Value* use = it.CurrentValue();
@@ skipping 12 matching lines @@
 
         // 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(isolate) TargetEntryInstr(flow_graph->max_block_id() + 1,
+            new(zone) TargetEntryInstr(flow_graph->max_block_id() + 1,
                                           block->try_index());
-        true_target->InheritDeoptTarget(isolate, join_true);
+        true_target->InheritDeoptTarget(zone, join_true);
         TargetEntryInstr* false_target =
-            new(isolate) TargetEntryInstr(flow_graph->max_block_id() + 2,
+            new(zone) TargetEntryInstr(flow_graph->max_block_id() + 2,
                                           block->try_index());
-        false_target->InheritDeoptTarget(isolate, join_false);
+        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(isolate) GotoInstr(join_true);
-        goto_true->InheritDeoptTarget(isolate, join_true);
+        GotoInstr* goto_true = new(zone) GotoInstr(join_true);
+        goto_true->InheritDeoptTarget(zone, join_true);
         true_target->LinkTo(goto_true);
         true_target->set_last_instruction(goto_true);
-        GotoInstr* goto_false = new(isolate) GotoInstr(join_false);
-        goto_false->InheritDeoptTarget(isolate, join_false);
+        GotoInstr* goto_false = new(zone) GotoInstr(join_false);
+        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 23 matching lines @@
 
   if ((block->next() == instr) &&
       (instr->next() == block->last_instruction())) {
     before->previous()->LinkTo(instr);
     instr->LinkTo(before);
   }
 }
 
 
 void IfConverter::Simplify(FlowGraph* flow_graph) {
-  Isolate* isolate = flow_graph->isolate();
+  Zone* zone = flow_graph->zone();
   bool changed = false;
 
   const GrowableArray<BlockEntryInstr*>& postorder = flow_graph->postorder();
   for (BlockIterator it(postorder); !it.Done(); it.Advance()) {
     BlockEntryInstr* block = it.Current();
     JoinEntryInstr* join = block->AsJoinEntry();
 
     // Detect diamond control flow pattern which materializes a value depending
     // on the result of the comparison:
     //
@@ skipping 34 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(isolate),
-                  comparison->right()->Copy(isolate));
-          IfThenElseInstr* if_then_else = new(isolate) IfThenElseInstr(
+                  comparison->left()->Copy(zone),
+                  comparison->right()->Copy(zone));
+          IfThenElseInstr* if_then_else = new(zone) IfThenElseInstr(
               new_comparison,
-              if_true->Copy(isolate),
-              if_false->Copy(isolate));
+              if_true->Copy(zone),
+              if_false->Copy(zone));
           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
@@ skipping 655 matching lines @@
 
   // Insert materializations at environment uses.
   for (intptr_t i = 0; i < exits_collector_.exits().length(); i++) {
     CreateMaterializationAt(
         exits_collector_.exits()[i], alloc, *slots);
   }
 }
 
 
 }  // namespace dart