Refactor allocation policies.

src/hydrogen.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 37 matching lines @@
 #else
 #error Unsupported target architecture.
 #endif
 
 namespace v8 {
 namespace internal {
 
 HBasicBlock::HBasicBlock(HGraph* graph)
     : block_id_(graph->GetNextBlockID()),
       graph_(graph),
-      phis_(4),
+      phis_(zone(), 4),
       first_(NULL),
       last_(NULL),
       end_(NULL),
       loop_information_(NULL),
-      predecessors_(2),
+      predecessors_(zone(), 2),
       dominator_(NULL),
-      dominated_blocks_(4),
+      dominated_blocks_(zone(), 4),
       last_environment_(NULL),
       argument_count_(-1),
       first_instruction_index_(-1),
       last_instruction_index_(-1),
-      deleted_phis_(4),
+      deleted_phis_(zone(), 4),
       parent_loop_header_(NULL),
       is_inline_return_target_(false),
       is_deoptimizing_(false) { }
 
 
 void HBasicBlock::AttachLoopInformation() {
   ASSERT(!IsLoopHeader());
   loop_information_ = new(zone()) HLoopInformation(this);
 }
 
@@ skipping 287 matching lines @@
 // the BitVector "reachable()" for every block that can be reached
 // from the start block of the graph. If "dont_visit" is non-null, the given
 // block is treated as if it would not be part of the graph. "visited_count()"
 // returns the number of reachable blocks.
 class ReachabilityAnalyzer BASE_EMBEDDED {
  public:
   ReachabilityAnalyzer(HBasicBlock* entry_block,
                        int block_count,
                        HBasicBlock* dont_visit)
       : visited_count_(0),
-        stack_(16),
+        stack_(ZONE, 16),
         reachable_(block_count),
         dont_visit_(dont_visit) {
     PushBlock(entry_block);
     Analyze();
   }
 
   int visited_count() const { return visited_count_; }
   const BitVector* reachable() const { return &reachable_; }
 
  private:
@@ skipping 201 matching lines @@
 void HBasicBlock::FinishExit(HControlInstruction* instruction) {
   Finish(instruction);
   ClearEnvironment();
 }
 
 
 HGraph::HGraph(CompilationInfo* info)
     : isolate_(info->isolate()),
       next_block_id_(0),
       entry_block_(NULL),
-      blocks_(8),
-      values_(16),
+      blocks_(info->zone(), 8),
+      values_(info->zone(), 16),
       phi_list_(NULL) {
   start_environment_ =
       new(zone()) HEnvironment(NULL, info->scope(), info->closure());
   start_environment_->set_ast_id(AstNode::kFunctionEntryId);
   entry_block_ = CreateBasicBlock();
   entry_block_->SetInitialEnvironment(start_environment_);
 }
 
 
 Handle<Code> HGraph::Compile(CompilationInfo* info) {
@@ skipping 56 matching lines @@
       instr = instr->next();
     }
   }
 }
 
 
 void HGraph::OrderBlocks() {
   HPhase phase("Block ordering");
   BitVector visited(blocks_.length());
 
-  ZoneList<HBasicBlock*> reverse_result(8);
+  ZoneList<HBasicBlock*> reverse_result(zone(), 8);
   HBasicBlock* start = blocks_[0];
   Postorder(start, &visited, &reverse_result, NULL);
 
   blocks_.Rewind(0);
   int index = 0;
   for (int i = reverse_result.length() - 1; i >= 0; --i) {
     HBasicBlock* b = reverse_result[i];
     blocks_.Add(b);
     b->set_block_id(index++);
   }
@@ skipping 68 matching lines @@
     MarkAsDeoptimizingRecursively(dominated);
   }
 }
 
 void HGraph::EliminateRedundantPhis() {
   HPhase phase("Redundant phi elimination", this);
 
   // Worklist of phis that can potentially be eliminated. Initialized with
   // all phi nodes. When elimination of a phi node modifies another phi node
   // the modified phi node is added to the worklist.
-  ZoneList<HPhi*> worklist(blocks_.length());
+  ZoneList<HPhi*> worklist(zone(), blocks_.length());
   for (int i = 0; i < blocks_.length(); ++i) {
     worklist.AddAll(*blocks_[i]->phis());
   }
 
   while (!worklist.is_empty()) {
     HPhi* phi = worklist.RemoveLast();
     HBasicBlock* block = phi->block();
 
     // Skip phi node if it was already replaced.
     if (block == NULL) continue;
@@ skipping 11 matching lines @@
       block->RemovePhi(phi);
     }
   }
 }
 
 
 void HGraph::EliminateUnreachablePhis() {
   HPhase phase("Unreachable phi elimination", this);
 
   // Initialize worklist.
-  ZoneList<HPhi*> phi_list(blocks_.length());
-  ZoneList<HPhi*> worklist(blocks_.length());
+  ZoneList<HPhi*> phi_list(zone(), blocks_.length());
+  ZoneList<HPhi*> worklist(zone(), blocks_.length());
   for (int i = 0; i < blocks_.length(); ++i) {
     for (int j = 0; j < blocks_[i]->phis()->length(); j++) {
       HPhi* phi = blocks_[i]->phis()->at(j);
       phi_list.Add(phi);
       // We can't eliminate phis in the receiver position in the environment
       // because in case of throwing an error we need this value to
       // construct a stack trace.
       if (phi->HasRealUses() || phi->IsReceiver())  {
         phi->set_is_live(true);
         worklist.Add(phi);
@@ skipping 20 matching lines @@
       HBasicBlock* block = phi->block();
       block->RemovePhi(phi);
       block->RecordDeletedPhi(phi->merged_index());
     }
   }
 }
 
 
 bool HGraph::CollectPhis() {
   int block_count = blocks_.length();
-  phi_list_ = new ZoneList<HPhi*>(block_count);
+  phi_list_ = ZoneList<HPhi*>::New(zone(), block_count);
   for (int i = 0; i < block_count; ++i) {
     for (int j = 0; j < blocks_[i]->phis()->length(); ++j) {
       HPhi* phi = blocks_[i]->phis()->at(j);
       phi_list_->Add(phi);
       // We don't support phi uses of arguments for now.
       if (phi->CheckFlag(HValue::kIsArguments)) return false;
       // Check for the hole value (from an uninitialized const).
       for (int k = 0; k < phi->OperandCount(); k++) {
         if (phi->OperandAt(k) == GetConstantHole()) return false;
       }
@@ skipping 21 matching lines @@
           worklist->Add(use);
         }
       }
     }
   }
 }
 
 
 class HRangeAnalysis BASE_EMBEDDED {
  public:
-  explicit HRangeAnalysis(HGraph* graph) : graph_(graph), changed_ranges_(16) {}
+  explicit HRangeAnalysis(HGraph* graph)
+      : graph_(graph),
+        changed_ranges_(graph->zone(), 16) {}
 
   void Analyze();
 
  private:
   void TraceRange(const char* msg, ...);
   void Analyze(HBasicBlock* block);
   void InferControlFlowRange(HCompareIDAndBranch* test, HBasicBlock* dest);
   void UpdateControlFlowRange(Token::Value op, HValue* value, HValue* other);
   void InferRange(HValue* value);
   void RollBackTo(int index);
@@ skipping 404 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(SparseSet);
 };
 
 
 class HGlobalValueNumberer BASE_EMBEDDED {
  public:
   explicit HGlobalValueNumberer(HGraph* graph, CompilationInfo* info)
       : graph_(graph),
         info_(info),
-        block_side_effects_(graph->blocks()->length()),
-        loop_side_effects_(graph->blocks()->length()),
-        visited_on_paths_(graph->zone(), graph->blocks()->length()) {
+        block_side_effects_(info->zone(), graph->blocks()->length()),
+        loop_side_effects_(info->zone(), graph->blocks()->length()),
+        visited_on_paths_(info->zone(), graph->blocks()->length()) {
     ASSERT(info->isolate()->heap()->allow_allocation(false));
     block_side_effects_.AddBlock(0, graph_->blocks()->length());
     loop_side_effects_.AddBlock(0, graph_->blocks()->length());
   }
   ~HGlobalValueNumberer() {
     ASSERT(!info_->isolate()->heap()->allow_allocation(true));
   }
 
   void Analyze();
 
@@ skipping 206 matching lines @@
                                                                     dominated));
     }
     AnalyzeBlock(dominated, successor_map);
   }
 }
 
 
 class HInferRepresentation BASE_EMBEDDED {
  public:
   explicit HInferRepresentation(HGraph* graph)
-      : graph_(graph), worklist_(8), in_worklist_(graph->GetMaximumValueID()) {}
+      : graph_(graph),
+        worklist_(graph->zone(), 8),
+        in_worklist_(graph->GetMaximumValueID()) {}
 
   void Analyze();
 
  private:
   Representation TryChange(HValue* current);
   void AddToWorklist(HValue* current);
   void InferBasedOnInputs(HValue* current);
   void AddDependantsToWorklist(HValue* current);
   void InferBasedOnUses(HValue* current);
 
@@ skipping 91 matching lines @@
 }
 
 
 void HInferRepresentation::Analyze() {
   HPhase phase("Infer representations", graph_);
 
   // (1) Initialize bit vectors and count real uses. Each phi gets a
   // bit-vector of length <number of phis>.
   const ZoneList<HPhi*>* phi_list = graph_->phi_list();
   int phi_count = phi_list->length();
-  ZoneList<BitVector*> connected_phis(phi_count);
+  ZoneList<BitVector*> connected_phis(graph_->zone(), phi_count);
   for (int i = 0; i < phi_count; ++i) {
     phi_list->at(i)->InitRealUses(i);
     BitVector* connected_set = new(zone()) BitVector(phi_count);
     connected_set->Add(i);
     connected_phis.Add(connected_set);
   }
 
   // (2) Do a fixed point iteration to find the set of connected phis.  A
   // phi is connected to another phi if its value is used either directly or
   // indirectly through a transitive closure of the def-use relation.
@@ skipping 92 matching lines @@
     }
 
     if (block->IsLoopHeader()) {
       HBasicBlock* last_back_edge =
           block->loop_information()->GetLastBackEdge();
       InitializeInferredTypes(i + 1, last_back_edge->block_id());
       // Skip all blocks already processed by the recursive call.
       i = last_back_edge->block_id();
       // Update phis of the loop header now after the whole loop body is
       // guaranteed to be processed.
-      ZoneList<HValue*> worklist(block->phis()->length());
+      ZoneList<HValue*> worklist(zone(), block->phis()->length());
       for (int j = 0; j < block->phis()->length(); ++j) {
         worklist.Add(block->phis()->at(j));
       }
       InferTypes(&worklist);
     }
   }
 }
 
 
 void HGraph::PropagateMinusZeroChecks(HValue* value, BitVector* visited) {
@@ skipping 599 matching lines @@
 
 void HGraphBuilder::PushAndAdd(HInstruction* instr) {
   Push(instr);
   AddInstruction(instr);
 }
 
 
 template <int V>
 HInstruction* HGraphBuilder::PreProcessCall(HCall<V>* call) {
   int count = call->argument_count();
-  ZoneList<HValue*> arguments(count);
+  ZoneList<HValue*> arguments(zone(), count);
   for (int i = 0; i < count; ++i) {
     arguments.Add(Pop());
   }
 
   while (!arguments.is_empty()) {
     AddInstruction(new(zone()) HPushArgument(arguments.RemoveLast()));
   }
   return call;
 }
 
@@ skipping 3790 matching lines @@
 
 
 #undef CHECK_BAILOUT
 #undef CHECK_ALIVE
 
 
 HEnvironment::HEnvironment(HEnvironment* outer,
                            Scope* scope,
                            Handle<JSFunction> closure)
     : closure_(closure),
-      values_(0),
-      assigned_variables_(4),
+      values_(ZONE, 0),
+      assigned_variables_(ZONE, 4),
       parameter_count_(0),
       specials_count_(1),
       local_count_(0),
       outer_(outer),
       pop_count_(0),
       push_count_(0),
       ast_id_(AstNode::kNoNumber) {
   Initialize(scope->num_parameters() + 1, scope->num_stack_slots(), 0);
 }
 
 
 HEnvironment::HEnvironment(const HEnvironment* other)
-    : values_(0),
-      assigned_variables_(0),
+    : values_(ZONE, 0),
+      assigned_variables_(ZONE, 0),
       parameter_count_(0),
       specials_count_(1),
       local_count_(0),
       outer_(NULL),
       pop_count_(0),
       push_count_(0),
       ast_id_(other->ast_id()) {
   Initialize(other);
 }
 
@@ skipping 487 matching lines @@
     }
   }
 
 #ifdef DEBUG
   if (graph_ != NULL) graph_->Verify();
   if (allocator_ != NULL) allocator_->Verify();
 #endif
 }
 
 } }  // namespace v8::internal