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

src/a64/macro-assembler-a64-inl.h

 // 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 729 matching lines @@
   if ((fd.Is64Bits() && IsImmFP64(imm)) ||
       (fd.Is32Bits() && IsImmFP32(imm)) ||
       ((imm == 0.0) && (copysign(1.0, imm) == 1.0))) {
     // These cases can be handled by the Assembler.
     fmov(fd, imm);
   } else {
     UseScratchRegisterScope temps(this);
     // TODO(all): The Assembler would try to relocate the immediate with
     // Assembler::ldr(const FPRegister& ft, double imm) but it is not
     // implemented yet.
-    if (fd.SizeInBits() == kDRegSize) {
+    if (fd.SizeInBits() == kDRegSizeInBits) {
       Register tmp = temps.AcquireX();
       Mov(tmp, double_to_rawbits(imm));
       Fmov(fd, tmp);
     } else {
-      ASSERT(fd.SizeInBits() == kSRegSize);
+      ASSERT(fd.SizeInBits() == kSRegSizeInBits);
       Register tmp = temps.AcquireW();
       Mov(tmp, float_to_rawbits(static_cast<float>(imm)));
       Fmov(fd, tmp);
     }
   }
 }
 
 
 void MacroAssembler::Fmov(Register rd, FPRegister fn) {
   ASSERT(allow_macro_instructions_);
@@ skipping 703 matching lines @@
 }
 
 
 void MacroAssembler::Claim(const Register& count, uint64_t unit_size) {
   ASSERT(IsPowerOf2(unit_size));
 
   if (unit_size == 0) {
     return;
   }
 
-  const int shift = CountTrailingZeros(unit_size, kXRegSize);
+  const int shift = CountTrailingZeros(unit_size, kXRegSizeInBits);
   const Operand size(count, LSL, shift);
 
   if (size.IsZero()) {
     return;
   }
 
   if (!csp.Is(StackPointer())) {
     BumpSystemStackPointer(size);
   }
 
   Sub(StackPointer(), StackPointer(), size);
 }
 
 
 void MacroAssembler::ClaimBySMI(const Register& count_smi, uint64_t unit_size) {
   ASSERT(IsPowerOf2(unit_size));
-  const int shift = CountTrailingZeros(unit_size, kXRegSize) - kSmiShift;
+  const int shift = CountTrailingZeros(unit_size, kXRegSizeInBits) - kSmiShift;
   const Operand size(count_smi,
                      (shift >= 0) ? (LSL) : (LSR),
                      (shift >= 0) ? (shift) : (-shift));
 
   if (size.IsZero()) {
     return;
   }
 
   if (!csp.Is(StackPointer())) {
     BumpSystemStackPointer(size);
@@ skipping 23 matching lines @@
 }
 
 
 void MacroAssembler::Drop(const Register& count, uint64_t unit_size) {
   ASSERT(IsPowerOf2(unit_size));
 
   if (unit_size == 0) {
     return;
   }
 
-  const int shift = CountTrailingZeros(unit_size, kXRegSize);
+  const int shift = CountTrailingZeros(unit_size, kXRegSizeInBits);
   const Operand size(count, LSL, shift);
 
   if (size.IsZero()) {
     return;
   }
 
   Add(StackPointer(), StackPointer(), size);
 
   if (!csp.Is(StackPointer()) && emit_debug_code()) {
     // It is safe to leave csp where it is when unwinding the JavaScript stack,
     // but if we keep it matching StackPointer, the simulator can detect memory
     // accesses in the now-free part of the stack.
     Mov(csp, StackPointer());
   }
 }
 
 
 void MacroAssembler::DropBySMI(const Register& count_smi, uint64_t unit_size) {
   ASSERT(IsPowerOf2(unit_size));
-  const int shift = CountTrailingZeros(unit_size, kXRegSize) - kSmiShift;
+  const int shift = CountTrailingZeros(unit_size, kXRegSizeInBits) - kSmiShift;
   const Operand size(count_smi,
                      (shift >= 0) ? (LSL) : (LSR),
                      (shift >= 0) ? (shift) : (-shift));
 
   if (size.IsZero()) {
     return;
   }
 
   Add(StackPointer(), StackPointer(), size);
 
@@ skipping 78 matching lines @@
   // characters are reserved for controlling features of the instrumentation.
   ASSERT(isprint(marker_name[0]) && isprint(marker_name[1]));
 
   InstructionAccurateScope scope(this, 1);
   movn(xzr, (marker_name[1] << 8) | marker_name[0]);
 }
 
 } }  // namespace v8::internal
 
 #endif  // V8_A64_MACRO_ASSEMBLER_A64_INL_H_