[turbofan] update SpillRange to use ZoneVector

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 690 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 >= static_cast<int>(live_ranges_.size())) {
-    live_ranges_.resize(index + 1, nullptr);
+  if (index >= static_cast<int>(live_ranges().size())) {
+    live_ranges().resize(index + 1, nullptr);
   }
   auto result = live_ranges()[index];
   if (result == nullptr) {
     result = new (local_zone()) LiveRange(index, code_zone());
     live_ranges()[index] = result;
   }
   return result;
 }
 
 
@@ skipping 87 matching lines @@
       if (interval2->end().Value() > interval1->start().Value()) {
         return true;
       }
       interval2 = interval2->next();
     }
   }
   return false;
 }
 
 
-SpillRange::SpillRange(LiveRange* range, int id, Zone* zone)
-    : id_(id), live_ranges_(1, zone), end_position_(range->End()) {
+SpillRange::SpillRange(LiveRange* range, Zone* zone) : live_ranges_(zone) {
   auto src = range->first_interval();
   UseInterval* result = nullptr;
   UseInterval* node = nullptr;
   // Copy the nodes
   while (src != nullptr) {
-    UseInterval* new_node = new (zone) UseInterval(src->start(), src->end());
+    auto new_node = new (zone) UseInterval(src->start(), src->end());
     if (result == nullptr) {
       result = new_node;
     } else {
       node->set_next(new_node);
     }
     node = new_node;
     src = src->next();
   }
   use_interval_ = result;
-  live_ranges_.Add(range, zone);
+  live_ranges().push_back(range);
+  end_position_ = node->end();
   DCHECK(!range->HasSpillRange());
   range->SetSpillRange(this);
 }
 
 
-bool SpillRange::IsIntersectingWith(SpillRange* other) {
-  if (End().Value() <= other->use_interval_->start().Value() ||
-      other->End().Value() <= use_interval_->start().Value()) {
+bool SpillRange::IsIntersectingWith(SpillRange* other) const {
+  if (this->use_interval_ == nullptr || other->use_interval_ == nullptr ||
+      this->End().Value() <= other->use_interval_->start().Value() ||
+      other->End().Value() <= this->use_interval_->start().Value()) {
     return false;
   }
   return AreUseIntervalsIntersecting(use_interval_, other->use_interval_);
 }
 
 
-bool SpillRange::TryMerge(SpillRange* other, Zone* zone) {
-  if (Kind() == other->Kind() &&
-      !AreUseIntervalsIntersecting(use_interval_, other->use_interval_)) {
-    if (End().Value() < other->End().Value()) {
-      end_position_ = other->End();
-    }
+bool SpillRange::TryMerge(SpillRange* other) {
+  if (Kind() != other->Kind() || IsIntersectingWith(other)) return false;
 
-    MergeDisjointIntervals(other->use_interval_, zone);
-    other->use_interval_ = nullptr;
+  auto max = LifetimePosition::MaxPosition();
+  if (End().Value() < other->End().Value() &&
+      other->End().Value() != max.Value()) {
+    end_position_ = other->End();
+  }
+  other->end_position_ = max;
 
-    for (int i = 0; i < other->live_ranges_.length(); i++) {
-      DCHECK(other->live_ranges_.at(i)->GetSpillRange() == other);
-      other->live_ranges_.at(i)->SetSpillRange(this);
-    }
+  MergeDisjointIntervals(other->use_interval_);
+  other->use_interval_ = nullptr;
 
-    live_ranges_.AddAll(other->live_ranges_, zone);
-    other->live_ranges_.Clear();
+  for (auto range : other->live_ranges()) {
+    DCHECK(range->GetSpillRange() == other);
+    range->SetSpillRange(this);
+  }
 
-    return true;
-  }
-  return false;
+  live_ranges().insert(live_ranges().end(), other->live_ranges().begin(),
+                       other->live_ranges().end());
+  other->live_ranges().clear();
+
+  return true;
 }
 
 
 void SpillRange::SetOperand(InstructionOperand* op) {
-  for (int i = 0; i < live_ranges_.length(); i++) {
-    DCHECK(live_ranges_.at(i)->GetSpillRange() == this);
-    live_ranges_.at(i)->CommitSpillOperand(op);
+  for (auto range : live_ranges()) {
+    DCHECK(range->GetSpillRange() == this);
+    range->CommitSpillOperand(op);
   }
 }
 
 
-void SpillRange::MergeDisjointIntervals(UseInterval* other, Zone* zone) {
+void SpillRange::MergeDisjointIntervals(UseInterval* other) {
   UseInterval* tail = nullptr;
   auto current = use_interval_;
   while (other != nullptr) {
     // Make sure the 'current' list starts first
     if (current == nullptr ||
         current->start().Value() > other->start().Value()) {
       std::swap(current, other);
     }
-
     // Check disjointness
     DCHECK(other == nullptr ||
            current->end().Value() <= other->start().Value());
-
     // Append the 'current' node to the result accumulator and move forward
     if (tail == nullptr) {
       use_interval_ = current;
     } else {
       tail->set_next(current);
     }
     tail = current;
     current = current->next();
   }
   // Other list is empty => we are done
 }
 
 
 void RegisterAllocator::ReuseSpillSlots() {
   DCHECK(FLAG_turbo_reuse_spill_slots);
 
   // Merge disjoint spill ranges
   for (size_t i = 0; i < spill_ranges().size(); i++) {
     auto range = spill_ranges()[i];
     if (range->IsEmpty()) continue;
     for (size_t j = i + 1; j < spill_ranges().size(); j++) {
       auto other = spill_ranges()[j];
       if (!other->IsEmpty()) {
-        range->TryMerge(other, local_zone());
+        range->TryMerge(other);
       }
     }
   }
 
   // Allocate slots for the merged spill ranges.
   for (auto range : spill_ranges()) {
     if (range->IsEmpty()) continue;
     // Allocate a new operand referring to the spill slot.
     auto kind = range->Kind();
     int index = frame()->AllocateSpillSlot(kind == DOUBLE_REGISTERS);
@@ skipping 13 matching lines @@
     range->ConvertUsesToOperand(assigned);
     if (range->IsSpilled()) {
       range->CommitSpillsAtDefinition(code(), assigned);
     }
   }
 }
 
 
 SpillRange* RegisterAllocator::AssignSpillRangeToLiveRange(LiveRange* range) {
   DCHECK(FLAG_turbo_reuse_spill_slots);
-  int spill_id = static_cast<int>(spill_ranges().size());
-  auto spill_range =
-      new (local_zone()) SpillRange(range, spill_id, local_zone());
+  auto spill_range = new (local_zone()) SpillRange(range, local_zone());
   spill_ranges().push_back(spill_range);
   return spill_range;
 }
 
 
 bool RegisterAllocator::TryReuseSpillForPhi(LiveRange* range) {
   DCHECK(FLAG_turbo_reuse_spill_slots);
   DCHECK(range->HasNoSpillType());
   if (range->IsChild() || !range->is_phi()) return false;
 
@@ skipping 29 matching lines @@
 
   // Try to merge the spilled operands and count the number of merged spilled
   // operands.
   DCHECK(first_op != nullptr);
   auto first_op_spill = first_op->GetSpillRange();
   size_t num_merged = 1;
   for (size_t i = 1; i < phi->operands().size(); i++) {
     int op = phi->operands()[i];
     auto op_range = LiveRangeFor(op);
     auto op_spill = op_range->GetSpillRange();
-    if (op_spill != nullptr) {
-      if (op_spill->id() == first_op_spill->id() ||
-          first_op_spill->TryMerge(op_spill, local_zone())) {
-        num_merged++;
-      }
+    if (op_spill != nullptr &&
+        (op_spill == first_op_spill || first_op_spill->TryMerge(op_spill))) {
+      num_merged++;
     }
   }
 
   // Only continue if enough operands could be merged to the
   // same spill slot.
   if (num_merged * 2 <= phi->operands().size() ||
       AreUseIntervalsIntersecting(first_op_spill->interval(),
                                   range->first_interval())) {
     return false;
   }
 
   // If the range does not need register soon, spill it to the merged
   // spill range.
   auto next_pos = range->Start();
   if (code()->IsGapAt(next_pos.InstructionIndex())) {
     next_pos = next_pos.NextInstruction();
   }
   auto pos = range->NextUsePositionRegisterIsBeneficial(next_pos);
   if (pos == nullptr) {
     auto spill_range = AssignSpillRangeToLiveRange(range->TopLevel());
-    CHECK(first_op_spill->TryMerge(spill_range, local_zone()));
+    CHECK(first_op_spill->TryMerge(spill_range));
     Spill(range);
     return true;
   } else if (pos->pos().Value() > range->Start().NextInstruction().Value()) {
     auto spill_range = AssignSpillRangeToLiveRange(range->TopLevel());
-    CHECK(first_op_spill->TryMerge(spill_range, local_zone()));
+    CHECK(first_op_spill->TryMerge(spill_range));
     SpillBetween(range, range->Start(), pos->pos());
     if (!AllocationOk()) return false;
     DCHECK(UnhandledIsSorted());
     return true;
   }
   return false;
 }
 
 
 void RegisterAllocator::MeetRegisterConstraints(const InstructionBlock* block) {
@@ skipping 1498 matching lines @@
   } else {
     DCHECK(range->Kind() == GENERAL_REGISTERS);
     assigned_registers_->Add(reg);
   }
   range->set_assigned_register(reg);
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8