[turbofan] Simplified splintering code.

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 176 matching lines @@
   LifetimePosition Intersect(const UseInterval* other) const {
     if (other->start() < start_) return other->Intersect(this);
     if (other->start() < end_) return other->start();
     return LifetimePosition::Invalid();
   }
 
   bool Contains(LifetimePosition point) const {
     return start_ <= point && point < end_;
   }
 
+  int FirstInstructionIndex() const {
+    int ret = start_.ToInstructionIndex();
+    if (start_.IsInstructionPosition() && start_.IsEnd()) {
+      ++ret;
+    }
+    return ret;
+  }
+
+  int LastInstructionIndex() const {
+    int ret = end_.ToInstructionIndex();
+    if (end_.IsGapPosition() || end_.IsStart()) {
+      --ret;
+    }
+    return ret;
+  }
+
  private:
   LifetimePosition start_;
   LifetimePosition end_;
   UseInterval* next_;
 
   DISALLOW_COPY_AND_ASSIGN(UseInterval);
 };
 
 
 enum class UsePositionType : uint8_t { kAny, kRequiresRegister, kRequiresSlot };
@@ skipping 336 matching lines @@
                         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
   // with slot use positions.
-  void MarkSpilledInDeferredBlock(const InstructionSequence* code);
+  void MarkSpilledInDeferredBlock() {
+    spill_start_index_ = -1;
+    spilled_in_deferred_blocks_ = true;
+    spill_move_insertion_locations_ = nullptr;
+  }
+
   bool TryCommitSpillInDeferredBlock(InstructionSequence* code,
                                      const InstructionOperand& spill_operand);
 
   TopLevelLiveRange* splintered_from() const { return splintered_from_; }
   bool IsSplinter() const { return splintered_from_ != nullptr; }
   bool MayRequireSpillRange() const {
     DCHECK(!IsSplinter());
     return !HasSpillOperand() && spill_range_ == nullptr;
   }
   void UpdateSpillRangePostMerge(TopLevelLiveRange* merged);
@@ skipping 200 matching lines @@
 
   MoveOperands* AddGapMove(int index, Instruction::GapPosition position,
                            const InstructionOperand& from,
                            const InstructionOperand& to);
 
   bool IsReference(TopLevelLiveRange* top_range) const {
     return code()->IsReference(top_range->vreg());
   }
 
   bool ExistsUseWithoutDefinition();
+  bool RangesDefinedInDeferredStayInDeferred();
 
   void MarkAllocated(RegisterKind kind, int index);
 
   PhiMapValue* InitializePhiMap(const InstructionBlock* block,
                                 PhiInstruction* phi);
   PhiMapValue* GetPhiMapValueFor(TopLevelLiveRange* top_range);
   PhiMapValue* GetPhiMapValueFor(int virtual_register);
   bool IsBlockBoundary(LifetimePosition pos) const;
 
   void Print(const InstructionSequence* instructionSequence);
@@ skipping 339 matching lines @@
   RegisterAllocationData* const data_;
 
   DISALLOW_COPY_AND_ASSIGN(LiveRangeConnector);
 };
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_REGISTER_ALLOCATOR_H_