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

src/crankshaft/lithium.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.h"
 
 #include "src/ast/scopes.h"
 
 #if V8_TARGET_ARCH_IA32
 #include "src/crankshaft/ia32/lithium-ia32.h"  // NOLINT
@@ skipping 22 matching lines @@
 #elif V8_TARGET_ARCH_S390
 #include "src/crankshaft/s390/lithium-s390.h"          // NOLINT
 #include "src/crankshaft/s390/lithium-codegen-s390.h"  // NOLINT
 #else
 #error "Unknown architecture."
 #endif
 
 namespace v8 {
 namespace internal {
 
+const auto GetRegConfig = RegisterConfiguration::Crankshaft;
 
 void LOperand::PrintTo(StringStream* stream) {
   LUnallocated* unalloc = NULL;
   switch (kind()) {
     case INVALID:
       stream->Add("(0)");
       break;
     case UNALLOCATED:
       unalloc = LUnallocated::cast(this);
       stream->Add("v%d", unalloc->virtual_register());
       if (unalloc->basic_policy() == LUnallocated::FIXED_SLOT) {
         stream->Add("(=%dS)", unalloc->fixed_slot_index());
         break;
       }
       switch (unalloc->extended_policy()) {
         case LUnallocated::NONE:
           break;
         case LUnallocated::FIXED_REGISTER: {
           int reg_index = unalloc->fixed_register_index();
           if (reg_index < 0 || reg_index >= Register::kNumRegisters) {
             stream->Add("(=invalid_reg#%d)", reg_index);
           } else {
             const char* register_name =
-                Register::from_code(reg_index).ToString();
+                GetRegConfig()->GetGeneralRegisterName(reg_index);
             stream->Add("(=%s)", register_name);
           }
           break;
         }
         case LUnallocated::FIXED_DOUBLE_REGISTER: {
           int reg_index = unalloc->fixed_register_index();
           if (reg_index < 0 || reg_index >= DoubleRegister::kMaxNumRegisters) {
             stream->Add("(=invalid_double_reg#%d)", reg_index);
           } else {
             const char* double_register_name =
-                DoubleRegister::from_code(reg_index).ToString();
+                GetRegConfig()->GetDoubleRegisterName(reg_index);
             stream->Add("(=%s)", double_register_name);
           }
           break;
         }
         case LUnallocated::MUST_HAVE_REGISTER:
           stream->Add("(R)");
           break;
         case LUnallocated::MUST_HAVE_DOUBLE_REGISTER:
           stream->Add("(D)");
           break;
@@ skipping 15 matching lines @@
       stream->Add("[stack:%d]", index());
       break;
     case DOUBLE_STACK_SLOT:
       stream->Add("[double_stack:%d]", index());
       break;
     case REGISTER: {
       int reg_index = index();
       if (reg_index < 0 || reg_index >= Register::kNumRegisters) {
         stream->Add("(=invalid_reg#%d|R)", reg_index);
       } else {
-        stream->Add("[%s|R]", Register::from_code(reg_index).ToString());
+        stream->Add("[%s|R]",
+                    GetRegConfig()->GetGeneralRegisterName(reg_index));
       }
       break;
     }
     case DOUBLE_REGISTER: {
       int reg_index = index();
       if (reg_index < 0 || reg_index >= DoubleRegister::kMaxNumRegisters) {
         stream->Add("(=invalid_double_reg#%d|R)", reg_index);
       } else {
-        stream->Add("[%s|R]", DoubleRegister::from_code(reg_index).ToString());
+        stream->Add("[%s|R]", GetRegConfig()->GetDoubleRegisterName(reg_index));
       }
       break;
     }
   }
 }
 
 
 template<LOperand::Kind kOperandKind, int kNumCachedOperands>
 LSubKindOperand<kOperandKind, kNumCachedOperands>*
 LSubKindOperand<kOperandKind, kNumCachedOperands>::cache = NULL;
@@ skipping 590 matching lines @@
 
 LPhase::~LPhase() {
   if (ShouldProduceTraceOutput()) {
     isolate()->GetHTracer()->TraceLithium(name(), chunk_);
   }
 }
 
 
 }  // namespace internal
 }  // namespace v8