Fix register allocator to properly allocate containers.

runtime/vm/flow_graph_allocator.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_allocator.h"
 
 #include "vm/bit_vector.h"
 #include "vm/intermediate_language.h"
 #include "vm/il_printer.h"
 #include "vm/flow_graph.h"
@@ skipping 67 matching lines @@
     value_representations_(flow_graph.max_virtual_register_number()),
     block_order_(flow_graph.reverse_postorder()),
     postorder_(flow_graph.postorder()),
     liveness_(flow_graph),
     vreg_count_(flow_graph.max_virtual_register_number()),
     live_ranges_(flow_graph.max_virtual_register_number()),
     cpu_regs_(),
     fpu_regs_(),
     blocked_cpu_registers_(),
     blocked_fpu_registers_(),
+    number_of_registers_(0),
+    registers_(),
+    blocked_registers_(),
     cpu_spill_slot_count_(0) {
   for (intptr_t i = 0; i < vreg_count_; i++) {
     live_ranges_.Add(NULL);
   }
   for (intptr_t i = 0; i < vreg_count_; i++) {
     value_representations_.Add(kNoRepresentation);
   }
 
   // All registers are marked as "not blocked" (array initialized to false).
   // Mark the unavailable ones as "blocked" (true).
@@ skipping 1756 matching lines @@
     }
   }
   range->set_assigned_location(parent->spill_slot());
   ConvertAllUses(range);
 }
 
 
 intptr_t FlowGraphAllocator::FirstIntersectionWithAllocated(
     intptr_t reg, LiveRange* unallocated) {
   intptr_t intersection = kMaxPosition;
-  for (intptr_t i = 0; i < registers_[reg].length(); i++) {
-    LiveRange* allocated = registers_[reg][i];
+  for (intptr_t i = 0; i < registers_[reg]->length(); i++) {
+    LiveRange* allocated = (*registers_[reg])[i];
     if (allocated == NULL) continue;
 
     UseInterval* allocated_head =
         allocated->finger()->first_pending_use_interval();
     if (allocated_head->start() >= intersection) continue;
 
     const intptr_t pos = FirstIntersection(
         unallocated->finger()->first_pending_use_interval(),
         allocated_head);
     if (pos < intersection) intersection = pos;
@@ skipping 83 matching lines @@
                                                   unallocated);
       candidate = hint.register_code();
     }
 
     TRACE_ALLOC(OS::Print("found hint %s for v%" Pd ": free until %" Pd "\n",
                           hint.Name(),
                           unallocated->vreg(),
                           free_until));
   } else {
     for (intptr_t reg = 0; reg < NumberOfRegisters(); ++reg) {
-      if (!blocked_registers_[reg] && (registers_[reg].length() == 0)) {
+      if (!blocked_registers_[reg] && (registers_[reg]->length() == 0)) {
         candidate = reg;
         free_until = kMaxPosition;
         break;
       }
     }
   }
 
   ASSERT(0 <= kMaxPosition);
   if (free_until != kMaxPosition) {
     for (intptr_t reg = 0; reg < NumberOfRegisters(); ++reg) {
@@ skipping 75 matching lines @@
   TRACE_ALLOC(MakeRegisterLocation(candidate).Print());
   TRACE_ALLOC(OS::Print(" to v%" Pd "\n", unallocated->vreg()));
 
   if (free_until != kMaxPosition) {
     // There was an intersection. Split unallocated.
     TRACE_ALLOC(OS::Print("  splitting at %" Pd "\n", free_until));
     LiveRange* tail = unallocated->SplitAt(free_until);
     AddToUnallocated(tail);
   }
 
-  registers_[candidate].Add(unallocated);
+  registers_[candidate]->Add(unallocated);
   unallocated->set_assigned_location(MakeRegisterLocation(candidate));
 
   return true;
 }
 
 
 bool FlowGraphAllocator::RangeHasOnlyUnconstrainedUsesInLoop(LiveRange* range,
                                                              intptr_t loop_id) {
   if (range->vreg() >= 0) {
     LiveRange* parent = GetLiveRange(range->vreg());
     return parent->HasOnlyUnconstrainedUsesInLoop(loop_id);
   }
   return false;
 }
 
 
 bool FlowGraphAllocator::IsCheapToEvictRegisterInLoop(BlockInfo* loop,
                                                       intptr_t reg) {
   const intptr_t loop_start = loop->entry()->start_pos();
   const intptr_t loop_end = loop->last_block()->end_pos();
 
-  for (intptr_t i = 0; i < registers_[reg].length(); i++) {
-    LiveRange* allocated = registers_[reg][i];
+  for (intptr_t i = 0; i < registers_[reg]->length(); i++) {
+    LiveRange* allocated = (*registers_[reg])[i];
 
     UseInterval* interval = allocated->finger()->first_pending_use_interval();
     if (interval->Contains(loop_start)) {
       if (!RangeHasOnlyUnconstrainedUsesInLoop(allocated, loop->loop_id())) {
         return false;
       }
     } else if (interval->start() < loop_end) {
       return false;
     }
   }
@@ skipping 76 matching lines @@
 
 
 bool FlowGraphAllocator::UpdateFreeUntil(intptr_t reg,
                                          LiveRange* unallocated,
                                          intptr_t* cur_free_until,
                                          intptr_t* cur_blocked_at) {
   intptr_t free_until = kMaxPosition;
   intptr_t blocked_at = kMaxPosition;
   const intptr_t start = unallocated->Start();
 
-  for (intptr_t i = 0; i < registers_[reg].length(); i++) {
-    LiveRange* allocated = registers_[reg][i];
+  for (intptr_t i = 0; i < registers_[reg]->length(); i++) {
+    LiveRange* allocated = (*registers_[reg])[i];
 
     UseInterval* first_pending_use_interval =
         allocated->finger()->first_pending_use_interval();
     if (first_pending_use_interval->Contains(start)) {
       // This is an active interval.
       if (allocated->vreg() < 0) {
         // This register blocked by an interval that
         // can't be spilled.
         return false;
       }
@@ skipping 30 matching lines @@
   ASSERT(free_until > *cur_free_until);
   *cur_free_until = free_until;
   *cur_blocked_at = blocked_at;
   return true;
 }
 
 
 void FlowGraphAllocator::RemoveEvicted(intptr_t reg, intptr_t first_evicted) {
   intptr_t to = first_evicted;
   intptr_t from = first_evicted + 1;
-  while (from < registers_[reg].length()) {
-    LiveRange* allocated = registers_[reg][from++];
-    if (allocated != NULL) registers_[reg][to++] = allocated;
+  while (from < registers_[reg]->length()) {
+    LiveRange* allocated = (*registers_[reg])[from++];
+    if (allocated != NULL) (*registers_[reg])[to++] = allocated;
   }
-  registers_[reg].TruncateTo(to);
+  registers_[reg]->TruncateTo(to);
 }
 
 
 void FlowGraphAllocator::AssignNonFreeRegister(LiveRange* unallocated,
                                                intptr_t reg) {
   intptr_t first_evicted = -1;
-  for (intptr_t i = registers_[reg].length() - 1; i >= 0; i--) {
-    LiveRange* allocated = registers_[reg][i];
+  for (intptr_t i = registers_[reg]->length() - 1; i >= 0; i--) {
+    LiveRange* allocated = (*registers_[reg])[i];
     if (allocated->vreg() < 0) continue;  // Can't be evicted.
     if (EvictIntersection(allocated, unallocated)) {
       // If allocated was not spilled convert all pending uses.
       if (allocated->assigned_location().IsMachineRegister()) {
         ASSERT(allocated->End() <= unallocated->Start());
         ConvertAllUses(allocated);
       }
-      registers_[reg][i] = NULL;
+      (*registers_[reg])[i] = NULL;
       first_evicted = i;
     }
   }
 
   // Remove evicted ranges from the array.
   if (first_evicted != -1) RemoveEvicted(reg, first_evicted);
 
-  registers_[reg].Add(unallocated);
+  registers_[reg]->Add(unallocated);
   unallocated->set_assigned_location(MakeRegisterLocation(reg));
 }
 
 
 bool FlowGraphAllocator::EvictIntersection(LiveRange* allocated,
                                            LiveRange* unallocated) {
   UseInterval* first_unallocated =
       unallocated->finger()->first_pending_use_interval();
   const intptr_t intersection = FirstIntersection(
       allocated->finger()->first_pending_use_interval(),
@@ skipping 72 matching lines @@
         ASSERT(safepoint->locs()->can_call());
         safepoint->locs()->live_registers()->Add(loc);
       }
     }
   }
 }
 
 
 void FlowGraphAllocator::AdvanceActiveIntervals(const intptr_t start) {
   for (intptr_t reg = 0; reg < NumberOfRegisters(); reg++) {
-    if (registers_[reg].is_empty()) continue;
+    if (registers_[reg]->is_empty()) continue;
 
     intptr_t first_evicted = -1;
-    for (intptr_t i = registers_[reg].length() - 1; i >= 0; i--) {
-      LiveRange* range = registers_[reg][i];
+    for (intptr_t i = registers_[reg]->length() - 1; i >= 0; i--) {
+      LiveRange* range = (*registers_[reg])[i];
       if (range->finger()->Advance(start)) {
         ConvertAllUses(range);
-        registers_[reg][i] = NULL;
+        (*registers_[reg])[i] = NULL;
         first_evicted = i;
       }
     }
 
     if (first_evicted != -1) RemoveEvicted(reg, first_evicted);
   }
 }
 
 
 bool LiveRange::Contains(intptr_t pos) const {
@@ skipping 78 matching lines @@
       UNREACHABLE();
       return false;
     }
   }
   return true;
 }
 #endif
 
 
 void FlowGraphAllocator::PrepareForAllocation(
-  Location::Kind register_kind,
-  intptr_t number_of_registers,
-  const GrowableArray<LiveRange*>& unallocated,
-  LiveRange** blocking_ranges,
-  bool* blocked_registers) {
-  ASSERT(number_of_registers <= kNumberOfCpuRegisters);
+    Location::Kind register_kind,
+    intptr_t number_of_registers,
+    const GrowableArray<LiveRange*>& unallocated,
+    LiveRange** blocking_ranges,
+    bool* blocked_registers) {
   register_kind_ = register_kind;
   number_of_registers_ = number_of_registers;
 
+  blocked_registers_.Clear();
+  registers_.Clear();
+  for (intptr_t i = 0; i < number_of_registers_; i++) {
+    blocked_registers_.Add(false);
+    registers_.Add(new ZoneGrowableArray<LiveRange*>);
+  }
   ASSERT(unallocated_.is_empty());
   unallocated_.AddArray(unallocated);
 
   for (intptr_t reg = 0; reg < number_of_registers; reg++) {
     blocked_registers_[reg] = blocked_registers[reg];
-    ASSERT(registers_[reg].is_empty());
+    ASSERT(registers_[reg]->is_empty());
 
     LiveRange* range = blocking_ranges[reg];
     if (range != NULL) {
       range->finger()->Initialize(range);
-      registers_[reg].Add(range);
+      registers_[reg]->Add(range);
     }
   }
 }
 
 
 void FlowGraphAllocator::AllocateUnallocatedRanges() {
 #if defined(DEBUG)
   ASSERT(UnallocatedIsSorted());
 #endif
 
@@ skipping 284 matching lines @@
     OS::Print("-- [after ssa allocator] ir [%s] -------------\n",
               function.ToFullyQualifiedCString());
     FlowGraphPrinter printer(flow_graph_, true);
     printer.PrintBlocks();
     OS::Print("----------------------------------------------\n");
   }
 }
 
 
 }  // namespace dart