[turbofan] Splinter when range ends at hot block start

src/compiler/register-allocator.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/base/adapters.h"
 #include "src/compiler/linkage.h"
 #include "src/compiler/register-allocator.h"
 #include "src/string-stream.h"
 
 namespace v8 {
@@ skipping 1408 matching lines @@
 bool RegisterAllocationData::RangesDefinedInDeferredStayInDeferred() {
   for (const TopLevelLiveRange* range : live_ranges()) {
     if (range == nullptr || range->IsEmpty() ||
         !code()
              ->GetInstructionBlock(range->Start().ToInstructionIndex())
              ->IsDeferred()) {
       continue;
     }
     for (const UseInterval* i = range->first_interval(); i != nullptr;
          i = i->next()) {
-      int first = i->FirstInstructionIndex();
-      int last = i->LastInstructionIndex();
+      int first = i->FirstGapIndex();
+      int last = i->LastGapIndex();
       for (int instr = first; instr <= last;) {
         const InstructionBlock* block = code()->GetInstructionBlock(instr);
         if (!block->IsDeferred()) return false;
         instr = block->last_instruction_index() + 1;
       }
     }
   }
   return true;
 }
 
@@ skipping 1935 matching lines @@
       LiveRangeBoundArray* array = finder.ArrayFor(iterator.Current());
       for (const RpoNumber& pred : block->predecessors()) {
         FindResult result;
         const InstructionBlock* pred_block = code()->InstructionBlockAt(pred);
         if (!array->FindConnectableSubranges(block, pred_block, &result)) {
           continue;
         }
         InstructionOperand pred_op = result.pred_cover_->GetAssignedOperand();
         InstructionOperand cur_op = result.cur_cover_->GetAssignedOperand();
         if (pred_op.Equals(cur_op)) continue;
-        ResolveControlFlow(block, cur_op, pred_block, pred_op);
+        int move_loc = ResolveControlFlow(block, cur_op, pred_block, pred_op);
+        USE(move_loc);
+        DCHECK_IMPLIES(
+            result.cur_cover_->TopLevel()->IsSpilledOnlyInDeferredBlocks() &&
+                !(pred_op.IsAnyRegister() && cur_op.IsAnyRegister()),
+            code()->GetInstructionBlock(move_loc)->IsDeferred());
       }
       iterator.Advance();
     }
   }
 }
 
 
-void LiveRangeConnector::ResolveControlFlow(const InstructionBlock* block,
-                                            const InstructionOperand& cur_op,
-                                            const InstructionBlock* pred,
-                                            const InstructionOperand& pred_op) {
+int LiveRangeConnector::ResolveControlFlow(const InstructionBlock* block,
+                                           const InstructionOperand& cur_op,
+                                           const InstructionBlock* pred,
+                                           const InstructionOperand& pred_op) {
   DCHECK(!pred_op.Equals(cur_op));
   int gap_index;
   Instruction::GapPosition position;
   if (block->PredecessorCount() == 1) {
     gap_index = block->first_instruction_index();
     position = Instruction::START;
   } else {
     DCHECK(pred->SuccessorCount() == 1);
     DCHECK(!code()
                 ->InstructionAt(pred->last_instruction_index())
                 ->HasReferenceMap());
     gap_index = pred->last_instruction_index();
     position = Instruction::END;
   }
   data()->AddGapMove(gap_index, position, pred_op, cur_op);
+  return gap_index;
 }
 
 
 void LiveRangeConnector::ConnectRanges(Zone* local_zone) {
   DelayedInsertionMap delayed_insertion_map(local_zone);
   for (TopLevelLiveRange* top_range : data()->live_ranges()) {
     if (top_range == nullptr) continue;
     bool connect_spilled = top_range->IsSpilledOnlyInDeferredBlocks();
     LiveRange* first_range = top_range;
     for (LiveRange *second_range = first_range->next(); second_range != nullptr;
@@ skipping 16 matching lines @@
       if (pos.IsGapPosition()) {
         gap_pos = pos.IsStart() ? Instruction::START : Instruction::END;
       } else {
         if (pos.IsStart()) {
           delay_insertion = true;
         } else {
           gap_index++;
         }
         gap_pos = delay_insertion ? Instruction::END : Instruction::START;
       }
+      // Fills or spills for spilled in deferred blocks ranges must happen
+      // only in deferred blocks.
+      DCHECK_IMPLIES(
+          connect_spilled &&
+              !(prev_operand.IsAnyRegister() && cur_operand.IsAnyRegister()),
+          code()->GetInstructionBlock(gap_index)->IsDeferred());
+
       ParallelMove* move =
           code()->InstructionAt(gap_index)->GetOrCreateParallelMove(
               gap_pos, code_zone());
       if (!delay_insertion) {
         move->AddMove(prev_operand, cur_operand);
       } else {
         delayed_insertion_map.insert(
             std::make_pair(std::make_pair(move, prev_operand), cur_operand));
       }
     }
@@ skipping 27 matching lines @@
     MoveOperands* eliminate = moves->PrepareInsertAfter(move);
     to_insert.push_back(move);
     if (eliminate != nullptr) to_eliminate.push_back(eliminate);
   }
 }
 
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8