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

src/a64/deoptimizer-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 130 matching lines @@
 #define __ masm()->
 
 void Deoptimizer::EntryGenerator::Generate() {
   GeneratePrologue();
 
   // TODO(all): This code needs to be revisited. We probably only need to save
   // caller-saved registers here. Callee-saved registers can be stored directly
   // in the input frame.
 
   // Save all allocatable floating point registers.
-  CPURegList saved_fp_registers(CPURegister::kFPRegister, kDRegSize,
+  CPURegList saved_fp_registers(CPURegister::kFPRegister, kDRegSizeInBits,
                                 0, FPRegister::NumAllocatableRegisters() - 1);
   __ PushCPURegList(saved_fp_registers);
 
   // We save all the registers expcept jssp, sp and lr.
-  CPURegList saved_registers(CPURegister::kRegister, kXRegSize, 0, 27);
+  CPURegList saved_registers(CPURegister::kRegister, kXRegSizeInBits, 0, 27);
   saved_registers.Combine(fp);
   __ PushCPURegList(saved_registers);
 
   const int kSavedRegistersAreaSize =
-      (saved_registers.Count() * kXRegSizeInBytes) +
-      (saved_fp_registers.Count() * kDRegSizeInBytes);
+      (saved_registers.Count() * kXRegSize) +
+      (saved_fp_registers.Count() * kDRegSize);
 
   // Floating point registers are saved on the stack above core registers.
-  const int kFPRegistersOffset = saved_registers.Count() * kXRegSizeInBytes;
+  const int kFPRegistersOffset = saved_registers.Count() * kXRegSize;
 
   // Get the bailout id from the stack.
   Register bailout_id = x2;
   __ Peek(bailout_id, kSavedRegistersAreaSize);
 
   Register code_object = x3;
   Register fp_to_sp = x4;
   // Get the address of the location in the code object. This is the return
   // address for lazy deoptimization.
   __ Mov(code_object, lr);
@@ skipping 38 matching lines @@
   for (int i = 0; i < saved_fp_registers.Count(); i++) {
     // TODO(all): Look for opportunities to optimize this by using ldp/stp.
     int dst_offset = FrameDescription::double_registers_offset() +
         (i * kDoubleSize);
     int src_offset = kFPRegistersOffset + (i * kDoubleSize);
     __ Peek(x2, src_offset);
     __ Str(x2, MemOperand(x1, dst_offset));
   }
 
   // Remove the bailout id and the saved registers from the stack.
-  __ Drop(1 + (kSavedRegistersAreaSize / kXRegSizeInBytes));
+  __ Drop(1 + (kSavedRegistersAreaSize / kXRegSize));
 
   // Compute a pointer to the unwinding limit in register x2; that is
   // the first stack slot not part of the input frame.
   Register unwind_limit = x2;
   __ Ldr(unwind_limit, MemOperand(x1, FrameDescription::frame_size_offset()));
   __ Add(unwind_limit, unwind_limit, __ StackPointer());
 
   // Unwind the stack down to - but not including - the unwinding
   // limit and copy the contents of the activation frame to the input
   // frame description.
@@ skipping 138 matching lines @@
 
 
 void FrameDescription::SetCallerFp(unsigned offset, intptr_t value) {
   SetFrameSlot(offset, value);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal