[turbofan] Separate LiveRange and TopLevelLiveRange concepts

src/compiler/live-range-separator.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/live-range-separator.h"
 #include "src/compiler/register-allocator.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
@@ skipping 48 matching lines @@
                                LifetimePosition end) {
   for (UseInterval *interval = range->first_interval(); interval != nullptr;
        interval = interval->next()) {
     if (interval->start() <= start && start < interval->end()) return false;
     if (interval->start() < end && end <= interval->end()) return false;
   }
   return true;
 }
 
 
-void CreateSplinter(LiveRange *range, RegisterAllocationData *data,
+void CreateSplinter(TopLevelLiveRange *range, RegisterAllocationData *data,
                     LifetimePosition first_cut, LifetimePosition last_cut) {
-  DCHECK(!range->IsChild());
   DCHECK(!range->IsSplinter());
   // We can ignore ranges that live solely in deferred blocks.
   // If a range ends right at the end of a deferred block, it is marked by
   // the range builder as ending at gap start of the next block - since the
   // end is a position where the variable isn't live. We need to take that
   // into consideration.
   LifetimePosition max_allowed_end = last_cut.NextFullStart();
 
   if (first_cut <= range->Start() && max_allowed_end >= range->End()) {
     return;
   }
 
   LifetimePosition start = Max(first_cut, range->Start());
   LifetimePosition end = Min(last_cut, range->End());
   // Skip ranges that have a hole where the deferred block(s) are.
   if (IsIntervalAlreadyExcluded(range, start, end)) return;
 
   if (start < end) {
     // Ensure the original range has a spill range associated, before it gets
     // splintered. Splinters will point to it. This way, when attempting to
     // reuse spill slots of splinters, during allocation, we avoid clobbering
     // such slots.
     if (range->MayRequireSpillRange()) {
       data->CreateSpillRangeForLiveRange(range);
     }
-    LiveRange *result = data->NewChildRangeFor(range);
+    TopLevelLiveRange *result = data->NextLiveRange(range->machine_type());
+    DCHECK_NULL(data->live_ranges()[result->vreg()]);
+    data->live_ranges()[result->vreg()] = result;
+
     Zone *zone = data->allocation_zone();
     range->Splinter(start, end, result, zone);
   }
 }
 
 
 // Splinter all ranges live inside successive deferred blocks.
 // No control flow analysis is performed. After the register allocation, we will
 // merge the splinters back into the original ranges, and then rely on the
 // range connector to properly connect them.
@@ skipping 23 matching lines @@
         last->last_instruction_index());
 
     BitVector ranges_to_splinter(*in_set, zone);
     ranges_to_splinter.Union(*out_set);
     BitVector::Iterator iterator(&ranges_to_splinter);
 
     while (!iterator.Done()) {
       int range_id = iterator.Current();
       iterator.Advance();
 
-      LiveRange *range = data->live_ranges()[range_id];
+      TopLevelLiveRange *range = data->live_ranges()[range_id];
       CreateSplinter(range, data, first_cut, last_cut);
     }
   }
 }
 }  // namespace
 
 
 void LiveRangeSeparator::Splinter() {
   AssociateDeferredBlockSequences(data()->code());
   SplinterRangesInDeferredBlocks(data());
 }
 
 
 void LiveRangeMerger::Merge() {
   int live_range_count = static_cast<int>(data()->live_ranges().size());
   for (int i = 0; i < live_range_count; ++i) {
-    LiveRange *range = data()->live_ranges()[i];
-    if (range == nullptr || range->IsEmpty() || range->IsChild() ||
-        !range->IsSplinter()) {
+    TopLevelLiveRange *range = data()->live_ranges()[i];
+    if (range == nullptr || range->IsEmpty() || !range->IsSplinter()) {
       continue;
     }
-    LiveRange *splinter_parent = range->splintered_from();
+    TopLevelLiveRange *splinter_parent = range->splintered_from();
 
     splinter_parent->Merge(range, data());
   }
 }
 
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8