[turbofan] Centralize splitting for memory operands.

src/compiler/greedy-allocator.cc

 // Copyright 2015 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/greedy-allocator.h"
 #include "src/compiler/register-allocator.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
@@ skipping 32 matching lines @@
   DCHECK(range->Start() < pos && pos < range->End());
   DCHECK(pos.IsStart() || pos.IsGapPosition() ||
          (data->code()
               ->GetInstructionBlock(pos.ToInstructionIndex())
               ->last_instruction_index() != pos.ToInstructionIndex()));
   LiveRange* result = range->SplitAt(pos, data->allocation_zone());
   return result;
 }
 
 
-// TODO(mtrofin): explain why splitting in gap START is always OK.
-LifetimePosition GetSplitPositionForInstruction(const LiveRange* range,
-                                                int instruction_index) {
-  LifetimePosition ret = LifetimePosition::Invalid();
-
-  ret = LifetimePosition::GapFromInstructionIndex(instruction_index);
-  if (range->Start() >= ret || ret >= range->End()) {
-    return LifetimePosition::Invalid();
-  }
-  return ret;
-}
-
-
 }  // namespace
 
 
 AllocationCandidate AllocationScheduler::GetNext() {
   DCHECK(!queue_.empty());
   AllocationCandidate ret = queue_.top();
   queue_.pop();
   return ret;
 }
 
@@ skipping 291 matching lines @@
     conflict->UnsetAssignedRegister();
     UnsetOperands(conflict, data());
     UpdateWeightAtEviction(conflict);
     scheduler().Schedule(conflict);
     TRACE("Evicted range %d%d.\n", conflict->TopLevel()->vreg(),
           conflict->relative_id());
   }
 }
 
 
-void GreedyAllocator::SplitAndSpillRangesDefinedByMemoryOperand() {
-  size_t initial_range_count = data()->live_ranges().size();
-  for (size_t i = 0; i < initial_range_count; ++i) {
-    TopLevelLiveRange* range = data()->live_ranges()[i];
-    if (!CanProcessRange(range)) continue;
-    if (!range->HasSpillOperand()) continue;
-
-    LifetimePosition start = range->Start();
-    TRACE("Live range %d:%d is defined by a spill operand.\n",
-          range->TopLevel()->vreg(), range->relative_id());
-    auto next_pos = start;
-    if (next_pos.IsGapPosition()) {
-      next_pos = next_pos.NextStart();
-    }
-    auto pos = range->NextUsePositionRegisterIsBeneficial(next_pos);
-    // If the range already has a spill operand and it doesn't need a
-    // register immediately, split it and spill the first part of the range.
-    if (pos == nullptr) {
-      Spill(range);
-    } else if (pos->pos() > range->Start().NextStart()) {
-      // Do not spill live range eagerly if use position that can benefit from
-      // the register is too close to the start of live range.
-      auto split_pos = GetSplitPositionForInstruction(
-          range, pos->pos().ToInstructionIndex());
-      // There is no place to split, so we can't split and spill.
-      if (!split_pos.IsValid()) continue;
-
-      split_pos =
-          FindOptimalSplitPos(range->Start().NextFullStart(), split_pos);
-
-      Split(range, data(), split_pos);
-      Spill(range);
-    }
-  }
-}
-
-
 void GreedyAllocator::AllocateRegisters() {
   CHECK(scheduler().empty());
   CHECK(allocations_.empty());
 
   TRACE("Begin allocating function %s with the Greedy Allocator\n",
         data()->debug_name());
 
   SplitAndSpillRangesDefinedByMemoryOperand();
   GroupLiveRanges();
   ScheduleAllocationCandidates();
@@ skipping 246 matching lines @@
 
 
 bool GreedyAllocator::IsProgressPossible(const LiveRange* range) {
   return range->CanBeSpilled(range->Start()) ||
          GetLastResortSplitPosition(range).IsValid();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8