object-macros.h 28 KB
Newer Older
1 2 3 4 5 6 7 8 9
// Copyright 2016 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

// Note 1: Any file that includes this one should include object-macros-undef.h
// at the bottom.

// Note 2: This file is deliberately missing the include guards (the undeffing
// approach wouldn't work otherwise).
10 11
//
// PRESUBMIT_INTENTIONALLY_MISSING_INCLUDE_GUARD
12

13 14 15 16
// The accessors with RELAXED_, ACQUIRE_, and RELEASE_ prefixes should be used
// for fields that can be written to and read from multiple threads at the same
// time. See comments in src/base/atomicops.h for the memory ordering sematics.

17
#include "src/base/memory.h"
18

19 20
// Since this changes visibility, it should always be last in a class
// definition.
21 22 23 24 25 26 27 28
#define OBJECT_CONSTRUCTORS(Type, ...)             \
 public:                                           \
  constexpr Type() : __VA_ARGS__() {}              \
                                                   \
 protected:                                        \
  template <typename TFieldType, int kFieldOffset> \
  friend class TaggedField;                        \
                                                   \
29
  explicit inline Type(Address ptr)
30 31 32

#define OBJECT_CONSTRUCTORS_IMPL(Type, Super) \
  inline Type::Type(Address ptr) : Super(ptr) { SLOW_DCHECK(Is##Type()); }
33 34 35 36 37
// In these cases, we don't have our own instance type to check, so check the
// supertype instead. This happens for types denoting a NativeContext-dependent
// set of maps.
#define OBJECT_CONSTRUCTORS_IMPL_CHECK_SUPER(Type, Super) \
  inline Type::Type(Address ptr) : Super(ptr) { SLOW_DCHECK(Is##Super()); }
38

39 40 41 42
#define NEVER_READ_ONLY_SPACE   \
  inline Heap* GetHeap() const; \
  inline Isolate* GetIsolate() const;

43 44
// TODO(leszeks): Add checks in the factory that we never allocate these
// objects in RO space.
45 46 47 48
#define NEVER_READ_ONLY_SPACE_IMPL(Type)                                   \
  Heap* Type::GetHeap() const { return GetHeapFromWritableObject(*this); } \
  Isolate* Type::GetIsolate() const {                                      \
    return GetIsolateFromWritableObject(*this);                            \
49 50
  }

51 52 53
#define DECL_PRIMITIVE_ACCESSORS(name, type) \
  inline type name() const;                  \
  inline void set_##name(type value);
54

55 56 57 58
#define DECL_SYNCHRONIZED_PRIMITIVE_ACCESSORS(name, type) \
  inline type synchronized_##name() const;                \
  inline void synchronized_set_##name(type value);

59
#define DECL_BOOLEAN_ACCESSORS(name) DECL_PRIMITIVE_ACCESSORS(name, bool)
60

61 62
#define DECL_INT_ACCESSORS(name) DECL_PRIMITIVE_ACCESSORS(name, int)

63 64 65
#define DECL_SYNCHRONIZED_INT_ACCESSORS(name) \
  DECL_SYNCHRONIZED_PRIMITIVE_ACCESSORS(name, int)

66
#define DECL_INT32_ACCESSORS(name) DECL_PRIMITIVE_ACCESSORS(name, int32_t)
67

68 69 70 71
#define DECL_UINT16_ACCESSORS(name) \
  inline uint16_t name() const;     \
  inline void set_##name(int value);

72 73 74 75
#define DECL_INT16_ACCESSORS(name) \
  inline int16_t name() const;     \
  inline void set_##name(int16_t value);

76 77 78 79
#define DECL_UINT8_ACCESSORS(name) \
  inline uint8_t name() const;     \
  inline void set_##name(int value);

80 81 82 83 84
// TODO(ishell): eventually isolate-less getters should not be used anymore.
// For full pointer-mode the C++ compiler should optimize away unused isolate
// parameter.
#define DECL_GETTER(name, type) \
  inline type name() const;     \
85
  inline type name(IsolateRoot isolate) const;
86

87 88 89 90 91 92
#define DEF_GETTER(holder, name, type)                  \
  type holder::name() const {                           \
    IsolateRoot isolate = GetIsolateForPtrCompr(*this); \
    return holder::name(isolate);                       \
  }                                                     \
  type holder::name(IsolateRoot isolate) const
93

94
#define DECL_SETTER(name, type)      \
95
  inline void set_##name(type value, \
96 97
                         WriteBarrierMode mode = UPDATE_WRITE_BARRIER);

98 99 100 101
#define DECL_ACCESSORS(name, type) \
  DECL_GETTER(name, type)          \
  DECL_SETTER(name, type)

102 103
#define DECL_ACCESSORS_LOAD_TAG(name, type, tag_type) \
  inline type name(tag_type tag) const;               \
104
  inline type name(IsolateRoot isolate, tag_type) const;
105 106 107 108 109

#define DECL_ACCESSORS_STORE_TAG(name, type, tag_type) \
  inline void set_##name(type value, tag_type,         \
                         WriteBarrierMode mode = UPDATE_WRITE_BARRIER);

110 111 112 113
#define DECL_RELAXED_GETTER(name, type) \
  DECL_ACCESSORS_LOAD_TAG(name, type, RelaxedLoadTag)

#define DECL_RELAXED_SETTER(name, type) \
114 115
  DECL_ACCESSORS_STORE_TAG(name, type, RelaxedStoreTag)

116 117 118 119 120 121 122 123
#define DECL_RELAXED_ACCESSORS(name, type) \
  DECL_RELAXED_GETTER(name, type)          \
  DECL_RELAXED_SETTER(name, type)

#define DECL_ACQUIRE_GETTER(name, type) \
  DECL_ACCESSORS_LOAD_TAG(name, type, AcquireLoadTag)

#define DECL_RELEASE_SETTER(name, type) \
124
  DECL_ACCESSORS_STORE_TAG(name, type, ReleaseStoreTag)
125

126 127 128 129
#define DECL_RELEASE_ACQUIRE_ACCESSORS(name, type) \
  DECL_ACQUIRE_GETTER(name, type)                  \
  DECL_RELEASE_SETTER(name, type)

130
#define DECL_CAST(Type)                                 \
131 132 133
  V8_INLINE static Type cast(Object object);            \
  V8_INLINE static Type unchecked_cast(Object object) { \
    return bit_cast<Type>(object);                      \
134
  }
135

136
#define CAST_ACCESSOR(Type) \
137
  Type Type::cast(Object object) { return Type(object.ptr()); }
138

139 140
#define INT_ACCESSORS(holder, name, offset)                   \
  int holder::name() const { return ReadField<int>(offset); } \
141
  void holder::set_##name(int value) { WriteField<int>(offset, value); }
142

143 144
#define INT32_ACCESSORS(holder, name, offset)                         \
  int32_t holder::name() const { return ReadField<int32_t>(offset); } \
145
  void holder::set_##name(int32_t value) { WriteField<int32_t>(offset, value); }
146

147 148
#define RELAXED_INT32_ACCESSORS(holder, name, offset) \
  int32_t holder::name() const {                      \
149
    return RELAXED_READ_INT32_FIELD(*this, offset);   \
150 151
  }                                                   \
  void holder::set_##name(int32_t value) {            \
152
    RELAXED_WRITE_INT32_FIELD(*this, offset, value);  \
153 154
  }

155 156 157 158 159
#define UINT16_ACCESSORS(holder, name, offset)                          \
  uint16_t holder::name() const { return ReadField<uint16_t>(offset); } \
  void holder::set_##name(int value) {                                  \
    DCHECK_GE(value, 0);                                                \
    DCHECK_LE(value, static_cast<uint16_t>(-1));                        \
160
    WriteField<uint16_t>(offset, value);                                \
161 162
  }

163 164 165 166 167
#define UINT8_ACCESSORS(holder, name, offset)                         \
  uint8_t holder::name() const { return ReadField<uint8_t>(offset); } \
  void holder::set_##name(int value) {                                \
    DCHECK_GE(value, 0);                                              \
    DCHECK_LE(value, static_cast<uint8_t>(-1));                       \
168
    WriteField<uint8_t>(offset, value);                               \
169 170
  }

171 172
#define ACCESSORS_CHECKED2(holder, name, type, offset, get_condition, \
                           set_condition)                             \
173
  DEF_GETTER(holder, name, type) {                                    \
174
    type value = TaggedField<type, offset>::load(isolate, *this);     \
175 176 177 178 179
    DCHECK(get_condition);                                            \
    return value;                                                     \
  }                                                                   \
  void holder::set_##name(type value, WriteBarrierMode mode) {        \
    DCHECK(set_condition);                                            \
180
    TaggedField<type, offset>::store(*this, value);                   \
181
    CONDITIONAL_WRITE_BARRIER(*this, offset, value, mode);            \
182
  }
183

184 185 186 187 188 189
#define ACCESSORS_CHECKED(holder, name, type, offset, condition) \
  ACCESSORS_CHECKED2(holder, name, type, offset, condition, condition)

#define ACCESSORS(holder, name, type, offset) \
  ACCESSORS_CHECKED(holder, name, type, offset, true)

190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206
#define RENAME_TORQUE_ACCESSORS(holder, name, torque_name, type)      \
  inline type holder::name() const {                                  \
    return TorqueGeneratedClass::torque_name();                       \
  }                                                                   \
  inline void holder::set_##name(type value, WriteBarrierMode mode) { \
    TorqueGeneratedClass::set_##torque_name(value, mode);             \
  }

#define RENAME_UINT16_TORQUE_ACCESSORS(holder, name, torque_name) \
  uint16_t holder::name() const {                                 \
    return TorqueGeneratedClass::torque_name();                   \
  }                                                               \
  void holder::set_##name(int value) {                            \
    DCHECK_EQ(value, static_cast<uint16_t>(value));               \
    TorqueGeneratedClass::set_##torque_name(value);               \
  }

207 208 209
#define RELAXED_ACCESSORS_CHECKED2(holder, name, type, offset, get_condition, \
                                   set_condition)                             \
  type holder::name(RelaxedLoadTag tag) const {                               \
210
    IsolateRoot isolate = GetIsolateForPtrCompr(*this);                       \
211 212
    return holder::name(isolate, tag);                                        \
  }                                                                           \
213
  type holder::name(IsolateRoot isolate, RelaxedLoadTag) const {              \
214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230
    type value = TaggedField<type, offset>::load(isolate, *this);             \
    DCHECK(get_condition);                                                    \
    return value;                                                             \
  }                                                                           \
  void holder::set_##name(type value, RelaxedStoreTag,                        \
                          WriteBarrierMode mode) {                            \
    DCHECK(set_condition);                                                    \
    TaggedField<type, offset>::store(*this, value);                           \
    CONDITIONAL_WRITE_BARRIER(*this, offset, value, mode);                    \
  }

#define RELAXED_ACCESSORS_CHECKED(holder, name, type, offset, condition) \
  RELAXED_ACCESSORS_CHECKED2(holder, name, type, offset, condition, condition)

#define RELAXED_ACCESSORS(holder, name, type, offset) \
  RELAXED_ACCESSORS_CHECKED(holder, name, type, offset, true)

231 232
#define RELEASE_ACQUIRE_ACCESSORS_CHECKED2(holder, name, type, offset,    \
                                           get_condition, set_condition)  \
233
  type holder::name(AcquireLoadTag tag) const {                           \
234
    IsolateRoot isolate = GetIsolateForPtrCompr(*this);                   \
235 236
    return holder::name(isolate, tag);                                    \
  }                                                                       \
237
  type holder::name(IsolateRoot isolate, AcquireLoadTag) const {          \
238 239 240 241
    type value = TaggedField<type, offset>::Acquire_Load(isolate, *this); \
    DCHECK(get_condition);                                                \
    return value;                                                         \
  }                                                                       \
242 243
  void holder::set_##name(type value, ReleaseStoreTag,                    \
                          WriteBarrierMode mode) {                        \
244 245 246
    DCHECK(set_condition);                                                \
    TaggedField<type, offset>::Release_Store(*this, value);               \
    CONDITIONAL_WRITE_BARRIER(*this, offset, value, mode);                \
247 248
  }

249 250 251 252
#define RELEASE_ACQUIRE_ACCESSORS_CHECKED(holder, name, type, offset,       \
                                          condition)                        \
  RELEASE_ACQUIRE_ACCESSORS_CHECKED2(holder, name, type, offset, condition, \
                                     condition)
253

254 255
#define RELEASE_ACQUIRE_ACCESSORS(holder, name, type, offset) \
  RELEASE_ACQUIRE_ACCESSORS_CHECKED(holder, name, type, offset, true)
256

257 258
#define WEAK_ACCESSORS_CHECKED2(holder, name, offset, get_condition,  \
                                set_condition)                        \
259
  DEF_GETTER(holder, name, MaybeObject) {                             \
260 261
    MaybeObject value =                                               \
        TaggedField<MaybeObject, offset>::load(isolate, *this);       \
262 263 264 265 266
    DCHECK(get_condition);                                            \
    return value;                                                     \
  }                                                                   \
  void holder::set_##name(MaybeObject value, WriteBarrierMode mode) { \
    DCHECK(set_condition);                                            \
267
    TaggedField<MaybeObject, offset>::store(*this, value);            \
268
    CONDITIONAL_WEAK_WRITE_BARRIER(*this, offset, value, mode);       \
269 270 271 272 273 274 275 276
  }

#define WEAK_ACCESSORS_CHECKED(holder, name, offset, condition) \
  WEAK_ACCESSORS_CHECKED2(holder, name, offset, condition, condition)

#define WEAK_ACCESSORS(holder, name, offset) \
  WEAK_ACCESSORS_CHECKED(holder, name, offset, true)

277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297
#define SYNCHRONIZED_WEAK_ACCESSORS_CHECKED2(holder, name, offset,         \
                                             get_condition, set_condition) \
  DEF_GETTER(holder, name, MaybeObject) {                                  \
    MaybeObject value =                                                    \
        TaggedField<MaybeObject, offset>::Acquire_Load(isolate, *this);    \
    DCHECK(get_condition);                                                 \
    return value;                                                          \
  }                                                                        \
  void holder::set_##name(MaybeObject value, WriteBarrierMode mode) {      \
    DCHECK(set_condition);                                                 \
    TaggedField<MaybeObject, offset>::Release_Store(*this, value);         \
    CONDITIONAL_WEAK_WRITE_BARRIER(*this, offset, value, mode);            \
  }

#define SYNCHRONIZED_WEAK_ACCESSORS_CHECKED(holder, name, offset, condition) \
  SYNCHRONIZED_WEAK_ACCESSORS_CHECKED2(holder, name, offset, condition,      \
                                       condition)

#define SYNCHRONIZED_WEAK_ACCESSORS(holder, name, offset) \
  SYNCHRONIZED_WEAK_ACCESSORS_CHECKED(holder, name, offset, true)

298
// Getter that returns a Smi as an int and writes an int as a Smi.
299 300 301 302 303 304 305 306 307
#define SMI_ACCESSORS_CHECKED(holder, name, offset, condition)   \
  int holder::name() const {                                     \
    DCHECK(condition);                                           \
    Smi value = TaggedField<Smi, offset>::load(*this);           \
    return value.value();                                        \
  }                                                              \
  void holder::set_##name(int value) {                           \
    DCHECK(condition);                                           \
    TaggedField<Smi, offset>::store(*this, Smi::FromInt(value)); \
308 309 310 311 312
  }

#define SMI_ACCESSORS(holder, name, offset) \
  SMI_ACCESSORS_CHECKED(holder, name, offset, true)

313 314 315 316 317 318 319
#define SYNCHRONIZED_SMI_ACCESSORS(holder, name, offset)                 \
  int holder::synchronized_##name() const {                              \
    Smi value = TaggedField<Smi, offset>::Acquire_Load(*this);           \
    return value.value();                                                \
  }                                                                      \
  void holder::synchronized_set_##name(int value) {                      \
    TaggedField<Smi, offset>::Release_Store(*this, Smi::FromInt(value)); \
320 321
  }

322 323 324 325 326 327 328
#define RELAXED_SMI_ACCESSORS(holder, name, offset)                      \
  int holder::relaxed_read_##name() const {                              \
    Smi value = TaggedField<Smi, offset>::Relaxed_Load(*this);           \
    return value.value();                                                \
  }                                                                      \
  void holder::relaxed_write_##name(int value) {                         \
    TaggedField<Smi, offset>::Relaxed_Store(*this, Smi::FromInt(value)); \
329 330 331 332 333 334 335 336 337 338 339
  }

#define BOOL_GETTER(holder, field, name, offset) \
  bool holder::name() const { return BooleanBit::get(field(), offset); }

#define BOOL_ACCESSORS(holder, field, name, offset)                      \
  bool holder::name() const { return BooleanBit::get(field(), offset); } \
  void holder::set_##name(bool value) {                                  \
    set_##field(BooleanBit::set(field(), offset, value));                \
  }

340 341 342 343 344 345 346 347
#define BIT_FIELD_ACCESSORS(holder, field, name, BitField)      \
  typename BitField::FieldType holder::name() const {           \
    return BitField::decode(field());                           \
  }                                                             \
  void holder::set_##name(typename BitField::FieldType value) { \
    set_##field(BitField::update(field(), value));              \
  }

348 349 350 351 352
#define INSTANCE_TYPE_CHECKER(type, forinstancetype)    \
  V8_INLINE bool Is##type(InstanceType instance_type) { \
    return instance_type == forinstancetype;            \
  }

353
#define TYPE_CHECKER(type, ...)                                         \
354
  DEF_GETTER(HeapObject, Is##type, bool) {                              \
355
    return InstanceTypeChecker::Is##type(map(isolate).instance_type()); \
356 357
  }

358 359
#define RELAXED_INT16_ACCESSORS(holder, name, offset) \
  int16_t holder::name() const {                      \
360
    return RELAXED_READ_INT16_FIELD(*this, offset);   \
361 362
  }                                                   \
  void holder::set_##name(int16_t value) {            \
363
    RELAXED_WRITE_INT16_FIELD(*this, offset, value);  \
364 365
  }

366
#define FIELD_ADDR(p, offset) ((p).ptr() + offset - kHeapObjectTag)
367

368
#define ACQUIRE_READ_FIELD(p, offset) \
369
  TaggedField<Object>::Acquire_Load(p, offset)
370

371
#define RELAXED_READ_FIELD(p, offset) \
372
  TaggedField<Object>::Relaxed_Load(p, offset)
373

374
#define RELAXED_READ_WEAK_FIELD(p, offset) \
375
  TaggedField<MaybeObject>::Relaxed_Load(p, offset)
376

377
#define WRITE_FIELD(p, offset, value) \
378
  TaggedField<Object>::store(p, offset, value)
379

380
#define RELEASE_WRITE_FIELD(p, offset, value) \
381
  TaggedField<Object>::Release_Store(p, offset, value)
382 383

#define RELAXED_WRITE_FIELD(p, offset, value) \
384
  TaggedField<Object>::Relaxed_Store(p, offset, value)
385

386
#define RELAXED_WRITE_WEAK_FIELD(p, offset, value) \
387
  TaggedField<MaybeObject>::Relaxed_Store(p, offset, value)
388

389 390 391
#ifdef V8_DISABLE_WRITE_BARRIERS
#define WRITE_BARRIER(object, offset, value)
#else
392 393 394 395 396
#define WRITE_BARRIER(object, offset, value)                         \
  do {                                                               \
    DCHECK_NOT_NULL(GetHeapFromWritableObject(object));              \
    WriteBarrier::Marking(object, (object).RawField(offset), value); \
    GenerationalBarrier(object, (object).RawField(offset), value);   \
397
  } while (false)
398
#endif
399

400 401 402
#ifdef V8_DISABLE_WRITE_BARRIERS
#define WEAK_WRITE_BARRIER(object, offset, value)
#else
403 404 405 406 407
#define WEAK_WRITE_BARRIER(object, offset, value)                             \
  do {                                                                        \
    DCHECK_NOT_NULL(GetHeapFromWritableObject(object));                       \
    WriteBarrier::Marking(object, (object).RawMaybeWeakField(offset), value); \
    GenerationalBarrier(object, (object).RawMaybeWeakField(offset), value);   \
408
  } while (false)
409
#endif
410

411 412
#ifdef V8_DISABLE_WRITE_BARRIERS
#define EPHEMERON_KEY_WRITE_BARRIER(object, offset, value)
413 414 415
#elif V8_ENABLE_UNCONDITIONAL_WRITE_BARRIERS
#define EPHEMERON_KEY_WRITE_BARRIER(object, offset, value) \
  WRITE_BARRIER(object, offset, value)
416
#else
417 418 419 420
#define EPHEMERON_KEY_WRITE_BARRIER(object, offset, value)                    \
  do {                                                                        \
    DCHECK_NOT_NULL(GetHeapFromWritableObject(object));                       \
    EphemeronHashTable table = EphemeronHashTable::cast(object);              \
421
    WriteBarrier::Marking(object, (object).RawField(offset), value);          \
422
    GenerationalEphemeronKeyBarrier(table, (object).RawField(offset), value); \
423
  } while (false)
424
#endif
425

426 427
#ifdef V8_DISABLE_WRITE_BARRIERS
#define CONDITIONAL_WRITE_BARRIER(object, offset, value, mode)
428 429 430
#elif V8_ENABLE_UNCONDITIONAL_WRITE_BARRIERS
#define CONDITIONAL_WRITE_BARRIER(object, offset, value, mode) \
  WRITE_BARRIER(object, offset, value)
431
#else
432 433 434 435 436 437 438 439 440 441
#define CONDITIONAL_WRITE_BARRIER(object, offset, value, mode)           \
  do {                                                                   \
    DCHECK_NOT_NULL(GetHeapFromWritableObject(object));                  \
    DCHECK_NE(mode, UPDATE_EPHEMERON_KEY_WRITE_BARRIER);                 \
    if (mode != SKIP_WRITE_BARRIER) {                                    \
      if (mode == UPDATE_WRITE_BARRIER) {                                \
        WriteBarrier::Marking(object, (object).RawField(offset), value); \
      }                                                                  \
      GenerationalBarrier(object, (object).RawField(offset), value);     \
    }                                                                    \
442
  } while (false)
443
#endif
444

445 446
#ifdef V8_DISABLE_WRITE_BARRIERS
#define CONDITIONAL_WEAK_WRITE_BARRIER(object, offset, value, mode)
447 448 449
#elif V8_ENABLE_UNCONDITIONAL_WRITE_BARRIERS
#define CONDITIONAL_WEAK_WRITE_BARRIER(object, offset, value, mode) \
  WRITE_BARRIER(object, offset, value)
450
#else
451 452 453 454 455 456
#define CONDITIONAL_WEAK_WRITE_BARRIER(object, offset, value, mode)           \
  do {                                                                        \
    DCHECK_NOT_NULL(GetHeapFromWritableObject(object));                       \
    DCHECK_NE(mode, UPDATE_EPHEMERON_KEY_WRITE_BARRIER);                      \
    if (mode != SKIP_WRITE_BARRIER) {                                         \
      if (mode == UPDATE_WRITE_BARRIER) {                                     \
457 458
        WriteBarrier::Marking(object, (object).RawMaybeWeakField(offset),     \
                              value);                                         \
459 460 461
      }                                                                       \
      GenerationalBarrier(object, (object).RawMaybeWeakField(offset), value); \
    }                                                                         \
462
  } while (false)
463
#endif
464

465 466 467
#ifdef V8_DISABLE_WRITE_BARRIERS
#define CONDITIONAL_EPHEMERON_KEY_WRITE_BARRIER(object, offset, value, mode)
#else
468 469 470 471 472 473 474
#define CONDITIONAL_EPHEMERON_KEY_WRITE_BARRIER(object, offset, value, mode) \
  do {                                                                       \
    DCHECK_NOT_NULL(GetHeapFromWritableObject(object));                      \
    DCHECK_NE(mode, UPDATE_EPHEMERON_KEY_WRITE_BARRIER);                     \
    EphemeronHashTable table = EphemeronHashTable::cast(object);             \
    if (mode != SKIP_WRITE_BARRIER) {                                        \
      if (mode == UPDATE_WRITE_BARRIER) {                                    \
475
        WriteBarrier::Marking(object, (object).RawField(offset), value);     \
476
      }                                                                      \
477
      GenerationalEphemeronKeyBarrier(table, (object).RawField(offset),      \
478 479 480
                                      value);                                \
    }                                                                        \
  } while (false)
481
#endif
482

483 484 485 486
#define ACQUIRE_READ_INT32_FIELD(p, offset) \
  static_cast<int32_t>(base::Acquire_Load(  \
      reinterpret_cast<const base::Atomic32*>(FIELD_ADDR(p, offset))))

487 488 489 490 491
#define RELAXED_WRITE_INT8_FIELD(p, offset, value)                             \
  base::Relaxed_Store(reinterpret_cast<base::Atomic8*>(FIELD_ADDR(p, offset)), \
                      static_cast<base::Atomic8>(value));
#define RELAXED_READ_INT8_FIELD(p, offset) \
  static_cast<int8_t>(base::Relaxed_Load(  \
492
      reinterpret_cast<const base::Atomic8*>(FIELD_ADDR(p, offset))))
493

494 495 496 497 498 499 500 501 502
#define RELAXED_READ_INT16_FIELD(p, offset) \
  static_cast<int16_t>(base::Relaxed_Load(  \
      reinterpret_cast<const base::Atomic16*>(FIELD_ADDR(p, offset))))

#define RELAXED_WRITE_INT16_FIELD(p, offset, value)             \
  base::Relaxed_Store(                                          \
      reinterpret_cast<base::Atomic16*>(FIELD_ADDR(p, offset)), \
      static_cast<base::Atomic16>(value));

503 504 505 506
#define RELAXED_READ_UINT32_FIELD(p, offset) \
  static_cast<uint32_t>(base::Relaxed_Load(  \
      reinterpret_cast<const base::Atomic32*>(FIELD_ADDR(p, offset))))

507 508 509 510
#define ACQUIRE_READ_UINT32_FIELD(p, offset) \
  static_cast<uint32_t>(base::Acquire_Load(  \
      reinterpret_cast<const base::Atomic32*>(FIELD_ADDR(p, offset))))

511 512 513 514 515
#define RELAXED_WRITE_UINT32_FIELD(p, offset, value)            \
  base::Relaxed_Store(                                          \
      reinterpret_cast<base::Atomic32*>(FIELD_ADDR(p, offset)), \
      static_cast<base::Atomic32>(value));

516 517 518 519 520
#define RELEASE_WRITE_UINT32_FIELD(p, offset, value)            \
  base::Release_Store(                                          \
      reinterpret_cast<base::Atomic32*>(FIELD_ADDR(p, offset)), \
      static_cast<base::Atomic32>(value));

521 522 523 524
#define RELAXED_READ_INT32_FIELD(p, offset) \
  static_cast<int32_t>(base::Relaxed_Load(  \
      reinterpret_cast<const base::Atomic32*>(FIELD_ADDR(p, offset))))

525 526
#define RELEASE_WRITE_INT32_FIELD(p, offset, value)             \
  base::Release_Store(                                          \
527 528 529 530 531
      reinterpret_cast<base::Atomic32*>(FIELD_ADDR(p, offset)), \
      static_cast<base::Atomic32>(value))

#define RELAXED_WRITE_INT32_FIELD(p, offset, value)             \
  base::Relaxed_Store(                                          \
532 533 534
      reinterpret_cast<base::Atomic32*>(FIELD_ADDR(p, offset)), \
      static_cast<base::Atomic32>(value));

535 536
#define RELAXED_READ_BYTE_FIELD(p, offset) \
  static_cast<byte>(base::Relaxed_Load(    \
537
      reinterpret_cast<const base::Atomic8*>(FIELD_ADDR(p, offset))))
538

539 540 541 542
#define ACQUIRE_READ_BYTE_FIELD(p, offset) \
  static_cast<byte>(base::Acquire_Load(    \
      reinterpret_cast<const base::Atomic8*>(FIELD_ADDR(p, offset))))

543 544 545
#define RELAXED_WRITE_BYTE_FIELD(p, offset, value)                             \
  base::Relaxed_Store(reinterpret_cast<base::Atomic8*>(FIELD_ADDR(p, offset)), \
                      static_cast<base::Atomic8>(value));
546

547 548 549 550
#define RELEASE_WRITE_BYTE_FIELD(p, offset, value)                             \
  base::Release_Store(reinterpret_cast<base::Atomic8*>(FIELD_ADDR(p, offset)), \
                      static_cast<base::Atomic8>(value));

551 552 553 554 555 556
#ifdef OBJECT_PRINT
#define DECL_PRINTER(Name) void Name##Print(std::ostream& os);  // NOLINT
#else
#define DECL_PRINTER(Name)
#endif

557
#ifdef VERIFY_HEAP
558
#define DECL_VERIFIER(Name) void Name##Verify(Isolate* isolate);
559 560
#define EXPORT_DECL_VERIFIER(Name) \
  V8_EXPORT_PRIVATE void Name##Verify(Isolate* isolate);
561
#else
562
#define DECL_VERIFIER(Name)
563
#define EXPORT_DECL_VERIFIER(Name)
564
#endif
565

566 567 568 569 570
#define DEFINE_DEOPT_ELEMENT_ACCESSORS(name, type) \
  type DeoptimizationData::name() const {          \
    return type::cast(get(k##name##Index));        \
  }                                                \
  void DeoptimizationData::Set##name(type value) { set(k##name##Index, value); }
571 572

#define DEFINE_DEOPT_ENTRY_ACCESSORS(name, type)                \
573
  type DeoptimizationData::name(int i) const {                  \
574 575
    return type::cast(get(IndexForEntry(i) + k##name##Offset)); \
  }                                                             \
576
  void DeoptimizationData::Set##name(int i, type value) {       \
577 578
    set(IndexForEntry(i) + k##name##Offset, value);             \
  }
579

580 581 582 583 584 585 586 587 588
#define TQ_OBJECT_CONSTRUCTORS(Type)               \
 public:                                           \
  constexpr Type() = default;                      \
                                                   \
 protected:                                        \
  template <typename TFieldType, int kFieldOffset> \
  friend class TaggedField;                        \
                                                   \
  inline explicit Type(Address ptr);               \
589 590 591 592 593
  friend class TorqueGenerated##Type<Type, Super>;

#define TQ_OBJECT_CONSTRUCTORS_IMPL(Type) \
  inline Type::Type(Address ptr)          \
      : TorqueGenerated##Type<Type, Type::Super>(ptr) {}