[turbofan] Splintering: special case deoptimizing blocks

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 35 matching lines @@
     block->set_last_deferred(last);
     // We know last is still deferred, and that last + 1, is not (or is an
     // invalid index). So skip over last + 1 and continue from last + 2. This
     // way, we visit each block exactly once, and the total complexity of this
     // function is O(n), n being jthe number of blocks.
     blk_id = last.ToInt() + 1;
   }
 }
 
 
-// If the live range has a liveness hole right between start and end,
-// we don't need to splinter it.
-bool IsIntervalAlreadyExcluded(const LiveRange *range, LifetimePosition start,
-                               LifetimePosition end) {
-  for (UseInterval *interval = range->first_interval(); interval != nullptr;
-       interval = interval->next()) {
-    if (interval->start() <= start && start < interval->end()) return false;
-    if (interval->start() < end && end <= interval->end()) return false;
-  }
-  return true;
-}
-
-
 void CreateSplinter(TopLevelLiveRange *range, RegisterAllocationData *data,
                     LifetimePosition first_cut, LifetimePosition last_cut) {
   DCHECK(!range->IsSplinter());
   // We can ignore ranges that live solely in deferred blocks.
   // If a range ends right at the end of a deferred block, it is marked by
   // the range builder as ending at gap start of the next block - since the
   // end is a position where the variable isn't live. We need to take that
   // into consideration.
   LifetimePosition max_allowed_end = last_cut.NextFullStart();
 
   if (first_cut <= range->Start() && max_allowed_end >= range->End()) {
     return;
   }
 
   LifetimePosition start = Max(first_cut, range->Start());
   LifetimePosition end = Min(last_cut, range->End());
-  // Skip ranges that have a hole where the deferred block(s) are.
-  if (IsIntervalAlreadyExcluded(range, start, end)) return;
 
   if (start < end) {
     // Ensure the original range has a spill range associated, before it gets
     // splintered. Splinters will point to it. This way, when attempting to
     // reuse spill slots of splinters, during allocation, we avoid clobbering
     // such slots.
     if (range->MayRequireSpillRange()) {
       data->CreateSpillRangeForLiveRange(range);
     }
     TopLevelLiveRange *result = data->NextLiveRange(range->machine_type());
@@ skipping 26 matching lines @@
 
     LifetimePosition first_cut = LifetimePosition::GapFromInstructionIndex(
         block->first_instruction_index());
 
     LifetimePosition last_cut = LifetimePosition::GapFromInstructionIndex(
         static_cast<int>(code->instructions().size()));
 
     const BitVector *in_set = in_sets[block->rpo_number().ToInt()];
     InstructionBlock *last = code->InstructionBlockAt(last_deferred);
     const BitVector *out_set = LiveRangeBuilder::ComputeLiveOut(last, data);
-    last_cut = LifetimePosition::GapFromInstructionIndex(
-        last->last_instruction_index());
+    int last_index = last->last_instruction_index();
+    if (code->InstructionAt(last_index)->opcode() ==
+        ArchOpcode::kArchDeoptimize) {
+      ++last_index;
+    }
+    last_cut = LifetimePosition::GapFromInstructionIndex(last_index);
 
     BitVector ranges_to_splinter(*in_set, zone);
     ranges_to_splinter.Union(*out_set);
     BitVector::Iterator iterator(&ranges_to_splinter);
 
     while (!iterator.Done()) {
       int range_id = iterator.Current();
       iterator.Advance();
 
       TopLevelLiveRange *range = data->live_ranges()[range_id];
@@ skipping 20 matching lines @@
     TopLevelLiveRange *splinter_parent = range->splintered_from();
 
     splinter_parent->Merge(range, data());
   }
 }
 
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8