| // 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). |
| // |
| // PRESUBMIT_INTENTIONALLY_MISSING_INCLUDE_GUARD |
| |
| // 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. |
| |
| // First, ensure that we do not include object-macros.h twice without including |
| // object-macros-undef.h in between. |
| #ifdef V8_OBJECT_MACROS_DEFINED |
| #error Include object-macros-undef.h before including object-macros.h again |
| #endif |
| #define V8_OBJECT_MACROS_DEFINED |
| |
| #include "src/base/memory.h" |
| |
| // V8 objects are defined as: |
| // |
| // V8_OBJECT class Foo : public Base { |
| // ... |
| // } V8_OBJECT_END; |
| // |
| // V8_ABSTRACT_OBJECT class AbstractFoo : public Base { |
| // ... |
| // // unused padding used in subclasses. |
| // } V8_OBJECT_END; |
| // |
| // These macros are to enable packing down to 4-byte alignment (i.e. int32 |
| // alignment, since we have int32 fields), and to add warnings which ensure that |
| // there is no unwanted within-object padding. When defining an abstract class, |
| // it might be useful to enable packing down to 1-byte alignment to let the |
| // subclasses utilize the unused padding in the base class appropriately, use |
| // V8_ABSTRACT_OBJECT instead of V8_OBJECT in that case. |
| #if V8_CC_GNU |
| #define V8_OBJECT_PUSH \ |
| _Pragma("pack(push)") _Pragma("pack(4)") _Pragma("GCC diagnostic push") \ |
| _Pragma("GCC diagnostic error \"-Wpadded\"") |
| #define V8_ABSTRACT_OBJECT_PUSH \ |
| _Pragma("pack(push)") _Pragma("pack(1)") _Pragma("GCC diagnostic push") \ |
| _Pragma("GCC diagnostic error \"-Wpadded\"") |
| #define V8_OBJECT_POP _Pragma("pack(pop)") _Pragma("GCC diagnostic pop") |
| #elif V8_CC_MSVC |
| #define V8_OBJECT_PUSH \ |
| __pragma(pack(push)) __pragma(pack(4)) __pragma(warning(push)) \ |
| __pragma(warning(default : 4820)) |
| #define V8_ABSTRACT_OBJECT_PUSH \ |
| __pragma(pack(push)) __pragma(pack(1)) __pragma(warning(push)) \ |
| __pragma(warning(default : 4820)) |
| #define V8_OBJECT_POP __pragma(pack(pop)) __pragma(warning(pop)) |
| #else |
| #error Unsupported compiler |
| #endif |
| |
| #define V8_OBJECT V8_OBJECT_PUSH |
| #define V8_ABSTRACT_OBJECT V8_ABSTRACT_OBJECT_PUSH |
| // Compilers wants the pragmas to be a new statement, but we prefer to have |
| // V8_OBJECT_END look like part of the definition. Insert a semicolon before the |
| // pragma to make the compilers happy, and use static_assert(true) to swallow |
| // the next semicolon. |
| #define V8_OBJECT_END \ |
| ; \ |
| V8_OBJECT_POP static_assert(true) |
| |
| #define V8_OBJECT_INNER_CLASS V8_OBJECT_POP |
| #define V8_OBJECT_INNER_CLASS_END \ |
| ; \ |
| V8_OBJECT_PUSH static_assert(true) |
| |
| // Instance-type markers for V8_OBJECT classes. They exist solely for the |
| // libclang-driven instance-type generator, which harvests them to drive |
| // `instance-type.h` emission, and they reach no other build: outside the |
| // harvest's parse they expand to a static_assert. Mirror the meanings of |
| // the Torque annotations they replace (see `src/torque/...` and the IT |
| // solver). |
| // |
| // Usage -- one per line in the class body, in any order: |
| // |
| // V8_OBJECT class JSReceiver : public HeapObject { |
| // public: |
| // V8_IT_ABSTRACT; |
| // ... |
| // } V8_OBJECT_END; |
| // |
| // Only the harvest's parse declares anything here, and it has to: an |
| // attribute must appertain to a declaration, and a bare `[[...]];` in a |
| // class body declares nothing, so the attribute rides an alias -- the |
| // carrier that adds no value, enumerator or function to the class. |
| // Everywhere else the marker's own `;` terminates a static_assert and |
| // the class is left untouched. |
| #ifdef V8_METAGEN_GENERATION_PASS |
| #define V8_IT_MARK(NAME, PAYLOAD) \ |
| using V8IT_##NAME [[clang::annotate(PAYLOAD)]] = void |
| #else |
| #define V8_IT_MARK(NAME, PAYLOAD) static_assert(true) |
| #endif |
| #define V8_IT_ABSTRACT V8_IT_MARK(Abstract, "V8_IT_ABSTRACT") |
| #define V8_IT_REUSE_PARENT V8_IT_MARK(ReuseParent, "V8_IT_REUSE_PARENT") |
| #define V8_IT_FIXED_VALUE(N) V8_IT_MARK(FixedValue, "V8_IT_FIXED_VALUE(" #N ")") |
| #define V8_IT_FLAG_BITS(N) V8_IT_MARK(FlagBits, "V8_IT_FLAG_BITS(" #N ")") |
| #define V8_IT_ORDER(POS) V8_IT_MARK(Order, "V8_IT_ORDER(" #POS ")") |
| // Explicit participation marker for concrete classes that also have |
| // concrete subclasses among the IT participants (concrete |
| // non-leaves). The default discovery rule -- "leaf in the candidate |
| // set OR carries any V8_IT_* annotation" -- treats unannotated |
| // intermediates as inheritance bookkeeping, not IT participants. A |
| // concrete intermediate that wants its own _TYPE value emitted has |
| // to opt in via this annotation. |
| // |
| // Examples: Map (has Map sub-types as children), JSArray (parent of |
| // TemplateLiteralObject), FixedArray (parent of FixedArrayExact), |
| // HashTable (parent of EphemeronHashTable / NameToIndexHashTable / |
| // RegisteredSymbolTable), etc. |
| // |
| // Pure-leaf classes don't need this -- they auto-participate. |
| // Abstract non-leaves use V8_IT_ABSTRACT (no own value, range |
| // markers only). V8_IT_REUSE_PARENT classes share the parent's IT. |
| #define V8_IT_OWN_TYPE V8_IT_MARK(OwnType, "V8_IT_OWN_TYPE") |
| // Excludes the class from metagen's generated checker bucket lists. By |
| // default it also excludes the class from the instance-type harvest entirely, |
| // so it gets no instance-type value of its own. Combine it with |
| // V8_IT_OWN_TYPE to retain the class and its own instance-type value while |
| // suppressing only its generated checker entries. |
| // |
| // Used for classes with a hand-written `IsX(...)` predicate (in |
| // instance-type-checker.h's INSTANCE_TYPE_CHECKERS_CUSTOM list, in the |
| // SINGLE/RANGE manual extras, or via DEF_HEAP_OBJECT_PREDICATE across src/) |
| // whose auto-emitted definition would collide with it. |
| #define V8_IT_NO_AUTO_CHECKER V8_IT_MARK(NoAutoChecker, "V8_IT_NO_AUTO_CHECKER") |
| // Excludes the class from the generated |
| // HEAP_OBJECT_DIAGNOSTIC_DISPATCH_LIST even though it declares both |
| // Name##Print and Name##Verify. Carriers are dispatched by hand-written |
| // cases in HeapObject::HeapObjectPrint (objects-printer.cc) and |
| // HeapObject::HeapObjectVerify (objects-debug.cc); without this marker |
| // the generated entry would produce a duplicate case label there |
| // (which is also the loud failure mode if the marker is forgotten). |
| #define V8_IT_NO_AUTO_DISPATCH \ |
| V8_IT_MARK(NoAutoDispatch, "V8_IT_NO_AUTO_DISPATCH") |
| |
| #define DECL_PRIMITIVE_GETTER(name, type) inline type name() const; |
| |
| #define DECL_PRIMITIVE_SETTER(name, type) inline void set_##name(type value); |
| |
| #define DECL_PRIMITIVE_ACCESSORS(name, type) \ |
| DECL_PRIMITIVE_GETTER(name, type) \ |
| DECL_PRIMITIVE_SETTER(name, type) |
| |
| #define DECL_BOOLEAN_ACCESSORS(name) DECL_PRIMITIVE_ACCESSORS(name, bool) |
| |
| #define DECL_INT_ACCESSORS(name) DECL_PRIMITIVE_ACCESSORS(name, int) |
| |
| #define DECL_INT32_ACCESSORS(name) DECL_PRIMITIVE_ACCESSORS(name, int32_t) |
| |
| #define DECL_SANDBOXED_POINTER_ACCESSORS(name, type) \ |
| DECL_PRIMITIVE_GETTER(name, type) \ |
| DECL_PRIMITIVE_SETTER(name, type) |
| |
| #define DECL_UINT16_ACCESSORS(name) DECL_PRIMITIVE_ACCESSORS(name, uint16_t) |
| |
| #define DECL_INT16_ACCESSORS(name) DECL_PRIMITIVE_ACCESSORS(name, int16_t) |
| |
| #define DECL_UINT8_ACCESSORS(name) DECL_PRIMITIVE_ACCESSORS(name, uint8_t) |
| |
| #define DECL_RELAXED_PRIMITIVE_ACCESSORS(name, type) \ |
| inline type name(RelaxedLoadTag) const; \ |
| inline void set_##name(type value, RelaxedStoreTag); |
| |
| #define DECL_RELAXED_INT32_ACCESSORS(name) \ |
| DECL_RELAXED_PRIMITIVE_ACCESSORS(name, int32_t) |
| |
| #define DECL_RELAXED_UINT32_ACCESSORS(name) \ |
| DECL_RELAXED_PRIMITIVE_ACCESSORS(name, uint32_t) |
| |
| #define DECL_RELAXED_UINT16_ACCESSORS(name) \ |
| DECL_RELAXED_PRIMITIVE_ACCESSORS(name, uint16_t) |
| |
| #define DECL_RELAXED_UINT8_ACCESSORS(name) \ |
| DECL_RELAXED_PRIMITIVE_ACCESSORS(name, uint8_t) |
| |
| #define DECL_GETTER(name, ...) inline __VA_ARGS__ name() const; |
| |
| #define DEF_GETTER(holder, name, ...) __VA_ARGS__ holder::name() const |
| |
| #define DEF_RELAXED_GETTER(holder, name, ...) \ |
| __VA_ARGS__ holder::name(RelaxedLoadTag tag) const |
| |
| #define DEF_ACQUIRE_GETTER(holder, name, ...) \ |
| __VA_ARGS__ holder::name(AcquireLoadTag tag) const |
| |
| #define DEF_HEAP_OBJECT_PREDICATE(name) \ |
| bool name(Tagged<Object> obj) { \ |
| Tagged<HeapObject> ho; \ |
| return TryCast<HeapObject>(obj, &ho) && name(ho); \ |
| } \ |
| bool name(Tagged<HeapObject> obj) |
| |
| #define DEF_CAST_TRAITS(Type, ...) \ |
| template <> \ |
| struct CastTraits<Type> { \ |
| static inline bool AllowFrom(Tagged<Object> value) { \ |
| return Is##Type(value); \ |
| } \ |
| static inline bool AllowFrom(Tagged<HeapObject> value) { \ |
| return Is##Type(value); \ |
| } \ |
| }; |
| |
| #define TQ_FIELD_TYPE(name, tq_type) \ |
| static constexpr const char* k##name##TqFieldType = tq_type; |
| |
| #define DECL_FIELD_OFFSET_TQ(name, value, tq_type) \ |
| static const int k##name##Offset = value; \ |
| TQ_FIELD_TYPE(name, tq_type) |
| |
| #define DECL_SETTER(name, ...) \ |
| inline void set_##name(__VA_ARGS__ value, \ |
| WriteBarrierMode mode = UPDATE_WRITE_BARRIER); |
| |
| #define DECL_ACCESSORS(name, ...) \ |
| DECL_GETTER(name, __VA_ARGS__) \ |
| DECL_SETTER(name, __VA_ARGS__) |
| |
| #define DECL_ACCESSORS_LOAD_TAG(name, type, tag_type) \ |
| inline UNPAREN(type) name(tag_type tag) const; |
| |
| #define DECL_ACCESSORS_STORE_TAG(name, type, tag_type) \ |
| inline void set_##name(UNPAREN(type) value, tag_type, \ |
| WriteBarrierMode mode = UPDATE_WRITE_BARRIER); |
| |
| #define DECL_RELAXED_GETTER(name, ...) \ |
| DECL_ACCESSORS_LOAD_TAG(name, (__VA_ARGS__), RelaxedLoadTag) |
| |
| #define DECL_RELAXED_SETTER(name, ...) \ |
| DECL_ACCESSORS_STORE_TAG(name, (__VA_ARGS__), RelaxedStoreTag) |
| |
| #define DECL_RELAXED_ACCESSORS(name, ...) \ |
| DECL_RELAXED_GETTER(name, __VA_ARGS__) \ |
| DECL_RELAXED_SETTER(name, __VA_ARGS__) |
| |
| #define DECL_ACQUIRE_GETTER(name, ...) \ |
| DECL_ACCESSORS_LOAD_TAG(name, (__VA_ARGS__), AcquireLoadTag) |
| |
| #define DECL_RELEASE_SETTER(name, ...) \ |
| DECL_ACCESSORS_STORE_TAG(name, (__VA_ARGS__), ReleaseStoreTag) |
| |
| #define DECL_RELEASE_ACQUIRE_ACCESSORS(name, ...) \ |
| DECL_ACQUIRE_GETTER(name, __VA_ARGS__) \ |
| DECL_RELEASE_SETTER(name, __VA_ARGS__) |
| |
| #define DEF_PRIMITIVE_ACCESSORS(holder, name, offset, type) \ |
| type holder::name() const { return ReadField<type>(offset); } \ |
| void holder::set_##name(type value) { WriteField<type>(offset, value); } |
| |
| #define INT_ACCESSORS(holder, name, offset) \ |
| DEF_PRIMITIVE_ACCESSORS(holder, name, offset, int) |
| |
| #define INT32_ACCESSORS(holder, name, offset) \ |
| DEF_PRIMITIVE_ACCESSORS(holder, name, offset, int32_t) |
| |
| #define UINT16_ACCESSORS(holder, name, offset) \ |
| DEF_PRIMITIVE_ACCESSORS(holder, name, offset, uint16_t) |
| |
| #define UINT8_ACCESSORS(holder, name, offset) \ |
| DEF_PRIMITIVE_ACCESSORS(holder, name, offset, uint8_t) |
| |
| #define RELAXED_INT32_ACCESSORS(holder, name, offset) \ |
| int32_t holder::name(RelaxedLoadTag) const { \ |
| return RELAXED_READ_INT32_FIELD(this, offset); \ |
| } \ |
| void holder::set_##name(int32_t value, RelaxedStoreTag) { \ |
| RELAXED_WRITE_INT32_FIELD(this, offset, value); \ |
| } |
| |
| #define RELAXED_UINT32_ACCESSORS(holder, name, offset) \ |
| uint32_t holder::name(RelaxedLoadTag) const { \ |
| return RELAXED_READ_UINT32_FIELD(this, offset); \ |
| } \ |
| void holder::set_##name(uint32_t value, RelaxedStoreTag) { \ |
| RELAXED_WRITE_UINT32_FIELD(this, offset, value); \ |
| } |
| |
| #define RELAXED_UINT16_ACCESSORS(holder, name, offset) \ |
| uint16_t holder::name(RelaxedLoadTag) const { \ |
| return RELAXED_READ_UINT16_FIELD(this, offset); \ |
| } \ |
| void holder::set_##name(uint16_t value, RelaxedStoreTag) { \ |
| RELAXED_WRITE_UINT16_FIELD(this, offset, value); \ |
| } |
| |
| #define RELAXED_UINT8_ACCESSORS(holder, name, offset) \ |
| uint8_t holder::name(RelaxedLoadTag) const { \ |
| return RELAXED_READ_UINT8_FIELD(this, offset); \ |
| } \ |
| void holder::set_##name(uint8_t value, RelaxedStoreTag) { \ |
| RELAXED_WRITE_UINT8_FIELD(this, offset, value); \ |
| } |
| |
| #define ACCESSORS_CHECKED2(holder, name, type, offset, get_condition, \ |
| set_condition) \ |
| DEF_GETTER(holder, name, UNPAREN(type)) { \ |
| UNPAREN(type) \ |
| value = TaggedField<UNPAREN(type), offset>::load(this); \ |
| DCHECK(get_condition); \ |
| return value; \ |
| } \ |
| void holder::set_##name(UNPAREN(type) value, WriteBarrierMode mode) { \ |
| DCHECK(set_condition); \ |
| TaggedField<UNPAREN(type), offset>::store(this, value); \ |
| CONDITIONAL_WRITE_BARRIER(this, offset, value, mode); \ |
| } |
| |
| #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) |
| |
| #define RENAME_TORQUE_ACCESSORS(holder, name, torque_name, ...) \ |
| inline __VA_ARGS__ holder::name() const { \ |
| return TorqueGeneratedClass::torque_name(); \ |
| } \ |
| inline void holder::set_##name(__VA_ARGS__ value, WriteBarrierMode mode) { \ |
| TorqueGeneratedClass::set_##torque_name(value, mode); \ |
| } |
| |
| #define RENAME_PRIMITIVE_TORQUE_ACCESSORS(holder, name, torque_name, type) \ |
| type holder::name() const { return TorqueGeneratedClass::torque_name(); } \ |
| void holder::set_##name(type value) { \ |
| TorqueGeneratedClass::set_##torque_name(value); \ |
| } |
| |
| #define ACCESSORS_RELAXED_CHECKED2(holder, name, type, offset, get_condition, \ |
| set_condition) \ |
| type holder::name() const { \ |
| type value = TaggedField<type, offset>::Relaxed_Load(this); \ |
| DCHECK(get_condition); \ |
| return value; \ |
| } \ |
| void holder::set_##name(type value, WriteBarrierMode mode) { \ |
| DCHECK(set_condition); \ |
| TaggedField<type, offset>::Relaxed_Store(this, value); \ |
| CONDITIONAL_WRITE_BARRIER(this, offset, value, mode); \ |
| } |
| |
| #define ACCESSORS_RELAXED_CHECKED(holder, name, type, offset, condition) \ |
| ACCESSORS_RELAXED_CHECKED2(holder, name, type, offset, condition, condition) |
| |
| #define ACCESSORS_RELAXED(holder, name, type, offset) \ |
| ACCESSORS_RELAXED_CHECKED(holder, name, type, offset, true) |
| |
| // Similar to ACCESSORS_RELAXED above but with respective relaxed tags. |
| #define RELAXED_ACCESSORS_CHECKED2(holder, name, type, offset, get_condition, \ |
| set_condition) \ |
| DEF_RELAXED_GETTER(holder, name, UNPAREN(type)) { \ |
| UNPAREN(type) \ |
| value = TaggedField<UNPAREN(type), offset>::Relaxed_Load(this); \ |
| DCHECK(get_condition); \ |
| return value; \ |
| } \ |
| void holder::set_##name(UNPAREN(type) value, RelaxedStoreTag, \ |
| WriteBarrierMode mode) { \ |
| DCHECK(set_condition); \ |
| TaggedField<UNPAREN(type), offset>::Relaxed_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) |
| |
| #define RELEASE_ACQUIRE_GETTER_CHECKED(holder, name, type, offset, \ |
| get_condition) \ |
| DEF_ACQUIRE_GETTER(holder, name, UNPAREN(type)) { \ |
| UNPAREN(type) \ |
| value = TaggedField<UNPAREN(type), offset>::Acquire_Load(this); \ |
| DCHECK(get_condition); \ |
| return value; \ |
| } |
| |
| #define RELEASE_ACQUIRE_SETTER_CHECKED(holder, name, type, offset, \ |
| set_condition) \ |
| void holder::set_##name(UNPAREN(type) value, ReleaseStoreTag, \ |
| WriteBarrierMode mode) { \ |
| DCHECK(set_condition); \ |
| TaggedField<UNPAREN(type), offset>::Release_Store(this, value); \ |
| CONDITIONAL_WRITE_BARRIER(this, offset, value, mode); \ |
| } |
| |
| #define RELEASE_ACQUIRE_ACCESSORS_CHECKED2(holder, name, type, offset, \ |
| get_condition, set_condition) \ |
| RELEASE_ACQUIRE_GETTER_CHECKED(holder, name, type, offset, get_condition) \ |
| RELEASE_ACQUIRE_SETTER_CHECKED(holder, name, type, offset, set_condition) |
| |
| #define RELEASE_ACQUIRE_ACCESSORS_CHECKED(holder, name, type, offset, \ |
| condition) \ |
| RELEASE_ACQUIRE_ACCESSORS_CHECKED2(holder, name, type, offset, condition, \ |
| condition) |
| |
| #define RELEASE_ACQUIRE_ACCESSORS(holder, name, type, offset) \ |
| RELEASE_ACQUIRE_ACCESSORS_CHECKED(holder, name, type, offset, true) |
| |
| // Getter that returns a Smi as an int and writes an int as a Smi. |
| #define SMI_ACCESSORS_CHECKED(holder, name, offset, condition) \ |
| int holder::name() const { \ |
| DCHECK(condition); \ |
| Tagged<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)); \ |
| } |
| |
| #define SMI_ACCESSORS(holder, name, offset) \ |
| SMI_ACCESSORS_CHECKED(holder, name, offset, true) |
| |
| #define DECL_RELEASE_ACQUIRE_INT_ACCESSORS(name) \ |
| inline int name(AcquireLoadTag) const; \ |
| inline void set_##name(int value, ReleaseStoreTag); |
| |
| #define RELEASE_ACQUIRE_SMI_ACCESSORS(holder, name, offset) \ |
| int holder::name(AcquireLoadTag) const { \ |
| Tagged<Smi> value = TaggedField<Smi, offset>::Acquire_Load(this); \ |
| return value.value(); \ |
| } \ |
| void holder::set_##name(int value, ReleaseStoreTag) { \ |
| TaggedField<Smi, offset>::Release_Store(this, Smi::FromInt(value)); \ |
| } |
| |
| #define DECL_RELAXED_INT_ACCESSORS(name) \ |
| inline int name(RelaxedLoadTag) const; \ |
| inline void set_##name(int value, RelaxedStoreTag); |
| |
| #define RELAXED_SMI_ACCESSORS(holder, name, offset) \ |
| int holder::name(RelaxedLoadTag) const { \ |
| Tagged<Smi> value = TaggedField<Smi, offset>::Relaxed_Load(this); \ |
| return value.value(); \ |
| } \ |
| void holder::set_##name(int value, RelaxedStoreTag) { \ |
| TaggedField<Smi, offset>::Relaxed_Store(this, Smi::FromInt(value)); \ |
| } |
| |
| #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)); \ |
| } |
| |
| #define DECL_RELAXED_BOOL_ACCESSORS(name) \ |
| inline bool name(RelaxedLoadTag) const; \ |
| inline void set_##name(bool value, RelaxedStoreTag); |
| |
| #define RELAXED_BOOL_ACCESSORS(holder, field, name, offset) \ |
| bool holder::name(RelaxedLoadTag) const { \ |
| return BooleanBit::get(field(kRelaxedLoad), offset); \ |
| } \ |
| void holder::set_##name(bool value, RelaxedStoreTag) { \ |
| set_##field(BooleanBit::set(field(kRelaxedLoad), offset, value), \ |
| kRelaxedStore); \ |
| } |
| |
| // Host objects in ReadOnlySpace can't define the isolate-less accessor. |
| #define DECL_LAZY_EXTERNAL_POINTER_ACCESSORS_MAYBE_READ_ONLY_HOST(name, type) \ |
| inline void init_##name(); \ |
| inline bool has_##name() const; \ |
| inline type name(i::IsolateForSandbox isolate) const; \ |
| inline void set_##name(i::IsolateForSandbox isolate, const type value); |
| |
| // Host objects in ReadOnlySpace can't define the isolate-less accessor. |
| #define LAZY_EXTERNAL_POINTER_ACCESSORS_MAYBE_READ_ONLY_HOST_CHECKED2( \ |
| holder, name, type, offset, tag, get_condition, set_condition) \ |
| void holder::init_##name() { \ |
| this->SetupLazilyInitializedExternalPointerField(offset); \ |
| } \ |
| bool holder::has_##name() const { \ |
| return this->IsLazilyInitializedExternalPointerFieldInitialized(offset); \ |
| } \ |
| type holder::name(i::IsolateForSandbox isolate) const { \ |
| DCHECK(get_condition); \ |
| /* This is a workaround for MSVC error C2440 not allowing */ \ |
| /* reinterpret casts to the same type. */ \ |
| struct C2440 {}; \ |
| Address result = \ |
| this->template ReadExternalPointerField<tag>(offset, isolate); \ |
| return reinterpret_cast<type>(reinterpret_cast<C2440*>(result)); \ |
| } \ |
| void holder::set_##name(i::IsolateForSandbox isolate, const type value) { \ |
| DCHECK(set_condition); \ |
| /* This is a workaround for MSVC error C2440 not allowing */ \ |
| /* reinterpret casts to the same type. */ \ |
| struct C2440 {}; \ |
| Address the_value = \ |
| reinterpret_cast<Address>(reinterpret_cast<const C2440*>(value)); \ |
| this->template WriteLazilyInitializedExternalPointerField<tag>( \ |
| offset, isolate, the_value); \ |
| } |
| |
| #define LAZY_EXTERNAL_POINTER_ACCESSORS_MAYBE_READ_ONLY_HOST_CHECKED( \ |
| holder, name, type, offset, tag, condition) \ |
| LAZY_EXTERNAL_POINTER_ACCESSORS_MAYBE_READ_ONLY_HOST_CHECKED2( \ |
| holder, name, type, offset, tag, condition, condition) |
| |
| #define LAZY_EXTERNAL_POINTER_ACCESSORS_MAYBE_READ_ONLY_HOST( \ |
| holder, name, type, offset, tag) \ |
| LAZY_EXTERNAL_POINTER_ACCESSORS_MAYBE_READ_ONLY_HOST_CHECKED2( \ |
| holder, name, type, offset, tag, true, true) |
| |
| // Declares all required accessors for a lazily initialized C function pointer |
| // that can be called from native code. |
| // In case the host and target architectures are different (i.e. simulator |
| // is enabled), we can't just call the C function from native code because |
| // of architecture difference and we need to "ask" the simulator to call |
| // the C function on behalf of the native code. This is a so-called |
| // "redirection". The pointer stored in the object is redirected while C++ |
| // accessors operate on an original C function pointer (wrapping/unwrapping |
| // is done the under the hood). |
| // Host objects in ReadOnlySpace can't define the isolate-less accessor. |
| #define DECL_LAZY_REDIRECTED_CALLBACK_ACCESSORS_MAYBE_READ_ONLY_HOST(name, \ |
| type) \ |
| private: \ |
| /* Returns a potentially redirected callback pointer as it's stored */ \ |
| /* in the object. This getter is used for printing of redirected value. */ \ |
| inline Address name##_raw(i::IsolateForSandbox isolate) const; \ |
| /* Adds/removes redirection for a callback pointer stored in the object. */ \ |
| inline void init_##name##_redirection(i::IsolateForSandbox isolate); \ |
| inline void remove_##name##_redirection(i::IsolateForSandbox isolate); \ |
| \ |
| public: \ |
| DECL_LAZY_EXTERNAL_POINTER_ACCESSORS_MAYBE_READ_ONLY_HOST(name, type) |
| |
| // Defines all required accessors for a lazily initialized C function pointer |
| // that can be called from native code. |
| // See DECL_LAZY_REDIRECTED_CALLBACK_ACCESSORS_MAYBE_READ_ONLY_HOST for details. |
| // Host objects in ReadOnlySpace can't define the isolate-less accessor. |
| #define LAZY_REDIRECTED_CALLBACK_ACCESSORS_MAYBE_READ_ONLY_HOST_CHECKED2( \ |
| holder, name, type, offset, tag, ext_ref_type, get_condition, \ |
| set_condition) \ |
| \ |
| /* Accessors for un-redirected callback pointer that can be used */ \ |
| /* in C++ code and an accessor to the raw value for printing. */ \ |
| void holder::init_##name() { \ |
| this->SetupLazilyInitializedExternalPointerField(offset); \ |
| } \ |
| bool holder::has_##name() const { \ |
| return this->IsLazilyInitializedExternalPointerFieldInitialized(offset); \ |
| } \ |
| Address holder::name##_raw(i::IsolateForSandbox isolate) const { \ |
| return this->template ReadExternalPointerField<tag>(offset, isolate); \ |
| } \ |
| type holder::name(i::IsolateForSandbox isolate) const { \ |
| Address result = name##_raw(isolate); \ |
| if (!USE_SIMULATOR_BOOL) return result; \ |
| if (result == kNullAddress) return kNullAddress; \ |
| return ExternalReference::UnwrapRedirection(result); \ |
| } \ |
| void holder::set_##name(i::IsolateForSandbox isolate, Address value) { \ |
| this->template WriteLazilyInitializedExternalPointerField<tag>( \ |
| offset, isolate, value); \ |
| if (USE_SIMULATOR_BOOL) { \ |
| init_##name##_redirection(isolate); \ |
| } \ |
| } \ |
| \ |
| /* Implementation of init/remove callback redirection methods. */ \ |
| void holder::init_##name##_redirection(i::IsolateForSandbox isolate) { \ |
| CHECK(USE_SIMULATOR_BOOL); \ |
| Address value = name##_raw(isolate); \ |
| if (value == kNullAddress) return; \ |
| value = ExternalReference::Redirect(value, ext_ref_type); \ |
| this->template WriteLazilyInitializedExternalPointerField<tag>( \ |
| offset, isolate, value); \ |
| } \ |
| void holder::remove_##name##_redirection(i::IsolateForSandbox isolate) { \ |
| CHECK(USE_SIMULATOR_BOOL); \ |
| Address value = name##_raw(isolate); \ |
| if (value == kNullAddress) return; \ |
| value = ExternalReference::UnwrapRedirection(value); \ |
| this->template WriteLazilyInitializedExternalPointerField<tag>( \ |
| offset, isolate, value); \ |
| } |
| |
| // Host objects in ReadOnlySpace can't define the isolate-less accessor. |
| #define DECL_EXTERNAL_POINTER_ACCESSORS_MAYBE_READ_ONLY_HOST(name, type) \ |
| inline type name(i::IsolateForSandbox isolate) const; \ |
| inline void init_##name(i::IsolateForSandbox isolate, \ |
| const type initial_value); \ |
| inline void set_##name(i::IsolateForSandbox isolate, const type value); |
| |
| // Host objects in ReadOnlySpace can't define the isolate-less accessor. |
| #define EXTERNAL_POINTER_ACCESSORS_MAYBE_READ_ONLY_HOST(holder, name, type, \ |
| offset, tag) \ |
| type holder::name(i::IsolateForSandbox isolate) const { \ |
| /* This is a workaround for MSVC error C2440 not allowing */ \ |
| /* reinterpret casts to the same type. */ \ |
| struct C2440 {}; \ |
| Address result = \ |
| this->template ReadExternalPointerField<tag>(offset, isolate); \ |
| return reinterpret_cast<type>(reinterpret_cast<C2440*>(result)); \ |
| } \ |
| void holder::init_##name(i::IsolateForSandbox isolate, \ |
| const type initial_value) { \ |
| /* This is a workaround for MSVC error C2440 not allowing */ \ |
| /* reinterpret casts to the same type. */ \ |
| struct C2440 {}; \ |
| Address the_value = reinterpret_cast<Address>( \ |
| reinterpret_cast<const C2440*>(initial_value)); \ |
| this->template InitExternalPointerField<tag>(offset, isolate, the_value); \ |
| } \ |
| void holder::set_##name(i::IsolateForSandbox isolate, const type value) { \ |
| /* This is a workaround for MSVC error C2440 not allowing */ \ |
| /* reinterpret casts to the same type. */ \ |
| struct C2440 {}; \ |
| Address the_value = \ |
| reinterpret_cast<Address>(reinterpret_cast<const C2440*>(value)); \ |
| this->template WriteExternalPointerField<tag>(offset, isolate, the_value); \ |
| } |
| |
| // Declares all required accessors for C function pointer that can be called |
| // from native code. |
| // In case the host and target architectures are different (i.e. simulator |
| // is enabled), we can't just call the C function from native code because |
| // of architecture difference and we need to "ask" the simulator to call |
| // the C function on behalf of the native code. This is a so-called |
| // "redirection". The pointer stored in the object is redirected while C++ |
| // accessors operate on an original C function pointer (wrapping/unwrapping |
| // is done the under the hood). |
| // Host objects in ReadOnlySpace can't define the isolate-less accessor. |
| #define DECL_REDIRECTED_CALLBACK_ACCESSORS_MAYBE_READ_ONLY_HOST(name, type) \ |
| private: \ |
| /* Returns a potentially redirected callback pointer as it's stored */ \ |
| /* in the object. This getter is used for printing of redirected value. */ \ |
| inline Address name##_raw(i::IsolateForSandbox isolate) const; \ |
| /* Adds/removes redirection for a callback pointer stored in the object. */ \ |
| inline void init_##name##_redirection(i::IsolateForSandbox isolate); \ |
| inline void remove_##name##_redirection(i::IsolateForSandbox isolate); \ |
| \ |
| public: \ |
| /* Declare accessors as for a regular external pointer. */ \ |
| DECL_EXTERNAL_POINTER_ACCESSORS_MAYBE_READ_ONLY_HOST(name, type) |
| |
| // Defines all required accessors for C function pointer that can be called |
| // from native code. |
| // See DECL_REDIRECTED_CALLBACK_ACCESSORS_MAYBE_READ_ONLY_HOST for details. |
| // Host objects in ReadOnlySpace can't define the isolate-less accessor. |
| #define REDIRECTED_CALLBACK_ACCESSORS_MAYBE_READ_ONLY_HOST( \ |
| holder, name, type, offset, tag, ext_ref_type) \ |
| \ |
| Address holder::name##_raw(i::IsolateForSandbox isolate) const { \ |
| return this->template ReadExternalPointerField<tag>(offset, isolate); \ |
| } \ |
| \ |
| /* Accessors for un-redirected callback pointer that can be used */ \ |
| /* in C++ code. */ \ |
| type holder::name(i::IsolateForSandbox isolate) const { \ |
| Address value = name##_raw(isolate); \ |
| if (!USE_SIMULATOR_BOOL) return value; \ |
| if (value == kNullAddress) return kNullAddress; \ |
| return ExternalReference::UnwrapRedirection(value); \ |
| } \ |
| void holder::init_##name(i::IsolateForSandbox isolate, \ |
| Address initial_value) { \ |
| this->template InitExternalPointerField<tag>(offset, isolate, \ |
| initial_value); \ |
| if (USE_SIMULATOR_BOOL) { \ |
| init_##name##_redirection(isolate); \ |
| } \ |
| } \ |
| void holder::set_##name(i::IsolateForSandbox isolate, Address value) { \ |
| this->template WriteExternalPointerField<tag>(offset, isolate, value); \ |
| if (USE_SIMULATOR_BOOL) { \ |
| init_##name##_redirection(isolate); \ |
| } \ |
| } \ |
| \ |
| /* Implementation of init/remove callback redirection methods. */ \ |
| void holder::init_##name##_redirection(i::IsolateForSandbox isolate) { \ |
| CHECK(USE_SIMULATOR_BOOL); \ |
| Address value = name##_raw(isolate); \ |
| if (value == kNullAddress) return; \ |
| value = ExternalReference::Redirect(value, ext_ref_type); \ |
| this->template WriteExternalPointerField<tag>(offset, isolate, value); \ |
| } \ |
| void holder::remove_##name##_redirection(i::IsolateForSandbox isolate) { \ |
| CHECK(USE_SIMULATOR_BOOL); \ |
| Address value = name##_raw(isolate); \ |
| if (value == kNullAddress) return; \ |
| value = ExternalReference::UnwrapRedirection(value); \ |
| this->template WriteExternalPointerField<tag>(offset, isolate, value); \ |
| } |
| |
| #define DECL_EXTERNAL_POINTER_ACCESSORS(name, type) \ |
| inline type name() const; \ |
| DECL_EXTERNAL_POINTER_ACCESSORS_MAYBE_READ_ONLY_HOST(name, type) |
| |
| #define EXTERNAL_POINTER_ACCESSORS(holder, name, type, offset, tag) \ |
| type holder::name() const { \ |
| i::IsolateForSandbox isolate = GetCurrentIsolateForSandbox(); \ |
| return holder::name(isolate); \ |
| } \ |
| EXTERNAL_POINTER_ACCESSORS_MAYBE_READ_ONLY_HOST(holder, name, type, offset, \ |
| tag) |
| |
| // Host objects in ReadOnlySpace can't define the isolate-less accessor. |
| #define DECL_CPP_POINTER_ACCESSORS_MAYBE_READ_ONLY_HOST(name, type) \ |
| inline type name(i::IsolateForPointerCompression isolate) const; \ |
| inline void init_##name(i::IsolateForPointerCompression isolate, \ |
| type initial_value); \ |
| inline void set_##name(i::IsolateForPointerCompression isolate, type value); |
| |
| #define DECL_CPP_POINTER_ACCESSORS(name, type) \ |
| inline type name() const; \ |
| DECL_CPP_POINTER_ACCESSORS_MAYBE_READ_ONLY_HOST(name, type) |
| |
| #define DECL_TRUSTED_POINTER_GETTERS(name, type) \ |
| /* Trusted pointers currently always have release-acquire semantics. */ \ |
| /* However, we still expose explicit release-acquire accessors so it */ \ |
| /* can be made clear when they are required. */ \ |
| /* If desired, we could create separate {Read|Write}TrustedPointer */ \ |
| /* routines for relaxed- and release-acquire semantics in the future. */ \ |
| inline Tagged<type> name(IsolateForSandbox isolate) const; \ |
| inline Tagged<type> name(IsolateForSandbox isolate, AcquireLoadTag) const; \ |
| inline bool has_##name() const; \ |
| /* Checks if the field in question is populated but unpublished. Most */ \ |
| /* code shouldn't need to care (i.e. may assume regularly published */ \ |
| /* fields), but some code needs to be robust to both situations. */ \ |
| inline bool has_##name##_unpublished(IsolateForSandbox isolate) const; |
| |
| #define DECL_TRUSTED_POINTER_SETTERS(name, type) \ |
| /* Trusted pointers currently always have release-acquire semantics. */ \ |
| /* However, we still expose explicit release-acquire accessors so it */ \ |
| /* can be made clear when they are required. */ \ |
| /* If desired, we could create separate {Read|Write}TrustedPointer */ \ |
| /* routines for relaxed- and release-acquire semantics in the future. */ \ |
| inline void set_##name(Tagged<type> value, \ |
| WriteBarrierMode mode = UPDATE_WRITE_BARRIER); \ |
| inline void set_##name(Tagged<type> value, ReleaseStoreTag, \ |
| WriteBarrierMode mode = UPDATE_WRITE_BARRIER); \ |
| inline void clear_##name(); |
| |
| #define DECL_TRUSTED_POINTER_ACCESSORS(name, type) \ |
| DECL_TRUSTED_POINTER_GETTERS(name, type) \ |
| DECL_TRUSTED_POINTER_SETTERS(name, type) |
| |
| #define TRUSTED_POINTER_ACCESSORS(holder, name, type, offset, tag) \ |
| Tagged<type> holder::name(IsolateForSandbox isolate) const { \ |
| return name(isolate, kAcquireLoad); \ |
| } \ |
| Tagged<type> holder::name(IsolateForSandbox isolate, AcquireLoadTag) const { \ |
| DCHECK(has_##name()); \ |
| return i::TrustedPointerField::ReadTrustedPointerField<tag>(this, offset, \ |
| isolate); \ |
| } \ |
| void holder::set_##name(Tagged<type> value, WriteBarrierMode mode) { \ |
| set_##name(value, kReleaseStore, mode); \ |
| } \ |
| void holder::set_##name(Tagged<type> value, ReleaseStoreTag, \ |
| WriteBarrierMode mode) { \ |
| i::TrustedPointerField::WriteTrustedPointerField<tag>(this, offset, \ |
| value); \ |
| CONDITIONAL_TRUSTED_POINTER_WRITE_BARRIER(this, offset, tag, value, mode); \ |
| } \ |
| bool holder::has_##name() const { \ |
| return !i::TrustedPointerField::IsTrustedPointerFieldEmpty(this, offset); \ |
| } \ |
| bool holder::has_##name##_unpublished(IsolateForSandbox isolate) const { \ |
| return i::TrustedPointerField::IsTrustedPointerFieldUnpublished( \ |
| this, offset, tag, isolate); \ |
| } \ |
| void holder::clear_##name() { \ |
| i::TrustedPointerField::ClearTrustedPointerField(this, offset); \ |
| } |
| |
| #define DECL_CODE_POINTER_ACCESSORS(name) \ |
| DECL_TRUSTED_POINTER_ACCESSORS(name, Code) |
| #define CODE_POINTER_ACCESSORS(holder, name, offset) \ |
| TRUSTED_POINTER_ACCESSORS(holder, name, Code, offset, kCodeIndirectPointerTag) |
| |
| // Accessors for "protected" pointers, i.e. references from one trusted object |
| // to another trusted object. For these pointers it can be assumed that neither |
| // the pointer nor the pointed-to object can be manipulated by an attacker. |
| #define DECL_PROTECTED_POINTER_ACCESSORS(name, type) \ |
| inline Tagged<type> name() const; \ |
| inline void set_##name(Tagged<type> value, \ |
| WriteBarrierMode mode = UPDATE_WRITE_BARRIER); \ |
| inline bool has_##name() const; \ |
| inline void clear_##name(); |
| |
| #define PROTECTED_POINTER_ACCESSORS(holder, name, type, offset) \ |
| static_assert(std::is_base_of_v<TrustedObject, holder>); \ |
| Tagged<type> holder::name() const { \ |
| DCHECK(has_##name()); \ |
| return ReadProtectedPointerField<type>(offset); \ |
| } \ |
| void holder::set_##name(Tagged<type> value, WriteBarrierMode mode) { \ |
| WriteProtectedPointerField(offset, value); \ |
| CONDITIONAL_PROTECTED_POINTER_WRITE_BARRIER(this, offset, value, mode); \ |
| } \ |
| bool holder::has_##name() const { \ |
| return !IsProtectedPointerFieldEmpty(offset); \ |
| } \ |
| void holder::clear_##name() { return ClearProtectedPointerField(offset); } |
| |
| #define DECL_RELEASE_ACQUIRE_PROTECTED_POINTER_ACCESSORS(name, type) \ |
| inline Tagged<type> name(AcquireLoadTag) const; \ |
| inline void set_##name(Tagged<type> value, ReleaseStoreTag, \ |
| WriteBarrierMode mode = UPDATE_WRITE_BARRIER); \ |
| inline bool has_##name(AcquireLoadTag) const; \ |
| inline void clear_##name(ReleaseStoreTag); |
| |
| #define RELEASE_ACQUIRE_PROTECTED_POINTER_ACCESSORS(holder, name, type, \ |
| offset) \ |
| static_assert(std::is_base_of_v<TrustedObject, holder>); \ |
| Tagged<type> holder::name(AcquireLoadTag tag) const { \ |
| DCHECK(has_##name(tag)); \ |
| return ReadProtectedPointerField<type>(offset, tag); \ |
| } \ |
| void holder::set_##name(Tagged<type> value, ReleaseStoreTag tag, \ |
| WriteBarrierMode mode) { \ |
| WriteProtectedPointerField(offset, value, tag); \ |
| CONDITIONAL_PROTECTED_POINTER_WRITE_BARRIER(this, offset, value, mode); \ |
| } \ |
| bool holder::has_##name(AcquireLoadTag tag) const { \ |
| return !IsProtectedPointerFieldEmpty(offset, tag); \ |
| } \ |
| void holder::clear_##name(ReleaseStoreTag tag) { \ |
| return ClearProtectedPointerField(offset, tag); \ |
| } |
| |
| #define BIT_FIELD_ACCESSORS2(holder, get_field, set_field, name, BitField) \ |
| typename BitField::FieldType holder::name() const { \ |
| return BitField::decode(get_field()); \ |
| } \ |
| void holder::set_##name(typename BitField::FieldType value) { \ |
| set_##set_field(BitField::update(set_field(), value)); \ |
| } |
| |
| #define BIT_FIELD_ACCESSORS(holder, field, name, BitField) \ |
| BIT_FIELD_ACCESSORS2(holder, field, field, name, BitField) |
| |
| #define RELAXED_INT16_ACCESSORS(holder, name, offset) \ |
| int16_t holder::name() const { \ |
| return RELAXED_READ_INT16_FIELD(this, offset); \ |
| } \ |
| void holder::set_##name(int16_t value) { \ |
| RELAXED_WRITE_INT16_FIELD(this, offset, value); \ |
| } |
| |
| #define FIELD_ADDR(p, offset) ((p)->ptr() + offset - kHeapObjectTag) |
| |
| #define SEQ_CST_READ_FIELD(p, offset) \ |
| TaggedField<Object>::SeqCst_Load(p, offset) |
| |
| #define ACQUIRE_READ_FIELD(p, offset) \ |
| TaggedField<Object>::Acquire_Load(p, offset) |
| |
| #define RELAXED_READ_FIELD(p, offset) \ |
| TaggedField<Object>::Relaxed_Load(p, offset) |
| |
| #define RELAXED_READ_WEAK_FIELD(p, offset) \ |
| TaggedField<MaybeObject>::Relaxed_Load(p, offset) |
| |
| #define WRITE_FIELD(p, offset, value) \ |
| TaggedField<Object>::store(p, offset, value) |
| |
| #define SEQ_CST_WRITE_FIELD(p, offset, value) \ |
| TaggedField<Object>::SeqCst_Store(p, offset, value) |
| |
| #define RELEASE_WRITE_FIELD(p, offset, value) \ |
| TaggedField<Object>::Release_Store(p, offset, value) |
| |
| #define RELAXED_WRITE_FIELD(p, offset, value) \ |
| TaggedField<Object>::Relaxed_Store(p, offset, value) |
| |
| #define RELAXED_WRITE_WEAK_FIELD(p, offset, value) \ |
| TaggedField<MaybeObject>::Relaxed_Store(p, offset, value) |
| |
| #define SEQ_CST_SWAP_FIELD(p, offset, value) \ |
| TaggedField<Object>::SeqCst_Swap(p, offset, value) |
| |
| #define SEQ_CST_COMPARE_AND_SWAP_FIELD(p, offset, expected, value) \ |
| TaggedField<Object>::SeqCst_CompareAndSwap(p, offset, expected, value) |
| |
| #ifdef V8_DISABLE_WRITE_BARRIERS |
| #define WRITE_BARRIER(object, offset, value) |
| #else |
| #define WRITE_BARRIER(object, offset, value) \ |
| do { \ |
| DCHECK(TrustedHeapLayout::IsOwnedByAnyHeap(object)); \ |
| static_assert(kTaggedCanConvertToRawObjects); \ |
| /* For write barriers, it doesn't matter if the slot is strong or weak, */ \ |
| /* so use the most generic slot (a maybe weak one). */ \ |
| WriteBarrier::ForValue(object, Tagged(object)->RawMaybeWeakField(offset), \ |
| value, UPDATE_WRITE_BARRIER); \ |
| } while (false) |
| #endif |
| |
| #ifdef V8_DISABLE_WRITE_BARRIERS |
| #define EXTERNAL_POINTER_WRITE_BARRIER(object, offset, tag, handle) |
| #else |
| #define EXTERNAL_POINTER_WRITE_BARRIER(object, offset, tag, handle) \ |
| do { \ |
| DCHECK(TrustedHeapLayout::IsOwnedByAnyHeap(object)); \ |
| WriteBarrier::ForExternalPointer( \ |
| object, Tagged(object)->RawExternalPointerField(offset, tag), handle, \ |
| UPDATE_WRITE_BARRIER); \ |
| } while (false) |
| #endif |
| |
| #ifdef V8_DISABLE_WRITE_BARRIERS |
| #define INDIRECT_POINTER_WRITE_BARRIER(object, offset, tag, value) |
| #else |
| #define INDIRECT_POINTER_WRITE_BARRIER(object, offset, tag, value) \ |
| do { \ |
| DCHECK(TrustedHeapLayout::IsOwnedByAnyHeap(object)); \ |
| WriteBarrier::ForIndirectPointer( \ |
| object, Tagged(object)->RawIndirectPointerField(offset, tag), value, \ |
| UPDATE_WRITE_BARRIER); \ |
| } while (false) |
| #endif |
| |
| #ifdef V8_DISABLE_WRITE_BARRIERS |
| #define JS_DISPATCH_HANDLE_WRITE_BARRIER(object, handle) |
| #else |
| #define JS_DISPATCH_HANDLE_WRITE_BARRIER(object, handle) \ |
| do { \ |
| DCHECK(TrustedHeapLayout::IsOwnedByAnyHeap(object)); \ |
| WriteBarrier::ForJSDispatchHandle(object, handle, UPDATE_WRITE_BARRIER); \ |
| } while (false) |
| #endif |
| |
| #ifdef V8_DISABLE_WRITE_BARRIERS |
| #define CONDITIONAL_WRITE_BARRIER(object, offset, value, mode) |
| #elif V8_ENABLE_UNCONDITIONAL_WRITE_BARRIERS |
| #define CONDITIONAL_WRITE_BARRIER(object, offset, value, mode) \ |
| WRITE_BARRIER(object, offset, value) |
| #else |
| #define CONDITIONAL_WRITE_BARRIER(object, offset, value, mode) \ |
| do { \ |
| DCHECK(TrustedHeapLayout::IsOwnedByAnyHeap(object)); \ |
| /* For write barriers, it doesn't matter if the slot is strong or weak, */ \ |
| /* so use the most generic slot (a maybe weak one). */ \ |
| WriteBarrier::ForValue(object, (object)->RawMaybeWeakField(offset), value, \ |
| mode); \ |
| } while (false) |
| #endif |
| |
| #ifdef V8_DISABLE_WRITE_BARRIERS |
| #define CONDITIONAL_EXTERNAL_POINTER_WRITE_BARRIER(object, offset, tag, \ |
| handle, mode) |
| #else |
| #define CONDITIONAL_EXTERNAL_POINTER_WRITE_BARRIER(object, offset, tag, \ |
| handle, mode) \ |
| do { \ |
| DCHECK(TrustedHeapLayout::IsOwnedByAnyHeap(object)); \ |
| WriteBarrier::ForExternalPointer( \ |
| object, Tagged(object)->RawExternalPointerField(offset, tag), handle, \ |
| mode); \ |
| } while (false) |
| #endif |
| #ifdef V8_DISABLE_WRITE_BARRIERS |
| #define CONDITIONAL_INDIRECT_POINTER_WRITE_BARRIER(object, offset, tag, value, \ |
| mode) |
| #else |
| #define CONDITIONAL_INDIRECT_POINTER_WRITE_BARRIER(object, offset, tag, value, \ |
| mode) \ |
| do { \ |
| DCHECK(TrustedHeapLayout::IsOwnedByAnyHeap(object)); \ |
| WriteBarrier::ForIndirectPointer( \ |
| object, Tagged(object)->RawIndirectPointerField(offset, tag), value, \ |
| mode); \ |
| } while (false) |
| #endif |
| |
| #ifdef V8_ENABLE_SANDBOX |
| #define CONDITIONAL_TRUSTED_POINTER_WRITE_BARRIER(object, offset, tag, value, \ |
| mode) \ |
| CONDITIONAL_INDIRECT_POINTER_WRITE_BARRIER(object, offset, tag, value, mode) |
| #else |
| #define CONDITIONAL_TRUSTED_POINTER_WRITE_BARRIER(object, offset, tag, value, \ |
| mode) \ |
| CONDITIONAL_WRITE_BARRIER(this, offset, value, mode); |
| #endif // V8_ENABLE_SANDBOX |
| #define CONDITIONAL_CODE_POINTER_WRITE_BARRIER(object, offset, value, mode) \ |
| CONDITIONAL_TRUSTED_POINTER_WRITE_BARRIER( \ |
| object, offset, kCodeIndirectPointerTag, value, mode) |
| |
| #define CONDITIONAL_PROTECTED_POINTER_WRITE_BARRIER(object, offset, value, \ |
| mode) \ |
| do { \ |
| DCHECK(TrustedHeapLayout::IsOwnedByAnyHeap(object)); \ |
| WriteBarrier::ForProtectedPointer( \ |
| object, (object)->RawProtectedPointerField(offset), value, mode); \ |
| } while (false) |
| |
| #ifdef V8_DISABLE_WRITE_BARRIERS |
| #define CONDITIONAL_JS_DISPATCH_HANDLE_WRITE_BARRIER(object, handle, mode) |
| #else |
| #define CONDITIONAL_JS_DISPATCH_HANDLE_WRITE_BARRIER(object, handle, mode) \ |
| do { \ |
| DCHECK(TrustedHeapLayout::IsOwnedByAnyHeap(object)); \ |
| WriteBarrier::ForJSDispatchHandle(object, handle, mode); \ |
| } while (false) |
| #endif |
| |
| #define ACQUIRE_READ_INT8_FIELD(p, offset) \ |
| static_cast<int8_t>(base::Acquire_Load( \ |
| reinterpret_cast<const base::Atomic8*>(FIELD_ADDR(p, offset)))) |
| |
| #define ACQUIRE_READ_INT32_FIELD(p, offset) \ |
| static_cast<int32_t>(base::Acquire_Load( \ |
| reinterpret_cast<const base::Atomic32*>(FIELD_ADDR(p, offset)))) |
| |
| #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( \ |
| reinterpret_cast<const base::Atomic8*>(FIELD_ADDR(p, offset)))) |
| |
| #define RELAXED_WRITE_UINT8_FIELD(p, offset, value) \ |
| base::Relaxed_Store(reinterpret_cast<base::Atomic8*>(FIELD_ADDR(p, offset)), \ |
| static_cast<base::Atomic8>(value)); |
| #define RELAXED_READ_UINT8_FIELD(p, offset) \ |
| static_cast<uint8_t>(base::Relaxed_Load( \ |
| reinterpret_cast<const base::Atomic8*>(FIELD_ADDR(p, offset)))) |
| |
| #define RELAXED_READ_UINT16_FIELD(p, offset) \ |
| static_cast<uint16_t>(base::Relaxed_Load( \ |
| reinterpret_cast<const base::Atomic16*>(FIELD_ADDR(p, offset)))) |
| |
| #define RELAXED_WRITE_UINT16_FIELD(p, offset, value) \ |
| base::Relaxed_Store( \ |
| reinterpret_cast<base::Atomic16*>(FIELD_ADDR(p, offset)), \ |
| static_cast<base::Atomic16>(value)); |
| |
| #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)); |
| |
| #define RELAXED_READ_UINT32_FIELD(p, offset) \ |
| static_cast<uint32_t>(base::Relaxed_Load( \ |
| reinterpret_cast<const base::Atomic32*>(FIELD_ADDR(p, offset)))) |
| |
| #define ACQUIRE_READ_UINT32_FIELD(p, offset) \ |
| static_cast<uint32_t>(base::Acquire_Load( \ |
| reinterpret_cast<const base::Atomic32*>(FIELD_ADDR(p, offset)))) |
| |
| #define RELAXED_WRITE_UINT32_FIELD(p, offset, value) \ |
| base::Relaxed_Store( \ |
| reinterpret_cast<base::Atomic32*>(FIELD_ADDR(p, offset)), \ |
| static_cast<base::Atomic32>(value)); |
| |
| #define RELEASE_WRITE_INT8_FIELD(p, offset, value) \ |
| base::Release_Store(reinterpret_cast<base::Atomic8*>(FIELD_ADDR(p, offset)), \ |
| static_cast<base::Atomic8>(value)); |
| |
| #define RELEASE_WRITE_UINT32_FIELD(p, offset, value) \ |
| base::Release_Store( \ |
| reinterpret_cast<base::Atomic32*>(FIELD_ADDR(p, offset)), \ |
| static_cast<base::Atomic32>(value)); |
| |
| #define RELAXED_READ_INT32_FIELD(p, offset) \ |
| static_cast<int32_t>(base::Relaxed_Load( \ |
| reinterpret_cast<const base::Atomic32*>(FIELD_ADDR(p, offset)))) |
| |
| #if defined(V8_HOST_ARCH_64_BIT) |
| #define RELAXED_READ_INT64_FIELD(p, offset) \ |
| static_cast<int64_t>(base::Relaxed_Load( \ |
| reinterpret_cast<const base::Atomic64*>(FIELD_ADDR(p, offset)))) |
| #endif |
| |
| #define RELEASE_WRITE_INT32_FIELD(p, offset, value) \ |
| base::Release_Store( \ |
| reinterpret_cast<base::Atomic32*>(FIELD_ADDR(p, offset)), \ |
| static_cast<base::Atomic32>(value)) |
| |
| #define RELAXED_WRITE_INT32_FIELD(p, offset, value) \ |
| base::Relaxed_Store( \ |
| reinterpret_cast<base::Atomic32*>(FIELD_ADDR(p, offset)), \ |
| static_cast<base::Atomic32>(value)) |
| |
| static_assert(sizeof(int) == sizeof(int32_t), |
| "sizeof int must match sizeof int32_t"); |
| |
| #define RELAXED_READ_INT_FIELD(p, offset) RELAXED_READ_INT32_FIELD(p, offset) |
| |
| #define RELAXED_WRITE_INT_FIELD(p, offset, value) \ |
| RELAXED_WRITE_INT32_FIELD(p, offset, value) |
| |
| static_assert(sizeof(unsigned) == sizeof(uint32_t), |
| "sizeof unsigned must match sizeof uint32_t"); |
| |
| #define RELAXED_READ_UINT_FIELD(p, offset) RELAXED_READ_UINT32_FIELD(p, offset) |
| |
| #define RELAXED_WRITE_UINT_FIELD(p, offset, value) \ |
| RELAXED_WRITE_UINT32_FIELD(p, offset, value) |
| |
| #define RELAXED_READ_BYTE_FIELD(p, offset) \ |
| static_cast<uint8_t>(base::Relaxed_Load( \ |
| reinterpret_cast<const base::Atomic8*>(FIELD_ADDR(p, offset)))) |
| |
| #define ACQUIRE_READ_BYTE_FIELD(p, offset) \ |
| static_cast<uint8_t>(base::Acquire_Load( \ |
| reinterpret_cast<const base::Atomic8*>(FIELD_ADDR(p, offset)))) |
| |
| #define RELAXED_WRITE_BYTE_FIELD(p, offset, value) \ |
| base::Relaxed_Store(reinterpret_cast<base::Atomic8*>(FIELD_ADDR(p, offset)), \ |
| static_cast<base::Atomic8>(value)); |
| |
| #define RELEASE_WRITE_BYTE_FIELD(p, offset, value) \ |
| base::Release_Store(reinterpret_cast<base::Atomic8*>(FIELD_ADDR(p, offset)), \ |
| static_cast<base::Atomic8>(value)); |
| |
| #ifdef OBJECT_PRINT |
| #define DECL_PRINTER(Name) void Name##Print(std::ostream& os); |
| #else |
| #define DECL_PRINTER(Name) |
| #endif |
| |
| #ifdef VERIFY_HEAP |
| #define DECL_VERIFIER(Name) void Name##Verify(Isolate* isolate); |
| #define EXPORT_DECL_VERIFIER(Name) \ |
| V8_EXPORT_PRIVATE void Name##Verify(Isolate* isolate); |
| #define DECL_STATIC_VERIFIER(Name) \ |
| static void Name##Verify(Tagged<Name> obj, Isolate* isolate); |
| #define EXPORT_DECL_STATIC_VERIFIER(Name) \ |
| V8_EXPORT_PRIVATE static void Name##Verify(Tagged<Name> obj, \ |
| Isolate* isolate); |
| #else |
| #define DECL_VERIFIER(Name) |
| #define EXPORT_DECL_VERIFIER(Name) |
| #define DECL_STATIC_VERIFIER(Name) |
| #define EXPORT_DECL_STATIC_VERIFIER(Name) |
| #endif |
| |
| #define DEFINE_DEOPT_ELEMENT_ACCESSORS(name, type) \ |
| auto DeoptimizationData::name() const -> Tagged<type> { \ |
| return TrustedCast<type>(get(k##name##Index)); \ |
| } \ |
| void DeoptimizationData::Set##name(Tagged<type> value) { \ |
| set(k##name##Index, value); \ |
| } |
| |
| #define DEFINE_DEOPT_ENTRY_ACCESSORS(name, type) \ |
| Tagged<type> DeoptimizationData::name(int i) const { \ |
| return Cast<type>(get(IndexForEntry(i) + k##name##Offset)); \ |
| } \ |
| void DeoptimizationData::Set##name(int i, Tagged<type> value) { \ |
| set(IndexForEntry(i) + k##name##Offset, value); \ |
| } |
| |
| #define TQ_CPP_OBJECT_DEFINITION_ASSERTS(_class, parent) \ |
| template class TorqueGenerated##_class##Asserts<_class, parent>; |
