ikan Uploader :
Directory : /home/ubuntu/node-v16.18.1/out/Release/obj/gen/torque-generated/src/objects/
Upload File : |
| Current File : //home/ubuntu/node-v16.18.1/out/Release/obj/gen/torque-generated/src/objects/struct-tq.inc |
class Struct;
class ClassPositions;
class AccessorPair;
class Tuple2;
// Alias for HeapObject::IsStruct() that avoids inlining.
V8_EXPORT_PRIVATE bool IsStruct_NonInline(HeapObject o);
template <class D, class P>
class TorqueGeneratedStruct : public P {
static_assert(std::is_same<Struct, D>::value,
"Use this class as direct base for Struct.");
static_assert(std::is_same<HeapObject, P>::value,
"Pass in HeapObject as second template parameter for TorqueGeneratedStruct.");
public:
using Super = P;
using TorqueGeneratedClass = TorqueGeneratedStruct<D,P>;
V8_INLINE static D cast(Object object) {
return D(object.ptr());
}
V8_INLINE static D unchecked_cast(Object object) {
return bit_cast<D>(object);
}
DECL_PRINTER(Struct)
#ifdef VERIFY_HEAP
V8_EXPORT_PRIVATE void StructVerify(Isolate* isolate);
#endif // VERIFY_HEAP
static constexpr int kStartOfWeakFieldsOffset = P::kHeaderSize;
static constexpr int kEndOfWeakFieldsOffset = P::kHeaderSize;
static constexpr int kStartOfStrongFieldsOffset = P::kHeaderSize;
static constexpr int kEndOfStrongFieldsOffset = P::kHeaderSize;
static constexpr int kHeaderSize = P::kHeaderSize;
friend class Factory;
public:
template <class DAlias = D>
constexpr TorqueGeneratedStruct() : P() {
static_assert(std::is_base_of<TorqueGeneratedStruct,
DAlias>::value,
"class TorqueGeneratedStruct should be used as direct base for Struct.");
}
protected:
inline explicit TorqueGeneratedStruct(Address ptr);
// Special-purpose constructor for subclasses that have fast paths where
// their ptr() is a Smi.
inline explicit TorqueGeneratedStruct(Address ptr, HeapObject::AllowInlineSmiStorage allow_smi);
};
// Alias for HeapObject::IsClassPositions() that avoids inlining.
V8_EXPORT_PRIVATE bool IsClassPositions_NonInline(HeapObject o);
template <class D, class P>
class TorqueGeneratedClassPositions : public P {
static_assert(std::is_same<ClassPositions, D>::value,
"Use this class as direct base for ClassPositions.");
static_assert(std::is_same<Struct, P>::value,
"Pass in Struct as second template parameter for TorqueGeneratedClassPositions.");
public:
using Super = P;
using TorqueGeneratedClass = TorqueGeneratedClassPositions<D,P>;
inline int start() const;
inline void set_start(int value);
inline int end() const;
inline void set_end(int value);
V8_INLINE static D cast(Object object) {
return D(object.ptr());
}
V8_INLINE static D unchecked_cast(Object object) {
return bit_cast<D>(object);
}
#ifdef VERIFY_HEAP
V8_EXPORT_PRIVATE void ClassPositionsVerify(Isolate* isolate);
#endif // VERIFY_HEAP
static constexpr int kStartOfStrongFieldsOffset = P::kHeaderSize;
static constexpr int kStartOffset = P::kHeaderSize;
static constexpr int kStartOffsetEnd = kStartOffset + kTaggedSize - 1;
static constexpr int kEndOffset = kStartOffsetEnd + 1;
static constexpr int kEndOffsetEnd = kEndOffset + kTaggedSize - 1;
static constexpr int kEndOfStrongFieldsOffset = kEndOffsetEnd + 1;
static constexpr int kStartOfWeakFieldsOffset = kEndOffsetEnd + 1;
static constexpr int kEndOfWeakFieldsOffset = kEndOffsetEnd + 1;
static constexpr int kHeaderSize = kEndOffsetEnd + 1;
static constexpr int kSize = kEndOffsetEnd + 1;
V8_INLINE static constexpr int32_t SizeFor() {
DCHECK(kHeaderSize == kSize && kHeaderSize == 24);
int32_t size = kHeaderSize;
return size;
}
V8_INLINE int32_t AllocatedSize() const {
return SizeFor();
}
friend class Factory;
public:
template <class DAlias = D>
constexpr TorqueGeneratedClassPositions() : P() {
static_assert(std::is_base_of<TorqueGeneratedClassPositions,
DAlias>::value,
"class TorqueGeneratedClassPositions should be used as direct base for ClassPositions.");
}
protected:
inline explicit TorqueGeneratedClassPositions(Address ptr);
// Special-purpose constructor for subclasses that have fast paths where
// their ptr() is a Smi.
inline explicit TorqueGeneratedClassPositions(Address ptr, HeapObject::AllowInlineSmiStorage allow_smi);
};
// Alias for HeapObject::IsAccessorPair() that avoids inlining.
V8_EXPORT_PRIVATE bool IsAccessorPair_NonInline(HeapObject o);
template <class D, class P>
class TorqueGeneratedAccessorPair : public P {
static_assert(std::is_same<AccessorPair, D>::value,
"Use this class as direct base for AccessorPair.");
static_assert(std::is_same<Struct, P>::value,
"Pass in Struct as second template parameter for TorqueGeneratedAccessorPair.");
public:
using Super = P;
using TorqueGeneratedClass = TorqueGeneratedAccessorPair<D,P>;
inline Object getter() const;
inline Object getter(PtrComprCageBase cage_base) const;
inline void set_getter(Object value, WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
inline Object setter() const;
inline Object setter(PtrComprCageBase cage_base) const;
inline void set_setter(Object value, WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
V8_INLINE static D cast(Object object) {
return D(object.ptr());
}
V8_INLINE static D unchecked_cast(Object object) {
return bit_cast<D>(object);
}
#ifdef VERIFY_HEAP
V8_EXPORT_PRIVATE void AccessorPairVerify(Isolate* isolate);
#endif // VERIFY_HEAP
static constexpr int kStartOfStrongFieldsOffset = P::kHeaderSize;
static constexpr int kGetterOffset = P::kHeaderSize;
static constexpr int kGetterOffsetEnd = kGetterOffset + kTaggedSize - 1;
static constexpr int kSetterOffset = kGetterOffsetEnd + 1;
static constexpr int kSetterOffsetEnd = kSetterOffset + kTaggedSize - 1;
static constexpr int kEndOfStrongFieldsOffset = kSetterOffsetEnd + 1;
static constexpr int kStartOfWeakFieldsOffset = kSetterOffsetEnd + 1;
static constexpr int kEndOfWeakFieldsOffset = kSetterOffsetEnd + 1;
static constexpr int kHeaderSize = kSetterOffsetEnd + 1;
static constexpr int kSize = kSetterOffsetEnd + 1;
V8_INLINE static constexpr int32_t SizeFor() {
DCHECK(kHeaderSize == kSize && kHeaderSize == 24);
int32_t size = kHeaderSize;
return size;
}
V8_INLINE int32_t AllocatedSize() const {
return SizeFor();
}
friend class Factory;
public:
template <class DAlias = D>
constexpr TorqueGeneratedAccessorPair() : P() {
static_assert(std::is_base_of<TorqueGeneratedAccessorPair,
DAlias>::value,
"class TorqueGeneratedAccessorPair should be used as direct base for AccessorPair.");
}
protected:
inline explicit TorqueGeneratedAccessorPair(Address ptr);
// Special-purpose constructor for subclasses that have fast paths where
// their ptr() is a Smi.
inline explicit TorqueGeneratedAccessorPair(Address ptr, HeapObject::AllowInlineSmiStorage allow_smi);
};
// Alias for HeapObject::IsTuple2() that avoids inlining.
V8_EXPORT_PRIVATE bool IsTuple2_NonInline(HeapObject o);
template <class D, class P>
class TorqueGeneratedTuple2 : public P {
static_assert(std::is_same<Tuple2, D>::value,
"Use this class as direct base for Tuple2.");
static_assert(std::is_same<Struct, P>::value,
"Pass in Struct as second template parameter for TorqueGeneratedTuple2.");
public:
using Super = P;
using TorqueGeneratedClass = TorqueGeneratedTuple2<D,P>;
inline Object value1() const;
inline Object value1(PtrComprCageBase cage_base) const;
inline void set_value1(Object value, WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
inline Object value2() const;
inline Object value2(PtrComprCageBase cage_base) const;
inline void set_value2(Object value, WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
V8_INLINE static D cast(Object object) {
return D(object.ptr());
}
V8_INLINE static D unchecked_cast(Object object) {
return bit_cast<D>(object);
}
DECL_PRINTER(Tuple2)
#ifdef VERIFY_HEAP
V8_EXPORT_PRIVATE void Tuple2Verify(Isolate* isolate);
#endif // VERIFY_HEAP
static constexpr int kStartOfStrongFieldsOffset = P::kHeaderSize;
static constexpr int kValue1Offset = P::kHeaderSize;
static constexpr int kValue1OffsetEnd = kValue1Offset + kTaggedSize - 1;
static constexpr int kValue2Offset = kValue1OffsetEnd + 1;
static constexpr int kValue2OffsetEnd = kValue2Offset + kTaggedSize - 1;
static constexpr int kEndOfStrongFieldsOffset = kValue2OffsetEnd + 1;
static constexpr int kStartOfWeakFieldsOffset = kValue2OffsetEnd + 1;
static constexpr int kEndOfWeakFieldsOffset = kValue2OffsetEnd + 1;
static constexpr int kHeaderSize = kValue2OffsetEnd + 1;
static constexpr int kSize = kValue2OffsetEnd + 1;
V8_INLINE static constexpr int32_t SizeFor() {
DCHECK(kHeaderSize == kSize && kHeaderSize == 24);
int32_t size = kHeaderSize;
return size;
}
V8_INLINE int32_t AllocatedSize() const {
return SizeFor();
}
friend class Factory;
public:
template <class DAlias = D>
constexpr TorqueGeneratedTuple2() : P() {
static_assert(std::is_base_of<TorqueGeneratedTuple2,
DAlias>::value,
"class TorqueGeneratedTuple2 should be used as direct base for Tuple2.");
}
protected:
inline explicit TorqueGeneratedTuple2(Address ptr);
// Special-purpose constructor for subclasses that have fast paths where
// their ptr() is a Smi.
inline explicit TorqueGeneratedTuple2(Address ptr, HeapObject::AllowInlineSmiStorage allow_smi);
};
Kontol Shell Bypass