[turbofan] Free TurboFan from the claws of ZoneList.

src/compiler/scheduler.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/compiler/scheduler.h"
 
 #include <iomanip>
 
 #include "src/base/adapters.h"
 #include "src/bit-vector.h"
@@ skipping 609 matching lines @@
   }
 
   // Print and verify the special reverse-post-order.
   void PrintAndVerifySpecialRPO() {
 #if DEBUG
     if (FLAG_trace_turbo_scheduler) PrintRPO();
     VerifySpecialRPO();
 #endif
   }
 
-  const ZoneList<BasicBlock*>& GetOutgoingBlocks(BasicBlock* block) {
+  const ZoneVector<BasicBlock*>& GetOutgoingBlocks(BasicBlock* block) {
     if (HasLoopNumber(block)) {
       LoopInfo const& loop = loops_[GetLoopNumber(block)];
       if (loop.outgoing) return *loop.outgoing;
     }
     return empty_;
   }
 
  private:
   typedef std::pair<BasicBlock*, size_t> Backedge;
 
   // Numbering for BasicBlock::rpo_number for this block traversal:
   static const int kBlockOnStack = -2;
   static const int kBlockVisited1 = -3;
   static const int kBlockVisited2 = -4;
   static const int kBlockUnvisited1 = -1;
   static const int kBlockUnvisited2 = kBlockVisited1;
 
   struct SpecialRPOStackFrame {
     BasicBlock* block;
     size_t index;
   };
 
   struct LoopInfo {
     BasicBlock* header;
-    ZoneList<BasicBlock*>* outgoing;
+    ZoneVector<BasicBlock*>* outgoing;
     BitVector* members;
     LoopInfo* prev;
     BasicBlock* end;
     BasicBlock* start;
 
     void AddOutgoing(Zone* zone, BasicBlock* block) {
       if (outgoing == NULL) {
-        outgoing = new (zone) ZoneList<BasicBlock*>(2, zone);
+        outgoing = new (zone->New(sizeof(ZoneVector<BasicBlock*>)))
+            ZoneVector<BasicBlock*>(zone);
       }
-      outgoing->Add(block, zone);
+      outgoing->push_back(block);
     }
   };
 
   int Push(ZoneVector<SpecialRPOStackFrame>& stack, int depth,
            BasicBlock* child, int unvisited) {
     if (child->rpo_number() == unvisited) {
       stack[depth].block = child;
       stack[depth].index = 0;
       child->set_rpo_number(kBlockOnStack);
       return depth + 1;
@@ skipping 108 matching lines @@
             order = loop->end;
             block->set_rpo_number(kBlockVisited2);
             // Pop the loop stack and continue visiting outgoing edges within
             // the context of the outer loop, if any.
             loop = loop->prev;
             // We leave the loop header on the stack; the rest of this iteration
             // and later iterations will go through its outgoing edges list.
           }
 
           // Use the next outgoing edge if there are any.
-          int outgoing_index =
-              static_cast<int>(frame->index - block->SuccessorCount());
+          size_t outgoing_index = frame->index - block->SuccessorCount();
           LoopInfo* info = &loops_[GetLoopNumber(block)];
           DCHECK(loop != info);
           if (block != entry && info->outgoing != NULL &&
-              outgoing_index < info->outgoing->length()) {
+              outgoing_index < info->outgoing->size()) {
             succ = info->outgoing->at(outgoing_index);
             frame->index++;
           }
         }
 
         if (succ != NULL) {
           // Process the next successor.
           if (succ->rpo_number() == kBlockOnStack) continue;
           if (succ->rpo_number() == kBlockVisited2) continue;
           DCHECK(succ->rpo_number() == kBlockUnvisited2);
@@ skipping 238 matching lines @@
 #endif  // DEBUG
 
   Zone* zone_;
   Schedule* schedule_;
   BasicBlock* order_;
   BasicBlock* beyond_end_;
   ZoneVector<LoopInfo> loops_;
   ZoneVector<Backedge> backedges_;
   ZoneVector<SpecialRPOStackFrame> stack_;
   size_t previous_block_count_;
-  ZoneList<BasicBlock*> const empty_;
+  ZoneVector<BasicBlock*> const empty_;
 };
 
 
 BasicBlockVector* Scheduler::ComputeSpecialRPO(Zone* zone, Schedule* schedule) {
   SpecialRPONumberer numberer(zone, schedule);
   numberer.ComputeSpecialRPO();
   numberer.SerializeRPOIntoSchedule();
   numberer.PrintAndVerifySpecialRPO();
   return schedule->rpo_order();
 }
@@ skipping 615 matching lines @@
   for (Node* const node : *nodes) {
     schedule_->SetBlockForNode(to, node);
     scheduled_nodes_[to->id().ToSize()].push_back(node);
   }
   nodes->clear();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8