[turbofan] Splinter into one range.

test/unittests/compiler/live-range-unittest.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 "test/unittests/compiler/live-range-builder.h"
 #include "test/unittests/test-utils.h"
 
 
 // TODO(mtrofin): would we want to centralize this definition?
@@ skipping 14 matching lines @@
 class LiveRangeUnitTest : public TestWithZone {
  public:
   // Split helper, to avoid int->LifetimePosition conversion nuisance.
   LiveRange* Split(LiveRange* range, int pos) {
     return range->SplitAt(LifetimePosition::FromInt(pos), zone());
   }
 
 
   TopLevelLiveRange* Splinter(TopLevelLiveRange* top, int start, int end,
                               int new_id = 0) {
-    TopLevelLiveRange* ret =
-        new (zone()) TopLevelLiveRange(new_id, MachineType::kRepTagged);
+    if (top->splinter() == nullptr) {
+      TopLevelLiveRange* ret =
+          new (zone()) TopLevelLiveRange(new_id, MachineType::kRepTagged);
+      top->SetSplinter(ret);
+    }
     top->Splinter(LifetimePosition::FromInt(start),
-                  LifetimePosition::FromInt(end), ret, zone());
-    return ret;
+                  LifetimePosition::FromInt(end), zone());
+    return top->splinter();
   }
 
   // Ranges first and second match structurally.
   bool RangesMatch(LiveRange* first, LiveRange* second) {
     if (first->Start() != second->Start() || first->End() != second->End()) {
       return false;
     }
     UseInterval* i1 = first->first_interval();
     UseInterval* i2 = second->first_interval();
 
@@ skipping 320 matching lines @@
   EXPECT_EQ(range, splinter->splintered_from());
 
   TopLevelLiveRange* expected_source =
       TestRangeBuilder(zone()).Add(0, 3).Add(6, 8).Build();
   TopLevelLiveRange* expected_splinter = TestRangeBuilder(zone()).Build(5, 6);
   EXPECT_TRUE(RangesMatch(expected_source, range));
   EXPECT_TRUE(RangesMatch(expected_splinter, splinter));
 }
 
 
+TEST_F(LiveRangeUnitTest, SplinterMergeMultipleTimes) {
+  TopLevelLiveRange* range =
+      TestRangeBuilder(zone()).Add(0, 3).Add(5, 10).Add(12, 16).Build();
+  Splinter(range, 4, 6);
+  Splinter(range, 8, 14);
+  TopLevelLiveRange* splinter = range->splinter();
+  EXPECT_EQ(nullptr, range->next());
+  EXPECT_EQ(nullptr, splinter->next());
+  EXPECT_EQ(range, splinter->splintered_from());
+
+  TopLevelLiveRange* expected_source =
+      TestRangeBuilder(zone()).Add(0, 3).Add(6, 8).Add(14, 16).Build();
+  TopLevelLiveRange* expected_splinter =
+      TestRangeBuilder(zone()).Add(5, 6).Add(8, 10).Add(12, 14).Build();
+  EXPECT_TRUE(RangesMatch(expected_source, range));
+  EXPECT_TRUE(RangesMatch(expected_splinter, splinter));
+}
+
+
 TEST_F(LiveRangeUnitTest, MergeMultipleIntervalsRight) {
   TopLevelLiveRange* original =
       TestRangeBuilder(zone()).Add(0, 3).Add(5, 8).Build();
   TopLevelLiveRange* splinter = Splinter(original, 4, 6);
   original->Merge(splinter, zone());
 
   TopLevelLiveRange* result =
       TestRangeBuilder(zone()).Add(0, 3).Add(5, 8).Build();
   LiveRange* child_1 = Split(result, 5);
   Split(child_1, 6);
@@ skipping 19 matching lines @@
 }
 
 
 TEST_F(LiveRangeUnitTest, IDGeneration) {
   TopLevelLiveRange* vreg = TestRangeBuilder(zone()).Id(2).Build(0, 100);
   EXPECT_EQ(2, vreg->vreg());
   EXPECT_EQ(0, vreg->relative_id());
 
   TopLevelLiveRange* splinter =
       new (zone()) TopLevelLiveRange(101, MachineType::kRepTagged);
+  vreg->SetSplinter(splinter);
   vreg->Splinter(LifetimePosition::FromInt(4), LifetimePosition::FromInt(12),
-                 splinter, zone());
+                 zone());
 
   EXPECT_EQ(101, splinter->vreg());
   EXPECT_EQ(1, splinter->relative_id());
 
   LiveRange* child = vreg->SplitAt(LifetimePosition::FromInt(50), zone());
 
   EXPECT_EQ(2, child->relative_id());
 
   LiveRange* splinter_child =
       splinter->SplitAt(LifetimePosition::FromInt(8), zone());
 
   EXPECT_EQ(1, splinter->relative_id());
   EXPECT_EQ(3, splinter_child->relative_id());
 
   vreg->Merge(splinter, zone());
   EXPECT_EQ(1, splinter->relative_id());
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8