[RegisterConfiguration] Streamline access to arch defaults, simplify Registers.

src/crankshaft/lithium-allocator.cc

 // Copyright 2012 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/crankshaft/lithium-allocator.h"
 
 #include "src/crankshaft/hydrogen.h"
 #include "src/crankshaft/lithium-inl.h"
 #include "src/crankshaft/lithium-allocator-inl.h"
 #include "src/register-configuration.h"
 #include "src/string-stream.h"
 
 namespace v8 {
 namespace internal {
 
+const auto GetRegConfig = RegisterConfiguration::Crankshaft;
+
 static inline LifetimePosition Min(LifetimePosition a, LifetimePosition b) {
   return a.Value() < b.Value() ? a : b;
 }
 
 
 static inline LifetimePosition Max(LifetimePosition a, LifetimePosition b) {
   return a.Value() > b.Value() ? a : b;
 }
 
 
@@ skipping 907 matching lines @@
         LOperand* output = instr->Output();
         if (output != NULL) {
           if (output->IsUnallocated()) {
             live->Remove(LUnallocated::cast(output)->virtual_register());
           }
           Define(curr_position, output, NULL);
         }
 
         if (instr->ClobbersRegisters()) {
           for (int i = 0; i < Register::kNumRegisters; ++i) {
-            if (Register::from_code(i).IsAllocatable()) {
+            if (GetRegConfig()->IsAllocatableGeneralCode(i)) {
               if (output == NULL || !output->IsRegister() ||
                   output->index() != i) {
                 LiveRange* range = FixedLiveRangeFor(i);
                 range->AddUseInterval(curr_position,
                                       curr_position.InstructionEnd(), zone());
               }
             }
           }
         }
 
         if (instr->ClobbersDoubleRegisters(isolate())) {
           for (int i = 0; i < DoubleRegister::kMaxNumRegisters; ++i) {
-            if (DoubleRegister::from_code(i).IsAllocatable()) {
+            if (GetRegConfig()->IsAllocatableDoubleCode(i)) {
               if (output == NULL || !output->IsDoubleRegister() ||
                   output->index() != i) {
                 LiveRange* range = FixedDoubleLiveRangeFor(i);
                 range->AddUseInterval(curr_position,
                                       curr_position.InstructionEnd(), zone());
               }
             }
           }
         }
 
@@ skipping 486 matching lines @@
         DCHECK(!operand->IsStackSlot());
         map->RecordPointer(operand, chunk()->zone());
       }
     }
   }
 }
 
 
 void LAllocator::AllocateGeneralRegisters() {
   LAllocatorPhase phase("L_Allocate general registers", this);
-  num_registers_ =
-      RegisterConfiguration::ArchDefault(RegisterConfiguration::CRANKSHAFT)
-          ->num_allocatable_general_registers();
-  allocatable_register_codes_ =
-      RegisterConfiguration::ArchDefault(RegisterConfiguration::CRANKSHAFT)
-          ->allocatable_general_codes();
+  num_registers_ = GetRegConfig()->num_allocatable_general_registers();
+  allocatable_register_codes_ = GetRegConfig()->allocatable_general_codes();
   mode_ = GENERAL_REGISTERS;
   AllocateRegisters();
 }
 
 
 void LAllocator::AllocateDoubleRegisters() {
   LAllocatorPhase phase("L_Allocate double registers", this);
-  num_registers_ =
-      RegisterConfiguration::ArchDefault(RegisterConfiguration::CRANKSHAFT)
-          ->num_allocatable_double_registers();
-  allocatable_register_codes_ =
-      RegisterConfiguration::ArchDefault(RegisterConfiguration::CRANKSHAFT)
-          ->allocatable_double_codes();
+  num_registers_ = GetRegConfig()->num_allocatable_double_registers();
+  allocatable_register_codes_ = GetRegConfig()->allocatable_double_codes();
   mode_ = DOUBLE_REGISTERS;
   AllocateRegisters();
 }
 
 
 void LAllocator::AllocateRegisters() {
   DCHECK(unhandled_live_ranges_.is_empty());
 
   for (int i = 0; i < live_ranges_.length(); ++i) {
     if (live_ranges_[i] != NULL) {
@@ skipping 97 matching lines @@
   }
 
   reusable_slots_.Rewind(0);
   active_live_ranges_.Rewind(0);
   inactive_live_ranges_.Rewind(0);
 }
 
 
 const char* LAllocator::RegisterName(int allocation_index) {
   if (mode_ == GENERAL_REGISTERS) {
-    return Register::from_code(allocation_index).ToString();
+    return GetRegConfig()->GetGeneralRegisterName(allocation_index);
   } else {
-    return DoubleRegister::from_code(allocation_index).ToString();
+    return GetRegConfig()->GetDoubleRegisterName(allocation_index);
   }
 }
 
 
 void LAllocator::TraceAlloc(const char* msg, ...) {
   if (FLAG_trace_alloc) {
     va_list arguments;
     va_start(arguments, msg);
     base::OS::VPrint(msg, arguments);
     va_end(arguments);
@@ skipping 576 matching lines @@
   }
 
 #ifdef DEBUG
   if (allocator_ != NULL) allocator_->Verify();
 #endif
 }
 
 
 }  // namespace internal
 }  // namespace v8