[turbofan] No prespill when having sufficient registers

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 2414 matching lines @@
   DCHECK(RegisterConfiguration::kMaxDoubleRegisters >=
          this->data()->config()->num_general_registers());
 }
 
 
 void LinearScanAllocator::AllocateRegisters() {
   DCHECK(unhandled_live_ranges().empty());
   DCHECK(active_live_ranges().empty());
   DCHECK(inactive_live_ranges().empty());
 
-  SplitAndSpillRangesDefinedByMemoryOperand(false);
+  SplitAndSpillRangesDefinedByMemoryOperand(code()->VirtualRegisterCount() <=
+                                            num_allocatable_registers());

[Jarin, 2015/11/24 10:17:36]

This seems to be a hacky approximation in both directions:

- if there seem to be enough allocatable registers, they can still be eaten by
fixed/temp register uses.
- if there are too many virtual registers, they might not be alive at the same
time.

I would like to understand what exactly is the problem. Could not we fix
SplitAndSpillRangesDefinedByMemoryOperand function to behave a bit better? For
example, it seems to me that if the next non-register use is in deferred code,
we would still decide to spill. Also if there is no use at all, we seem to
prefer spilling.

 
   for (TopLevelLiveRange* range : data()->live_ranges()) {
     if (!CanProcessRange(range)) continue;
     for (LiveRange* to_add = range; to_add != nullptr;
          to_add = to_add->next()) {
       if (!to_add->spilled()) {
         AddToUnhandledUnsorted(to_add);
       }
     }
   }
@@ skipping 1019 matching lines @@
     auto eliminate = moves->PrepareInsertAfter(move);
     to_insert.push_back(move);
     if (eliminate != nullptr) to_eliminate.push_back(eliminate);
   }
 }
 
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8