[turbofan] Splinter when range ends at hot block start

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 51 matching lines @@
 void SplinterLiveRange(TopLevelLiveRange *range, RegisterAllocationData *data) {
   const InstructionSequence *code = data->code();
   UseInterval *interval = range->first_interval();
 
   LifetimePosition first_cut = LifetimePosition::Invalid();
   LifetimePosition last_cut = LifetimePosition::Invalid();
 
   while (interval != nullptr) {
     UseInterval *next_interval = interval->next();
     const InstructionBlock *first_block =
-        code->GetInstructionBlock(interval->FirstInstructionIndex());
+        code->GetInstructionBlock(interval->FirstGapIndex());
     const InstructionBlock *last_block =
-        code->GetInstructionBlock(interval->LastInstructionIndex());
+        code->GetInstructionBlock(interval->LastGapIndex());
     int first_block_nr = first_block->rpo_number().ToInt();
     int last_block_nr = last_block->rpo_number().ToInt();
     for (int block_id = first_block_nr; block_id <= last_block_nr; ++block_id) {
       const InstructionBlock *current_block =
           code->InstructionBlockAt(RpoNumber::FromInt(block_id));
       if (current_block->IsDeferred()) {
         if (!first_cut.IsValid()) {
           first_cut = LifetimePosition::GapFromInstructionIndex(
               current_block->first_instruction_index());
         }
@@ skipping 18 matching lines @@
 }  // namespace
 
 
 void LiveRangeSeparator::Splinter() {
   size_t virt_reg_count = data()->live_ranges().size();
   for (size_t vreg = 0; vreg < virt_reg_count; ++vreg) {
     TopLevelLiveRange *range = data()->live_ranges()[vreg];
     if (range == nullptr || range->IsEmpty() || range->IsSplinter()) {
       continue;
     }
-    int first_instr = range->first_interval()->FirstInstructionIndex();
+    int first_instr = range->first_interval()->FirstGapIndex();
     if (!data()->code()->GetInstructionBlock(first_instr)->IsDeferred()) {
       SplinterLiveRange(range, data());
     }
   }
 }
 
 
 void LiveRangeMerger::MarkRangesSpilledInDeferredBlocks() {
   for (TopLevelLiveRange *top : data()->live_ranges()) {
     if (top == nullptr || top->IsEmpty() || top->splinter() == nullptr) {
@@ skipping 26 matching lines @@
     int to_remove = range->vreg();
     splinter_parent->Merge(range, data()->allocation_zone());
     data()->live_ranges()[to_remove] = nullptr;
   }
 }
 
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8