[assembler] Make register definitions constexpr

src/mips/macro-assembler-mips.h

 // 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.
 
 #ifndef V8_MIPS_MACRO_ASSEMBLER_MIPS_H_
 #define V8_MIPS_MACRO_ASSEMBLER_MIPS_H_
 
 #include "src/assembler.h"
 #include "src/globals.h"
 #include "src/mips/assembler-mips.h"
 
 namespace v8 {
 namespace internal {
 
 // Give alias names to registers for calling conventions.
-const Register kReturnRegister0 = {Register::kCode_v0};
-const Register kReturnRegister1 = {Register::kCode_v1};
-const Register kReturnRegister2 = {Register::kCode_a0};
-const Register kJSFunctionRegister = {Register::kCode_a1};
-const Register kContextRegister = {Register::kCpRegister};
-const Register kAllocateSizeRegister = {Register::kCode_a0};
-const Register kInterpreterAccumulatorRegister = {Register::kCode_v0};
-const Register kInterpreterBytecodeOffsetRegister = {Register::kCode_t4};
-const Register kInterpreterBytecodeArrayRegister = {Register::kCode_t5};
-const Register kInterpreterDispatchTableRegister = {Register::kCode_t6};
-const Register kJavaScriptCallArgCountRegister = {Register::kCode_a0};
-const Register kJavaScriptCallNewTargetRegister = {Register::kCode_a3};
-const Register kRuntimeCallFunctionRegister = {Register::kCode_a1};
-const Register kRuntimeCallArgCountRegister = {Register::kCode_a0};
+constexpr Register kReturnRegister0 = {Register::kCode_v0};
+constexpr Register kReturnRegister1 = {Register::kCode_v1};
+constexpr Register kReturnRegister2 = {Register::kCode_a0};
+constexpr Register kJSFunctionRegister = {Register::kCode_a1};
+constexpr Register kContextRegister = {Register::kCpRegister};
+constexpr Register kAllocateSizeRegister = {Register::kCode_a0};
+constexpr Register kInterpreterAccumulatorRegister = {Register::kCode_v0};
+constexpr Register kInterpreterBytecodeOffsetRegister = {Register::kCode_t4};
+constexpr Register kInterpreterBytecodeArrayRegister = {Register::kCode_t5};
+constexpr Register kInterpreterDispatchTableRegister = {Register::kCode_t6};
+constexpr Register kJavaScriptCallArgCountRegister = {Register::kCode_a0};
+constexpr Register kJavaScriptCallNewTargetRegister = {Register::kCode_a3};
+constexpr Register kRuntimeCallFunctionRegister = {Register::kCode_a1};
+constexpr Register kRuntimeCallArgCountRegister = {Register::kCode_a0};
 
 // Forward declaration.
 class JumpTarget;
 
 // Reserved Register Usage Summary.
 //
 // Registers t8, t9, and at are reserved for use by the MacroAssembler.
 //
 // The programmer should know that the MacroAssembler may clobber these three,
 // but won't touch other registers except in special cases.
@@ skipping 163 matching lines @@
   bool IsNear(Label* L, Condition cond, int rs_reg);
 
   void Branch(Label* L,
               Condition cond,
               Register rs,
               Heap::RootListIndex index,
               BranchDelaySlot bdslot = PROTECT);
 
 // Number of instructions needed for calculation of switch table entry address
 #ifdef _MIPS_ARCH_MIPS32R6
-  static const int kSwitchTablePrologueSize = 5;
+  static constexpr int kSwitchTablePrologueSize = 5;
 #else
-  static const int kSwitchTablePrologueSize = 10;
+  static constexpr int kSwitchTablePrologueSize = 10;
 #endif
   // GetLabelFunction must be lambda '[](size_t index) -> Label*' or a
   // functor/function with 'Label *func(size_t index)' declaration.
   template <typename Func>
   void GenerateSwitchTable(Register index, size_t case_count,
                            Func GetLabelFunction);
 #undef COND_ARGS
 
   // Emit code that loads |parameter_index|'th parameter from the stack to
   // the register according to the CallInterfaceDescriptor definition.
@@ skipping 1399 matching lines @@
     Ext(dst, src, Field::kShift, Field::kSize);
   }
 
   template<typename Field>
   void DecodeField(Register reg) {
     DecodeField<Field>(reg, reg);
   }
 
   template<typename Field>
   void DecodeFieldToSmi(Register dst, Register src) {
-    static const int shift = Field::kShift;
-    static const int mask = Field::kMask >> shift << kSmiTagSize;
+    constexpr int shift = Field::kShift;
+    constexpr int mask = Field::kMask >> shift << kSmiTagSize;
     STATIC_ASSERT((mask & (0x80000000u >> (kSmiTagSize - 1))) == 0);
     STATIC_ASSERT(kSmiTag == 0);
     if (shift < kSmiTagSize) {
       sll(dst, src, kSmiTagSize - shift);
       And(dst, dst, Operand(mask));
     } else if (shift > kSmiTagSize) {
       srl(dst, src, shift - kSmiTagSize);
       And(dst, dst, Operand(mask));
     } else {
       And(dst, src, Operand(mask));
@@ skipping 174 matching lines @@
     dd(GetLabelFunction(index));
   }
 }
 
 #define ACCESS_MASM(masm) masm->
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_MIPS_MACRO_ASSEMBLER_MIPS_H_