[turbofan] put spill slot reuse behind a flag

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/compiler/linkage.h"
 #include "src/compiler/register-allocator.h"
 #include "src/string-stream.h"
 
 namespace v8 {
 namespace internal {
@@ skipping 527 matching lines @@
                          local_zone()),
       fixed_double_live_ranges_(this->config()->num_double_registers(), NULL,
                                 local_zone()),
       unhandled_live_ranges_(code->VirtualRegisterCount() * 2, local_zone()),
       active_live_ranges_(8, local_zone()),
       inactive_live_ranges_(8, local_zone()),
       reusable_slots_(8, local_zone()),
       spill_ranges_(8, local_zone()),
       mode_(UNALLOCATED_REGISTERS),
       num_registers_(-1),
-      allocation_ok_(true) {
+      allocation_ok_(true),
+      use_spill_ranges_(FLAG_turbo_reuse_spill_slots) {

[Jarin, 2014/11/21 10:55:39]

Why is there this extra indirection? Can't we use the naked flag? (That will
simplify the removal once we are done.)

[dcarney, 2014/11/21 11:03:55]

ok

   DCHECK(this->config()->num_general_registers() <=
          RegisterConfiguration::kMaxGeneralRegisters);
   DCHECK(this->config()->num_double_registers() <=
          RegisterConfiguration::kMaxDoubleRegisters);
   // TryAllocateFreeReg and AllocateBlockedReg assume this
   // when allocating local arrays.
   DCHECK(this->config()->num_double_registers() >=
          this->config()->num_general_registers());
   assigned_registers_ =
       new (code_zone()) BitVector(config->num_general_registers(), code_zone());
@@ skipping 315 matching lines @@
       tail->set_next(current);
     }
     tail = current;
     current = current->next();
   }
   // Other list is empty => we are done
 }
 
 
 void RegisterAllocator::ReuseSpillSlots() {
+  DCHECK(use_spill_ranges_);
+
   // Merge disjoint spill ranges
   for (int i = 0; i < spill_ranges_.length(); i++) {
     SpillRange* range = spill_ranges_.at(i);
     if (!range->IsEmpty()) {
       for (int j = i + 1; j < spill_ranges_.length(); j++) {
         SpillRange* other = spill_ranges_.at(j);
         if (!other->IsEmpty()) {
           range->TryMerge(spill_ranges_.at(j), local_zone());
         }
       }
@@ skipping 14 matching lines @@
         DCHECK(kind == GENERAL_REGISTERS);
         op = StackSlotOperand::Create(index, local_zone());
       }
       range->SetOperand(op);
     }
   }
 }
 
 
 SpillRange* RegisterAllocator::AssignSpillRangeToLiveRange(LiveRange* range) {
+  DCHECK(use_spill_ranges_);
   int spill_id = spill_ranges_.length();
   SpillRange* spill_range =
       new (local_zone()) SpillRange(range, spill_id, local_zone());
   spill_ranges_.Add(spill_range, local_zone());
   return spill_range;
 }
 
 
 void RegisterAllocator::MeetRegisterConstraints(const InstructionBlock* block) {
   int start = block->first_instruction_index();
@@ skipping 997 matching lines @@
   int len = unhandled_live_ranges_.length();
   for (int i = 1; i < len; i++) {
     LiveRange* a = unhandled_live_ranges_.at(i - 1);
     LiveRange* b = unhandled_live_ranges_.at(i);
     if (a->Start().Value() < b->Start().Value()) return false;
   }
   return true;
 }
 
 
+void RegisterAllocator::FreeSpillSlot(LiveRange* range) {
+  DCHECK(!use_spill_ranges_);
+  // Check that we are the last range.
+  if (range->next() != NULL) return;
+
+  if (!range->TopLevel()->HasAllocatedSpillOperand()) return;
+
+  InstructionOperand* spill_operand = range->TopLevel()->GetSpillOperand();
+  if (spill_operand->IsConstant()) return;
+  if (spill_operand->index() >= 0) {
+    reusable_slots_.Add(range, local_zone());
+  }
+}
+
+
+InstructionOperand* RegisterAllocator::TryReuseSpillSlot(LiveRange* range) {
+  DCHECK(!use_spill_ranges_);
+  if (reusable_slots_.is_empty()) return NULL;
+  if (reusable_slots_.first()->End().Value() >
+      range->TopLevel()->Start().Value()) {
+    return NULL;
+  }
+  InstructionOperand* result =
+      reusable_slots_.first()->TopLevel()->GetSpillOperand();
+  reusable_slots_.Remove(0);
+  return result;
+}
+
+
 void RegisterAllocator::ActiveToHandled(LiveRange* range) {
   DCHECK(active_live_ranges_.Contains(range));
   active_live_ranges_.RemoveElement(range);
   TraceAlloc("Moving live range %d from active to handled\n", range->id());
+  if (!use_spill_ranges_) FreeSpillSlot(range);
 }
 
 
 void RegisterAllocator::ActiveToInactive(LiveRange* range) {
   DCHECK(active_live_ranges_.Contains(range));
   active_live_ranges_.RemoveElement(range);
   inactive_live_ranges_.Add(range, local_zone());
   TraceAlloc("Moving live range %d from active to inactive\n", range->id());
 }
 
 
 void RegisterAllocator::InactiveToHandled(LiveRange* range) {
   DCHECK(inactive_live_ranges_.Contains(range));
   inactive_live_ranges_.RemoveElement(range);
   TraceAlloc("Moving live range %d from inactive to handled\n", range->id());
+  if (!use_spill_ranges_) FreeSpillSlot(range);
 }
 
 
 void RegisterAllocator::InactiveToActive(LiveRange* range) {
   DCHECK(inactive_live_ranges_.Contains(range));
   inactive_live_ranges_.RemoveElement(range);
   active_live_ranges_.Add(range, local_zone());
   TraceAlloc("Moving live range %d from inactive to active\n", range->id());
 }
 
@@ skipping 364 matching lines @@
   }
 }
 
 
 void RegisterAllocator::Spill(LiveRange* range) {
   DCHECK(!range->IsSpilled());
   TraceAlloc("Spilling live range %d\n", range->id());
   LiveRange* first = range->TopLevel();
 
   if (!first->HasAllocatedSpillOperand()) {
-    AssignSpillRangeToLiveRange(first);
+    if (use_spill_ranges_) {
+      AssignSpillRangeToLiveRange(first);
+    } else {
+      InstructionOperand* op = TryReuseSpillSlot(range);
+      if (op == NULL) {
+        // Allocate a new operand referring to the spill slot.
+        RegisterKind kind = range->Kind();
+        int index = frame()->AllocateSpillSlot(kind == DOUBLE_REGISTERS);
+        if (kind == DOUBLE_REGISTERS) {
+          op = DoubleStackSlotOperand::Create(index, local_zone());
+        } else {
+          DCHECK(kind == GENERAL_REGISTERS);
+          op = StackSlotOperand::Create(index, local_zone());
+        }
+      }
+      first->SetSpillOperand(op);
+    }
   }
   range->MakeSpilled(code_zone());
 }
 
 
 int RegisterAllocator::RegisterCount() const { return num_registers_; }
 
 
 #ifdef DEBUG
 
@@ skipping 15 matching lines @@
   } else {
     DCHECK(range->Kind() == GENERAL_REGISTERS);
     assigned_registers_->Add(reg);
   }
   range->set_assigned_register(reg, code_zone());
 }
 
 }
 }
 }  // namespace v8::internal::compiler