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

src/a64/builtins-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 164 matching lines @@
     __ LoadGlobalFunction(Context::STRING_FUNCTION_INDEX, x10);
     __ Cmp(function, x10);
     __ Assert(eq, kUnexpectedStringFunction);
   }
 
   // Load the first arguments in x0 and get rid of the rest.
   Label no_arguments;
   __ Cbz(argc, &no_arguments);
   // First args = sp[(argc - 1) * 8].
   __ Sub(argc, argc, 1);
-  __ Claim(argc, kXRegSizeInBytes);
+  __ Claim(argc, kXRegSize);
   // jssp now point to args[0], load and drop args[0] + receiver.
   Register arg = argc;
   __ Ldr(arg, MemOperand(jssp, 2 * kPointerSize, PostIndex));
   argc = NoReg;
 
   Register argument = x2;
   Label not_cached, argument_is_string;
   __ LookupNumberStringCache(arg,        // Input.
                              argument,   // Result.
                              x10,        // Scratch.
@@ skipping 329 matching lines @@
     // x4: JSObject
     __ Bind(&allocated);
     __ Push(x4, x4);
 
     // Reload the number of arguments from the stack.
     // Set it up in x0 for the function call below.
     // jssp[0]: receiver
     // jssp[1]: receiver
     // jssp[2]: constructor function
     // jssp[3]: number of arguments (smi-tagged)
-    __ Peek(constructor, 2 * kXRegSizeInBytes);  // Load constructor.
-    __ Peek(argc, 3 * kXRegSizeInBytes);  // Load number of arguments.
+    __ Peek(constructor, 2 * kXRegSize);  // Load constructor.
+    __ Peek(argc, 3 * kXRegSize);  // Load number of arguments.
     __ SmiUntag(argc);
 
     // Set up pointer to last argument.
     __ Add(x2, fp, StandardFrameConstants::kCallerSPOffset);
 
     // Copy arguments and receiver to the expression stack.
     // Copy 2 values every loop to use ldp/stp.
     // x0: number of arguments
     // x1: constructor function
     // x2: address of last argument (caller sp)
@@ skipping 63 matching lines @@
     __ Bind(&use_receiver);
     __ Peek(x0, 0);
 
     // Remove the receiver from the stack, remove caller arguments, and
     // return.
     __ Bind(&exit);
     // x0: result
     // jssp[0]: receiver (newly allocated object)
     // jssp[1]: constructor function
     // jssp[2]: number of arguments (smi-tagged)
-    __ Peek(x1, 2 * kXRegSizeInBytes);
+    __ Peek(x1, 2 * kXRegSize);
 
     // Leave construct frame.
   }
 
   __ DropBySMI(x1);
   __ Drop(1);
   __ IncrementCounter(isolate->counters()->constructed_objects(), 1, x1, x2);
   __ Ret();
 }
 
@@ skipping 379 matching lines @@
     __ Cbnz(argc, &done);
     __ LoadRoot(scratch1, Heap::kUndefinedValueRootIndex);
     __ Push(scratch1);
     __ Mov(argc, 1);
     __ Bind(&done);
   }
 
   // 2. Get the function to call (passed as receiver) from the stack, check
   //    if it is a function.
   Label slow, non_function;
-  __ Peek(function, Operand(argc, LSL, kXRegSizeInBytesLog2));
+  __ Peek(function, Operand(argc, LSL, kXRegSizeLog2));
   __ JumpIfSmi(function, &non_function);
   __ JumpIfNotObjectType(function, scratch1, receiver_type,
                          JS_FUNCTION_TYPE, &slow);
 
   // 3a. Patch the first argument if necessary when calling a function.
   Label shift_arguments;
   __ Mov(call_type, static_cast<int>(call_type_JS_func));
   { Label convert_to_object, use_global_receiver, patch_receiver;
     // Change context eagerly in case we need the global receiver.
     __ Ldr(cp, FieldMemOperand(function, JSFunction::kContextOffset));
 
     // Do not transform the receiver for strict mode functions.
     // Also do not transform the receiver for native (Compilerhints already in
     // x3).
     __ Ldr(scratch1,
            FieldMemOperand(function, JSFunction::kSharedFunctionInfoOffset));
     __ Ldr(scratch2.W(),
            FieldMemOperand(scratch1, SharedFunctionInfo::kCompilerHintsOffset));
     __ TestAndBranchIfAnySet(
         scratch2.W(),
         (1 << SharedFunctionInfo::kStrictModeFunction) |
         (1 << SharedFunctionInfo::kNative),
         &shift_arguments);
 
     // Compute the receiver in non-strict mode.
     Register receiver = x2;
     __ Sub(scratch1, argc, 1);
-    __ Peek(receiver, Operand(scratch1, LSL, kXRegSizeInBytesLog2));
+    __ Peek(receiver, Operand(scratch1, LSL, kXRegSizeLog2));
     __ JumpIfSmi(receiver, &convert_to_object);
 
     __ JumpIfRoot(receiver, Heap::kUndefinedValueRootIndex,
                   &use_global_receiver);
     __ JumpIfRoot(receiver, Heap::kNullValueRootIndex, &use_global_receiver);
 
     STATIC_ASSERT(LAST_SPEC_OBJECT_TYPE == LAST_TYPE);
     __ JumpIfObjectType(receiver, scratch1, scratch2,
                         FIRST_SPEC_OBJECT_TYPE, &shift_arguments, ge);
 
     __ Bind(&convert_to_object);
 
     {
       // Enter an internal frame in order to preserve argument count.
       FrameScope scope(masm, StackFrame::INTERNAL);
       __ SmiTag(argc);
 
       __ Push(argc, receiver);
       __ InvokeBuiltin(Builtins::TO_OBJECT, CALL_FUNCTION);
       __ Mov(receiver, x0);
 
       __ Pop(argc);
       __ SmiUntag(argc);
 
       // Exit the internal frame.
     }
 
     // Restore the function and flag in the registers.
-    __ Peek(function, Operand(argc, LSL, kXRegSizeInBytesLog2));
+    __ Peek(function, Operand(argc, LSL, kXRegSizeLog2));
     __ Mov(call_type, static_cast<int>(call_type_JS_func));
     __ B(&patch_receiver);
 
     __ Bind(&use_global_receiver);
     __ Ldr(receiver, GlobalObjectMemOperand());
     __ Ldr(receiver,
            FieldMemOperand(receiver, GlobalObject::kGlobalReceiverOffset));
 
 
     __ Bind(&patch_receiver);
     __ Sub(scratch1, argc, 1);
-    __ Poke(receiver, Operand(scratch1, LSL, kXRegSizeInBytesLog2));
+    __ Poke(receiver, Operand(scratch1, LSL, kXRegSizeLog2));
 
     __ B(&shift_arguments);
   }
 
   // 3b. Check for function proxy.
   __ Bind(&slow);
   __ Mov(call_type, static_cast<int>(call_type_func_proxy));
   __ Cmp(receiver_type, JS_FUNCTION_PROXY_TYPE);
   __ B(eq, &shift_arguments);
   __ Bind(&non_function);
   __ Mov(call_type, static_cast<int>(call_type_non_func));
 
   // 3c. Patch the first argument when calling a non-function.  The
   //     CALL_NON_FUNCTION builtin expects the non-function callee as
   //     receiver, so overwrite the first argument which will ultimately
   //     become the receiver.
   // call type (0: JS function, 1: function proxy, 2: non-function)
   __ Sub(scratch1, argc, 1);
-  __ Poke(function, Operand(scratch1, LSL, kXRegSizeInBytesLog2));
+  __ Poke(function, Operand(scratch1, LSL, kXRegSizeLog2));
 
   // 4. Shift arguments and return address one slot down on the stack
   //    (overwriting the original receiver).  Adjust argument count to make
   //    the original first argument the new receiver.
   // call type (0: JS function, 1: function proxy, 2: non-function)
   __ Bind(&shift_arguments);
   { Label loop;
     // Calculate the copy start address (destination). Copy end address is jssp.
     __ Add(scratch2, jssp, Operand(argc, LSL, kPointerSizeLog2));
     __ Sub(scratch1, scratch2, kPointerSize);
@@ skipping 225 matching lines @@
 static void LeaveArgumentsAdaptorFrame(MacroAssembler* masm) {
   // ----------- S t a t e -------------
   //  -- x0 : result being passed through
   // -----------------------------------
   // Get the number of arguments passed (as a smi), tear down the frame and
   // then drop the parameters and the receiver.
   __ Ldr(x10, MemOperand(fp, -(StandardFrameConstants::kFixedFrameSizeFromFp +
                                kPointerSize)));
   __ Mov(jssp, fp);
   __ Pop(fp, lr);
-  __ DropBySMI(x10, kXRegSizeInBytes);
+  __ DropBySMI(x10, kXRegSize);
   __ Drop(1);
 }
 
 
 void Builtins::Generate_ArgumentsAdaptorTrampoline(MacroAssembler* masm) {
   ASM_LOCATION("Builtins::Generate_ArgumentsAdaptorTrampoline");
   // ----------- S t a t e -------------
   //  -- x0 : actual number of arguments
   //  -- x1 : function (passed through to callee)
   //  -- x2 : expected number of arguments
@@ skipping 119 matching lines @@
   __ Bind(&dont_adapt_arguments);
   __ Jump(code_entry);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_ARM