[turbofan] Single entry into deferred regions

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 3393 matching lines @@
 
 void LiveRangeConnector::ResolveControlFlow(Zone* local_zone) {
   // Lazily linearize live ranges in memory for fast lookup.
   LiveRangeFinder finder(data(), local_zone);
   ZoneVector<BitVector*>& live_in_sets = data()->live_in_sets();
   for (const InstructionBlock* block : code()->instruction_blocks()) {
     if (CanEagerlyResolveControlFlow(block)) continue;
     BitVector* live = live_in_sets[block->rpo_number().ToInt()];
     BitVector::Iterator iterator(live);
     while (!iterator.Done()) {
+      int vreg = iterator.Current();

[Benedikt Meurer, 2016/04/23 12:04:49]

Stale change?

[Mircea Trofin, 2016/04/23 16:27:07]

Ya, I meant to use vreg in the finder.ArrayFor call below. For some reason, the
debugger (or at least lldb) 
won't show the value of iterator.Current() (or its underlying field). Small
change, and helps with debuggability.

+      USE(vreg);
       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;
@@ skipping 197 matching lines @@
   }
 
   ZoneQueue<int> worklist(temp_zone);
 
   for (BitVector::Iterator iterator(
            range->GetListOfBlocksRequiringSpillOperands());
        !iterator.Done(); iterator.Advance()) {
     worklist.push(iterator.Current());
   }
 
+  ZoneSet<std::pair<RpoNumber, int>> done_moves(temp_zone);
   // Seek the deferred blocks that dominate locations requiring spill operands,
   // and spill there. We only need to spill at the start of such blocks.
   BitVector done_blocks(
       range->GetListOfBlocksRequiringSpillOperands()->length(), temp_zone);
   while (!worklist.empty()) {
     int block_id = worklist.front();
     worklist.pop();
     if (done_blocks.Contains(block_id)) continue;
     done_blocks.Add(block_id);
     InstructionBlock* spill_block =
         code->InstructionBlockAt(RpoNumber::FromInt(block_id));
 
     for (const RpoNumber& pred : spill_block->predecessors()) {
       const InstructionBlock* pred_block = code->InstructionBlockAt(pred);
 
       if (pred_block->IsDeferred()) {
         worklist.push(pred_block->rpo_number().ToInt());
       } else {
         LifetimePosition pred_end =
             LifetimePosition::InstructionFromInstructionIndex(
                 pred_block->last_instruction_index());
 
         LiveRangeBound* bound = array->Find(pred_end);
 
         InstructionOperand pred_op = bound->range_->GetAssignedOperand();
 
-        data()->AddGapMove(spill_block->first_instruction_index(),
-                           Instruction::GapPosition::START, pred_op,
-                           spill_operand);
-        spill_block->mark_needs_frame();
+        RpoNumber spill_block_number = spill_block->rpo_number();
+        if (done_moves.find(std::make_pair(
+                spill_block_number, range->vreg())) == done_moves.end()) {
+          data()->AddGapMove(spill_block->first_instruction_index(),
+                             Instruction::GapPosition::START, pred_op,
+                             spill_operand);
+          done_moves.insert(std::make_pair(spill_block_number, range->vreg()));
+          spill_block->mark_needs_frame();
+        }
       }
     }
   }
 }
 
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8