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

src/register-configuration.h

 // 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.
 
 #ifndef V8_COMPILER_REGISTER_CONFIGURATION_H_
 #define V8_COMPILER_REGISTER_CONFIGURATION_H_
 
 #include "src/base/macros.h"
 #include "src/machine-type.h"
 
 namespace v8 {
 namespace internal {
 
 // An architecture independent representation of the sets of registers available
 // for instruction creation.
 class RegisterConfiguration {
  public:
-  // Define the optimized compiler selector for register configuration
-  // selection.
-  //
-  // TODO(X87): This distinction in RegisterConfigurations is temporary
-  // until x87 TF supports all of the registers that Crankshaft does.
-  enum CompilerSelector { CRANKSHAFT, TURBOFAN };
-
   enum AliasingKind {
     // Registers alias a single register of every other size (e.g. Intel).
     OVERLAP,
     // Registers alias two registers of the next smaller size (e.g. ARM).
     COMBINE
   };
 
   // Architecture independent maxes.
   static const int kMaxGeneralRegisters = 32;
   static const int kMaxFPRegisters = 32;
 
-  static const RegisterConfiguration* ArchDefault(CompilerSelector compiler);
+  // Default RegisterConfigurations for the target architecture.
+  // TODO(X87): This distinction in RegisterConfigurations is temporary
+  // until x87 TF supports all of the registers that Crankshaft does.
+  static const RegisterConfiguration* Crankshaft();
+  static const RegisterConfiguration* Turbofan();
 
   RegisterConfiguration(int num_general_registers, int num_double_registers,
                         int num_allocatable_general_registers,
                         int num_allocatable_double_registers,
                         const int* allocatable_general_codes,
                         const int* allocatable_double_codes,
                         AliasingKind fp_aliasing_kind,
                         char const* const* general_names,
                         char const* const* float_names,
                         char const* const* double_names);
@@ skipping 13 matching lines @@
   AliasingKind fp_aliasing_kind() const { return fp_aliasing_kind_; }
   int32_t allocatable_general_codes_mask() const {
     return allocatable_general_codes_mask_;
   }
   int32_t allocatable_double_codes_mask() const {
     return allocatable_double_codes_mask_;
   }
   int GetAllocatableGeneralCode(int index) const {
     return allocatable_general_codes_[index];
   }
+  bool IsAllocatableGeneralCode(int index) const {
+    return ((1 << index) & allocatable_general_codes_mask_) != 0;
+  }
   int GetAllocatableDoubleCode(int index) const {
     return allocatable_double_codes_[index];
   }
+  bool IsAllocatableDoubleCode(int index) const {
+    return ((1 << index) & allocatable_double_codes_mask_) != 0;
+  }
   int GetAllocatableFloatCode(int index) const {
     return allocatable_float_codes_[index];
   }
+  bool IsAllocatableFloatCode(int index) const {
+    return ((1 << index) & allocatable_float_codes_mask_) != 0;
+  }
   const char* GetGeneralRegisterName(int code) const {
     return general_register_names_[code];
   }
   const char* GetFloatRegisterName(int code) const {
     return float_register_names_[code];
   }
   const char* GetDoubleRegisterName(int code) const {
     return double_register_names_[code];
   }
   const int* allocatable_general_codes() const {
@@ skipping 20 matching lines @@
 
  private:
   const int num_general_registers_;
   int num_float_registers_;
   const int num_double_registers_;
   int num_allocatable_general_registers_;
   int num_allocatable_double_registers_;
   int num_allocatable_float_registers_;
   int32_t allocatable_general_codes_mask_;
   int32_t allocatable_double_codes_mask_;
+  int32_t allocatable_float_codes_mask_;
   const int* allocatable_general_codes_;
   const int* allocatable_double_codes_;
   int allocatable_float_codes_[kMaxFPRegisters];
   AliasingKind fp_aliasing_kind_;
   char const* const* general_register_names_;
   char const* const* float_register_names_;
   char const* const* double_register_names_;
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_REGISTER_CONFIGURATION_H_