Switch two ZoneLists to ZoneVector in register allocator.

src/compiler/register-allocator.cc

 // Copyright 2014 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/linkage.h"
 #include "src/compiler/register-allocator.h"
 #include "src/string-stream.h"
 
 namespace v8 {
 namespace internal {
@@ skipping 549 matching lines @@
       new (code_zone()) BitVector(config->num_general_registers(), code_zone());
   assigned_double_registers_ = new (code_zone())
       BitVector(config->num_aliased_double_registers(), code_zone());
   frame->SetAllocatedRegisters(assigned_registers_);
   frame->SetAllocatedDoubleRegisters(assigned_double_registers_);
 }
 
 
 void RegisterAllocator::InitializeLivenessAnalysis() {
   // Initialize the live_in sets for each block to NULL.
-  int block_count = code()->InstructionBlockCount();
-  live_in_sets_.Initialize(block_count, local_zone());
-  live_in_sets_.AddBlock(NULL, block_count, local_zone());
+  std::fill(live_in_sets_.begin(), live_in_sets_.end(), nullptr);
 }
 
 
 BitVector* RegisterAllocator::ComputeLiveOut(const InstructionBlock* block) {
   // Compute live out for the given block, except not including backward
   // successor edges.
   BitVector* live_out = new (local_zone())
       BitVector(code()->VirtualRegisterCount(), local_zone());
 
   // Process all successor blocks.
   for (auto succ : block->successors()) {
     // Add values live on entry to the successor. Note the successor's
     // live_in will not be computed yet for backwards edges.
-    BitVector* live_in = live_in_sets_[static_cast<int>(succ.ToSize())];
+    BitVector* live_in = live_in_sets_[succ.ToSize()];
     if (live_in != NULL) live_out->Union(*live_in);
 
     // All phi input operands corresponding to this successor edge are live
     // out from this block.
     const InstructionBlock* successor = code()->InstructionBlockAt(succ);
     size_t index = successor->PredecessorIndexOf(block->rpo_number());
     DCHECK(index < successor->PredecessorCount());
     for (auto phi : successor->phis()) {
       live_out->Add(phi->operands()[index]);
     }
@@ skipping 79 matching lines @@
     DCHECK(result->IsFixed());
     result->kind_ = DOUBLE_REGISTERS;
     SetLiveRangeAssignedRegister(result, index);
     fixed_double_live_ranges_[index] = result;
   }
   return result;
 }
 
 
 LiveRange* RegisterAllocator::LiveRangeFor(int index) {
-  if (index >= live_ranges_.length()) {
-    live_ranges_.AddBlock(NULL, index - live_ranges_.length() + 1,
-                          local_zone());
+  if (index >= static_cast<int>(live_ranges_.size())) {
+    live_ranges_.resize(index + 1, NULL);
   }
   LiveRange* result = live_ranges_[index];
   if (result == NULL) {
     result = new (local_zone()) LiveRange(index, code_zone());
     live_ranges_[index] = result;
   }
   return result;
 }
 
 
@@ skipping 622 matching lines @@
 }
 
 
 const InstructionBlock* RegisterAllocator::GetInstructionBlock(
     LifetimePosition pos) {
   return code()->GetInstructionBlock(pos.InstructionIndex());
 }
 
 
 void RegisterAllocator::ConnectRanges() {
-  for (int i = 0; i < live_ranges().length(); ++i) {
+  for (size_t i = 0; i < live_ranges().size(); ++i) {
     LiveRange* first_range = live_ranges().at(i);
     if (first_range == NULL || first_range->parent() != NULL) continue;
 
     LiveRange* second_range = first_range->next();
     while (second_range != NULL) {
       LifetimePosition pos = second_range->Start();
 
       if (!second_range->IsSpilled()) {
         // Add gap move if the two live ranges touch and there is no block
         // boundary.
@@ skipping 125 matching lines @@
   LiveRangeBound* start_;
 
   DISALLOW_COPY_AND_ASSIGN(LiveRangeBoundArray);
 };
 
 
 class LiveRangeFinder {
  public:
   explicit LiveRangeFinder(const RegisterAllocator& allocator)
       : allocator_(allocator),
-        bounds_length_(allocator.live_ranges().length()),
+        bounds_length_(static_cast<int>(allocator.live_ranges().size())),
         bounds_(allocator.local_zone()->NewArray<LiveRangeBoundArray>(
             bounds_length_)) {
     for (int i = 0; i < bounds_length_; ++i) {
       new (&bounds_[i]) LiveRangeBoundArray();
     }
   }
 
   LiveRangeBoundArray* ArrayFor(int operand_index) {
     DCHECK(operand_index < bounds_length_);
     const LiveRange* range = allocator_.live_ranges()[operand_index];
@@ skipping 150 matching lines @@
       }
 
       // Insert all values into the live in sets of all blocks in the loop.
       for (int i = block->rpo_number().ToInt() + 1;
            i < block->loop_end().ToInt(); ++i) {
         live_in_sets_[i]->Union(*live);
       }
     }
   }
 
-  for (int i = 0; i < live_ranges_.length(); ++i) {
+  for (size_t i = 0; i < live_ranges_.size(); ++i) {
     if (live_ranges_[i] != NULL) {
       live_ranges_[i]->kind_ = RequiredRegisterKind(live_ranges_[i]->id());
 
       // TODO(bmeurer): This is a horrible hack to make sure that for constant
       // live ranges, every use requires the constant to be in a register.
       // Without this hack, all uses with "any" policy would get the constant
       // operand assigned.
       LiveRange* range = live_ranges_[i];
       if (range->HasAllocatedSpillOperand() &&
           range->GetSpillOperand()->IsConstant()) {
@@ skipping 49 matching lines @@
 
 
 void RegisterAllocator::PopulatePointerMaps() {
   DCHECK(SafePointsAreInOrder());
 
   // Iterate over all safe point positions and record a pointer
   // for all spilled live ranges at this point.
   int last_range_start = 0;
   const PointerMapDeque* pointer_maps = code()->pointer_maps();
   PointerMapDeque::const_iterator first_it = pointer_maps->begin();
-  for (int range_idx = 0; range_idx < live_ranges().length(); ++range_idx) {
+  for (size_t range_idx = 0; range_idx < live_ranges().size(); ++range_idx) {
     LiveRange* range = live_ranges().at(range_idx);
     if (range == NULL) continue;
     // Iterate over the first parts of multi-part live ranges.
     if (range->parent() != NULL) continue;
     // Skip non-reference values.
     if (!HasTaggedValue(range->id())) continue;
     // Skip empty live ranges.
     if (range->IsEmpty()) continue;
 
     // Find the extent of the range and its children.
@@ skipping 70 matching lines @@
 void RegisterAllocator::AllocateDoubleRegisters() {
   num_registers_ = config()->num_aliased_double_registers();
   mode_ = DOUBLE_REGISTERS;
   AllocateRegisters();
 }
 
 
 void RegisterAllocator::AllocateRegisters() {
   DCHECK(unhandled_live_ranges_.is_empty());
 
-  for (int i = 0; i < live_ranges_.length(); ++i) {
+  for (size_t i = 0; i < live_ranges_.size(); ++i) {
     if (live_ranges_[i] != NULL) {
       if (live_ranges_[i]->Kind() == mode_) {
         AddToUnhandledUnsorted(live_ranges_[i]);
       }
     }
   }
   SortUnhandled();
   DCHECK(UnhandledIsSorted());
 
   DCHECK(reusable_slots_.is_empty());
@@ skipping 659 matching lines @@
   } else {
     DCHECK(range->Kind() == GENERAL_REGISTERS);
     assigned_registers_->Add(reg);
   }
   range->set_assigned_register(reg, code_zone());
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8