[turbofan] Separate LiveRange and TopLevelLiveRange concepts

test/unittests/compiler/coalesced-live-ranges-unittest.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/coalesced-live-ranges.h"
 #include "test/unittests/test-utils.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
@@ skipping 11 matching lines @@
     return *this;
   }
   TestRangeBuilder& Add(int start, int end) {
     pairs_.push_back({start, end});
     return *this;
   }
 
   LiveRange* Build(int start, int end) { return Add(start, end).Build(); }
 
   LiveRange* Build() {
-    LiveRange* range = new (zone_) LiveRange(id_, MachineType::kRepTagged);
+    TopLevelLiveRange* range =
+        new (zone_) TopLevelLiveRange(id_, MachineType::kRepTagged);
     // Traverse the provided interval specifications backwards, because that is
     // what LiveRange expects.
     for (int i = static_cast<int>(pairs_.size()) - 1; i >= 0; --i) {
       Interval pair = pairs_[i];
       LifetimePosition start = LifetimePosition::FromInt(pair.first);
       LifetimePosition end = LifetimePosition::FromInt(pair.second);
       CHECK(start < end);
       range->AddUseInterval(start, end, zone_);
     }
 
@@ skipping 50 matching lines @@
   LiveRangeIDs set(zone());
   return IsRangeConflictingWith(range, set);
 }
 
 
 void CoalescedLiveRangesTest::RemoveConflicts(LiveRange* range) {
   auto conflicts = ranges().GetConflicts(range);
   LiveRangeIDs seen(zone());
   for (auto c = conflicts.Current(); c != nullptr;
        c = conflicts.RemoveCurrentAndGetNext()) {
-    EXPECT_FALSE(seen.count(c->id()) > 0);
-    seen.insert(c->id());
+    int id = c->TopLevel()->vreg();
+    EXPECT_FALSE(seen.count(id) > 0);
+    seen.insert(c->TopLevel()->vreg());
   }
 }
 
 
 bool CoalescedLiveRangesTest::AllocationsAreValid() const {
   return ranges().VerifyAllocationsAreValidForTesting();
 }
 
 
 bool CoalescedLiveRangesTest::IsRangeConflictingWith(const LiveRange* range,
                                                      const LiveRangeIDs& ids) {
   LiveRangeIDs found_ids(zone());
 
   auto conflicts = ranges().GetConflicts(range);
   for (auto conflict = conflicts.Current(); conflict != nullptr;
        conflict = conflicts.GetNext()) {
-    found_ids.insert(conflict->id());
+    found_ids.insert(conflict->TopLevel()->vreg());
   }
   return found_ids == ids;
 }
 
 
 TEST_F(CoalescedLiveRangesTest, VisitEmptyAllocations) {
   LiveRange* range = TestRangeBuilder(zone()).Id(1).Build(1, 5);
   ASSERT_TRUE(ranges().empty());
   ASSERT_TRUE(AllocationsAreValid());
   ASSERT_TRUE(HasNoConflicts(range));
@@ skipping 168 matching lines @@
       TestRangeBuilder(zone()).Id(3).Add(1, 8).Add(22, 25).Build();
   RemoveConflicts(query);
   query = TestRangeBuilder(zone()).Id(4).Build(0, 60);
   ASSERT_TRUE(ConflictsPreciselyWith(query, 2));
 }
 
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8