[turbofan] Splinter into one range.

src/compiler/register-allocator.h

 // 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.
 
 #ifndef V8_REGISTER_ALLOCATOR_H_
 #define V8_REGISTER_ALLOCATOR_H_
 
 #include "src/compiler/instruction.h"
 #include "src/ostreams.h"
 #include "src/register-configuration.h"
@@ skipping 475 matching lines @@
   void AddUseInterval(LifetimePosition start, LifetimePosition end, Zone* zone);
   void AddUsePosition(UsePosition* pos);
 
   // Shorten the most recently added interval by setting a new start.
   void ShortenTo(LifetimePosition start);
 
   // Detaches between start and end, and attributes the resulting range to
   // result.
   // The current range is pointed to as "splintered_from". No parent/child
   // relationship is established between this and result.
-  void Splinter(LifetimePosition start, LifetimePosition end,
-                TopLevelLiveRange* result, Zone* zone);
+  void Splinter(LifetimePosition start, LifetimePosition end, Zone* zone);
 
   // Assuming other was splintered from this range, embeds other and its
   // children as part of the children sequence of this range.
   void Merge(TopLevelLiveRange* other, Zone* zone);
 
   // Spill range management.
   void SetSpillRange(SpillRange* spill_range);
   enum class SpillType { kNoSpillType, kSpillOperand, kSpillRange };
   void set_spill_type(SpillType value) {
     bits_ = SpillTypeField::update(bits_, value);
@@ skipping 23 matching lines @@
 
   AllocatedOperand GetSpillRangeOperand() const;
 
   void SpillAtDefinition(Zone* zone, int gap_index,
                          InstructionOperand* operand);
   void SetSpillOperand(InstructionOperand* operand);
   void SetSpillStartIndex(int start) {
     spill_start_index_ = Min(start, spill_start_index_);
   }
 
-  void SetSplinteredFrom(TopLevelLiveRange* splinter_parent);
   void CommitSpillsAtDefinition(InstructionSequence* sequence,
                                 const InstructionOperand& operand,
                                 bool might_be_duplicated);
 
   // If all the children of this range are spilled in deferred blocks, and if
   // for any non-spilled child with a use position requiring a slot, that range
   // is contained in a deferred block, mark the range as
   // IsSpilledOnlyInDeferredBlocks, so that we avoid spilling at definition,
   // and instead let the LiveRangeConnector perform the spills within the
   // deferred blocks. If so, we insert here spills for non-spilled ranges
@@ skipping 19 matching lines @@
     return spilled_in_deferred_blocks_;
   }
 
   struct SpillAtDefinitionList;
 
   SpillAtDefinitionList* spills_at_definition() const {
     return spills_at_definition_;
   }
   void set_last_child(LiveRange* range) { last_child_ = range; }
   LiveRange* last_child() const { return last_child_; }
+  TopLevelLiveRange* splinter() const { return splinter_; }
+  void SetSplinter(TopLevelLiveRange* splinter) {
+    DCHECK_NULL(splinter_);
+    DCHECK_NOT_NULL(splinter);
+
+    splinter_ = splinter;
+    splinter->relative_id_ = GetNextChildId();
+    splinter->set_spill_type(spill_type());
+    splinter->SetSplinteredFrom(this);
+  }
 
  private:
+  void SetSplinteredFrom(TopLevelLiveRange* splinter_parent);
+
   typedef BitField<bool, 1, 1> HasSlotUseField;
   typedef BitField<bool, 2, 1> IsPhiField;
   typedef BitField<bool, 3, 1> IsNonLoopPhiField;
   typedef BitField<SpillType, 4, 2> SpillTypeField;
 
   int vreg_;
   int last_child_id_;
   TopLevelLiveRange* splintered_from_;
   union {
     // Correct value determined by spill_type()
     InstructionOperand* spill_operand_;
     SpillRange* spill_range_;
   };
   SpillAtDefinitionList* spills_at_definition_;
   // TODO(mtrofin): generalize spilling after definition, currently specialized
   // just for spill in a single deferred block.
   bool spilled_in_deferred_blocks_;
   int spill_start_index_;
   LiveRange* last_child_;
-  LiveRange* last_insertion_point_;
+  UsePosition* last_pos_;
+  TopLevelLiveRange* splinter_;
 
   DISALLOW_COPY_AND_ASSIGN(TopLevelLiveRange);
 };
 
 
 struct PrintableLiveRange {
   const RegisterConfiguration* register_configuration_;
   const LiveRange* range_;
 };
 
@@ skipping 473 matching lines @@
   RegisterAllocationData* const data_;
 
   DISALLOW_COPY_AND_ASSIGN(LiveRangeConnector);
 };
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_REGISTER_ALLOCATOR_H_