[runtime] Change FIELD_ADDR to .ptr() instead of ->ptr()

We should just always get an Object in rather than both Object and Object*
where the former is dealt with through operator->.

Change-Id: I2d2542f37a357d4c410cc5f07c8e3563e66660b7
Reviewed-on: https://chromium-review.googlesource.com/c/1470104Reviewed-by: Leszek Swirski <leszeks@chromium.org>
Reviewed-by: Andreas Haas <ahaas@chromium.org>
Commit-Queue: Toon Verwaest <verwaest@chromium.org>
Cr-Commit-Position: refs/heads/master@{#59553}

src/contexts-inl.h

@@ -236,11 +236,11 @@ Map Context::GetInitialJSArrayMap(ElementsKind kind) const {
 
 MicrotaskQueue* NativeContext::microtask_queue() const {
   return reinterpret_cast<MicrotaskQueue*>(
-      READ_INTPTR_FIELD(this, kMicrotaskQueueOffset));
+      READ_INTPTR_FIELD(*this, kMicrotaskQueueOffset));
 }
 
 void NativeContext::set_microtask_queue(MicrotaskQueue* microtask_queue) {
-  WRITE_INTPTR_FIELD(this, kMicrotaskQueueOffset,
+  WRITE_INTPTR_FIELD(*this, kMicrotaskQueueOffset,
                      reinterpret_cast<intptr_t>(microtask_queue));
 }
 

src/feedback-vector-inl.h

@@ -32,19 +32,19 @@ INT32_ACCESSORS(FeedbackMetadata, slot_count, kSlotCountOffset)
 
 int32_t FeedbackMetadata::synchronized_slot_count() const {
   return base::Acquire_Load(reinterpret_cast<const base::Atomic32*>(
-      FIELD_ADDR(this, kSlotCountOffset)));
+      FIELD_ADDR(*this, kSlotCountOffset)));
 }
 
 int32_t FeedbackMetadata::get(int index) const {
   DCHECK(index >= 0 && index < length());
   int offset = kHeaderSize + index * kInt32Size;
-  return READ_INT32_FIELD(this, offset);
+  return READ_INT32_FIELD(*this, offset);
 }
 
 void FeedbackMetadata::set(int index, int32_t value) {
   DCHECK(index >= 0 && index < length());
   int offset = kHeaderSize + index * kInt32Size;
-  WRITE_INT32_FIELD(this, offset, value);
+  WRITE_INT32_FIELD(*this, offset, value);
 }
 
 bool FeedbackMetadata::is_empty() const { return slot_count() == 0; }

src/objects-inl.h

@@ -586,7 +586,7 @@ MaybeHandle<Object> Object::SetElement(Isolate* isolate, Handle<Object> object,
 }
 
 ObjectSlot HeapObject::RawField(int byte_offset) const {
-  return ObjectSlot(FIELD_ADDR(this, byte_offset));
+  return ObjectSlot(FIELD_ADDR(*this, byte_offset));
 }
 
 ObjectSlot HeapObject::RawField(const HeapObject obj, int byte_offset) {
@@ -594,7 +594,7 @@ ObjectSlot HeapObject::RawField(const HeapObject obj, int byte_offset) {
 }
 
 MaybeObjectSlot HeapObject::RawMaybeWeakField(int byte_offset) const {
-  return MaybeObjectSlot(FIELD_ADDR(this, byte_offset));
+  return MaybeObjectSlot(FIELD_ADDR(*this, byte_offset));
 }
 
 MaybeObjectSlot HeapObject::RawMaybeWeakField(HeapObject obj, int byte_offset) {
@@ -618,15 +618,16 @@ HeapObject MapWord::ToForwardingAddress() {
 
 #ifdef VERIFY_HEAP
 void HeapObject::VerifyObjectField(Isolate* isolate, int offset) {
-  VerifyPointer(isolate, READ_FIELD(this, offset));
+  VerifyPointer(isolate, READ_FIELD(*this, offset));
 }
 
 void HeapObject::VerifyMaybeObjectField(Isolate* isolate, int offset) {
-  MaybeObject::VerifyMaybeObjectPointer(isolate, READ_WEAK_FIELD(this, offset));
+  MaybeObject::VerifyMaybeObjectPointer(isolate,
+                                        READ_WEAK_FIELD(*this, offset));
 }
 
 void HeapObject::VerifySmiField(int offset) {
-  CHECK(READ_FIELD(this, offset)->IsSmi());
+  CHECK(READ_FIELD(*this, offset)->IsSmi());
 }
 
 #endif
@@ -824,7 +825,7 @@ AllocationAlignment HeapObject::RequiredAlignment(Map map) {
 }
 
 Address HeapObject::GetFieldAddress(int field_offset) const {
-  return FIELD_ADDR(this, field_offset);
+  return FIELD_ADDR(*this, field_offset);
 }
 
 ACCESSORS(TemplateObjectDescription, raw_strings, FixedArray, kRawStringsOffset)

src/objects/bigint.cc

@@ -184,22 +184,22 @@ class MutableBigInt : public FreshlyAllocatedBigInt {
 // Internal field setters. Non-mutable BigInts don't have these.
 #include "src/objects/object-macros.h"
   inline void set_sign(bool new_sign) {
-    int32_t bitfield = RELAXED_READ_INT32_FIELD(this, kBitfieldOffset);
+    int32_t bitfield = RELAXED_READ_INT32_FIELD(*this, kBitfieldOffset);
     bitfield = SignBits::update(bitfield, new_sign);
-    RELAXED_WRITE_INT32_FIELD(this, kBitfieldOffset, bitfield);
+    RELAXED_WRITE_INT32_FIELD(*this, kBitfieldOffset, bitfield);
   }
   inline void synchronized_set_length(int new_length) {
-    int32_t bitfield = RELAXED_READ_INT32_FIELD(this, kBitfieldOffset);
+    int32_t bitfield = RELAXED_READ_INT32_FIELD(*this, kBitfieldOffset);
     bitfield = LengthBits::update(bitfield, new_length);
-    RELEASE_WRITE_INT32_FIELD(this, kBitfieldOffset, bitfield);
+    RELEASE_WRITE_INT32_FIELD(*this, kBitfieldOffset, bitfield);
   }
   inline void initialize_bitfield(bool sign, int length) {
     int32_t bitfield = LengthBits::encode(length) | SignBits::encode(sign);
-    WRITE_INT32_FIELD(this, kBitfieldOffset, bitfield);
+    WRITE_INT32_FIELD(*this, kBitfieldOffset, bitfield);
   }
   inline void set_digit(int n, digit_t value) {
     SLOW_DCHECK(0 <= n && n < length());
-    Address address = FIELD_ADDR(this, kDigitsOffset + n * kDigitSize);
+    Address address = FIELD_ADDR(*this, kDigitsOffset + n * kDigitSize);
     (*reinterpret_cast<digit_t*>(address)) = value;
   }
 

src/objects/bigint.h

@@ -25,13 +25,13 @@ class ValueSerializer;
 class BigIntBase : public HeapObject {
  public:
   inline int length() const {
-    int32_t bitfield = RELAXED_READ_INT32_FIELD(this, kBitfieldOffset);
+    int32_t bitfield = RELAXED_READ_INT32_FIELD(*this, kBitfieldOffset);
     return LengthBits::decode(static_cast<uint32_t>(bitfield));
   }
 
   // For use by the GC.
   inline int synchronized_length() const {
-    int32_t bitfield = ACQUIRE_READ_INT32_FIELD(this, kBitfieldOffset);
+    int32_t bitfield = ACQUIRE_READ_INT32_FIELD(*this, kBitfieldOffset);
     return LengthBits::decode(static_cast<uint32_t>(bitfield));
   }
 
@@ -81,13 +81,13 @@ class BigIntBase : public HeapObject {
 
   // sign() == true means negative.
   inline bool sign() const {
-    int32_t bitfield = RELAXED_READ_INT32_FIELD(this, kBitfieldOffset);
+    int32_t bitfield = RELAXED_READ_INT32_FIELD(*this, kBitfieldOffset);
     return SignBits::decode(static_cast<uint32_t>(bitfield));
   }
 
   inline digit_t digit(int n) const {
     SLOW_DCHECK(0 <= n && n < length());
-    Address address = FIELD_ADDR(this, kDigitsOffset + n * kDigitSize);
+    Address address = FIELD_ADDR(*this, kDigitsOffset + n * kDigitSize);
     return *reinterpret_cast<digit_t*>(address);
   }
 

src/objects/code-inl.h

@@ -216,10 +216,10 @@ SYNCHRONIZED_CODE_ACCESSORS(code_data_container, CodeDataContainer,
 #undef SYNCHRONIZED_CODE_ACCESSORS
 
 void Code::WipeOutHeader() {
-  WRITE_FIELD(this, kRelocationInfoOffset, Smi::FromInt(0));
-  WRITE_FIELD(this, kDeoptimizationDataOffset, Smi::FromInt(0));
-  WRITE_FIELD(this, kSourcePositionTableOffset, Smi::FromInt(0));
-  WRITE_FIELD(this, kCodeDataContainerOffset, Smi::FromInt(0));
+  WRITE_FIELD(*this, kRelocationInfoOffset, Smi::FromInt(0));
+  WRITE_FIELD(*this, kDeoptimizationDataOffset, Smi::FromInt(0));
+  WRITE_FIELD(*this, kSourcePositionTableOffset, Smi::FromInt(0));
+  WRITE_FIELD(*this, kCodeDataContainerOffset, Smi::FromInt(0));
 }
 
 void Code::clear_padding() {
@@ -256,7 +256,7 @@ int Code::InstructionSize() const {
 }
 
 Address Code::raw_instruction_start() const {
-  return FIELD_ADDR(this, kHeaderSize);
+  return FIELD_ADDR(*this, kHeaderSize);
 }
 
 Address Code::InstructionStart() const {
@@ -287,17 +287,17 @@ int Code::GetUnwindingInfoSizeOffset() const {
 int Code::unwinding_info_size() const {
   DCHECK(has_unwinding_info());
   return static_cast<int>(
-      READ_UINT64_FIELD(this, GetUnwindingInfoSizeOffset()));
+      READ_UINT64_FIELD(*this, GetUnwindingInfoSizeOffset()));
 }
 
 void Code::set_unwinding_info_size(int value) {
   DCHECK(has_unwinding_info());
-  WRITE_UINT64_FIELD(this, GetUnwindingInfoSizeOffset(), value);
+  WRITE_UINT64_FIELD(*this, GetUnwindingInfoSizeOffset(), value);
 }
 
 Address Code::unwinding_info_start() const {
   DCHECK(has_unwinding_info());
-  return FIELD_ADDR(this, GetUnwindingInfoSizeOffset()) + kInt64Size;
+  return FIELD_ADDR(*this, GetUnwindingInfoSizeOffset()) + kInt64Size;
 }
 
 Address Code::unwinding_info_end() const {
@@ -321,7 +321,7 @@ int Code::SizeIncludingMetadata() const {
 }
 
 ByteArray Code::unchecked_relocation_info() const {
-  return ByteArray::unchecked_cast(READ_FIELD(this, kRelocationInfoOffset));
+  return ByteArray::unchecked_cast(READ_FIELD(*this, kRelocationInfoOffset));
 }
 
 byte* Code::relocation_start() const {
@@ -367,7 +367,7 @@ void Code::CopyRelocInfoToByteArray(ByteArray dest, const CodeDesc& desc) {
 int Code::CodeSize() const { return SizeFor(body_size()); }
 
 Code::Kind Code::kind() const {
-  return KindField::decode(READ_UINT32_FIELD(this, kFlagsOffset));
+  return KindField::decode(READ_UINT32_FIELD(*this, kFlagsOffset));
 }
 
 void Code::initialize_flags(Kind kind, bool has_unwinding_info,
@@ -380,7 +380,7 @@ void Code::initialize_flags(Kind kind, bool has_unwinding_info,
                    IsTurbofannedField::encode(is_turbofanned) |
                    StackSlotsField::encode(stack_slots) |
                    IsOffHeapTrampoline::encode(is_off_heap_trampoline);
-  WRITE_UINT32_FIELD(this, kFlagsOffset, flags);
+  WRITE_UINT32_FIELD(*this, kFlagsOffset, flags);
   DCHECK_IMPLIES(stack_slots != 0, has_safepoint_info());
 }
 
@@ -406,11 +406,11 @@ inline bool Code::has_tagged_params() const {
 }
 
 inline bool Code::has_unwinding_info() const {
-  return HasUnwindingInfoField::decode(READ_UINT32_FIELD(this, kFlagsOffset));
+  return HasUnwindingInfoField::decode(READ_UINT32_FIELD(*this, kFlagsOffset));
 }
 
 inline bool Code::is_turbofanned() const {
-  return IsTurbofannedField::decode(READ_UINT32_FIELD(this, kFlagsOffset));
+  return IsTurbofannedField::decode(READ_UINT32_FIELD(*this, kFlagsOffset));
 }
 
 inline bool Code::can_have_weak_objects() const {
@@ -453,7 +453,7 @@ inline void Code::set_is_exception_caught(bool value) {
 }
 
 inline bool Code::is_off_heap_trampoline() const {
-  return IsOffHeapTrampoline::decode(READ_UINT32_FIELD(this, kFlagsOffset));
+  return IsOffHeapTrampoline::decode(READ_UINT32_FIELD(*this, kFlagsOffset));
 }
 
 inline HandlerTable::CatchPrediction Code::GetBuiltinCatchPrediction() {
@@ -463,14 +463,14 @@ inline HandlerTable::CatchPrediction Code::GetBuiltinCatchPrediction() {
 }
 
 int Code::builtin_index() const {
-  int index = READ_INT_FIELD(this, kBuiltinIndexOffset);
+  int index = READ_INT_FIELD(*this, kBuiltinIndexOffset);
   DCHECK(index == -1 || Builtins::IsBuiltinId(index));
   return index;
 }
 
 void Code::set_builtin_index(int index) {
   DCHECK(index == -1 || Builtins::IsBuiltinId(index));
-  WRITE_INT_FIELD(this, kBuiltinIndexOffset, index);
+  WRITE_INT_FIELD(*this, kBuiltinIndexOffset, index);
 }
 
 bool Code::is_builtin() const { return builtin_index() != -1; }
@@ -481,7 +481,7 @@ bool Code::has_safepoint_info() const {
 
 int Code::stack_slots() const {
   DCHECK(has_safepoint_info());
-  return StackSlotsField::decode(READ_UINT32_FIELD(this, kFlagsOffset));
+  return StackSlotsField::decode(READ_UINT32_FIELD(*this, kFlagsOffset));
 }
 
 bool Code::marked_for_deoptimization() const {
@@ -531,13 +531,13 @@ bool Code::is_wasm_code() const { return kind() == WASM_FUNCTION; }
 
 int Code::constant_pool_offset() const {
   if (!FLAG_enable_embedded_constant_pool) return code_comments_offset();
-  return READ_INT_FIELD(this, kConstantPoolOffsetOffset);
+  return READ_INT_FIELD(*this, kConstantPoolOffsetOffset);
 }
 
 void Code::set_constant_pool_offset(int value) {
   if (!FLAG_enable_embedded_constant_pool) return;
   DCHECK_LE(value, InstructionSize());
-  WRITE_INT_FIELD(this, kConstantPoolOffsetOffset, value);
+  WRITE_INT_FIELD(*this, kConstantPoolOffsetOffset, value);
 }
 
 Address Code::constant_pool() const {
@@ -605,22 +605,22 @@ void CodeDataContainer::clear_padding() {
 
 byte BytecodeArray::get(int index) {
   DCHECK(index >= 0 && index < this->length());
-  return READ_BYTE_FIELD(this, kHeaderSize + index * kCharSize);
+  return READ_BYTE_FIELD(*this, kHeaderSize + index * kCharSize);
 }
 
 void BytecodeArray::set(int index, byte value) {
   DCHECK(index >= 0 && index < this->length());
-  WRITE_BYTE_FIELD(this, kHeaderSize + index * kCharSize, value);
+  WRITE_BYTE_FIELD(*this, kHeaderSize + index * kCharSize, value);
 }
 
 void BytecodeArray::set_frame_size(int frame_size) {
   DCHECK_GE(frame_size, 0);
   DCHECK(IsAligned(frame_size, kSystemPointerSize));
-  WRITE_INT_FIELD(this, kFrameSizeOffset, frame_size);
+  WRITE_INT_FIELD(*this, kFrameSizeOffset, frame_size);
 }
 
 int BytecodeArray::frame_size() const {
-  return READ_INT_FIELD(this, kFrameSizeOffset);
+  return READ_INT_FIELD(*this, kFrameSizeOffset);
 }
 
 int BytecodeArray::register_count() const {
@@ -631,14 +631,14 @@ void BytecodeArray::set_parameter_count(int number_of_parameters) {
   DCHECK_GE(number_of_parameters, 0);
   // Parameter count is stored as the size on stack of the parameters to allow
   // it to be used directly by generated code.
-  WRITE_INT_FIELD(this, kParameterSizeOffset,
+  WRITE_INT_FIELD(*this, kParameterSizeOffset,
                   (number_of_parameters << kSystemPointerSizeLog2));
 }
 
 interpreter::Register BytecodeArray::incoming_new_target_or_generator_register()
     const {
   int register_operand =
-      READ_INT_FIELD(this, kIncomingNewTargetOrGeneratorRegisterOffset);
+      READ_INT_FIELD(*this, kIncomingNewTargetOrGeneratorRegisterOffset);
   if (register_operand == 0) {
     return interpreter::Register::invalid_value();
   } else {
@@ -649,38 +649,38 @@ interpreter::Register BytecodeArray::incoming_new_target_or_generator_register()
 void BytecodeArray::set_incoming_new_target_or_generator_register(
     interpreter::Register incoming_new_target_or_generator_register) {
   if (!incoming_new_target_or_generator_register.is_valid()) {
-    WRITE_INT_FIELD(this, kIncomingNewTargetOrGeneratorRegisterOffset, 0);
+    WRITE_INT_FIELD(*this, kIncomingNewTargetOrGeneratorRegisterOffset, 0);
   } else {
     DCHECK(incoming_new_target_or_generator_register.index() <
            register_count());
     DCHECK_NE(0, incoming_new_target_or_generator_register.ToOperand());
-    WRITE_INT_FIELD(this, kIncomingNewTargetOrGeneratorRegisterOffset,
+    WRITE_INT_FIELD(*this, kIncomingNewTargetOrGeneratorRegisterOffset,
                     incoming_new_target_or_generator_register.ToOperand());
   }
 }
 
 int BytecodeArray::interrupt_budget() const {
-  return READ_INT_FIELD(this, kInterruptBudgetOffset);
+  return READ_INT_FIELD(*this, kInterruptBudgetOffset);
 }
 
 void BytecodeArray::set_interrupt_budget(int interrupt_budget) {
   DCHECK_GE(interrupt_budget, 0);
-  WRITE_INT_FIELD(this, kInterruptBudgetOffset, interrupt_budget);
+  WRITE_INT_FIELD(*this, kInterruptBudgetOffset, interrupt_budget);
 }
 
 int BytecodeArray::osr_loop_nesting_level() const {
-  return READ_INT8_FIELD(this, kOSRNestingLevelOffset);
+  return READ_INT8_FIELD(*this, kOSRNestingLevelOffset);
 }
 
 void BytecodeArray::set_osr_loop_nesting_level(int depth) {
   DCHECK(0 <= depth && depth <= AbstractCode::kMaxLoopNestingMarker);
   STATIC_ASSERT(AbstractCode::kMaxLoopNestingMarker < kMaxInt8);
-  WRITE_INT8_FIELD(this, kOSRNestingLevelOffset, depth);
+  WRITE_INT8_FIELD(*this, kOSRNestingLevelOffset, depth);
 }
 
 BytecodeArray::Age BytecodeArray::bytecode_age() const {
   // Bytecode is aged by the concurrent marker.
-  return static_cast<Age>(RELAXED_READ_INT8_FIELD(this, kBytecodeAgeOffset));
+  return static_cast<Age>(RELAXED_READ_INT8_FIELD(*this, kBytecodeAgeOffset));
 }
 
 void BytecodeArray::set_bytecode_age(BytecodeArray::Age age) {
@@ -688,13 +688,13 @@ void BytecodeArray::set_bytecode_age(BytecodeArray::Age age) {
   DCHECK_LE(age, kLastBytecodeAge);
   STATIC_ASSERT(kLastBytecodeAge <= kMaxInt8);
   // Bytecode is aged by the concurrent marker.
-  RELAXED_WRITE_INT8_FIELD(this, kBytecodeAgeOffset, static_cast<int8_t>(age));
+  RELAXED_WRITE_INT8_FIELD(*this, kBytecodeAgeOffset, static_cast<int8_t>(age));
 }
 
 int BytecodeArray::parameter_count() const {
   // Parameter count is stored as the size on stack of the parameters to allow
   // it to be used directly by generated code.
-  return READ_INT_FIELD(this, kParameterSizeOffset) >> kSystemPointerSizeLog2;
+  return READ_INT_FIELD(*this, kParameterSizeOffset) >> kSystemPointerSizeLog2;
 }
 
 ACCESSORS(BytecodeArray, constant_pool, FixedArray, kConstantPoolOffset)

src/objects/descriptor-array-inl.h

@@ -54,7 +54,7 @@ inline int16_t DescriptorArray::CompareAndSwapRawNumberOfMarkedDescriptors(
     int16_t expected, int16_t value) {
   return base::Relaxed_CompareAndSwap(
       reinterpret_cast<base::Atomic16*>(
-          FIELD_ADDR(this, kRawNumberOfMarkedDescriptorsOffset)),
+          FIELD_ADDR(*this, kRawNumberOfMarkedDescriptorsOffset)),
       expected, value);
 }
 

src/objects/embedder-data-array-inl.h

@@ -24,11 +24,11 @@ SMI_ACCESSORS(EmbedderDataArray, length, kLengthOffset)
 OBJECT_CONSTRUCTORS_IMPL(EmbedderDataArray, HeapObject)
 
 Address EmbedderDataArray::slots_start() {
-  return FIELD_ADDR(this, OffsetOfElementAt(0));
+  return FIELD_ADDR(*this, OffsetOfElementAt(0));
 }
 
 Address EmbedderDataArray::slots_end() {
-  return FIELD_ADDR(this, OffsetOfElementAt(length()));
+  return FIELD_ADDR(*this, OffsetOfElementAt(length()));
 }
 
 }  // namespace internal

src/objects/fixed-array-inl.h

@@ -69,7 +69,7 @@ SYNCHRONIZED_SMI_ACCESSORS(WeakArrayList, capacity, kCapacityOffset)
 SMI_ACCESSORS(WeakArrayList, length, kLengthOffset)
 
 Object FixedArrayBase::unchecked_synchronized_length() const {
-  return ACQUIRE_READ_FIELD(this, kLengthOffset);
+  return ACQUIRE_READ_FIELD(*this, kLengthOffset);
 }
 
 ACCESSORS(FixedTypedArrayBase, base_pointer, Object, kBasePointerOffset)
@@ -90,7 +90,7 @@ bool FixedArray::ContainsOnlySmisOrHoles() {
 
 Object FixedArray::get(int index) const {
   DCHECK(index >= 0 && index < this->length());
-  return RELAXED_READ_FIELD(this, kHeaderSize + index * kTaggedSize);
+  return RELAXED_READ_FIELD(*this, kHeaderSize + index * kTaggedSize);
 }
 
 Handle<Object> FixedArray::get(FixedArray array, int index, Isolate* isolate) {
@@ -120,7 +120,7 @@ void FixedArray::set(int index, Smi value) {
   DCHECK_LT(index, this->length());
   DCHECK(Object(value).IsSmi());
   int offset = kHeaderSize + index * kTaggedSize;
-  RELAXED_WRITE_FIELD(this, offset, value);
+  RELAXED_WRITE_FIELD(*this, offset, value);
 }
 
 void FixedArray::set(int index, Object value) {
@@ -310,7 +310,7 @@ double FixedDoubleArray::get_scalar(int index) {
          map() != GetReadOnlyRoots().fixed_array_map());
   DCHECK(index >= 0 && index < this->length());
   DCHECK(!is_the_hole(index));
-  return READ_DOUBLE_FIELD(this, kHeaderSize + index * kDoubleSize);
+  return READ_DOUBLE_FIELD(*this, kHeaderSize + index * kDoubleSize);
 }
 
 uint64_t FixedDoubleArray::get_representation(int index) {
@@ -318,7 +318,7 @@ uint64_t FixedDoubleArray::get_representation(int index) {
          map() != GetReadOnlyRoots().fixed_array_map());
   DCHECK(index >= 0 && index < this->length());
   int offset = kHeaderSize + index * kDoubleSize;
-  return READ_UINT64_FIELD(this, offset);
+  return READ_UINT64_FIELD(*this, offset);
 }
 
 Handle<Object> FixedDoubleArray::get(FixedDoubleArray array, int index,
@@ -335,9 +335,9 @@ void FixedDoubleArray::set(int index, double value) {
          map() != GetReadOnlyRoots().fixed_array_map());
   int offset = kHeaderSize + index * kDoubleSize;
   if (std::isnan(value)) {
-    WRITE_DOUBLE_FIELD(this, offset, std::numeric_limits<double>::quiet_NaN());
+    WRITE_DOUBLE_FIELD(*this, offset, std::numeric_limits<double>::quiet_NaN());
   } else {
-    WRITE_DOUBLE_FIELD(this, offset, value);
+    WRITE_DOUBLE_FIELD(*this, offset, value);
   }
   DCHECK(!is_the_hole(index));
 }
@@ -350,7 +350,7 @@ void FixedDoubleArray::set_the_hole(int index) {
   DCHECK(map() != GetReadOnlyRoots().fixed_cow_array_map() &&
          map() != GetReadOnlyRoots().fixed_array_map());
   int offset = kHeaderSize + index * kDoubleSize;
-  WRITE_UINT64_FIELD(this, offset, kHoleNanInt64);
+  WRITE_UINT64_FIELD(*this, offset, kHoleNanInt64);
 }
 
 bool FixedDoubleArray::is_the_hole(Isolate* isolate, int index) {
@@ -464,46 +464,46 @@ int ByteArray::Size() { return RoundUp(length() + kHeaderSize, kTaggedSize); }
 
 byte ByteArray::get(int index) const {
   DCHECK(index >= 0 && index < this->length());
-  return READ_BYTE_FIELD(this, kHeaderSize + index * kCharSize);
+  return READ_BYTE_FIELD(*this, kHeaderSize + index * kCharSize);
 }
 
 void ByteArray::set(int index, byte value) {
   DCHECK(index >= 0 && index < this->length());
-  WRITE_BYTE_FIELD(this, kHeaderSize + index * kCharSize, value);
+  WRITE_BYTE_FIELD(*this, kHeaderSize + index * kCharSize, value);
 }
 
 void ByteArray::copy_in(int index, const byte* buffer, int length) {
   DCHECK(index >= 0 && length >= 0 && length <= kMaxInt - index &&
          index + length <= this->length());
-  Address dst_addr = FIELD_ADDR(this, kHeaderSize + index * kCharSize);
+  Address dst_addr = FIELD_ADDR(*this, kHeaderSize + index * kCharSize);
   memcpy(reinterpret_cast<void*>(dst_addr), buffer, length);
 }
 
 void ByteArray::copy_out(int index, byte* buffer, int length) {
   DCHECK(index >= 0 && length >= 0 && length <= kMaxInt - index &&
          index + length <= this->length());
-  Address src_addr = FIELD_ADDR(this, kHeaderSize + index * kCharSize);
+  Address src_addr = FIELD_ADDR(*this, kHeaderSize + index * kCharSize);
   memcpy(buffer, reinterpret_cast<void*>(src_addr), length);
 }
 
 int ByteArray::get_int(int index) const {
   DCHECK(index >= 0 && index < this->length() / kIntSize);
-  return READ_INT_FIELD(this, kHeaderSize + index * kIntSize);
+  return READ_INT_FIELD(*this, kHeaderSize + index * kIntSize);
 }
 
 void ByteArray::set_int(int index, int value) {
   DCHECK(index >= 0 && index < this->length() / kIntSize);
-  WRITE_INT_FIELD(this, kHeaderSize + index * kIntSize, value);
+  WRITE_INT_FIELD(*this, kHeaderSize + index * kIntSize, value);
 }
 
 uint32_t ByteArray::get_uint32(int index) const {
   DCHECK(index >= 0 && index < this->length() / kUInt32Size);
-  return READ_UINT32_FIELD(this, kHeaderSize + index * kUInt32Size);
+  return READ_UINT32_FIELD(*this, kHeaderSize + index * kUInt32Size);
 }
 
 void ByteArray::set_uint32(int index, uint32_t value) {
   DCHECK(index >= 0 && index < this->length() / kUInt32Size);
-  WRITE_UINT32_FIELD(this, kHeaderSize + index * kUInt32Size, value);
+  WRITE_UINT32_FIELD(*this, kHeaderSize + index * kUInt32Size, value);
 }
 
 void ByteArray::clear_padding() {
@@ -550,14 +550,14 @@ int PodArray<T>::length() const {
 }
 
 void* FixedTypedArrayBase::external_pointer() const {
-  intptr_t ptr = READ_INTPTR_FIELD(this, kExternalPointerOffset);
+  intptr_t ptr = READ_INTPTR_FIELD(*this, kExternalPointerOffset);
   return reinterpret_cast<void*>(ptr);
 }
 
 void FixedTypedArrayBase::set_external_pointer(void* value,
                                                WriteBarrierMode mode) {
   intptr_t ptr = reinterpret_cast<intptr_t>(value);
-  WRITE_INTPTR_FIELD(this, kExternalPointerOffset, ptr);
+  WRITE_INTPTR_FIELD(*this, kExternalPointerOffset, ptr);
 }
 
 void* FixedTypedArrayBase::DataPtr() {

src/objects/foreign-inl.h

@@ -26,11 +26,11 @@ bool Foreign::IsNormalized(Object value) {
 }
 
 Address Foreign::foreign_address() {
-  return READ_UINTPTR_FIELD(this, kForeignAddressOffset);
+  return READ_UINTPTR_FIELD(*this, kForeignAddressOffset);
 }
 
 void Foreign::set_foreign_address(Address value) {
-  WRITE_UINTPTR_FIELD(this, kForeignAddressOffset, value);
+  WRITE_UINTPTR_FIELD(*this, kForeignAddressOffset, value);
 }
 
 }  // namespace internal

src/objects/heap-number-inl.h

@@ -23,29 +23,29 @@ CAST_ACCESSOR(HeapNumber)
 CAST_ACCESSOR(MutableHeapNumber)
 
 double HeapNumberBase::value() const {
-  return READ_DOUBLE_FIELD(this, kValueOffset);
+  return READ_DOUBLE_FIELD(*this, kValueOffset);
 }
 
 void HeapNumberBase::set_value(double value) {
-  WRITE_DOUBLE_FIELD(this, kValueOffset, value);
+  WRITE_DOUBLE_FIELD(*this, kValueOffset, value);
 }
 
 uint64_t HeapNumberBase::value_as_bits() const {
-  return READ_UINT64_FIELD(this, kValueOffset);
+  return READ_UINT64_FIELD(*this, kValueOffset);
 }
 
 void HeapNumberBase::set_value_as_bits(uint64_t bits) {
-  WRITE_UINT64_FIELD(this, kValueOffset, bits);
+  WRITE_UINT64_FIELD(*this, kValueOffset, bits);
 }
 
 int HeapNumberBase::get_exponent() {
-  return ((READ_INT_FIELD(this, kExponentOffset) & kExponentMask) >>
+  return ((READ_INT_FIELD(*this, kExponentOffset) & kExponentMask) >>
           kExponentShift) -
          kExponentBias;
 }
 
 int HeapNumberBase::get_sign() {
-  return READ_INT_FIELD(this, kExponentOffset) & kSignMask;
+  return READ_INT_FIELD(*this, kExponentOffset) & kSignMask;
 }
 
 }  // namespace internal

src/objects/js-array-buffer-inl.h

@@ -27,21 +27,21 @@ CAST_ACCESSOR(JSTypedArray)
 CAST_ACCESSOR(JSDataView)
 
 size_t JSArrayBuffer::byte_length() const {
-  return READ_UINTPTR_FIELD(this, kByteLengthOffset);
+  return READ_UINTPTR_FIELD(*this, kByteLengthOffset);
 }
 
 void JSArrayBuffer::set_byte_length(size_t value) {
-  WRITE_UINTPTR_FIELD(this, kByteLengthOffset, value);
+  WRITE_UINTPTR_FIELD(*this, kByteLengthOffset, value);
 }
 
 void* JSArrayBuffer::backing_store() const {
-  intptr_t ptr = READ_INTPTR_FIELD(this, kBackingStoreOffset);
+  intptr_t ptr = READ_INTPTR_FIELD(*this, kBackingStoreOffset);
   return reinterpret_cast<void*>(ptr);
 }
 
 void JSArrayBuffer::set_backing_store(void* value, WriteBarrierMode mode) {
   intptr_t ptr = reinterpret_cast<intptr_t>(value);
-  WRITE_INTPTR_FIELD(this, kBackingStoreOffset, ptr);
+  WRITE_INTPTR_FIELD(*this, kBackingStoreOffset, ptr);
 }
 
 size_t JSArrayBuffer::allocation_length() const {
@@ -95,11 +95,11 @@ void JSArrayBuffer::clear_padding() {
 }
 
 void JSArrayBuffer::set_bit_field(uint32_t bits) {
-  WRITE_UINT32_FIELD(this, kBitFieldOffset, bits);
+  WRITE_UINT32_FIELD(*this, kBitFieldOffset, bits);
 }
 
 uint32_t JSArrayBuffer::bit_field() const {
-  return READ_UINT32_FIELD(this, kBitFieldOffset);
+  return READ_UINT32_FIELD(*this, kBitFieldOffset);
 }
 
 // |bit_field| fields.
@@ -115,19 +115,19 @@ BIT_FIELD_ACCESSORS(JSArrayBuffer, bit_field, is_growable,
                     JSArrayBuffer::IsGrowableBit)
 
 size_t JSArrayBufferView::byte_offset() const {
-  return READ_UINTPTR_FIELD(this, kByteOffsetOffset);
+  return READ_UINTPTR_FIELD(*this, kByteOffsetOffset);
 }
 
 void JSArrayBufferView::set_byte_offset(size_t value) {
-  WRITE_UINTPTR_FIELD(this, kByteOffsetOffset, value);
+  WRITE_UINTPTR_FIELD(*this, kByteOffsetOffset, value);
 }
 
 size_t JSArrayBufferView::byte_length() const {
-  return READ_UINTPTR_FIELD(this, kByteLengthOffset);
+  return READ_UINTPTR_FIELD(*this, kByteLengthOffset);
 }
 
 void JSArrayBufferView::set_byte_length(size_t value) {
-  WRITE_UINTPTR_FIELD(this, kByteLengthOffset, value);
+  WRITE_UINTPTR_FIELD(*this, kByteLengthOffset, value);
 }
 
 ACCESSORS(JSArrayBufferView, buffer, Object, kBufferOffset)
@@ -136,7 +136,7 @@ bool JSArrayBufferView::WasDetached() const {
   return JSArrayBuffer::cast(buffer())->was_detached();
 }
 
-Object JSTypedArray::length() const { return READ_FIELD(this, kLengthOffset); }
+Object JSTypedArray::length() const { return READ_FIELD(*this, kLengthOffset); }
 
 size_t JSTypedArray::length_value() const {
   double val = length()->Number();
@@ -148,7 +148,7 @@ size_t JSTypedArray::length_value() const {
 }
 
 void JSTypedArray::set_length(Object value, WriteBarrierMode mode) {
-  WRITE_FIELD(this, kLengthOffset, value);
+  WRITE_FIELD(*this, kLengthOffset, value);
   CONDITIONAL_WRITE_BARRIER(*this, kLengthOffset, value, mode);
 }
 

src/objects/js-array-inl.h

@@ -63,11 +63,11 @@ ACCESSORS(JSArrayIterator, next_index, Object, kNextIndexOffset)
 
 IterationKind JSArrayIterator::kind() const {
   return static_cast<IterationKind>(
-      Smi::cast(READ_FIELD(this, kKindOffset))->value());
+      Smi::cast(READ_FIELD(*this, kKindOffset))->value());
 }
 
 void JSArrayIterator::set_kind(IterationKind kind) {
-  WRITE_FIELD(this, kKindOffset, Smi::FromInt(static_cast<int>(kind)));
+  WRITE_FIELD(*this, kKindOffset, Smi::FromInt(static_cast<int>(kind)));
 }
 
 }  // namespace internal

src/objects/js-break-iterator-inl.h

@@ -22,11 +22,11 @@ OBJECT_CONSTRUCTORS_IMPL(JSV8BreakIterator, JSObject)
 
 inline void JSV8BreakIterator::set_type(Type type) {
   DCHECK_GT(JSV8BreakIterator::Type::COUNT, type);
-  WRITE_FIELD(this, kTypeOffset, Smi::FromInt(static_cast<int>(type)));
+  WRITE_FIELD(*this, kTypeOffset, Smi::FromInt(static_cast<int>(type)));
 }
 
 inline JSV8BreakIterator::Type JSV8BreakIterator::type() const {
-  Object value = READ_FIELD(this, kTypeOffset);
+  Object value = READ_FIELD(*this, kTypeOffset);
   return static_cast<JSV8BreakIterator::Type>(Smi::ToInt(value));
 }
 

src/objects/js-objects-inl.h

@@ -131,7 +131,7 @@ bool JSObject::PrototypeHasNoElements(Isolate* isolate, JSObject object) {
 ACCESSORS(JSReceiver, raw_properties_or_hash, Object, kPropertiesOrHashOffset)
 
 FixedArrayBase JSObject::elements() const {
-  Object array = READ_FIELD(this, kElementsOffset);
+  Object array = READ_FIELD(*this, kElementsOffset);
   return FixedArrayBase::cast(array);
 }
 
@@ -332,7 +332,7 @@ bool JSObject::IsUnboxedDoubleField(FieldIndex index) {
 Object JSObject::RawFastPropertyAt(FieldIndex index) {
   DCHECK(!IsUnboxedDoubleField(index));
   if (index.is_inobject()) {
-    return READ_FIELD(this, index.offset());
+    return READ_FIELD(*this, index.offset());
   } else {
     return property_array()->get(index.outobject_array_index());
   }
@@ -340,12 +340,12 @@ Object JSObject::RawFastPropertyAt(FieldIndex index) {
 
 double JSObject::RawFastDoublePropertyAt(FieldIndex index) {
   DCHECK(IsUnboxedDoubleField(index));
-  return READ_DOUBLE_FIELD(this, index.offset());
+  return READ_DOUBLE_FIELD(*this, index.offset());
 }
 
 uint64_t JSObject::RawFastDoublePropertyAsBitsAt(FieldIndex index) {
   DCHECK(IsUnboxedDoubleField(index));
-  return READ_UINT64_FIELD(this, index.offset());
+  return READ_UINT64_FIELD(*this, index.offset());
 }
 
 void JSObject::RawFastPropertyAtPut(FieldIndex index, Object value) {
@@ -454,7 +454,7 @@ void JSObject::InitializeBody(Map map, int start_offset,
 }
 
 Object JSBoundFunction::raw_bound_target_function() const {
-  return READ_FIELD(this, kBoundTargetFunctionOffset);
+  return READ_FIELD(*this, kBoundTargetFunctionOffset);
 }
 
 ACCESSORS(JSBoundFunction, bound_target_function, JSReceiver,
@@ -716,11 +716,11 @@ ACCESSORS(JSDate, min, Object, kMinOffset)
 ACCESSORS(JSDate, sec, Object, kSecOffset)
 
 MessageTemplate JSMessageObject::type() const {
-  Object value = READ_FIELD(this, kTypeOffset);
+  Object value = READ_FIELD(*this, kTypeOffset);
   return MessageTemplateFromInt(Smi::ToInt(value));
 }
 void JSMessageObject::set_type(MessageTemplate value) {
-  WRITE_FIELD(this, kTypeOffset, Smi::FromInt(static_cast<int>(value)));
+  WRITE_FIELD(*this, kTypeOffset, Smi::FromInt(static_cast<int>(value)));
 }
 ACCESSORS(JSMessageObject, argument, Object, kArgumentsOffset)
 ACCESSORS(JSMessageObject, script, Script, kScriptOffset)
@@ -733,7 +733,7 @@ ElementsKind JSObject::GetElementsKind() const {
   ElementsKind kind = map()->elements_kind();
 #if VERIFY_HEAP && DEBUG
   FixedArrayBase fixed_array =
-      FixedArrayBase::unchecked_cast(READ_FIELD(this, kElementsOffset));
+      FixedArrayBase::unchecked_cast(READ_FIELD(*this, kElementsOffset));
 
   // If a GC was caused while constructing this object, the elements
   // pointer may point to a one pointer filler map.
@@ -854,10 +854,10 @@ void JSReceiver::initialize_properties() {
   DCHECK(!Heap::InYoungGeneration(roots.empty_fixed_array()));
   DCHECK(!Heap::InYoungGeneration(roots.empty_property_dictionary()));
   if (map()->is_dictionary_map()) {
-    WRITE_FIELD(this, kPropertiesOrHashOffset,
+    WRITE_FIELD(*this, kPropertiesOrHashOffset,
                 roots.empty_property_dictionary());
   } else {
-    WRITE_FIELD(this, kPropertiesOrHashOffset, roots.empty_fixed_array());
+    WRITE_FIELD(*this, kPropertiesOrHashOffset, roots.empty_fixed_array());
   }
 }
 

src/objects/map-inl.h

@@ -209,20 +209,20 @@ FixedArrayBase Map::GetInitialElements() const {
 
 VisitorId Map::visitor_id() const {
   return static_cast<VisitorId>(
-      RELAXED_READ_BYTE_FIELD(this, kVisitorIdOffset));
+      RELAXED_READ_BYTE_FIELD(*this, kVisitorIdOffset));
 }
 
 void Map::set_visitor_id(VisitorId id) {
   CHECK_LT(static_cast<unsigned>(id), 256);
-  RELAXED_WRITE_BYTE_FIELD(this, kVisitorIdOffset, static_cast<byte>(id));
+  RELAXED_WRITE_BYTE_FIELD(*this, kVisitorIdOffset, static_cast<byte>(id));
 }
 
 int Map::instance_size_in_words() const {
-  return RELAXED_READ_BYTE_FIELD(this, kInstanceSizeInWordsOffset);
+  return RELAXED_READ_BYTE_FIELD(*this, kInstanceSizeInWordsOffset);
 }
 
 void Map::set_instance_size_in_words(int value) {
-  RELAXED_WRITE_BYTE_FIELD(this, kInstanceSizeInWordsOffset,
+  RELAXED_WRITE_BYTE_FIELD(*this, kInstanceSizeInWordsOffset,
                            static_cast<byte>(value));
 }
 
@@ -239,14 +239,14 @@ void Map::set_instance_size(int value) {
 
 int Map::inobject_properties_start_or_constructor_function_index() const {
   return RELAXED_READ_BYTE_FIELD(
-      this, kInObjectPropertiesStartOrConstructorFunctionIndexOffset);
+      *this, kInObjectPropertiesStartOrConstructorFunctionIndexOffset);
 }
 
 void Map::set_inobject_properties_start_or_constructor_function_index(
     int value) {
   CHECK_LT(static_cast<unsigned>(value), 256);
   RELAXED_WRITE_BYTE_FIELD(
-      this, kInObjectPropertiesStartOrConstructorFunctionIndexOffset,
+      *this, kInObjectPropertiesStartOrConstructorFunctionIndexOffset,
       static_cast<byte>(value));
 }
 
@@ -289,11 +289,11 @@ Handle<Map> Map::AddMissingTransitionsForTesting(
 
 InstanceType Map::instance_type() const {
   return static_cast<InstanceType>(
-      READ_UINT16_FIELD(this, kInstanceTypeOffset));
+      READ_UINT16_FIELD(*this, kInstanceTypeOffset));
 }
 
 void Map::set_instance_type(InstanceType value) {
-  WRITE_UINT16_FIELD(this, kInstanceTypeOffset, value);
+  WRITE_UINT16_FIELD(*this, kInstanceTypeOffset, value);
 }
 
 int Map::UnusedPropertyFields() const {
@@ -322,12 +322,12 @@ int Map::UnusedInObjectProperties() const {
 }
 
 int Map::used_or_unused_instance_size_in_words() const {
-  return RELAXED_READ_BYTE_FIELD(this, kUsedOrUnusedInstanceSizeInWordsOffset);
+  return RELAXED_READ_BYTE_FIELD(*this, kUsedOrUnusedInstanceSizeInWordsOffset);
 }
 
 void Map::set_used_or_unused_instance_size_in_words(int value) {
   CHECK_LE(static_cast<unsigned>(value), 255);
-  RELAXED_WRITE_BYTE_FIELD(this, kUsedOrUnusedInstanceSizeInWordsOffset,
+  RELAXED_WRITE_BYTE_FIELD(*this, kUsedOrUnusedInstanceSizeInWordsOffset,
                            static_cast<byte>(value));
 }
 
@@ -415,16 +415,18 @@ void Map::AccountAddedOutOfObjectPropertyField(int unused_in_property_array) {
   DCHECK_EQ(unused_in_property_array, UnusedPropertyFields());
 }
 
-byte Map::bit_field() const { return READ_BYTE_FIELD(this, kBitFieldOffset); }
+byte Map::bit_field() const { return READ_BYTE_FIELD(*this, kBitFieldOffset); }
 
 void Map::set_bit_field(byte value) {
-  WRITE_BYTE_FIELD(this, kBitFieldOffset, value);
+  WRITE_BYTE_FIELD(*this, kBitFieldOffset, value);
 }
 
-byte Map::bit_field2() const { return READ_BYTE_FIELD(this, kBitField2Offset); }
+byte Map::bit_field2() const {
+  return READ_BYTE_FIELD(*this, kBitField2Offset);
+}
 
 void Map::set_bit_field2(byte value) {
-  WRITE_BYTE_FIELD(this, kBitField2Offset, value);
+  WRITE_BYTE_FIELD(*this, kBitField2Offset, value);
 }
 
 bool Map::is_abandoned_prototype_map() const {
@@ -549,7 +551,7 @@ bool Map::IsPrimitiveMap() const {
   return instance_type() <= LAST_PRIMITIVE_TYPE;
 }
 
-Object Map::prototype() const { return READ_FIELD(this, kPrototypeOffset); }
+Object Map::prototype() const { return READ_FIELD(*this, kPrototypeOffset); }
 
 void Map::set_prototype(Object value, WriteBarrierMode mode) {
   DCHECK(value->IsNull() || value->IsJSReceiver());
@@ -616,13 +618,13 @@ void Map::InitializeDescriptors(Isolate* isolate, DescriptorArray descriptors,
 
 void Map::set_bit_field3(uint32_t bits) {
   if (kInt32Size != kTaggedSize) {
-    RELAXED_WRITE_UINT32_FIELD(this, kBitField3Offset + kInt32Size, 0);
+    RELAXED_WRITE_UINT32_FIELD(*this, kBitField3Offset + kInt32Size, 0);
   }
-  RELAXED_WRITE_UINT32_FIELD(this, kBitField3Offset, bits);
+  RELAXED_WRITE_UINT32_FIELD(*this, kBitField3Offset, bits);
 }
 
 uint32_t Map::bit_field3() const {
-  return RELAXED_READ_UINT32_FIELD(this, kBitField3Offset);
+  return RELAXED_READ_UINT32_FIELD(*this, kBitField3Offset);
 }
 
 LayoutDescriptor Map::GetLayoutDescriptor() const {
@@ -678,7 +680,7 @@ Map Map::ElementsTransitionMap() {
 
 Object Map::prototype_info() const {
   DCHECK(is_prototype_map());
-  return READ_FIELD(this, Map::kTransitionsOrPrototypeInfoOffset);
+  return READ_FIELD(*this, Map::kTransitionsOrPrototypeInfoOffset);
 }
 
 void Map::set_prototype_info(Object value, WriteBarrierMode mode) {

src/objects/name-inl.h

@@ -52,11 +52,11 @@ bool Name::IsUniqueName() const {
 }
 
 uint32_t Name::hash_field() {
-  return READ_UINT32_FIELD(this, kHashFieldOffset);
+  return READ_UINT32_FIELD(*this, kHashFieldOffset);
 }
 
 void Name::set_hash_field(uint32_t value) {
-  WRITE_UINT32_FIELD(this, kHashFieldOffset, value);
+  WRITE_UINT32_FIELD(*this, kHashFieldOffset, value);
 }
 
 bool Name::Equals(Name other) {

src/objects/object-macros.h

@@ -80,38 +80,38 @@
 #define CAST_ACCESSOR(Type) \
   Type Type::cast(Object object) { return Type(object.ptr()); }
 
-#define INT_ACCESSORS(holder, name, offset)                         \
-  int holder::name() const { return READ_INT_FIELD(this, offset); } \
-  void holder::set_##name(int value) { WRITE_INT_FIELD(this, offset, value); }
-
-#define INT32_ACCESSORS(holder, name, offset)                             \
-  int32_t holder::name() const { return READ_INT32_FIELD(this, offset); } \
-  void holder::set_##name(int32_t value) {                                \
-    WRITE_INT32_FIELD(this, offset, value);                               \
+#define INT_ACCESSORS(holder, name, offset)                          \
+  int holder::name() const { return READ_INT_FIELD(*this, offset); } \
+  void holder::set_##name(int value) { WRITE_INT_FIELD(*this, offset, value); }
+
+#define INT32_ACCESSORS(holder, name, offset)                              \
+  int32_t holder::name() const { return READ_INT32_FIELD(*this, offset); } \
+  void holder::set_##name(int32_t value) {                                 \
+    WRITE_INT32_FIELD(*this, offset, value);                               \
   }
 
 #define RELAXED_INT32_ACCESSORS(holder, name, offset) \
   int32_t holder::name() const {                      \
-    return RELAXED_READ_INT32_FIELD(this, offset);    \
+    return RELAXED_READ_INT32_FIELD(*this, offset);   \
   }                                                   \
   void holder::set_##name(int32_t value) {            \
-    RELAXED_WRITE_INT32_FIELD(this, offset, value);   \
+    RELAXED_WRITE_INT32_FIELD(*this, offset, value);  \
   }
 
-#define UINT16_ACCESSORS(holder, name, offset)                              \
-  uint16_t holder::name() const { return READ_UINT16_FIELD(this, offset); } \
-  void holder::set_##name(int value) {                                      \
-    DCHECK_GE(value, 0);                                                    \
-    DCHECK_LE(value, static_cast<uint16_t>(-1));                            \
-    WRITE_UINT16_FIELD(this, offset, value);                                \
+#define UINT16_ACCESSORS(holder, name, offset)                               \
+  uint16_t holder::name() const { return READ_UINT16_FIELD(*this, offset); } \
+  void holder::set_##name(int value) {                                       \
+    DCHECK_GE(value, 0);                                                     \
+    DCHECK_LE(value, static_cast<uint16_t>(-1));                             \
+    WRITE_UINT16_FIELD(*this, offset, value);                                \
   }
 
-#define UINT8_ACCESSORS(holder, name, offset)                             \
-  uint8_t holder::name() const { return READ_UINT8_FIELD(this, offset); } \
-  void holder::set_##name(int value) {                                    \
-    DCHECK_GE(value, 0);                                                  \
-    DCHECK_LE(value, static_cast<uint8_t>(-1));                           \
-    WRITE_UINT8_FIELD(this, offset, value);                               \
+#define UINT8_ACCESSORS(holder, name, offset)                              \
+  uint8_t holder::name() const { return READ_UINT8_FIELD(*this, offset); } \
+  void holder::set_##name(int value) {                                     \
+    DCHECK_GE(value, 0);                                                   \
+    DCHECK_LE(value, static_cast<uint8_t>(-1));                            \
+    WRITE_UINT8_FIELD(*this, offset, value);                               \
   }
 
 #define ACCESSORS_CHECKED2(holder, name, type, offset, get_condition, \
@@ -240,7 +240,7 @@
     RELAXED_WRITE_INT16_FIELD(*this, offset, value);  \
   }
 
-#define FIELD_ADDR(p, offset) ((p)->ptr() + offset - kHeapObjectTag)
+#define FIELD_ADDR(p, offset) ((p).ptr() + offset - kHeapObjectTag)
 
 #define READ_FIELD(p, offset) (*ObjectSlot(FIELD_ADDR(p, offset)))
 

src/objects/oddball-inl.h

@@ -20,25 +20,27 @@ OBJECT_CONSTRUCTORS_IMPL(Oddball, HeapObject)
 CAST_ACCESSOR(Oddball)
 
 double Oddball::to_number_raw() const {
-  return READ_DOUBLE_FIELD(this, kToNumberRawOffset);
+  return READ_DOUBLE_FIELD(*this, kToNumberRawOffset);
 }
 
 void Oddball::set_to_number_raw(double value) {
-  WRITE_DOUBLE_FIELD(this, kToNumberRawOffset, value);
+  WRITE_DOUBLE_FIELD(*this, kToNumberRawOffset, value);
 }
 
 void Oddball::set_to_number_raw_as_bits(uint64_t bits) {
-  WRITE_UINT64_FIELD(this, kToNumberRawOffset, bits);
+  WRITE_UINT64_FIELD(*this, kToNumberRawOffset, bits);
 }
 
 ACCESSORS(Oddball, to_string, String, kToStringOffset)
 ACCESSORS(Oddball, to_number, Object, kToNumberOffset)
 ACCESSORS(Oddball, type_of, String, kTypeOfOffset)
 
-byte Oddball::kind() const { return Smi::ToInt(READ_FIELD(this, kKindOffset)); }
+byte Oddball::kind() const {
+  return Smi::ToInt(READ_FIELD(*this, kKindOffset));
+}
 
 void Oddball::set_kind(byte value) {
-  WRITE_FIELD(this, kKindOffset, Smi::FromInt(value));
+  WRITE_FIELD(*this, kKindOffset, Smi::FromInt(value));
 }
 
 // static

src/objects/ordered-hash-table.h

@@ -406,7 +406,7 @@ class SmallOrderedHashTable : public HeapObject {
   Object KeyAt(int entry) const {
     DCHECK_LT(entry, Capacity());
     Offset entry_offset = GetDataEntryOffset(entry, Derived::kKeyIndex);
-    return READ_FIELD(this, entry_offset);
+    return READ_FIELD(*this, entry_offset);
   }
 
   DECL_VERIFIER(SmallOrderedHashTable)
@@ -449,7 +449,7 @@ class SmallOrderedHashTable : public HeapObject {
   }
 
   Address GetHashTableStartAddress(int capacity) const {
-    return FIELD_ADDR(this,
+    return FIELD_ADDR(*this,
                       DataTableStartOffset() + DataTableSizeFor(capacity));
   }
 
@@ -491,7 +491,7 @@ class SmallOrderedHashTable : public HeapObject {
     DCHECK_LT(entry, Capacity());
     DCHECK_LE(static_cast<unsigned>(relative_index), Derived::kEntrySize);
     Offset entry_offset = GetDataEntryOffset(entry, relative_index);
-    return READ_FIELD(this, entry_offset);
+    return READ_FIELD(*this, entry_offset);
   }
 
   int HashToBucket(int hash) const { return hash & (NumberOfBuckets() - 1); }
@@ -542,13 +542,13 @@ class SmallOrderedHashTable : public HeapObject {
   byte getByte(Offset offset, ByteIndex index) const {
     DCHECK(offset < DataTableStartOffset() ||
            offset >= GetBucketsStartOffset());
-    return READ_BYTE_FIELD(this, offset + (index * kOneByteSize));
+    return READ_BYTE_FIELD(*this, offset + (index * kOneByteSize));
   }
 
   void setByte(Offset offset, ByteIndex index, byte value) {
     DCHECK(offset < DataTableStartOffset() ||
            offset >= GetBucketsStartOffset());
-    WRITE_BYTE_FIELD(this, offset + (index * kOneByteSize), value);
+    WRITE_BYTE_FIELD(*this, offset + (index * kOneByteSize), value);
   }
 
   Offset GetDataEntryOffset(int entry, int relative_index) const {

src/objects/shared-function-info-inl.h

@@ -61,7 +61,7 @@ void PreparseData::set(int index, byte value) {
 void PreparseData::copy_in(int index, const byte* buffer, int length) {
   DCHECK(index >= 0 && length >= 0 && length <= kMaxInt - index &&
          index + length <= this->data_length());
-  Address dst_addr = FIELD_ADDR(this, kDataStartOffset + index * kByteSize);
+  Address dst_addr = FIELD_ADDR(*this, kDataStartOffset + index * kByteSize);
   memcpy(reinterpret_cast<void*>(dst_addr), buffer, length);
 }
 

src/objects/string-inl.h

@@ -25,12 +25,12 @@ INT32_ACCESSORS(String, length, kLengthOffset)
 
 int String::synchronized_length() const {
   return base::AsAtomic32::Acquire_Load(
-      reinterpret_cast<const int32_t*>(FIELD_ADDR(this, kLengthOffset)));
+      reinterpret_cast<const int32_t*>(FIELD_ADDR(*this, kLengthOffset)));
 }
 
 void String::synchronized_set_length(int value) {
   base::AsAtomic32::Release_Store(
-      reinterpret_cast<int32_t*>(FIELD_ADDR(this, kLengthOffset)), value);
+      reinterpret_cast<int32_t*>(FIELD_ADDR(*this, kLengthOffset)), value);
 }
 
 OBJECT_CONSTRUCTORS_IMPL(String, Name)
@@ -382,7 +382,7 @@ String String::GetUnderlying() {
   STATIC_ASSERT(static_cast<int>(ConsString::kFirstOffset) ==
                 static_cast<int>(ThinString::kActualOffset));
   const int kUnderlyingOffset = SlicedString::kParentOffset;
-  return String::cast(READ_FIELD(this, kUnderlyingOffset));
+  return String::cast(READ_FIELD(*this, kUnderlyingOffset));
 }
 
 template <class Visitor>
@@ -467,17 +467,17 @@ uint32_t String::ToValidIndex(Object number) {
 
 uint16_t SeqOneByteString::SeqOneByteStringGet(int index) {
   DCHECK(index >= 0 && index < length());
-  return READ_BYTE_FIELD(this, kHeaderSize + index * kCharSize);
+  return READ_BYTE_FIELD(*this, kHeaderSize + index * kCharSize);
 }
 
 void SeqOneByteString::SeqOneByteStringSet(int index, uint16_t value) {
   DCHECK(index >= 0 && index < length() && value <= kMaxOneByteCharCode);
-  WRITE_BYTE_FIELD(this, kHeaderSize + index * kCharSize,
+  WRITE_BYTE_FIELD(*this, kHeaderSize + index * kCharSize,
                    static_cast<byte>(value));
 }
 
 Address SeqOneByteString::GetCharsAddress() {
-  return FIELD_ADDR(this, kHeaderSize);
+  return FIELD_ADDR(*this, kHeaderSize);
 }
 
 uint8_t* SeqOneByteString::GetChars(const DisallowHeapAllocation& no_gc) {
@@ -486,22 +486,22 @@ uint8_t* SeqOneByteString::GetChars(const DisallowHeapAllocation& no_gc) {
 }
 
 Address SeqTwoByteString::GetCharsAddress() {
-  return FIELD_ADDR(this, kHeaderSize);
+  return FIELD_ADDR(*this, kHeaderSize);
 }
 
 uc16* SeqTwoByteString::GetChars(const DisallowHeapAllocation& no_gc) {
   USE(no_gc);
-  return reinterpret_cast<uc16*>(FIELD_ADDR(this, kHeaderSize));
+  return reinterpret_cast<uc16*>(FIELD_ADDR(*this, kHeaderSize));
 }
 
 uint16_t SeqTwoByteString::SeqTwoByteStringGet(int index) {
   DCHECK(index >= 0 && index < length());
-  return READ_UINT16_FIELD(this, kHeaderSize + index * kShortSize);
+  return READ_UINT16_FIELD(*this, kHeaderSize + index * kShortSize);
 }
 
 void SeqTwoByteString::SeqTwoByteStringSet(int index, uint16_t value) {
   DCHECK(index >= 0 && index < length());
-  WRITE_UINT16_FIELD(this, kHeaderSize + index * kShortSize, value);
+  WRITE_UINT16_FIELD(*this, kHeaderSize + index * kShortSize, value);
 }
 
 int SeqTwoByteString::SeqTwoByteStringSize(InstanceType instance_type) {
@@ -526,7 +526,7 @@ void SlicedString::set_parent(Isolate* isolate, String parent,
 SMI_ACCESSORS(SlicedString, offset, kOffsetOffset)
 
 String ConsString::first() {
-  return String::cast(READ_FIELD(this, kFirstOffset));
+  return String::cast(READ_FIELD(*this, kFirstOffset));
 }
 
 Object ConsString::unchecked_first() { return READ_FIELD(*this, kFirstOffset); }

src/objects/struct-inl.h

@@ -36,7 +36,7 @@ CAST_ACCESSOR(ClassPositions)
 void Struct::InitializeBody(int object_size) {
   Object value = GetReadOnlyRoots().undefined_value();
   for (int offset = kHeaderSize; offset < object_size; offset += kPointerSize) {
-    WRITE_FIELD(this, offset, value);
+    WRITE_FIELD(*this, offset, value);
   }
 }
 

src/wasm/wasm-objects-inl.h

@@ -62,10 +62,10 @@ CAST_ACCESSOR(AsmWasmData)
 
 #define PRIMITIVE_ACCESSORS(holder, name, type, offset) \
   type holder::name() const {                           \
-    return READ_PRIMITIVE_FIELD(this, type, offset);    \
+    return READ_PRIMITIVE_FIELD(*this, type, offset);   \
   }                                                     \
   void holder::set_##name(type value) {                 \
-    WRITE_PRIMITIVE_FIELD(this, type, offset, value);   \
+    WRITE_PRIMITIVE_FIELD(*this, type, offset, value);  \
   }
 
 // WasmModuleObject
@@ -91,7 +91,7 @@ const wasm::WasmModule* WasmModuleObject::module() const {
   return native_module()->module();
 }
 void WasmModuleObject::reset_breakpoint_infos() {
-  WRITE_FIELD(this, kBreakPointInfosOffset,
+  WRITE_FIELD(*this, kBreakPointInfosOffset,
               GetReadOnlyRoots().undefined_value());
 }
 bool WasmModuleObject::is_asm_js() {