A64: Rename k<Y>RegSize to k<Y>RegSizeInBits, and k<Y>RegSizeInBytes to k<Y>RegSize.

src/a64/regexp-macro-assembler-a64.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 181 matching lines @@
         __ Ldr(w10, register_location(reg));
         __ Add(w10, w10, by);
         __ Str(w10, register_location(reg));
         break;
       case CACHED_LSW:
         to_advance = GetCachedRegister(reg);
         __ Add(to_advance, to_advance, by);
         break;
       case CACHED_MSW:
         to_advance = GetCachedRegister(reg);
-        __ Add(to_advance, to_advance, static_cast<int64_t>(by) << kWRegSize);
+        __ Add(to_advance, to_advance,
+               static_cast<int64_t>(by) << kWRegSizeInBits);
         break;
       default:
         UNREACHABLE();
         break;
     }
   }
 }
 
 
 void RegExpMacroAssemblerA64::Backtrack() {
@@ skipping 76 matching lines @@
     CompareAndBranchOrBacktrack(w10, str[i], ne, on_failure);
   }
 }
 
 
 void RegExpMacroAssemblerA64::CheckGreedyLoop(Label* on_equal) {
   __ Ldr(w10, MemOperand(backtrack_stackpointer()));
   __ Cmp(current_input_offset(), w10);
   __ Cset(x11, eq);
   __ Add(backtrack_stackpointer(),
-         backtrack_stackpointer(), Operand(x11, LSL, kWRegSizeInBytesLog2));
+         backtrack_stackpointer(), Operand(x11, LSL, kWRegSizeLog2));
   BranchOrBacktrack(eq, on_equal);
 }
 
 void RegExpMacroAssemblerA64::CheckNotBackReferenceIgnoreCase(
     int start_reg,
     Label* on_no_match) {
   Label fallthrough;
 
   Register capture_start_offset = w10;
   // Save the capture length in a callee-saved register so it will
   // be preserved if we call a C helper.
   Register capture_length = w19;
   ASSERT(kCalleeSaved.IncludesAliasOf(capture_length));
 
   // Find length of back-referenced capture.
   ASSERT((start_reg % 2) == 0);
   if (start_reg < kNumCachedRegisters) {
     __ Mov(capture_start_offset.X(), GetCachedRegister(start_reg));
-    __ Lsr(x11, GetCachedRegister(start_reg), kWRegSize);
+    __ Lsr(x11, GetCachedRegister(start_reg), kWRegSizeInBits);
   } else {
     __ Ldp(w11, capture_start_offset, capture_location(start_reg, x10));
   }
   __ Sub(capture_length, w11, capture_start_offset);  // Length to check.
   // Succeed on empty capture (including no capture).
   __ Cbz(capture_length, &fallthrough);
 
   // Check that there are enough characters left in the input.
   __ Cmn(capture_length, current_input_offset());
   BranchOrBacktrack(gt, on_no_match);
@@ skipping 53 matching lines @@
       __ Cmp(current_input_offset().X(), Operand(current_input_offset(), SXTW));
       __ Ccmp(current_input_offset(), 0, NoFlag, eq);
       // The current input offset should be <= 0, and fit in a W register.
       __ Check(le, kOffsetOutOfRange);
     }
   } else {
     ASSERT(mode_ == UC16);
     int argument_count = 4;
 
     // The cached registers need to be retained.
-    CPURegList cached_registers(CPURegister::kRegister, kXRegSize, 0, 7);
+    CPURegList cached_registers(CPURegister::kRegister, kXRegSizeInBits, 0, 7);
     ASSERT((cached_registers.Count() * 2) == kNumCachedRegisters);
     __ PushCPURegList(cached_registers);
 
     // Put arguments into arguments registers.
     // Parameters are
     //   x0: Address byte_offset1 - Address captured substring's start.
     //   x1: Address byte_offset2 - Address of current character position.
     //   w2: size_t byte_length - length of capture in bytes(!)
     //   x3: Isolate* isolate
 
@@ skipping 31 matching lines @@
 
   Register capture_start_address = x12;
   Register capture_end_address = x13;
   Register current_position_address = x14;
   Register capture_length = w15;
 
   // Find length of back-referenced capture.
   ASSERT((start_reg % 2) == 0);
   if (start_reg < kNumCachedRegisters) {
     __ Mov(x10, GetCachedRegister(start_reg));
-    __ Lsr(x11, GetCachedRegister(start_reg), kWRegSize);
+    __ Lsr(x11, GetCachedRegister(start_reg), kWRegSizeInBits);
   } else {
     __ Ldp(w11, w10, capture_location(start_reg, x10));
   }
   __ Sub(capture_length, w11, w10);  // Length to check.
   // Succeed on empty capture (including no capture).
   __ Cbz(capture_length, &fallthrough);
 
   // Check that there are enough characters left in the input.
   __ Cmn(capture_length, current_input_offset());
   BranchOrBacktrack(gt, on_no_match);
@@ skipping 264 matching lines @@
   //   - (num_registers_ - kNumCachedRegisters) (W registers)
   int num_wreg_to_allocate = num_registers_ - kNumCachedRegisters;
   // Do not allocate registers on the stack if they can all be cached.
   if (num_wreg_to_allocate < 0) { num_wreg_to_allocate = 0; }
   // Make room for the success_counter.
   num_wreg_to_allocate += 2;
 
   // Make sure the stack alignment will be respected.
   int alignment = masm_->ActivationFrameAlignment();
   ASSERT_EQ(alignment % 16, 0);
-  int align_mask = (alignment / kWRegSizeInBytes) - 1;
+  int align_mask = (alignment / kWRegSize) - 1;
   num_wreg_to_allocate = (num_wreg_to_allocate + align_mask) & ~align_mask;
 
   // Check if we have space on the stack.
   Label stack_limit_hit;
   Label stack_ok;
 
   ExternalReference stack_limit =
       ExternalReference::address_of_stack_limit(isolate());
   __ Mov(x10, Operand(stack_limit));
   __ Ldr(x10, MemOperand(x10));
   __ Subs(x10, csp, x10);
 
   // Handle it if the stack pointer is already below the stack limit.
   __ B(ls, &stack_limit_hit);
 
   // Check if there is room for the variable number of registers above
   // the stack limit.
-  __ Cmp(x10, num_wreg_to_allocate * kWRegSizeInBytes);
+  __ Cmp(x10, num_wreg_to_allocate * kWRegSize);
   __ B(hs, &stack_ok);
 
   // Exit with OutOfMemory exception. There is not enough space on the stack
   // for our working registers.
   __ Mov(w0, EXCEPTION);
   __ B(&return_w0);
 
   __ Bind(&stack_limit_hit);
   CallCheckStackGuardState(x10);
   // If returned value is non-zero, we exit with the returned value as result.
   __ Cbnz(w0, &return_w0);
 
   __ Bind(&stack_ok);
 
   // Allocate space on stack.
-  __ Claim(num_wreg_to_allocate, kWRegSizeInBytes);
+  __ Claim(num_wreg_to_allocate, kWRegSize);
 
   // Initialize success_counter with 0.
   __ Str(wzr, MemOperand(frame_pointer(), kSuccessCounter));
 
   // Find negative length (offset of start relative to end).
   __ Sub(x10, input_start(), input_end());
   if (masm_->emit_debug_code()) {
     // Check that the input string length is < 2^30.
     __ Neg(x11, x10);
     __ Cmp(x11, (1<<30) - 1);
     __ Check(ls, kInputStringTooLong);
   }
   __ Mov(current_input_offset(), w10);
 
   // The non-position value is used as a clearing value for the
   // capture registers, it corresponds to the position of the first character
   // minus one.
   __ Sub(non_position_value(), current_input_offset(), char_size());
   __ Sub(non_position_value(), non_position_value(),
          Operand(start_offset(), LSL, (mode_ == UC16) ? 1 : 0));
   // We can store this value twice in an X register for initializing
   // on-stack registers later.
   __ Orr(twice_non_position_value(),
          non_position_value().X(),
-         Operand(non_position_value().X(), LSL, kWRegSize));
+         Operand(non_position_value().X(), LSL, kWRegSizeInBits));
 
   // Initialize code pointer register.
   __ Mov(code_pointer(), Operand(masm_->CodeObject()));
 
   Label load_char_start_regexp, start_regexp;
   // Load newline if index is at start, previous character otherwise.
   __ Cbnz(start_offset(), &load_char_start_regexp);
   __ Mov(current_character(), '\n');
   __ B(&start_regexp);
 
@@ skipping 45 matching lines @@
         __ Add(input_length, start_offset(), Operand(w10, LSR, 1));
       } else {
         __ Add(input_length, start_offset(), w10);
       }
 
       // Copy the results to the output array from the cached registers first.
       for (int i = 0;
            (i < num_saved_registers_) && (i < kNumCachedRegisters);
            i += 2) {
         __ Mov(capture_start.X(), GetCachedRegister(i));
-        __ Lsr(capture_end.X(), capture_start.X(), kWRegSize);
+        __ Lsr(capture_end.X(), capture_start.X(), kWRegSizeInBits);
         if ((i == 0) && global_with_zero_length_check()) {
           // Keep capture start for the zero-length check later.
           __ Mov(first_capture_start, capture_start);
         }
         // Offsets need to be relative to the start of the string.
         if (mode_ == UC16) {
           __ Add(capture_start, input_length, Operand(capture_start, ASR, 1));
           __ Add(capture_end, input_length, Operand(capture_end, ASR, 1));
         } else {
           __ Add(capture_start, input_length, capture_start);
@@ skipping 134 matching lines @@
   __ Mov(csp, fp);
 
   // Restore registers.
   __ PopCPURegList(registers_to_retain);
 
   __ Ret();
 
   Label exit_with_exception;
   // Registers x0 to x7 are used to store the first captures, they need to be
   // retained over calls to C++ code.
-  CPURegList cached_registers(CPURegister::kRegister, kXRegSize, 0, 7);
+  CPURegList cached_registers(CPURegister::kRegister, kXRegSizeInBits, 0, 7);
   ASSERT((cached_registers.Count() * 2) == kNumCachedRegisters);
 
   if (check_preempt_label_.is_linked()) {
     __ Bind(&check_preempt_label_);
     SaveLinkRegister();
     // The cached registers need to be retained.
     __ PushCPURegList(cached_registers);
     CallCheckStackGuardState(x10);
     // Returning from the regexp code restores the stack (csp <- fp)
     // so we don't need to drop the link register from it before exiting.
@@ skipping 141 matching lines @@
   switch (register_state) {
     case STACKED:
       __ Ldr(current_input_offset(), register_location(reg));
       break;
     case CACHED_LSW:
       cached_register = GetCachedRegister(reg);
       __ Mov(current_input_offset(), cached_register.W());
       break;
     case CACHED_MSW:
       cached_register = GetCachedRegister(reg);
-      __ Lsr(current_input_offset().X(), cached_register, kWRegSize);
+      __ Lsr(current_input_offset().X(), cached_register, kWRegSizeInBits);
       break;
     default:
       UNREACHABLE();
       break;
   }
 }
 
 
 void RegExpMacroAssemblerA64::ReadStackPointerFromRegister(int reg) {
   Register read_from = GetRegister(reg, w10);
@@ skipping 74 matching lines @@
     ASSERT(reg_from >= kNumCachedRegisters);
 
     // Move down the indexes of the registers on stack to get the correct offset
     // in memory.
     reg_from -= kNumCachedRegisters;
     reg_to -= kNumCachedRegisters;
     // We should not unroll the loop for less than 2 registers.
     STATIC_ASSERT(kNumRegistersToUnroll > 2);
     // We position the base pointer to (reg_from + 1).
     int base_offset = kFirstRegisterOnStack -
-        kWRegSizeInBytes - (kWRegSizeInBytes * reg_from);
+        kWRegSize - (kWRegSize * reg_from);
     if (num_registers > kNumRegistersToUnroll) {
       Register base = x10;
       __ Add(base, frame_pointer(), base_offset);
 
       Label loop;
       __ Mov(x11, num_registers);
       __ Bind(&loop);
       __ Str(twice_non_position_value(),
              MemOperand(base, -kPointerSize, PostIndex));
       __ Sub(x11, x11, 2);
       __ Cbnz(x11, &loop);
     } else {
       for (int i = reg_from; i <= reg_to; i += 2) {
         __ Str(twice_non_position_value(),
                MemOperand(frame_pointer(), base_offset));
-        base_offset -= kWRegSizeInBytes * 2;
+        base_offset -= kWRegSize * 2;
       }
     }
   }
 }
 
 
 void RegExpMacroAssemblerA64::WriteStackPointerToRegister(int reg) {
   __ Ldr(x10, MemOperand(frame_pointer(), kStackBase));
   __ Sub(x10, backtrack_stackpointer(), x10);
   if (masm_->emit_debug_code()) {
@@ skipping 129 matching lines @@
 
 // Private methods:
 
 void RegExpMacroAssemblerA64::CallCheckStackGuardState(Register scratch) {
   // Allocate space on the stack to store the return address. The
   // CheckStackGuardState C++ function will override it if the code
   // moved. Allocate extra space for 2 arguments passed by pointers.
   // AAPCS64 requires the stack to be 16 byte aligned.
   int alignment = masm_->ActivationFrameAlignment();
   ASSERT_EQ(alignment % 16, 0);
-  int align_mask = (alignment / kXRegSizeInBytes) - 1;
+  int align_mask = (alignment / kXRegSize) - 1;
   int xreg_to_claim = (3 + align_mask) & ~align_mask;
 
   ASSERT(csp.Is(__ StackPointer()));
   __ Claim(xreg_to_claim);
 
   // CheckStackGuardState needs the end and start addresses of the input string.
   __ Poke(input_end(), 2 * kPointerSize);
   __ Add(x5, csp, 2 * kPointerSize);
   __ Poke(input_start(), kPointerSize);
   __ Add(x4, csp, kPointerSize);
@@ skipping 91 matching lines @@
   __ Cmp(backtrack_stackpointer(), x10);
   CallIf(&stack_overflow_label_, ls);
 }
 
 
 void RegExpMacroAssemblerA64::Push(Register source) {
   ASSERT(source.Is32Bits());
   ASSERT(!source.is(backtrack_stackpointer()));
   __ Str(source,
          MemOperand(backtrack_stackpointer(),
-                    -static_cast<int>(kWRegSizeInBytes),
+                    -static_cast<int>(kWRegSize),
                     PreIndex));
 }
 
 
 void RegExpMacroAssemblerA64::Pop(Register target) {
   ASSERT(target.Is32Bits());
   ASSERT(!target.is(backtrack_stackpointer()));
   __ Ldr(target,
-         MemOperand(backtrack_stackpointer(), kWRegSizeInBytes, PostIndex));
+         MemOperand(backtrack_stackpointer(), kWRegSize, PostIndex));
 }
 
 
 Register RegExpMacroAssemblerA64::GetCachedRegister(int register_index) {
   ASSERT(register_index < kNumCachedRegisters);
-  return Register::Create(register_index / 2, kXRegSize);
+  return Register::Create(register_index / 2, kXRegSizeInBits);
 }
 
 
 Register RegExpMacroAssemblerA64::GetRegister(int register_index,
                                               Register maybe_result) {
   ASSERT(maybe_result.Is32Bits());
   ASSERT(register_index >= 0);
   if (num_registers_ <= register_index) {
     num_registers_ = register_index + 1;
   }
   Register result;
   RegisterState register_state = GetRegisterState(register_index);
   switch (register_state) {
     case STACKED:
       __ Ldr(maybe_result, register_location(register_index));
       result = maybe_result;
       break;
     case CACHED_LSW:
       result = GetCachedRegister(register_index).W();
       break;
     case CACHED_MSW:
-      __ Lsr(maybe_result.X(), GetCachedRegister(register_index), kWRegSize);
+      __ Lsr(maybe_result.X(), GetCachedRegister(register_index),
+             kWRegSizeInBits);
       result = maybe_result;
       break;
     default:
       UNREACHABLE();
       break;
   }
   ASSERT(result.Is32Bits());
   return result;
 }
 
 
 void RegExpMacroAssemblerA64::StoreRegister(int register_index,
                                             Register source) {
   ASSERT(source.Is32Bits());
   ASSERT(register_index >= 0);
   if (num_registers_ <= register_index) {
     num_registers_ = register_index + 1;
   }
 
   Register cached_register;
   RegisterState register_state = GetRegisterState(register_index);
   switch (register_state) {
     case STACKED:
       __ Str(source, register_location(register_index));
       break;
     case CACHED_LSW:
       cached_register = GetCachedRegister(register_index);
       if (!source.Is(cached_register.W())) {
-        __ Bfi(cached_register, source.X(), 0, kWRegSize);
+        __ Bfi(cached_register, source.X(), 0, kWRegSizeInBits);
       }
       break;
     case CACHED_MSW:
       cached_register = GetCachedRegister(register_index);
-      __ Bfi(cached_register, source.X(), kWRegSize, kWRegSize);
+      __ Bfi(cached_register, source.X(), kWRegSizeInBits, kWRegSizeInBits);
       break;
     default:
       UNREACHABLE();
       break;
   }
 }
 
 
 void RegExpMacroAssemblerA64::CallIf(Label* to, Condition condition) {
   Label skip_call;
@@ skipping 17 matching lines @@
 }
 
 
 MemOperand RegExpMacroAssemblerA64::register_location(int register_index) {
   ASSERT(register_index < (1<<30));
   ASSERT(register_index >= kNumCachedRegisters);
   if (num_registers_ <= register_index) {
     num_registers_ = register_index + 1;
   }
   register_index -= kNumCachedRegisters;
-  int offset = kFirstRegisterOnStack - register_index * kWRegSizeInBytes;
+  int offset = kFirstRegisterOnStack - register_index * kWRegSize;
   return MemOperand(frame_pointer(), offset);
 }
 
 MemOperand RegExpMacroAssemblerA64::capture_location(int register_index,
                                                      Register scratch) {
   ASSERT(register_index < (1<<30));
   ASSERT(register_index < num_saved_registers_);
   ASSERT(register_index >= kNumCachedRegisters);
   ASSERT_EQ(register_index % 2, 0);
   register_index -= kNumCachedRegisters;
-  int offset = kFirstCaptureOnStack - register_index * kWRegSizeInBytes;
+  int offset = kFirstCaptureOnStack - register_index * kWRegSize;
   // capture_location is used with Stp instructions to load/store 2 registers.
   // The immediate field in the encoding is limited to 7 bits (signed).
   if (is_int7(offset)) {
     return MemOperand(frame_pointer(), offset);
   } else {
     __ Add(scratch, frame_pointer(), offset);
     return MemOperand(scratch);
   }
 }
 
@@ skipping 44 matching lines @@
       __ Ldrh(current_character(), MemOperand(input_end(), offset, SXTW));
     }
   }
 }
 
 #endif  // V8_INTERPRETED_REGEXP
 
 }}  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_A64