Introduce simple Thread class to support gradual refactoring of interfaces.

runtime/vm/flow_graph.cc

 // Copyright (c) 2012, 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.h"
 
 #include "vm/bit_vector.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/intermediate_language.h"
 #include "vm/growable_array.h"
 #include "vm/object_store.h"
 #include "vm/report.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, prune_dead_locals, true, "optimize dead locals away");
 DECLARE_FLAG(bool, reorder_basic_blocks);
 DECLARE_FLAG(bool, trace_optimization);
 DECLARE_FLAG(bool, verify_compiler);
 
 
 FlowGraph::FlowGraph(ParsedFunction* parsed_function,
                      GraphEntryInstr* graph_entry,
                      intptr_t max_block_id)
-  : isolate_(Isolate::Current()),
+  : thread_(Thread::Current()),
     parent_(),
     current_ssa_temp_index_(0),
     max_block_id_(max_block_id),
     parsed_function_(parsed_function),
     num_copied_params_(parsed_function->num_copied_params()),
     num_non_copied_params_(parsed_function->num_non_copied_params()),
     graph_entry_(graph_entry),
     preorder_(),
     postorder_(),
     reverse_postorder_(),
     optimized_block_order_(),
     constant_null_(NULL),
     constant_dead_(NULL),
     constant_empty_context_(NULL),
     block_effects_(NULL),
     licm_allowed_(true),
     loop_headers_(NULL),
     loop_invariant_loads_(NULL),
     guarded_fields_(parsed_function->guarded_fields()),
     deferred_prefixes_(parsed_function->deferred_prefixes()),
-    captured_parameters_(
-        new(isolate_) BitVector(isolate_, variable_count())) {
+    captured_parameters_(new(zone()) BitVector(zone(), variable_count())) {
   DiscoverBlocks();
 }
 
 
 void FlowGraph::AddToGuardedFields(
     ZoneGrowableArray<const Field*>* array,
     const Field* field) {
   if ((field->guarded_cid() == kDynamicCid) ||
       (field->guarded_cid() == kIllegalCid)) {
     return;
@@ skipping 33 matching lines @@
   return ShouldReorderBlocks(parsed_function()->function(), is_optimized)
       ? &optimized_block_order_
       : &reverse_postorder_;
 }
 
 
 ConstantInstr* FlowGraph::GetConstant(const Object& object) {
   ConstantInstr* constant = constant_instr_pool_.Lookup(object);
   if (constant == NULL) {
     // Otherwise, allocate and add it to the pool.
-    constant = new(isolate()) ConstantInstr(
+    constant = new(zone()) ConstantInstr(
         Object::ZoneHandle(isolate(), object.raw()));
     constant->set_ssa_temp_index(alloc_ssa_temp_index());
 
     AddToInitialDefinitions(constant);
     constant_instr_pool_.Insert(constant);
   }
   return constant;
 }
 
 
@@ skipping 105 matching lines @@
 
   // Block effects are using postorder numbering. Discard computed information.
   block_effects_ = NULL;
   loop_headers_ = NULL;
   loop_invariant_loads_ = NULL;
 }
 
 
 void FlowGraph::MergeBlocks() {
   bool changed = false;
-  BitVector* merged = new(isolate()) BitVector(isolate(), postorder().length());
+  BitVector* merged = new(zone()) BitVector(zone(), postorder().length());
   for (BlockIterator block_it = reverse_postorder_iterator();
        !block_it.Done();
        block_it.Advance()) {
     BlockEntryInstr* block = block_it.Current();
     if (block->IsGraphEntry()) continue;
     if (merged->Contains(block->postorder_number())) continue;
 
     Instruction* last = block->last_instruction();
     BlockEntryInstr* successor = NULL;
     while ((!last->IsIndirectGoto()) &&
@@ skipping 127 matching lines @@
       VerifyUseListsInInstruction(it.Current());
     }
   }
   return true;  // Return true so we can ASSERT validation.
 }
 
 
 LivenessAnalysis::LivenessAnalysis(
   intptr_t variable_count,
   const GrowableArray<BlockEntryInstr*>& postorder)
-    : isolate_(Isolate::Current()),
+    : zone_(Thread::Current()->zone()),
       variable_count_(variable_count),
       postorder_(postorder),
       live_out_(postorder.length()),
       kill_(postorder.length()),
       live_in_(postorder.length()) {
 }
 
 
 bool LivenessAnalysis::UpdateLiveOut(const BlockEntryInstr& block) {
   BitVector* live_out = live_out_[block.postorder_number()];
@@ skipping 36 matching lines @@
         changed = true;
       }
     }
   } while (changed);
 }
 
 
 void LivenessAnalysis::Analyze() {
   const intptr_t block_count = postorder_.length();
   for (intptr_t i = 0; i < block_count; i++) {
-    live_out_.Add(new(isolate()) BitVector(isolate(), variable_count_));
-    kill_.Add(new(isolate()) BitVector(isolate(), variable_count_));
-    live_in_.Add(new(isolate()) BitVector(isolate(), variable_count_));
+    live_out_.Add(new(zone()) BitVector(zone(), variable_count_));
+    kill_.Add(new(zone()) BitVector(zone(), variable_count_));
+    live_in_.Add(new(zone()) BitVector(zone(), variable_count_));
   }
 
   ComputeInitialSets();
   ComputeLiveInAndLiveOutSets();
 }
 
 
 static void PrintBitVector(const char* tag, BitVector* v) {
   OS::Print("%s:", tag);
   for (BitVector::Iterator it(v); !it.Done(); it.Advance()) {
@@ skipping 96 matching lines @@
 
   const FlowGraph* flow_graph_;
   const intptr_t num_non_copied_params_;
   GrowableArray<BitVector*> assigned_vars_;
 };
 
 
 void VariableLivenessAnalysis::ComputeInitialSets() {
   const intptr_t block_count = postorder_.length();
 
-  BitVector* last_loads = new(isolate()) BitVector(isolate(), variable_count_);
+  BitVector* last_loads = new(zone()) BitVector(zone(), variable_count_);
   for (intptr_t i = 0; i < block_count; i++) {
     BlockEntryInstr* block = postorder_[i];
 
     BitVector* kill = kill_[i];
     BitVector* live_in = live_in_[i];
     last_loads->Clear();
 
     // There is an implicit use (load-local) of every local variable at each
     // call inside a try{} block and every call has an implicit control-flow
     // to the catch entry. As an approximation we mark all locals as live
@@ skipping 105 matching lines @@
   // Use a link-eval data structure with path compression.  Implement path
   // compression in place by mutating the parent array.  Each block has a
   // label, which is the minimum block number on the compressed path.
 
   // Initialize idom, semi, and label used by SEMI-NCA.  Initialize the
   // dominance frontier output array.
   for (intptr_t i = 0; i < size; ++i) {
     idom.Add(parent_[i]);
     semi.Add(i);
     label.Add(i);
-    dominance_frontier->Add(new(isolate()) BitVector(isolate(), size));
+    dominance_frontier->Add(new(zone()) BitVector(zone(), size));
   }
 
   // Loop over the blocks in reverse preorder (not including the graph
   // entry).  Clear the dominated blocks in the graph entry in case
   // ComputeDominators is used to recompute them.
   preorder_[0]->ClearDominatedBlocks();
   for (intptr_t block_index = size - 1; block_index >= 1; --block_index) {
     // Loop over the predecessors.
     BlockEntryInstr* block = preorder_[block_index];
     // Clear the immediately dominated blocks in case ComputeDominators is
@@ skipping 149 matching lines @@
       Definition* defn = (*inlining_parameters)[i];
       AllocateSSAIndexes(defn);
       AddToInitialDefinitions(defn);
       env.Add(defn);
     }
   } else {
     // Create new parameters.  For functions compiled for OSR, the locals
     // are unknown and so treated like parameters.
     intptr_t count = IsCompiledForOsr() ? variable_count() : parameter_count();
     for (intptr_t i = 0; i < count; ++i) {
-      ParameterInstr* param = new(isolate()) ParameterInstr(i, entry);
+      ParameterInstr* param = new(zone()) ParameterInstr(i, entry);
       param->set_ssa_temp_index(alloc_ssa_temp_index());  // New SSA temp.
       AddToInitialDefinitions(param);
       env.Add(param);
     }
   }
 
   // Initialize all locals in the renaming environment  For OSR, the locals have
   // already been handled as parameters.
   if (!IsCompiledForOsr()) {
     for (intptr_t i = parameter_count(); i < variable_count(); ++i) {
@@ skipping 65 matching lines @@
             // more redundant phis.
             phi->mark_alive();
             live_phis->Add(phi);
           }
         }
       }
     }
   } else if (block_entry->IsCatchBlockEntry()) {
     // Add real definitions for all locals and parameters.
     for (intptr_t i = 0; i < env->length(); ++i) {
-      ParameterInstr* param = new(isolate()) ParameterInstr(i, block_entry);
+      ParameterInstr* param = new(zone()) ParameterInstr(i, block_entry);
       param->set_ssa_temp_index(alloc_ssa_temp_index());  // New SSA temp.
       (*env)[i] = param;
       block_entry->AsCatchBlockEntry()->initial_definitions()->Add(param);
     }
   }
 
   // Prune non-live variables at block entry by replacing their environment
   // slots with null.
   BitVector* live_in = variable_liveness->GetLiveInSet(block_entry);
   for (intptr_t i = 0; i < variable_count(); i++) {
@@ skipping 158 matching lines @@
       block_entry->last_instruction()->SuccessorAt(0)->IsJoinEntry()) {
     JoinEntryInstr* successor =
         block_entry->last_instruction()->SuccessorAt(0)->AsJoinEntry();
     intptr_t pred_index = successor->IndexOfPredecessor(block_entry);
     ASSERT(pred_index >= 0);
     if (successor->phis() != NULL) {
       for (intptr_t i = 0; i < successor->phis()->length(); ++i) {
         PhiInstr* phi = (*successor->phis())[i];
         if (phi != NULL) {
           // Rename input operand.
-          Value* use = new(isolate()) Value((*env)[i]);
+          Value* use = new(zone()) Value((*env)[i]);
           phi->SetInputAt(pred_index, use);
         }
       }
     }
   }
 }
 
 
 void FlowGraph::RemoveDeadPhis(GrowableArray<PhiInstr*>* live_phis) {
   // Augment live_phis with those that have implicit real used at
@@ skipping 64 matching lines @@
     }
   }
 }
 
 
 // Find the natural loop for the back edge m->n and attach loop information
 // to block n (loop header). The algorithm is described in "Advanced Compiler
 // Design & Implementation" (Muchnick) p192.
 BitVector* FlowGraph::FindLoop(BlockEntryInstr* m, BlockEntryInstr* n) const {
   GrowableArray<BlockEntryInstr*> stack;
-  BitVector* loop = new(isolate()) BitVector(isolate(), preorder_.length());
+  BitVector* loop = new(zone()) BitVector(zone(), preorder_.length());
 
   loop->Add(n->preorder_number());
   if (n != m) {
     loop->Add(m->preorder_number());
     stack.Add(m);
   }
 
   while (!stack.is_empty()) {
     BlockEntryInstr* p = stack.RemoveLast();
     for (intptr_t i = 0; i < p->PredecessorCount(); ++i) {
       BlockEntryInstr* q = p->PredecessorAt(i);
       if (!loop->Contains(q->preorder_number())) {
         loop->Add(q->preorder_number());
         stack.Add(q);
       }
     }
   }
   return loop;
 }
 
 
 ZoneGrowableArray<BlockEntryInstr*>* FlowGraph::ComputeLoops() const {
   ZoneGrowableArray<BlockEntryInstr*>* loop_headers =
-      new(isolate()) ZoneGrowableArray<BlockEntryInstr*>();
+      new(zone()) ZoneGrowableArray<BlockEntryInstr*>();
 
   for (BlockIterator it = postorder_iterator();
        !it.Done();
        it.Advance()) {
     BlockEntryInstr* block = it.Current();
     for (intptr_t i = 0; i < block->PredecessorCount(); ++i) {
       BlockEntryInstr* pred = block->PredecessorAt(i);
       if (block->Dominates(pred)) {
         if (FLAG_trace_optimization) {
           OS::Print("Back edge B%" Pd " -> B%" Pd "\n", pred->block_id(),
@@ skipping 40 matching lines @@
          !it.Done();
          it.Advance()) {
       ++size;
     }
   }
   return size;
 }
 
 
 void FlowGraph::ComputeBlockEffects() {
-  block_effects_ = new(isolate()) BlockEffects(this);
+  block_effects_ = new(zone()) BlockEffects(this);
 }
 
 
 BlockEffects::BlockEffects(FlowGraph* flow_graph)
     : available_at_(flow_graph->postorder().length()) {
   // We are tracking a single effect.
   ASSERT(EffectSet::kLastEffect == 1);
-  Isolate* isolate = flow_graph->isolate();
+  Zone* zone = flow_graph->zone();
   const intptr_t block_count = flow_graph->postorder().length();
 
   // Set of blocks that contain side-effects.
-  BitVector* kill = new(isolate) BitVector(isolate, block_count);
+  BitVector* kill = new(zone) BitVector(zone, block_count);
 
   // Per block available-after sets. Block A is available after the block B if
   // and only if A is either equal to B or A is available at B and B contains no
   // side-effects. Initially we consider all blocks available after all other
   // blocks.
   GrowableArray<BitVector*> available_after(block_count);
 
   // Discover all blocks with side-effects.
   for (BlockIterator it = flow_graph->postorder_iterator();
        !it.Done();
        it.Advance()) {
     available_at_.Add(NULL);
     available_after.Add(NULL);
 
     BlockEntryInstr* block = it.Current();
     for (ForwardInstructionIterator it(block);
          !it.Done();
          it.Advance()) {
       if (!it.Current()->Effects().IsNone()) {
         kill->Add(block->postorder_number());
         break;
       }
     }
   }
 
-  BitVector* temp = new(isolate) BitVector(isolate, block_count);
+  BitVector* temp = new(zone) BitVector(zone, block_count);
 
   // Recompute available-at based on predecessors' available-after until the fix
   // point is reached.
   bool changed;
   do {
     changed = false;
 
     for (BlockIterator it = flow_graph->reverse_postorder_iterator();
          !it.Done();
          it.Advance()) {
@@ skipping 12 matching lines @@
             temp->Intersect(available_after[pred]);
           }
         }
       }
 
       BitVector* current = available_at_[block_num];
       if ((current == NULL) || !current->Equals(*temp)) {
         // Available-at changed: update it and recompute available-after.
         if (available_at_[block_num] == NULL) {
           current = available_at_[block_num] =
-              new(isolate) BitVector(isolate, block_count);
+              new(zone) BitVector(zone, block_count);
           available_after[block_num] =
-              new(isolate) BitVector(isolate, block_count);
+              new(zone) BitVector(zone, block_count);
           // Block is always available after itself.
           available_after[block_num]->Add(block_num);
         }
         current->CopyFrom(temp);
         if (!kill->Contains(block_num)) {
           available_after[block_num]->CopyFrom(temp);
           // Block is always available after itself.
           available_after[block_num]->Add(block_num);
         }
         changed = true;
@@ skipping 17 matching lines @@
 }
 
 
 bool BlockEffects::IsSideEffectFreePath(BlockEntryInstr* from,
                                         BlockEntryInstr* to) const {
   return available_at_[to->postorder_number()]->Contains(
       from->postorder_number());
 }
 
 }  // namespace dart