[cleanup][x64] Final set of x64-specific kPointerSize fixes

Bug: v8:8477, v8:8562
Change-Id: I28a8244ef22035db85b520d86aa6d5578c7c7f5d
Reviewed-on: https://chromium-review.googlesource.com/c/1384309
Commit-Queue: Igor Sheludko <ishell@chromium.org>
Reviewed-by: Toon Verwaest <verwaest@chromium.org>
Reviewed-by: Jakob Gruber <jgruber@chromium.org>
Cr-Commit-Position: refs/heads/master@{#58426}

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

@@ -729,7 +729,7 @@ Handle<HeapObject> RegExpMacroAssemblerX64::GetCode(Handle<String> source) {
   __ j(below_equal, &stack_limit_hit);
   // Check if there is room for the variable number of registers above
   // the stack limit.
-  __ cmpp(rcx, Immediate(num_registers_ * kPointerSize));
+  __ cmpp(rcx, Immediate(num_registers_ * kSystemPointerSize));
   __ j(above_equal, &stack_ok);
   // Exit with OutOfMemory exception. There is not enough space on the stack
   // for our working registers.
@@ -746,7 +746,7 @@ Handle<HeapObject> RegExpMacroAssemblerX64::GetCode(Handle<String> source) {
   __ bind(&stack_ok);
 
   // Allocate space on stack for registers.
-  __ subp(rsp, Immediate(num_registers_ * kPointerSize));
+  __ subp(rsp, Immediate(num_registers_ * kSystemPointerSize));
   // Load string length.
   __ movp(rsi, Operand(rbp, kInputEnd));
   // Load input position.
@@ -770,7 +770,7 @@ Handle<HeapObject> RegExpMacroAssemblerX64::GetCode(Handle<String> source) {
   // Ensure that we have written to each stack page, in order. Skipping a page
   // on Windows can cause segmentation faults. Assuming page size is 4k.
   const int kPageSize = 4096;
-  const int kRegistersPerPage = kPageSize / kPointerSize;
+  const int kRegistersPerPage = kPageSize / kSystemPointerSize;
   for (int i = num_saved_registers_ + kRegistersPerPage - 1;
       i < num_registers_;
       i += kRegistersPerPage) {
@@ -804,9 +804,9 @@ Handle<HeapObject> RegExpMacroAssemblerX64::GetCode(Handle<String> source) {
       Label init_loop;
       __ bind(&init_loop);
       __ movp(Operand(rbp, rcx, times_1, 0), rax);
-      __ subq(rcx, Immediate(kPointerSize));
-      __ cmpq(rcx,
-              Immediate(kRegisterZero - num_saved_registers_ * kPointerSize));
+      __ subq(rcx, Immediate(kSystemPointerSize));
+      __ cmpq(rcx, Immediate(kRegisterZero -
+                             num_saved_registers_ * kSystemPointerSize));
       __ j(greater, &init_loop);
     } else {  // Unroll the loop.
       for (int i = 0; i < num_saved_registers_; i++) {
@@ -1093,12 +1093,11 @@ void RegExpMacroAssemblerX64::PushRegister(int register_index,
   if (check_stack_limit) CheckStackLimit();
 }
 
-
-STATIC_ASSERT(kPointerSize == kInt64Size || kPointerSize == kInt32Size);
-
+STATIC_ASSERT(kSystemPointerSize == kInt64Size ||
+              kSystemPointerSize == kInt32Size);
 
 void RegExpMacroAssemblerX64::ReadCurrentPositionFromRegister(int reg) {
-  if (kPointerSize == kInt64Size) {
+  if (kSystemPointerSize == kInt64Size) {
     __ movq(rdi, register_location(reg));
   } else {
     // Need sign extension for x32 as rdi might be used as an index register.
@@ -1108,7 +1107,7 @@ void RegExpMacroAssemblerX64::ReadCurrentPositionFromRegister(int reg) {
 
 
 void RegExpMacroAssemblerX64::ReadPositionFromRegister(Register dst, int reg) {
-  if (kPointerSize == kInt64Size) {
+  if (kSystemPointerSize == kInt64Size) {
     __ movq(dst, register_location(reg));
   } else {
     // Need sign extension for x32 as dst might be used as an index register.
@@ -1189,7 +1188,7 @@ void RegExpMacroAssemblerX64::CallCheckStackGuardState() {
   __ movp(r8, rbp);
   // First argument: Next address on the stack (will be address of
   // return address).
-  __ leap(rcx, Operand(rsp, -kPointerSize));
+  __ leap(rcx, Operand(rsp, -kSystemPointerSize));
 #else
   // Third argument: RegExp code frame pointer.
   __ movp(rdx, rbp);
@@ -1236,7 +1235,7 @@ Operand RegExpMacroAssemblerX64::register_location(int register_index) {
   if (num_registers_ <= register_index) {
     num_registers_ = register_index + 1;
   }
-  return Operand(rbp, kRegisterZero - register_index * kPointerSize);
+  return Operand(rbp, kRegisterZero - register_index * kSystemPointerSize);
 }
 
 

src/regexp/x64/regexp-macro-assembler-x64.h

@@ -147,13 +147,15 @@ class RegExpMacroAssemblerX64: public NativeRegExpMacroAssembler {
   static const int kLastCalleeSaveRegister = kBackup_rbx;
 #endif
 
-  static const int kSuccessfulCaptures = kLastCalleeSaveRegister - kPointerSize;
+  static const int kSuccessfulCaptures =
+      kLastCalleeSaveRegister - kSystemPointerSize;
   // When adding local variables remember to push space for them in
   // the frame in GetCode.
-  static const int kStringStartMinusOne = kSuccessfulCaptures - kPointerSize;
+  static const int kStringStartMinusOne =
+      kSuccessfulCaptures - kSystemPointerSize;
 
   // First register address. Following registers are below it on the stack.
-  static const int kRegisterZero = kStringStartMinusOne - kPointerSize;
+  static const int kRegisterZero = kStringStartMinusOne - kSystemPointerSize;
 
   // Initial size of code buffer.
   static const size_t kRegExpCodeSize = 1024;

src/s390/assembler-s390.h

@@ -325,16 +325,6 @@ class V8_EXPORT_PRIVATE Assembler : public AssemblerBase {
   // Patch will be appiled to other FIXED_SEQUENCE call
   static constexpr int kCallTargetAddressOffset = 6;
 
-// The length of FIXED_SEQUENCE call
-// iihf    r8, <address_hi>  // <64-bit only>
-// iilf    r8, <address_lo>
-// basr    r14, r8
-#if V8_TARGET_ARCH_S390X
-  static constexpr int kCallSequenceLength = 14;
-#else
-  static constexpr int kCallSequenceLength = 8;
-#endif
-
   // ---------------------------------------------------------------------------
   // Code generation
 

src/x64/assembler-x64-inl.h

@@ -311,7 +311,7 @@ int RelocInfo::target_address_size() {
   if (IsCodedSpecially()) {
     return Assembler::kSpecialTargetSize;
   } else {
-    return kPointerSize;
+    return kSystemPointerSize;
   }
 }
 

src/x64/assembler-x64.cc

@@ -1656,12 +1656,12 @@ void Assembler::emit_lea(Register dst, Operand src, int size) {
 
 void Assembler::load_rax(Address value, RelocInfo::Mode mode) {
   EnsureSpace ensure_space(this);
-  if (kPointerSize == kInt64Size) {
+  if (kSystemPointerSize == kInt64Size) {
     emit(0x48);  // REX.W
     emit(0xA1);
     emitp(value, mode);
   } else {
-    DCHECK_EQ(kPointerSize, kInt32Size);
+    DCHECK_EQ(kSystemPointerSize, kInt32Size);
     emit(0xA1);
     emitp(value, mode);
     // In 64-bit mode, need to zero extend the operand to 8 bytes.
@@ -1805,11 +1805,11 @@ void Assembler::movp(Register dst, Address value, RelocInfo::Mode rmode) {
   if (constpool_.TryRecordEntry(value, rmode)) {
     // Emit rip-relative move with offset = 0
     Label label;
-    emit_mov(dst, Operand(&label, 0), kPointerSize);
+    emit_mov(dst, Operand(&label, 0), kSystemPointerSize);
     bind(&label);
   } else {
     EnsureSpace ensure_space(this);
-    emit_rex(dst, kPointerSize);
+    emit_rex(dst, kSystemPointerSize);
     emit(0xB8 | dst.low_bits());
     emitp(value, rmode);
   }
@@ -1817,7 +1817,7 @@ void Assembler::movp(Register dst, Address value, RelocInfo::Mode rmode) {
 
 void Assembler::movp_heap_number(Register dst, double value) {
   EnsureSpace ensure_space(this);
-  emit_rex(dst, kPointerSize);
+  emit_rex(dst, kSystemPointerSize);
   emit(0xB8 | dst.low_bits());
   RequestHeapObject(HeapObjectRequest(value));
   emitp(0, RelocInfo::EMBEDDED_OBJECT);
@@ -1825,7 +1825,7 @@ void Assembler::movp_heap_number(Register dst, double value) {
 
 void Assembler::movp_string(Register dst, const StringConstantBase* str) {
   EnsureSpace ensure_space(this);
-  emit_rex(dst, kPointerSize);
+  emit_rex(dst, kSystemPointerSize);
   emit(0xB8 | dst.low_bits());
   RequestHeapObject(HeapObjectRequest(str));
   emitp(0, RelocInfo::EMBEDDED_OBJECT);
@@ -1835,7 +1835,7 @@ void Assembler::movq(Register dst, int64_t value, RelocInfo::Mode rmode) {
   if (constpool_.TryRecordEntry(value, rmode)) {
     // Emit rip-relative move with offset = 0
     Label label;
-    emit_mov(dst, Operand(&label, 0), kPointerSize);
+    emit_mov(dst, Operand(&label, 0), kInt64Size);
     bind(&label);
   } else {
     EnsureSpace ensure_space(this);
@@ -2329,12 +2329,12 @@ void Assembler::emit_xchg(Register dst, Operand src, int size) {
 
 void Assembler::store_rax(Address dst, RelocInfo::Mode mode) {
   EnsureSpace ensure_space(this);
-  if (kPointerSize == kInt64Size) {
+  if (kSystemPointerSize == kInt64Size) {
     emit(0x48);  // REX.W
     emit(0xA3);
     emitp(dst, mode);
   } else {
-    DCHECK_EQ(kPointerSize, kInt32Size);
+    DCHECK_EQ(kSystemPointerSize, kInt32Size);
     emit(0xA3);
     emitp(dst, mode);
     // In 64-bit mode, need to zero extend the operand to 8 bytes.

src/x64/assembler-x64.h

@@ -192,7 +192,7 @@ class V8_EXPORT_PRIVATE Operand {
   const Data data_;
 };
 ASSERT_TRIVIALLY_COPYABLE(Operand);
-static_assert(sizeof(Operand) <= 2 * kPointerSize,
+static_assert(sizeof(Operand) <= 2 * kSystemPointerSize,
               "Operand must be small enough to pass it by value");
 
 #define ASSEMBLER_INSTRUCTION_LIST(V) \
@@ -219,8 +219,8 @@ static_assert(sizeof(Operand) <= 2 * kPointerSize,
   V(xchg)                             \
   V(xor)
 
-// Shift instructions on operands/registers with kPointerSize, kInt32Size and
-// kInt64Size.
+// Shift instructions on operands/registers with kSystemPointerSize, kInt32Size
+// and kInt64Size.
 #define SHIFT_INSTRUCTION_LIST(V) \
   V(rol, 0x0)                     \
   V(ror, 0x1)                     \
@@ -366,15 +366,6 @@ class V8_EXPORT_PRIVATE Assembler : public AssemblerBase {
   // Distance between the address of the code target in the call instruction
   // and the return address pushed on the stack.
   static constexpr int kCallTargetAddressOffset = 4;  // 32-bit displacement.
-  // The length of call(kScratchRegister).
-  static constexpr int kCallScratchRegisterInstructionLength = 3;
-  // The length of movq(kScratchRegister, address).
-  static constexpr int kMoveAddressIntoScratchRegisterInstructionLength =
-      2 + kPointerSize;
-  // The length of movq(kScratchRegister, address) and call(kScratchRegister).
-  static constexpr int kCallSequenceLength =
-      kMoveAddressIntoScratchRegisterInstructionLength +
-      kCallScratchRegisterInstructionLength;
 
   // One byte opcode for test eax,0xXXXXXXXX.
   static constexpr byte kTestEaxByte = 0xA9;
@@ -566,7 +557,7 @@ class V8_EXPORT_PRIVATE Assembler : public AssemblerBase {
 
   void repmovsb();
   void repmovsw();
-  void repmovsp() { emit_repmovs(kPointerSize); }
+  void repmovsp() { emit_repmovs(kSystemPointerSize); }
   void repmovsl() { emit_repmovs(kInt32Size); }
   void repmovsq() { emit_repmovs(kInt64Size); }
 
@@ -645,41 +636,45 @@ class V8_EXPORT_PRIVATE Assembler : public AssemblerBase {
   // Multiply rax by src, put the result in rdx:rax.
   void mulq(Register src);
 
-#define DECLARE_SHIFT_INSTRUCTION(instruction, subcode)                       \
-  void instruction##p(Register dst, Immediate imm8) {                         \
-    shift(dst, imm8, subcode, kPointerSize);                                  \
-  }                                                                           \
-                                                                              \
-  void instruction##l(Register dst, Immediate imm8) {                         \
-    shift(dst, imm8, subcode, kInt32Size);                                    \
-  }                                                                           \
-                                                                              \
-  void instruction##q(Register dst, Immediate imm8) {                         \
-    shift(dst, imm8, subcode, kInt64Size);                                    \
-  }                                                                           \
-                                                                              \
-  void instruction##p(Operand dst, Immediate imm8) {                          \
-    shift(dst, imm8, subcode, kPointerSize);                                  \
-  }                                                                           \
-                                                                              \
-  void instruction##l(Operand dst, Immediate imm8) {                          \
-    shift(dst, imm8, subcode, kInt32Size);                                    \
-  }                                                                           \
-                                                                              \
-  void instruction##q(Operand dst, Immediate imm8) {                          \
-    shift(dst, imm8, subcode, kInt64Size);                                    \
-  }                                                                           \
-                                                                              \
-  void instruction##p_cl(Register dst) { shift(dst, subcode, kPointerSize); } \
-                                                                              \
-  void instruction##l_cl(Register dst) { shift(dst, subcode, kInt32Size); }   \
-                                                                              \
-  void instruction##q_cl(Register dst) { shift(dst, subcode, kInt64Size); }   \
-                                                                              \
-  void instruction##p_cl(Operand dst) { shift(dst, subcode, kPointerSize); }  \
-                                                                              \
-  void instruction##l_cl(Operand dst) { shift(dst, subcode, kInt32Size); }    \
-                                                                              \
+#define DECLARE_SHIFT_INSTRUCTION(instruction, subcode)                     \
+  void instruction##p(Register dst, Immediate imm8) {                       \
+    shift(dst, imm8, subcode, kSystemPointerSize);                          \
+  }                                                                         \
+                                                                            \
+  void instruction##l(Register dst, Immediate imm8) {                       \
+    shift(dst, imm8, subcode, kInt32Size);                                  \
+  }                                                                         \
+                                                                            \
+  void instruction##q(Register dst, Immediate imm8) {                       \
+    shift(dst, imm8, subcode, kInt64Size);                                  \
+  }                                                                         \
+                                                                            \
+  void instruction##p(Operand dst, Immediate imm8) {                        \
+    shift(dst, imm8, subcode, kSystemPointerSize);                          \
+  }                                                                         \
+                                                                            \
+  void instruction##l(Operand dst, Immediate imm8) {                        \
+    shift(dst, imm8, subcode, kInt32Size);                                  \
+  }                                                                         \
+                                                                            \
+  void instruction##q(Operand dst, Immediate imm8) {                        \
+    shift(dst, imm8, subcode, kInt64Size);                                  \
+  }                                                                         \
+                                                                            \
+  void instruction##p_cl(Register dst) {                                    \
+    shift(dst, subcode, kSystemPointerSize);                                \
+  }                                                                         \
+                                                                            \
+  void instruction##l_cl(Register dst) { shift(dst, subcode, kInt32Size); } \
+                                                                            \
+  void instruction##q_cl(Register dst) { shift(dst, subcode, kInt64Size); } \
+                                                                            \
+  void instruction##p_cl(Operand dst) {                                     \
+    shift(dst, subcode, kSystemPointerSize);                                \
+  }                                                                         \
+                                                                            \
+  void instruction##l_cl(Operand dst) { shift(dst, subcode, kInt32Size); }  \
+                                                                            \
   void instruction##q_cl(Operand dst) { shift(dst, subcode, kInt64Size); }
   SHIFT_INSTRUCTION_LIST(DECLARE_SHIFT_INSTRUCTION)
 #undef DECLARE_SHIFT_INSTRUCTION

src/x64/deoptimizer-x64.cc

@@ -124,7 +124,7 @@ void Deoptimizer::TableEntryGenerator::Generate() {
 
   // Fill in the input registers.
   for (int i = kNumberOfRegisters -1; i >= 0; i--) {
-    int offset = (i * kPointerSize) + FrameDescription::registers_offset();
+    int offset = (i * kRegisterSize) + FrameDescription::registers_offset();
     __ PopQuad(Operand(rbx, offset));
   }
 
@@ -200,7 +200,7 @@ void Deoptimizer::TableEntryGenerator::Generate() {
   __ bind(&inner_loop_header);
   __ testp(rcx, rcx);
   __ j(not_zero, &inner_push_loop);
-  __ addp(rax, Immediate(kPointerSize));
+  __ addp(rax, Immediate(kSystemPointerSize));
   __ bind(&outer_loop_header);
   __ cmpp(rax, rdx);
   __ j(below, &outer_push_loop);
@@ -218,7 +218,7 @@ void Deoptimizer::TableEntryGenerator::Generate() {
 
   // Push the registers from the last output frame.
   for (int i = 0; i < kNumberOfRegisters; i++) {
-    int offset = (i * kPointerSize) + FrameDescription::registers_offset();
+    int offset = (i * kRegisterSize) + FrameDescription::registers_offset();
     __ PushQuad(Operand(rbx, offset));
   }
 
@@ -254,18 +254,18 @@ void Deoptimizer::TableEntryGenerator::GeneratePrologue() {
 bool Deoptimizer::PadTopOfStackRegister() { return false; }
 
 void FrameDescription::SetCallerPc(unsigned offset, intptr_t value) {
-  if (kPCOnStackSize == 2 * kPointerSize) {
+  if (kPCOnStackSize == 2 * kSystemPointerSize) {
     // Zero out the high-32 bit of PC for x32 port.
-    SetFrameSlot(offset + kPointerSize, 0);
+    SetFrameSlot(offset + kSystemPointerSize, 0);
   }
   SetFrameSlot(offset, value);
 }
 
 
 void FrameDescription::SetCallerFp(unsigned offset, intptr_t value) {
-  if (kFPOnStackSize == 2 * kPointerSize) {
+  if (kFPOnStackSize == 2 * kSystemPointerSize) {
     // Zero out the high-32 bit of FP for x32 port.
-    SetFrameSlot(offset + kPointerSize, 0);
+    SetFrameSlot(offset + kSystemPointerSize, 0);
   }
   SetFrameSlot(offset, value);
 }

src/x64/eh-frame-x64.cc

@@ -21,9 +21,9 @@ void EhFrameWriter::WriteReturnAddressRegisterCode() {
 }
 
 void EhFrameWriter::WriteInitialStateInCie() {
-  SetBaseAddressRegisterAndOffset(rsp, kPointerSize);
+  SetBaseAddressRegisterAndOffset(rsp, kSystemPointerSize);
   // x64 rip (r16) has no Register instance associated.
-  RecordRegisterSavedToStack(kRipDwarfCode, -kPointerSize);
+  RecordRegisterSavedToStack(kRipDwarfCode, -kSystemPointerSize);
 }
 
 // static

src/x64/frame-constants-x64.h

@@ -25,17 +25,18 @@ class EntryFrameConstants : public AllStatic {
   // pushing the c_entry_fp, plus we manually allocate kXMMRegistersBlockSize
   // bytes on the stack.
   static constexpr int kCallerFPOffset =
-      -3 * kPointerSize + -7 * kRegisterSize - kXMMRegistersBlockSize;
+      -3 * kSystemPointerSize + -7 * kRegisterSize - kXMMRegistersBlockSize;
 
   // Stack offsets for arguments passed to JSEntry.
-  static constexpr int kArgvOffset = 6 * kPointerSize;
-  static constexpr int kRootRegisterValueOffset = 7 * kPointerSize;
+  static constexpr int kArgvOffset = 6 * kSystemPointerSize;
+  static constexpr int kRootRegisterValueOffset = 7 * kSystemPointerSize;
 #else
   // This is the offset to where JSEntry pushes the current value of
   // Isolate::c_entry_fp onto the stack.
   // On x64, there are 5 pushq() and 3 Push() calls between setting up rbp and
   // pushing the c_entry_fp.
-  static constexpr int kCallerFPOffset = -3 * kPointerSize + -5 * kRegisterSize;
+  static constexpr int kCallerFPOffset =
+      -3 * kSystemPointerSize + -5 * kRegisterSize;
 #endif
 };
 
@@ -45,7 +46,7 @@ class ExitFrameConstants : public TypedFrameConstants {
   static constexpr int kCodeOffset = TYPED_FRAME_PUSHED_VALUE_OFFSET(1);
   DEFINE_TYPED_FRAME_SIZES(2);
 
-  static constexpr int kCallerFPOffset = +0 * kPointerSize;
+  static constexpr int kCallerFPOffset = +0 * kSystemPointerSize;
   static constexpr int kCallerPCOffset = kFPOnStackSize;
 
   // FP-relative displacement of the caller's SP.  It points just
@@ -64,7 +65,7 @@ class WasmCompileLazyFrameConstants : public TypedFrameConstants {
   static constexpr int kWasmInstanceOffset = TYPED_FRAME_PUSHED_VALUE_OFFSET(0);
   static constexpr int kFixedFrameSizeFromFp =
       TypedFrameConstants::kFixedFrameSizeFromFp +
-      kNumberOfSavedGpParamRegs * kPointerSize +
+      kNumberOfSavedGpParamRegs * kSystemPointerSize +
       kNumberOfSavedFpParamRegs * kSimd128Size;
 };
 
@@ -78,8 +79,8 @@ class JavaScriptFrameConstants : public AllStatic {
       StandardFrameConstants::kFunctionOffset;
 
   // Caller SP-relative.
-  static constexpr int kParam0Offset = -2 * kPointerSize;
-  static constexpr int kReceiverOffset = -1 * kPointerSize;
+  static constexpr int kParam0Offset = -2 * kSystemPointerSize;
+  static constexpr int kReceiverOffset = -1 * kSystemPointerSize;
 };
 
 }  // namespace internal

src/x64/macro-assembler-x64.cc

@@ -41,18 +41,19 @@ Operand StackArgumentsAccessor::GetArgumentOperand(int index) {
   displacement_to_last_argument += extra_displacement_to_last_argument_;
   if (argument_count_reg_ == no_reg) {
     // argument[0] is at base_reg_ + displacement_to_last_argument +
-    // (argument_count_immediate_ + receiver - 1) * kPointerSize.
+    // (argument_count_immediate_ + receiver - 1) * kSystemPointerSize.
     DCHECK_GT(argument_count_immediate_ + receiver, 0);
-    return Operand(
-        base_reg_,
-        displacement_to_last_argument +
-            (argument_count_immediate_ + receiver - 1 - index) * kPointerSize);
+    return Operand(base_reg_,
+                   displacement_to_last_argument +
+                       (argument_count_immediate_ + receiver - 1 - index) *
+                           kSystemPointerSize);
   } else {
     // argument[0] is at base_reg_ + displacement_to_last_argument +
-    // argument_count_reg_ * times_pointer_size + (receiver - 1) * kPointerSize.
-    return Operand(
-        base_reg_, argument_count_reg_, times_pointer_size,
-        displacement_to_last_argument + (receiver - 1 - index) * kPointerSize);
+    // argument_count_reg_ * times_pointer_size + (receiver - 1) *
+    // kSystemPointerSize.
+    return Operand(base_reg_, argument_count_reg_, times_pointer_size,
+                   displacement_to_last_argument +
+                       (receiver - 1 - index) * kSystemPointerSize);
   }
 }
 
@@ -377,13 +378,13 @@ void MacroAssembler::RecordWriteField(Register object, int offset,
   }
 
   // Although the object register is tagged, the offset is relative to the start
-  // of the object, so so offset must be a multiple of kPointerSize.
-  DCHECK(IsAligned(offset, kPointerSize));
+  // of the object, so the offset must be a multiple of kTaggedSize.
+  DCHECK(IsAligned(offset, kTaggedSize));
 
   leap(dst, FieldOperand(object, offset));
   if (emit_debug_code()) {
     Label ok;
-    testb(dst, Immediate(kPointerSize - 1));
+    testb(dst, Immediate(kTaggedSize - 1));
     j(zero, &ok, Label::kNear);
     int3();
     bind(&ok);
@@ -572,7 +573,7 @@ void TurboAssembler::Check(Condition cc, AbortReason reason) {
 void TurboAssembler::CheckStackAlignment() {
   int frame_alignment = base::OS::ActivationFrameAlignment();
   int frame_alignment_mask = frame_alignment - 1;
-  if (frame_alignment > kPointerSize) {
+  if (frame_alignment > kSystemPointerSize) {
     DCHECK(base::bits::IsPowerOfTwo(frame_alignment));
     Label alignment_as_expected;
     testp(rsp, Immediate(frame_alignment_mask));
@@ -694,7 +695,7 @@ int TurboAssembler::RequiredStackSizeForCallerSaved(SaveFPRegsMode fp_mode,
   for (int i = 0; i < kNumberOfSavedRegs; i++) {
     Register reg = saved_regs[i];
     if (reg != exclusion1 && reg != exclusion2 && reg != exclusion3) {
-      bytes += kPointerSize;
+      bytes += kSystemPointerSize;
     }
   }
 
@@ -716,7 +717,7 @@ int TurboAssembler::PushCallerSaved(SaveFPRegsMode fp_mode, Register exclusion1,
     Register reg = saved_regs[i];
     if (reg != exclusion1 && reg != exclusion2 && reg != exclusion3) {
       pushq(reg);
-      bytes += kPointerSize;
+      bytes += kSystemPointerSize;
     }
   }
 
@@ -751,7 +752,7 @@ int TurboAssembler::PopCallerSaved(SaveFPRegsMode fp_mode, Register exclusion1,
     Register reg = saved_regs[i];
     if (reg != exclusion1 && reg != exclusion2 && reg != exclusion3) {
       popq(reg);
-      bytes += kPointerSize;
+      bytes += kSystemPointerSize;
     }
   }
 
@@ -1130,7 +1131,7 @@ void TurboAssembler::Set(Register dst, int64_t x) {
 }
 
 void TurboAssembler::Set(Operand dst, intptr_t x) {
-  if (kPointerSize == kInt64Size) {
+  if (kSystemPointerSize == kInt64Size) {
     if (is_int32(x)) {
       movp(dst, Immediate(static_cast<int32_t>(x)));
     } else {
@@ -1296,7 +1297,7 @@ void MacroAssembler::SmiAddConstant(Operand dst, Smi constant) {
            Immediate(constant->value()));
     } else {
       DCHECK(SmiValuesAre31Bits());
-      if (kPointerSize == kInt64Size) {
+      if (kSystemPointerSize == kInt64Size) {
         // Sign-extend value after addition
         movl(kScratchRegister, dst);
         addl(kScratchRegister, Immediate(constant));
@@ -1354,7 +1355,7 @@ void TurboAssembler::Push(Smi source) {
   }
   int first_byte_set = base::bits::CountTrailingZeros64(smi) / 8;
   int last_byte_set = (63 - base::bits::CountLeadingZeros64(smi)) / 8;
-  if (first_byte_set == last_byte_set && kPointerSize == kInt64Size) {
+  if (first_byte_set == last_byte_set && kSystemPointerSize == kInt64Size) {
     // This sequence has only 7 bytes, compared to the 12 bytes below.
     Push(Immediate(0));
     movb(Operand(rsp, first_byte_set),
@@ -1498,7 +1499,7 @@ void TurboAssembler::MoveStringConstant(Register result,
 
 void MacroAssembler::Drop(int stack_elements) {
   if (stack_elements > 0) {
-    addp(rsp, Immediate(stack_elements * kPointerSize));
+    addp(rsp, Immediate(stack_elements * kSystemPointerSize));
   }
 }
 
@@ -1506,7 +1507,7 @@ void MacroAssembler::Drop(int stack_elements) {
 void MacroAssembler::DropUnderReturnAddress(int stack_elements,
                                             Register scratch) {
   DCHECK_GT(stack_elements, 0);
-  if (kPointerSize == kInt64Size && stack_elements == 1) {
+  if (kSystemPointerSize == kInt64Size && stack_elements == 1) {
     popq(MemOperand(rsp, 0));
     return;
   }
@@ -1517,7 +1518,7 @@ void MacroAssembler::DropUnderReturnAddress(int stack_elements,
 }
 
 void TurboAssembler::Push(Register src) {
-  if (kPointerSize == kInt64Size) {
+  if (kSystemPointerSize == kInt64Size) {
     pushq(src);
   } else {
     // x32 uses 64-bit push for rbp in the prologue.
@@ -1528,7 +1529,7 @@ void TurboAssembler::Push(Register src) {
 }
 
 void TurboAssembler::Push(Operand src) {
-  if (kPointerSize == kInt64Size) {
+  if (kSystemPointerSize == kInt64Size) {
     pushq(src);
   } else {
     movp(kScratchRegister, src);
@@ -1538,7 +1539,7 @@ void TurboAssembler::Push(Operand src) {
 }
 
 void MacroAssembler::PushQuad(Operand src) {
-  if (kPointerSize == kInt64Size) {
+  if (kSystemPointerSize == kInt64Size) {
     pushq(src);
   } else {
     movp(kScratchRegister, src);
@@ -1547,7 +1548,7 @@ void MacroAssembler::PushQuad(Operand src) {
 }
 
 void TurboAssembler::Push(Immediate value) {
-  if (kPointerSize == kInt64Size) {
+  if (kSystemPointerSize == kInt64Size) {
     pushq(value);
   } else {
     leal(rsp, Operand(rsp, -4));
@@ -1557,7 +1558,7 @@ void TurboAssembler::Push(Immediate value) {
 
 
 void MacroAssembler::PushImm32(int32_t imm32) {
-  if (kPointerSize == kInt64Size) {
+  if (kSystemPointerSize == kInt64Size) {
     pushq_imm32(imm32);
   } else {
     leal(rsp, Operand(rsp, -4));
@@ -1567,7 +1568,7 @@ void MacroAssembler::PushImm32(int32_t imm32) {
 
 
 void MacroAssembler::Pop(Register dst) {
-  if (kPointerSize == kInt64Size) {
+  if (kSystemPointerSize == kInt64Size) {
     popq(dst);
   } else {
     // x32 uses 64-bit pop for rbp in the epilogue.
@@ -1578,7 +1579,7 @@ void MacroAssembler::Pop(Register dst) {
 }
 
 void MacroAssembler::Pop(Operand dst) {
-  if (kPointerSize == kInt64Size) {
+  if (kSystemPointerSize == kInt64Size) {
     popq(dst);
   } else {
     Register scratch = dst.AddressUsesRegister(kScratchRegister)
@@ -1594,7 +1595,7 @@ void MacroAssembler::Pop(Operand dst) {
 }
 
 void MacroAssembler::PopQuad(Operand dst) {
-  if (kPointerSize == kInt64Size) {
+  if (kSystemPointerSize == kInt64Size) {
     popq(dst);
   } else {
     popq(kScratchRegister);
@@ -1608,7 +1609,7 @@ void TurboAssembler::Jump(ExternalReference ext) {
 }
 
 void TurboAssembler::Jump(Operand op) {
-  if (kPointerSize == kInt64Size) {
+  if (kSystemPointerSize == kInt64Size) {
     jmp(op);
   } else {
     movp(kScratchRegister, op);
@@ -1677,7 +1678,7 @@ void TurboAssembler::Call(ExternalReference ext) {
 }
 
 void TurboAssembler::Call(Operand op) {
-  if (kPointerSize == kInt64Size && !CpuFeatures::IsSupported(ATOM)) {
+  if (kSystemPointerSize == kInt64Size && !CpuFeatures::IsSupported(ATOM)) {
     call(op);
   } else {
     movp(kScratchRegister, op);
@@ -1996,16 +1997,16 @@ void MacroAssembler::Pushad() {
   Push(r15);
   STATIC_ASSERT(12 == kNumSafepointSavedRegisters);
   // Use lea for symmetry with Popad.
-  int sp_delta =
-      (kNumSafepointRegisters - kNumSafepointSavedRegisters) * kPointerSize;
+  int sp_delta = (kNumSafepointRegisters - kNumSafepointSavedRegisters) *
+                 kSystemPointerSize;
   leap(rsp, Operand(rsp, -sp_delta));
 }
 
 
 void MacroAssembler::Popad() {
   // Popad must not change the flags, so use lea instead of addq.
-  int sp_delta =
-      (kNumSafepointRegisters - kNumSafepointSavedRegisters) * kPointerSize;
+  int sp_delta = (kNumSafepointRegisters - kNumSafepointSavedRegisters) *
+                 kSystemPointerSize;
   leap(rsp, Operand(rsp, sp_delta));
   Pop(r15);
   Pop(r14);
@@ -2046,7 +2047,7 @@ MacroAssembler::kSafepointPushRegisterIndices[Register::kNumRegisters] = {
 
 void MacroAssembler::PushStackHandler() {
   // Adjust this code if not the case.
-  STATIC_ASSERT(StackHandlerConstants::kSize == 2 * kPointerSize);
+  STATIC_ASSERT(StackHandlerConstants::kSize == 2 * kSystemPointerSize);
   STATIC_ASSERT(StackHandlerConstants::kNextOffset == 0);
 
   Push(Immediate(0));  // Padding.
@@ -2066,7 +2067,7 @@ void MacroAssembler::PopStackHandler() {
   ExternalReference handler_address =
       ExternalReference::Create(IsolateAddressId::kHandlerAddress, isolate());
   Pop(ExternalReferenceAsOperand(handler_address));
-  addp(rsp, Immediate(StackHandlerConstants::kSize - kPointerSize));
+  addp(rsp, Immediate(StackHandlerConstants::kSize - kSystemPointerSize));
 }
 
 void TurboAssembler::Ret() { ret(0); }
@@ -2282,9 +2283,10 @@ void TurboAssembler::PrepareForTailCall(const ParameterCount& callee_args_count,
     leap(new_sp_reg, Operand(rbp, caller_args_count_reg, times_pointer_size,
                              StandardFrameConstants::kCallerPCOffset));
   } else {
-    leap(new_sp_reg, Operand(rbp, caller_args_count_reg, times_pointer_size,
-                             StandardFrameConstants::kCallerPCOffset -
-                                 callee_args_count.immediate() * kPointerSize));
+    leap(new_sp_reg,
+         Operand(rbp, caller_args_count_reg, times_pointer_size,
+                 StandardFrameConstants::kCallerPCOffset -
+                     callee_args_count.immediate() * kSystemPointerSize));
   }
 
   if (FLAG_debug_code) {
@@ -2536,13 +2538,13 @@ void MacroAssembler::EnterExitFramePrologue(bool save_rax,
   DCHECK_EQ(kFPOnStackSize + kPCOnStackSize,
             ExitFrameConstants::kCallerSPDisplacement);
   DCHECK_EQ(kFPOnStackSize, ExitFrameConstants::kCallerPCOffset);
-  DCHECK_EQ(0 * kPointerSize, ExitFrameConstants::kCallerFPOffset);
+  DCHECK_EQ(0 * kSystemPointerSize, ExitFrameConstants::kCallerFPOffset);
   pushq(rbp);
   movp(rbp, rsp);
 
   // Reserve room for entry stack pointer and push the code object.
   Push(Immediate(StackFrame::TypeToMarker(frame_type)));
-  DCHECK_EQ(-2 * kPointerSize, ExitFrameConstants::kSPOffset);
+  DCHECK_EQ(-2 * kSystemPointerSize, ExitFrameConstants::kSPOffset);
   Push(Immediate(0));  // Saved entry sp, patched before call.
   Move(kScratchRegister, CodeObject(), RelocInfo::EMBEDDED_OBJECT);
   Push(kScratchRegister);  // Accessed from ExitFrame::code_slot.
@@ -2603,7 +2605,7 @@ void MacroAssembler::EnterExitFrame(int arg_stack_space, bool save_doubles,
 
   // Set up argv in callee-saved register r15. It is reused in LeaveExitFrame,
   // so it must be retained across the C-call.
-  int offset = StandardFrameConstants::kCallerSPOffset - kPointerSize;
+  int offset = StandardFrameConstants::kCallerSPOffset - kSystemPointerSize;
   leap(r15, Operand(rbp, r14, times_pointer_size, offset));
 
   EnterExitFrameEpilogue(arg_stack_space, save_doubles);
@@ -2632,11 +2634,11 @@ void MacroAssembler::LeaveExitFrame(bool save_doubles, bool pop_arguments) {
   if (pop_arguments) {
     // Get the return address from the stack and restore the frame pointer.
     movp(rcx, Operand(rbp, kFPOnStackSize));
-    movp(rbp, Operand(rbp, 0 * kPointerSize));
+    movp(rbp, Operand(rbp, 0 * kSystemPointerSize));
 
     // Drop everything up to and including the arguments and the receiver
     // from the caller stack.
-    leap(rsp, Operand(r15, 1 * kPointerSize));
+    leap(rsp, Operand(r15, 1 * kSystemPointerSize));
 
     PushReturnAddressFrom(rcx);
   } else {

src/x64/macro-assembler-x64.h

@@ -625,13 +625,14 @@ class V8_EXPORT_PRIVATE MacroAssembler : public TurboAssembler {
   // sets up the number of arguments in register rdi and the pointer
   // to the first argument in register rsi.
   //
-  // Allocates arg_stack_space * kPointerSize memory (not GCed) on the stack
-  // accessible via StackSpaceOperand.
+  // Allocates arg_stack_space * kSystemPointerSize memory (not GCed) on the
+  // stack accessible via StackSpaceOperand.
   void EnterExitFrame(int arg_stack_space = 0, bool save_doubles = false,
                       StackFrame::Type frame_type = StackFrame::EXIT);
 
-  // Enter specific kind of exit frame. Allocates arg_stack_space * kPointerSize
-  // memory (not GCed) on the stack accessible via StackSpaceOperand.
+  // Enter specific kind of exit frame. Allocates
+  // (arg_stack_space * kSystemPointerSize) memory (not GCed) on the stack
+  // accessible via StackSpaceOperand.
   void EnterApiExitFrame(int arg_stack_space);
 
   // Leave the current exit frame. Expects/provides the return value in
@@ -712,8 +713,8 @@ class V8_EXPORT_PRIVATE MacroAssembler : public TurboAssembler {
   // Converts, if necessary, a smi to a combination of number and
   // multiplier to be used as a scaled index.
   // The src register contains a *positive* smi value. The shift is the
-  // power of two to multiply the index value by (e.g.
-  // to index by smi-value * kPointerSize, pass the smi and kPointerSizeLog2).
+  // power of two to multiply the index value by (e.g. to index by
+  // smi-value * kSystemPointerSize, pass the smi and kSystemPointerSizeLog2).
   // The returned index register may be either src or dst, depending
   // on what is most efficient. If src and dst are different registers,
   // src is always unchanged.
@@ -889,8 +890,8 @@ class V8_EXPORT_PRIVATE MacroAssembler : public TurboAssembler {
 
   void EnterExitFramePrologue(bool save_rax, StackFrame::Type frame_type);
 
-  // Allocates arg_stack_space * kPointerSize memory (not GCed) on the stack
-  // accessible via StackSpaceOperand.
+  // Allocates arg_stack_space * kSystemPointerSize memory (not GCed) on the
+  // stack accessible via StackSpaceOperand.
   void EnterExitFrameEpilogue(int arg_stack_space, bool save_doubles);
 
   void LeaveExitFrameEpilogue();
@@ -949,9 +950,9 @@ inline Operand NativeContextOperand() {
 inline Operand StackSpaceOperand(int index) {
 #ifdef _WIN64
   const int kShaddowSpace = 4;
-  return Operand(rsp, (index + kShaddowSpace) * kPointerSize);
+  return Operand(rsp, (index + kShaddowSpace) * kSystemPointerSize);
 #else
-  return Operand(rsp, index * kPointerSize);
+  return Operand(rsp, index * kSystemPointerSize);
 #endif
 }
 

test/cctest/test-macro-assembler-x64.cc

@@ -494,9 +494,9 @@ TEST(OperandOffset) {
   // r15 = rsp[3]
   // rbx = rsp[5]
   // r13 = rsp[7]
-  __ leaq(r14, Operand(rsp, 3 * kPointerSize));
-  __ leaq(r13, Operand(rbp, -3 * kPointerSize));
-  __ leaq(rbx, Operand(rbp, -5 * kPointerSize));
+  __ leaq(r14, Operand(rsp, 3 * kSystemPointerSize));
+  __ leaq(r13, Operand(rbp, -3 * kSystemPointerSize));
+  __ leaq(rbx, Operand(rbp, -5 * kSystemPointerSize));
   __ movl(rcx, Immediate(2));
   __ Move(r8, reinterpret_cast<Address>(&data[128]), RelocInfo::NONE);
   __ movl(rax, Immediate(1));
@@ -511,12 +511,12 @@ TEST(OperandOffset) {
 
   // Test 2.
   // Zero to non-zero displacement.
-  __ movl(rdx, Operand(sp0, 2 * kPointerSize));
+  __ movl(rdx, Operand(sp0, 2 * kSystemPointerSize));
   __ cmpl(rdx, Immediate(0x107));
   __ j(not_equal, &exit);
   __ incq(rax);
 
-  Operand sp2 = Operand(rsp, 2 * kPointerSize);
+  Operand sp2 = Operand(rsp, 2 * kSystemPointerSize);
 
   // Test 3.
   __ movl(rdx, sp2);  // Sanity check.
@@ -524,18 +524,18 @@ TEST(OperandOffset) {
   __ j(not_equal, &exit);
   __ incq(rax);
 
-  __ movl(rdx, Operand(sp2, 2 * kPointerSize));
+  __ movl(rdx, Operand(sp2, 2 * kSystemPointerSize));
   __ cmpl(rdx, Immediate(0x105));
   __ j(not_equal, &exit);
   __ incq(rax);
 
   // Non-zero to zero displacement.
-  __ movl(rdx, Operand(sp2, -2 * kPointerSize));
+  __ movl(rdx, Operand(sp2, -2 * kSystemPointerSize));
   __ cmpl(rdx, Immediate(0x109));
   __ j(not_equal, &exit);
   __ incq(rax);
 
-  Operand sp2c2 = Operand(rsp, rcx, times_pointer_size, 2 * kPointerSize);
+  Operand sp2c2 = Operand(rsp, rcx, times_pointer_size, 2 * kSystemPointerSize);
 
   // Test 6.
   __ movl(rdx, sp2c2);  // Sanity check.
@@ -543,13 +543,13 @@ TEST(OperandOffset) {
   __ j(not_equal, &exit);
   __ incq(rax);
 
-  __ movl(rdx, Operand(sp2c2, 2 * kPointerSize));
+  __ movl(rdx, Operand(sp2c2, 2 * kSystemPointerSize));
   __ cmpl(rdx, Immediate(0x103));
   __ j(not_equal, &exit);
   __ incq(rax);
 
   // Non-zero to zero displacement.
-  __ movl(rdx, Operand(sp2c2, -2 * kPointerSize));
+  __ movl(rdx, Operand(sp2c2, -2 * kSystemPointerSize));
   __ cmpl(rdx, Immediate(0x107));
   __ j(not_equal, &exit);
   __ incq(rax);
@@ -564,12 +564,12 @@ TEST(OperandOffset) {
   __ incq(rax);
 
   // Zero to non-zero displacement.
-  __ movl(rdx, Operand(bp0, -2 * kPointerSize));
+  __ movl(rdx, Operand(bp0, -2 * kSystemPointerSize));
   __ cmpl(rdx, Immediate(0x102));
   __ j(not_equal, &exit);
   __ incq(rax);
 
-  Operand bp2 = Operand(rbp, -2 * kPointerSize);
+  Operand bp2 = Operand(rbp, -2 * kSystemPointerSize);
 
   // Test 11.
   __ movl(rdx, bp2);  // Sanity check.
@@ -578,17 +578,18 @@ TEST(OperandOffset) {
   __ incq(rax);
 
   // Non-zero to zero displacement.
-  __ movl(rdx, Operand(bp2, 2 * kPointerSize));
+  __ movl(rdx, Operand(bp2, 2 * kSystemPointerSize));
   __ cmpl(rdx, Immediate(0x100));
   __ j(not_equal, &exit);
   __ incq(rax);
 
-  __ movl(rdx, Operand(bp2, -2 * kPointerSize));
+  __ movl(rdx, Operand(bp2, -2 * kSystemPointerSize));
   __ cmpl(rdx, Immediate(0x104));
   __ j(not_equal, &exit);
   __ incq(rax);
 
-  Operand bp2c4 = Operand(rbp, rcx, times_pointer_size, -4 * kPointerSize);
+  Operand bp2c4 =
+      Operand(rbp, rcx, times_pointer_size, -4 * kSystemPointerSize);
 
   // Test 14:
   __ movl(rdx, bp2c4);  // Sanity check.
@@ -596,12 +597,12 @@ TEST(OperandOffset) {
   __ j(not_equal, &exit);
   __ incq(rax);
 
-  __ movl(rdx, Operand(bp2c4, 2 * kPointerSize));
+  __ movl(rdx, Operand(bp2c4, 2 * kSystemPointerSize));
   __ cmpl(rdx, Immediate(0x100));
   __ j(not_equal, &exit);
   __ incq(rax);
 
-  __ movl(rdx, Operand(bp2c4, -2 * kPointerSize));
+  __ movl(rdx, Operand(bp2c4, -2 * kSystemPointerSize));
   __ cmpl(rdx, Immediate(0x104));
   __ j(not_equal, &exit);
   __ incq(rax);
@@ -614,17 +615,17 @@ TEST(OperandOffset) {
   __ j(not_equal, &exit);
   __ incq(rax);
 
-  __ movl(rdx, Operand(bx0, 5 * kPointerSize));
+  __ movl(rdx, Operand(bx0, 5 * kSystemPointerSize));
   __ cmpl(rdx, Immediate(0x100));
   __ j(not_equal, &exit);
   __ incq(rax);
 
-  __ movl(rdx, Operand(bx0, -4 * kPointerSize));
+  __ movl(rdx, Operand(bx0, -4 * kSystemPointerSize));
   __ cmpl(rdx, Immediate(0x109));
   __ j(not_equal, &exit);
   __ incq(rax);
 
-  Operand bx2 = Operand(rbx, 2 * kPointerSize);
+  Operand bx2 = Operand(rbx, 2 * kSystemPointerSize);
 
   // Test 20.
   __ movl(rdx, bx2);  // Sanity check.
@@ -632,18 +633,19 @@ TEST(OperandOffset) {
   __ j(not_equal, &exit);
   __ incq(rax);
 
-  __ movl(rdx, Operand(bx2, 2 * kPointerSize));
+  __ movl(rdx, Operand(bx2, 2 * kSystemPointerSize));
   __ cmpl(rdx, Immediate(0x101));
   __ j(not_equal, &exit);
   __ incq(rax);
 
   // Non-zero to zero displacement.
-  __ movl(rdx, Operand(bx2, -2 * kPointerSize));
+  __ movl(rdx, Operand(bx2, -2 * kSystemPointerSize));
   __ cmpl(rdx, Immediate(0x105));
   __ j(not_equal, &exit);
   __ incq(rax);
 
-  Operand bx2c2 = Operand(rbx, rcx, times_pointer_size, -2 * kPointerSize);
+  Operand bx2c2 =
+      Operand(rbx, rcx, times_pointer_size, -2 * kSystemPointerSize);
 
   // Test 23.
   __ movl(rdx, bx2c2);  // Sanity check.
@@ -651,12 +653,12 @@ TEST(OperandOffset) {
   __ j(not_equal, &exit);
   __ incq(rax);
 
-  __ movl(rdx, Operand(bx2c2, 2 * kPointerSize));
+  __ movl(rdx, Operand(bx2c2, 2 * kSystemPointerSize));
   __ cmpl(rdx, Immediate(0x103));
   __ j(not_equal, &exit);
   __ incq(rax);
 
-  __ movl(rdx, Operand(bx2c2, -2 * kPointerSize));
+  __ movl(rdx, Operand(bx2c2, -2 * kSystemPointerSize));
   __ cmpl(rdx, Immediate(0x107));
   __ j(not_equal, &exit);
   __ incq(rax);
@@ -794,7 +796,7 @@ TEST(OperandOffset) {
 
   __ movl(rax, Immediate(0));
   __ bind(&exit);
-  __ leaq(rsp, Operand(rbp, kPointerSize));
+  __ leaq(rsp, Operand(rbp, kSystemPointerSize));
   __ popq(rbp);
   __ popq(rbx);
   __ popq(r14);
@@ -823,131 +825,145 @@ TEST(LoadAndStoreWithRepresentation) {
 
   MacroAssembler* masm = &assembler;  // Create a pointer for the __ macro.
   EntryCode(masm);
-  __ subq(rsp, Immediate(1 * kPointerSize));
+  __ subq(rsp, Immediate(1 * kSystemPointerSize));
   Label exit;
 
   // Test 1.
   __ movq(rax, Immediate(1));  // Test number.
-  __ movq(Operand(rsp, 0 * kPointerSize), Immediate(0));
+  __ movq(Operand(rsp, 0 * kSystemPointerSize), Immediate(0));
   __ movq(rcx, Immediate(-1));
-  __ Store(Operand(rsp, 0 * kPointerSize), rcx, Representation::UInteger8());
-  __ movq(rcx, Operand(rsp, 0 * kPointerSize));
+  __ Store(Operand(rsp, 0 * kSystemPointerSize), rcx,
+           Representation::UInteger8());
+  __ movq(rcx, Operand(rsp, 0 * kSystemPointerSize));
   __ movl(rdx, Immediate(255));
   __ cmpq(rcx, rdx);
   __ j(not_equal, &exit);
-  __ Load(rdx, Operand(rsp, 0 * kPointerSize), Representation::UInteger8());
+  __ Load(rdx, Operand(rsp, 0 * kSystemPointerSize),
+          Representation::UInteger8());
   __ cmpq(rcx, rdx);
   __ j(not_equal, &exit);
 
   // Test 2.
   __ movq(rax, Immediate(2));  // Test number.
-  __ movq(Operand(rsp, 0 * kPointerSize), Immediate(0));
+  __ movq(Operand(rsp, 0 * kSystemPointerSize), Immediate(0));
   __ Set(rcx, V8_2PART_UINT64_C(0xDEADBEAF, 12345678));
-  __ Store(Operand(rsp, 0 * kPointerSize), rcx, Representation::Smi());
-  __ movq(rcx, Operand(rsp, 0 * kPointerSize));
+  __ Store(Operand(rsp, 0 * kSystemPointerSize), rcx, Representation::Smi());
+  __ movq(rcx, Operand(rsp, 0 * kSystemPointerSize));
   __ Set(rdx, V8_2PART_UINT64_C(0xDEADBEAF, 12345678));
   __ cmpq(rcx, rdx);
   __ j(not_equal, &exit);
-  __ Load(rdx, Operand(rsp, 0 * kPointerSize), Representation::Smi());
+  __ Load(rdx, Operand(rsp, 0 * kSystemPointerSize), Representation::Smi());
   __ cmpq(rcx, rdx);
   __ j(not_equal, &exit);
 
   // Test 3.
   __ movq(rax, Immediate(3));  // Test number.
-  __ movq(Operand(rsp, 0 * kPointerSize), Immediate(0));
+  __ movq(Operand(rsp, 0 * kSystemPointerSize), Immediate(0));
   __ movq(rcx, Immediate(-1));
-  __ Store(Operand(rsp, 0 * kPointerSize), rcx, Representation::Integer32());
-  __ movq(rcx, Operand(rsp, 0 * kPointerSize));
+  __ Store(Operand(rsp, 0 * kSystemPointerSize), rcx,
+           Representation::Integer32());
+  __ movq(rcx, Operand(rsp, 0 * kSystemPointerSize));
   __ movl(rdx, Immediate(-1));
   __ cmpq(rcx, rdx);
   __ j(not_equal, &exit);
-  __ Load(rdx, Operand(rsp, 0 * kPointerSize), Representation::Integer32());
+  __ Load(rdx, Operand(rsp, 0 * kSystemPointerSize),
+          Representation::Integer32());
   __ cmpq(rcx, rdx);
   __ j(not_equal, &exit);
 
   // Test 4.
   __ movq(rax, Immediate(4));  // Test number.
-  __ movq(Operand(rsp, 0 * kPointerSize), Immediate(0));
+  __ movq(Operand(rsp, 0 * kSystemPointerSize), Immediate(0));
   __ movl(rcx, Immediate(0x44332211));
-  __ Store(Operand(rsp, 0 * kPointerSize), rcx, Representation::HeapObject());
-  __ movq(rcx, Operand(rsp, 0 * kPointerSize));
+  __ Store(Operand(rsp, 0 * kSystemPointerSize), rcx,
+           Representation::HeapObject());
+  __ movq(rcx, Operand(rsp, 0 * kSystemPointerSize));
   __ movl(rdx, Immediate(0x44332211));
   __ cmpq(rcx, rdx);
   __ j(not_equal, &exit);
-  __ Load(rdx, Operand(rsp, 0 * kPointerSize), Representation::HeapObject());
+  __ Load(rdx, Operand(rsp, 0 * kSystemPointerSize),
+          Representation::HeapObject());
   __ cmpq(rcx, rdx);
   __ j(not_equal, &exit);
 
   // Test 5.
   __ movq(rax, Immediate(5));  // Test number.
-  __ movq(Operand(rsp, 0 * kPointerSize), Immediate(0));
+  __ movq(Operand(rsp, 0 * kSystemPointerSize), Immediate(0));
   __ Set(rcx, V8_2PART_UINT64_C(0x12345678, DEADBEAF));
-  __ Store(Operand(rsp, 0 * kPointerSize), rcx, Representation::Tagged());
-  __ movq(rcx, Operand(rsp, 0 * kPointerSize));
+  __ Store(Operand(rsp, 0 * kSystemPointerSize), rcx, Representation::Tagged());
+  __ movq(rcx, Operand(rsp, 0 * kSystemPointerSize));
   __ Set(rdx, V8_2PART_UINT64_C(0x12345678, DEADBEAF));
   __ cmpq(rcx, rdx);
   __ j(not_equal, &exit);
-  __ Load(rdx, Operand(rsp, 0 * kPointerSize), Representation::Tagged());
+  __ Load(rdx, Operand(rsp, 0 * kSystemPointerSize), Representation::Tagged());
   __ cmpq(rcx, rdx);
   __ j(not_equal, &exit);
 
   // Test 6.
   __ movq(rax, Immediate(6));  // Test number.
-  __ movq(Operand(rsp, 0 * kPointerSize), Immediate(0));
+  __ movq(Operand(rsp, 0 * kSystemPointerSize), Immediate(0));
   __ Set(rcx, V8_2PART_UINT64_C(0x11223344, 55667788));
-  __ Store(Operand(rsp, 0 * kPointerSize), rcx, Representation::External());
-  __ movq(rcx, Operand(rsp, 0 * kPointerSize));
+  __ Store(Operand(rsp, 0 * kSystemPointerSize), rcx,
+           Representation::External());
+  __ movq(rcx, Operand(rsp, 0 * kSystemPointerSize));
   __ Set(rdx, V8_2PART_UINT64_C(0x11223344, 55667788));
   __ cmpq(rcx, rdx);
   __ j(not_equal, &exit);
-  __ Load(rdx, Operand(rsp, 0 * kPointerSize), Representation::External());
+  __ Load(rdx, Operand(rsp, 0 * kSystemPointerSize),
+          Representation::External());
   __ cmpq(rcx, rdx);
   __ j(not_equal, &exit);
 
   // Test 7.
   __ movq(rax, Immediate(7));  // Test number.
-  __ movq(Operand(rsp, 0 * kPointerSize), Immediate(0));
+  __ movq(Operand(rsp, 0 * kSystemPointerSize), Immediate(0));
   __ movq(rcx, Immediate(-1));
-  __ Store(Operand(rsp, 0 * kPointerSize), rcx, Representation::Integer8());
-  __ movq(rcx, Operand(rsp, 0 * kPointerSize));
+  __ Store(Operand(rsp, 0 * kSystemPointerSize), rcx,
+           Representation::Integer8());
+  __ movq(rcx, Operand(rsp, 0 * kSystemPointerSize));
   __ movl(rdx, Immediate(255));
   __ cmpq(rcx, rdx);
   __ j(not_equal, &exit);
-  __ Load(rdx, Operand(rsp, 0 * kPointerSize), Representation::Integer8());
+  __ Load(rdx, Operand(rsp, 0 * kSystemPointerSize),
+          Representation::Integer8());
   __ movq(rcx, Immediate(-1));
   __ cmpq(rcx, rdx);
   __ j(not_equal, &exit);
 
   // Test 8.
   __ movq(rax, Immediate(8));  // Test number.
-  __ movq(Operand(rsp, 0 * kPointerSize), Immediate(0));
+  __ movq(Operand(rsp, 0 * kSystemPointerSize), Immediate(0));
   __ movq(rcx, Immediate(-1));
-  __ Store(Operand(rsp, 0 * kPointerSize), rcx, Representation::Integer16());
-  __ movq(rcx, Operand(rsp, 0 * kPointerSize));
+  __ Store(Operand(rsp, 0 * kSystemPointerSize), rcx,
+           Representation::Integer16());
+  __ movq(rcx, Operand(rsp, 0 * kSystemPointerSize));
   __ movl(rdx, Immediate(65535));
   __ cmpq(rcx, rdx);
   __ j(not_equal, &exit);
-  __ Load(rdx, Operand(rsp, 0 * kPointerSize), Representation::Integer16());
+  __ Load(rdx, Operand(rsp, 0 * kSystemPointerSize),
+          Representation::Integer16());
   __ movq(rcx, Immediate(-1));
   __ cmpq(rcx, rdx);
   __ j(not_equal, &exit);
 
   // Test 9.
   __ movq(rax, Immediate(9));  // Test number.
-  __ movq(Operand(rsp, 0 * kPointerSize), Immediate(0));
+  __ movq(Operand(rsp, 0 * kSystemPointerSize), Immediate(0));
   __ movq(rcx, Immediate(-1));
-  __ Store(Operand(rsp, 0 * kPointerSize), rcx, Representation::UInteger16());
-  __ movq(rcx, Operand(rsp, 0 * kPointerSize));
+  __ Store(Operand(rsp, 0 * kSystemPointerSize), rcx,
+           Representation::UInteger16());
+  __ movq(rcx, Operand(rsp, 0 * kSystemPointerSize));
   __ movl(rdx, Immediate(65535));
   __ cmpq(rcx, rdx);
   __ j(not_equal, &exit);
-  __ Load(rdx, Operand(rsp, 0 * kPointerSize), Representation::UInteger16());
+  __ Load(rdx, Operand(rsp, 0 * kSystemPointerSize),
+          Representation::UInteger16());
   __ cmpq(rcx, rdx);
   __ j(not_equal, &exit);
 
   __ xorq(rax, rax);  // Success.
   __ bind(&exit);
-  __ addq(rsp, Immediate(1 * kPointerSize));
+  __ addq(rsp, Immediate(1 * kSystemPointerSize));
   ExitCode(masm);
   __ ret(0);