Flutter Engine
The Flutter Engine
Loading...
Searching...
No Matches
Classes | Namespaces | Macros | Enumerations | Functions
raw_object.h File Reference
#include "platform/assert.h"
#include "vm/class_id.h"
#include "vm/compiler/method_recognizer.h"
#include "vm/compiler/runtime_api.h"
#include "vm/exceptions.h"
#include "vm/globals.h"
#include "vm/pointer_tagging.h"
#include "vm/snapshot.h"
#include "vm/tagged_pointer.h"
#include "vm/thread.h"
#include "vm/token.h"
#include "vm/token_position.h"
#include "vm/visitor.h"

Go to the source code of this file.

Classes

class  dart::UntaggedObject
 
class  dart::UntaggedObject::SizeTag
 
class  dart::UntaggedObject::ClassIdTag
 
class  dart::UntaggedObject::CardRememberedBit
 
class  dart::UntaggedObject::NotMarkedBit
 
class  dart::UntaggedObject::NewBit
 
class  dart::UntaggedObject::CanonicalBit
 
class  dart::UntaggedObject::AlwaysSetBit
 
class  dart::UntaggedObject::OldAndNotRememberedBit
 
class  dart::UntaggedObject::ImmutableBit
 
class  dart::UntaggedObject::ReservedBit
 
class  dart::UntaggedClass
 
class  dart::UntaggedPatchClass
 
class  dart::UntaggedFunction
 
class  dart::UntaggedFunction::UnboxedParameterBitmap
 
class  dart::UntaggedClosureData
 
class  dart::UntaggedFfiTrampolineData
 
class  dart::UntaggedField
 
class  dart::UntaggedScript
 
class  dart::UntaggedLibrary
 
class  dart::UntaggedNamespace
 
class  dart::UntaggedKernelProgramInfo
 
class  dart::UntaggedWeakSerializationReference
 
class  dart::UntaggedWeakArray
 
class  dart::UntaggedCode
 
class  dart::UntaggedObjectPool
 
class  dart::UntaggedInstructions
 
class  dart::UntaggedInstructionsSection
 
class  dart::UntaggedPcDescriptors
 
class  dart::UntaggedPcDescriptors::KindAndMetadata
 
class  dart::UntaggedCodeSourceMap
 
class  dart::UntaggedCompressedStackMaps
 
struct  dart::UntaggedCompressedStackMaps::Payload
 
class  dart::UntaggedInstructionsTable
 
class  dart::UntaggedLocalVarDescriptors
 
class  dart::UntaggedLocalVarDescriptors::IndexBits
 
class  dart::UntaggedLocalVarDescriptors::KindBits
 
struct  dart::UntaggedLocalVarDescriptors::VarInfo
 
class  dart::UntaggedExceptionHandlers
 
class  dart::UntaggedContext
 
class  dart::UntaggedContextScope
 
class  dart::UntaggedSentinel
 
class  dart::UntaggedSingleTargetCache
 
class  dart::UntaggedMonomorphicSmiableCall
 
class  dart::UntaggedCallSiteData
 
class  dart::UntaggedUnlinkedCall
 
class  dart::UntaggedICData
 
class  dart::UntaggedMegamorphicCache
 
class  dart::UntaggedSubtypeTestCache
 
class  dart::UntaggedLoadingUnit
 
class  dart::UntaggedError
 
class  dart::UntaggedApiError
 
class  dart::UntaggedLanguageError
 
class  dart::UntaggedUnhandledException
 
class  dart::UntaggedUnwindError
 
class  dart::UntaggedInstance
 
class  dart::UntaggedLibraryPrefix
 
class  dart::UntaggedTypeArguments
 
class  dart::UntaggedTypeParameters
 
class  dart::UntaggedAbstractType
 
class  dart::UntaggedType
 
class  dart::UntaggedFunctionType
 
class  dart::UntaggedRecordType
 
class  dart::UntaggedTypeParameter
 
class  dart::UntaggedClosure
 
class  dart::UntaggedNumber
 
class  dart::UntaggedInteger
 
class  dart::UntaggedSmi
 
class  dart::UntaggedMint
 
class  dart::UntaggedDouble
 
class  dart::UntaggedString
 
class  dart::UntaggedOneByteString
 
class  dart::UntaggedTwoByteString
 
class  dart::UntaggedPointerBase
 
class  dart::UntaggedTypedDataBase
 
class  dart::UntaggedTypedData
 
class  dart::UntaggedTypedDataView
 
class  dart::UntaggedBool
 
class  dart::UntaggedArray
 
class  dart::UntaggedImmutableArray
 
class  dart::UntaggedGrowableObjectArray
 
class  dart::UntaggedLinkedHashBase
 
class  dart::UntaggedMap
 
class  dart::UntaggedConstMap
 
class  dart::UntaggedSet
 
class  dart::UntaggedConstSet
 
class  dart::UntaggedFloat32x4
 
class  dart::UntaggedInt32x4
 
class  dart::UntaggedFloat64x2
 
class  dart::UntaggedRecord
 
class  dart::UntaggedExternalTypedData
 
class  dart::UntaggedPointer
 
class  dart::UntaggedDynamicLibrary
 
class  dart::UntaggedCapability
 
class  dart::UntaggedSendPort
 
class  dart::UntaggedReceivePort
 
class  dart::UntaggedTransferableTypedData
 
class  dart::UntaggedStackTrace
 
class  dart::UntaggedSuspendState
 
class  dart::UntaggedRegExp
 
class  dart::UntaggedWeakProperty
 
class  dart::UntaggedWeakReference
 
class  dart::UntaggedFinalizerBase
 
class  dart::UntaggedFinalizer
 
class  dart::UntaggedNativeFinalizer
 
class  dart::UntaggedFinalizerEntry
 
class  dart::UntaggedMirrorReference
 
class  dart::UntaggedUserTag
 
class  dart::UntaggedFutureOr
 

Namespaces

namespace  dart
 

Macros

#define DEFINE_FORWARD_DECLARATION(clazz)   class Untagged##clazz;
 
#define DEFINE_CONTAINS_COMPRESSED(type)
 
#define CHECK_CONTAIN_COMPRESSED(type)
 
#define VISIT_FROM(first)
 
#define VISIT_FROM_PAYLOAD_START(elem_type)
 
#define VISIT_TO(last)
 
#define VISIT_TO_PAYLOAD_END(elem_type)
 
#define VISIT_NOTHING()   int NothingToVisit();
 
#define ASSERT_UNCOMPRESSED(Type)
 
#define ASSERT_COMPRESSED(Type)
 
#define ASSERT_NOTHING_TO_VISIT(Type)    ASSERT(SIZE_OF_RETURNED_VALUE(Untagged##Type, NothingToVisit) == sizeof(int))
 
#define V(name)   k##name##Element,
 
#define VISITOR_SUPPORT(object)
 
#define RAW_OBJECT_IMPLEMENTATION(object)
 
#define RAW_HEAP_OBJECT_IMPLEMENTATION(object)
 
#define POINTER_FIELD(type, name)
 
#define COMPRESSED_POINTER_FIELD(type, name)
 
#define ARRAY_POINTER_FIELD(type, name)
 
#define COMPRESSED_ARRAY_POINTER_FIELD(type, name)
 
#define VARIABLE_POINTER_FIELDS(type, accessor_name, array_name)
 
#define COMPRESSED_VARIABLE_POINTER_FIELDS(type, accessor_name, array_name)
 
#define SMI_FIELD(type, name)
 
#define COMPRESSED_SMI_FIELD(type, name)
 
#define WSR_COMPRESSED_POINTER_FIELD(Type, Name)    COMPRESSED_POINTER_FIELD(Type, Name)
 
#define FOR_EACH_RAW_FUNCTION_KIND(V)
 
#define KIND_DEFN(Name)   k##Name,
 
#define KIND_CASE(Name)
 
#define KIND_CASE(Name)
 
#define JIT_FUNCTION_COUNTERS(F)
 
#define DECLARE(return_type, type, name)   type name##_;
 
#define FOR_EACH_RAW_PC_DESCRIPTOR(V)
 
#define ENUM_DEF(name, init)   k##name = init,
 
#define CONTEXT_SCOPE_VARIABLE_DESC_FLAG_LIST(V)
 
#define DECLARE_BIT(Name)   kIs##Name,
 
#define DEFINE_ACCESSOR(type, name)
 

Enumerations

enum  dart::TypedDataElementType
 
enum class  dart::InstantiationMode : uint8_t { dart::kNeedsInstantiation , dart::kIsInstantiated , dart::kSharesInstantiatorTypeArguments , dart::kSharesFunctionTypeArguments }
 

Functions

 dart::COMPILE_ASSERT (sizeof(UntaggedMint)==16)
 
 dart::COMPILE_ASSERT (sizeof(UntaggedDouble)==16)
 
 dart::COMPILE_ASSERT (sizeof(UntaggedFloat32x4)==24)
 
 dart::COMPILE_ASSERT (sizeof(UntaggedInt32x4)==24)
 
 dart::COMPILE_ASSERT (sizeof(UntaggedFloat64x2)==24)
 

Macro Definition Documentation

◆ ARRAY_POINTER_FIELD

#define ARRAY_POINTER_FIELD (   type,
  name 
)
Value:
public: \
template <std::memory_order order = std::memory_order_relaxed> \
type name() const { \
return LoadPointer<type, order>(&name##_); \
} \
template <std::memory_order order = std::memory_order_relaxed> \
void set_##name(type value) { \
StoreArrayPointer<type, order>(&name##_, value); \
} \
\
protected: \
type name##_;
type
uint8_t type
Definition fl_standard_message_codec_test.cc:1115
name
const char * name
Definition fuchsia.cc:50
dart_profiler_symbols._
_
Definition dart_profiler_symbols.py:59

Definition at line 896 of file raw_object.h.

897 : \
898 template <std::memory_order order = std::memory_order_relaxed> \
899 type name() const { \
900 return LoadPointer<type, order>(&name##_); \
901 } \
902 template <std::memory_order order = std::memory_order_relaxed> \
903 void set_##name(type value) { \
904 StoreArrayPointer<type, order>(&name##_, value); \
905 } \
906 \
907 protected: \
908 type name##_;

◆ ASSERT_COMPRESSED

#define ASSERT_COMPRESSED (   Type)

Definition at line 117 of file raw_object.h.

◆ ASSERT_NOTHING_TO_VISIT

#define ASSERT_NOTHING_TO_VISIT (   Type)     ASSERT(SIZE_OF_RETURNED_VALUE(Untagged##Type, NothingToVisit) == sizeof(int))

Definition at line 120 of file raw_object.h.

◆ ASSERT_UNCOMPRESSED

#define ASSERT_UNCOMPRESSED (   Type)

Definition at line 116 of file raw_object.h.

◆ CHECK_CONTAIN_COMPRESSED

#define CHECK_CONTAIN_COMPRESSED (   type)
Value:
static_assert( \
kContainsCompressedPointers || is_uncompressed_ptr<type>::value, \
"From declaration uses ObjectPtr"); \
static_assert( \
!kContainsCompressedPointers || is_compressed_ptr<type>::value, \
"From declaration uses CompressedObjectPtr");

Definition at line 52 of file raw_object.h.

◆ COMPRESSED_ARRAY_POINTER_FIELD

#define COMPRESSED_ARRAY_POINTER_FIELD (   type,
  name 
)
Value:
public: \
template <std::memory_order order = std::memory_order_relaxed> \
type name() const { \
return LoadPointer<Compressed##type, order>(&name##_).Decompress( \
heap_base()); \
} \
template <std::memory_order order = std::memory_order_relaxed> \
void set_##name(type value) { \
StoreCompressedArrayPointer<type, Compressed##type, order>(&name##_, \
value); \
} \
\
protected: \
Compressed##type name##_;

Definition at line 910 of file raw_object.h.

911 : \
912 template <std::memory_order order = std::memory_order_relaxed> \
913 type name() const { \
914 return LoadPointer<Compressed##type, order>(&name##_).Decompress( \
915 heap_base()); \
916 } \
917 template <std::memory_order order = std::memory_order_relaxed> \
918 void set_##name(type value) { \
919 StoreCompressedArrayPointer<type, Compressed##type, order>(&name##_, \
920 value); \
921 } \
922 \
923 protected: \
924 Compressed##type name##_;

◆ COMPRESSED_POINTER_FIELD

#define COMPRESSED_POINTER_FIELD (   type,
  name 
)
Value:
public: \
template <std::memory_order order = std::memory_order_relaxed> \
type name() const { \
return LoadCompressedPointer<type, Compressed##type, order>(&name##_); \
} \
template <std::memory_order order = std::memory_order_relaxed> \
void set_##name(type value) { \
StoreCompressedPointer<type, Compressed##type, order>(&name##_, value); \
} \
\
protected: \
Compressed##type name##_;

Definition at line 882 of file raw_object.h.

883 : \
884 template <std::memory_order order = std::memory_order_relaxed> \
885 type name() const { \
886 return LoadCompressedPointer<type, Compressed##type, order>(&name##_); \
887 } \
888 template <std::memory_order order = std::memory_order_relaxed> \
889 void set_##name(type value) { \
890 StoreCompressedPointer<type, Compressed##type, order>(&name##_, value); \
891 } \
892 \
893 protected: \
894 Compressed##type name##_;

◆ COMPRESSED_SMI_FIELD

#define COMPRESSED_SMI_FIELD (   type,
  name 
)
Value:
public: \
template <std::memory_order order = std::memory_order_relaxed> \
type name() const { \
type result = LoadCompressedSmi<order>(&name##_); \
ASSERT(!result.IsHeapObject()); \
return result; \
} \
template <std::memory_order order = std::memory_order_relaxed> \
void set_##name(type value) { \
ASSERT(!value.IsHeapObject()); \
StoreCompressedSmi(&name##_, value); \
} \
\
protected: \
Compressed##type name##_;
value
uint8_t value
Definition fl_standard_message_codec.cc:36
result
GAsyncResult * result
Definition fl_text_input_plugin.cc:106

Definition at line 994 of file raw_object.h.

995 : \
996 template <std::memory_order order = std::memory_order_relaxed> \
997 type name() const { \
998 type result = LoadCompressedSmi<order>(&name##_); \
999 ASSERT(!result.IsHeapObject()); \
1000 return result; \
1001 } \
1002 template <std::memory_order order = std::memory_order_relaxed> \
1003 void set_##name(type value) { \
1004 ASSERT(!value.IsHeapObject()); \
1005 StoreCompressedSmi(&name##_, value); \
1006 } \
1007 \
1008 protected: \
1009 Compressed##type name##_;

◆ COMPRESSED_VARIABLE_POINTER_FIELDS

#define COMPRESSED_VARIABLE_POINTER_FIELDS (   type,
  accessor_name,
  array_name 
)
Value:
public: \
template <std::memory_order order = std::memory_order_relaxed> \
type accessor_name(intptr_t index) const { \
return LoadCompressedPointer<type, Compressed##type, order>( \
&array_name()[index]); \
} \
template <std::memory_order order = std::memory_order_relaxed> \
void set_##accessor_name(intptr_t index, type value) { \
StoreCompressedArrayPointer<type, Compressed##type, order>( \
&array_name()[index], value); \
} \
template <std::memory_order order = std::memory_order_relaxed> \
void set_##accessor_name(intptr_t index, type value, Thread* thread) { \
StoreCompressedArrayPointer<type, Compressed##type, order>( \
&array_name()[index], value, thread); \
} \
\
protected: \
Compressed##type* array_name() { \
OPEN_ARRAY_START(Compressed##type, Compressed##type); \
} \
Compressed##type const* array_name() const { \
OPEN_ARRAY_START(Compressed##type, Compressed##type); \
} \
VISIT_TO_PAYLOAD_END(Compressed##type)

Definition at line 950 of file raw_object.h.

951 : \
952 template <std::memory_order order = std::memory_order_relaxed> \
953 type accessor_name(intptr_t index) const { \
954 return LoadCompressedPointer<type, Compressed##type, order>( \
955 &array_name()[index]); \
956 } \
957 template <std::memory_order order = std::memory_order_relaxed> \
958 void set_##accessor_name(intptr_t index, type value) { \
959 StoreCompressedArrayPointer<type, Compressed##type, order>( \
960 &array_name()[index], value); \
961 } \
962 template <std::memory_order order = std::memory_order_relaxed> \
963 void set_##accessor_name(intptr_t index, type value, Thread* thread) { \
964 StoreCompressedArrayPointer<type, Compressed##type, order>( \
965 &array_name()[index], value, thread); \
966 } \
967 \
968 protected: \
969 Compressed##type* array_name() { \
970 OPEN_ARRAY_START(Compressed##type, Compressed##type); \
971 } \
972 Compressed##type const* array_name() const { \
973 OPEN_ARRAY_START(Compressed##type, Compressed##type); \
974 } \
975 VISIT_TO_PAYLOAD_END(Compressed##type)

◆ CONTEXT_SCOPE_VARIABLE_DESC_FLAG_LIST

#define CONTEXT_SCOPE_VARIABLE_DESC_FLAG_LIST (   V)
Value:
V(Final) \
V(Late) \
V(Nullable) \
V(Invisible) \
V(AwaiterLink)
V
#define V(name)
Definition raw_object.h:124

Definition at line 2418 of file raw_object.h.

◆ DECLARE

#define DECLARE (   return_type,
  type,
  name 
)    type name##_;

Definition at line 1433 of file raw_object.h.

◆ DECLARE_BIT

#define DECLARE_BIT (   Name)    kIs##Name,

Definition at line 2436 of file raw_object.h.

◆ DEFINE_ACCESSOR

#define DEFINE_ACCESSOR (   type,
  name 
)
Value:
type name##_at(intptr_t index) { \
return LoadCompressedPointer<type>(&VariableDescAddr(index)->name); \
} \
void set_##name##_at(intptr_t index, type value) { \
StoreCompressedPointer(&VariableDescAddr(index)->name, value); \
}

Definition at line 2468 of file raw_object.h.

2469 { \
2470 return LoadCompressedPointer<type>(&VariableDescAddr(index)->name); \
2471 } \
2472 void set_##name##_at(intptr_t index, type value) { \
2473 StoreCompressedPointer(&VariableDescAddr(index)->name, value); \
2474 }

◆ DEFINE_CONTAINS_COMPRESSED

#define DEFINE_CONTAINS_COMPRESSED (   type)
Value:
static constexpr bool kContainsCompressedPointers = \
is_compressed_ptr<type>::value;

Definition at line 48 of file raw_object.h.

◆ DEFINE_FORWARD_DECLARATION

#define DEFINE_FORWARD_DECLARATION (   clazz)    class Untagged##clazz;

Definition at line 42 of file raw_object.h.

◆ ENUM_DEF

#define ENUM_DEF (   name,
  init 
)    k##name = init,

Definition at line 2050 of file raw_object.h.

◆ FOR_EACH_RAW_FUNCTION_KIND

#define FOR_EACH_RAW_FUNCTION_KIND (   V)

Definition at line 1219 of file raw_object.h.

◆ FOR_EACH_RAW_PC_DESCRIPTOR

#define FOR_EACH_RAW_PC_DESCRIPTOR (   V)
Value:
/* Deoptimization continuation point. */ \
V(Deopt, 1) \
/* IC call. */ \
V(IcCall, kDeopt << 1) \
/* Call to a known target via stub. */ \
V(UnoptStaticCall, kIcCall << 1) \
/* Runtime call. */ \
V(RuntimeCall, kUnoptStaticCall << 1) \
/* OSR entry point in unopt. code. */ \
V(OsrEntry, kRuntimeCall << 1) \
/* Call rewind target address. */ \
V(Rewind, kOsrEntry << 1) \
/* Target-word-size relocation. */ \
V(BSSRelocation, kRewind << 1) \
V(Other, kBSSRelocation << 1) \
V(AnyKind, -1)

Definition at line 2031 of file raw_object.h.

◆ JIT_FUNCTION_COUNTERS

#define JIT_FUNCTION_COUNTERS (   F)
Value:
F(intptr_t, int32_t, usage_counter) \
F(intptr_t, uint16_t, optimized_instruction_count) \
F(intptr_t, uint16_t, optimized_call_site_count) \
F(int8_t, int8_t, deoptimization_counter) \
F(intptr_t, int8_t, state_bits) \
F(int, int8_t, inlining_depth)
F
#define F(x)

Definition at line 1422 of file raw_object.h.

◆ KIND_CASE [1/2]

#define KIND_CASE (   Name)
Value:
case Kind::k##Name: \
return #Name;

◆ KIND_CASE [2/2]

#define KIND_CASE (   Name)
Value:
if (strcmp(str, #Name) == 0) { \
*out = Kind::k##Name; \
return true; \
}

◆ KIND_DEFN

#define KIND_DEFN (   Name)    k##Name,

Definition at line 1257 of file raw_object.h.

◆ POINTER_FIELD

#define POINTER_FIELD (   type,
  name 
)
Value:
public: \
template <std::memory_order order = std::memory_order_relaxed> \
type name() const { \
return LoadPointer<type, order>(&name##_); \
} \
template <std::memory_order order = std::memory_order_relaxed> \
void set_##name(type value) { \
StorePointer<type, order>(&name##_, value); \
} \
\
protected: \
type name##_;

Definition at line 868 of file raw_object.h.

869 : \
870 template <std::memory_order order = std::memory_order_relaxed> \
871 type name() const { \
872 return LoadPointer<type, order>(&name##_); \
873 } \
874 template <std::memory_order order = std::memory_order_relaxed> \
875 void set_##name(type value) { \
876 StorePointer<type, order>(&name##_, value); \
877 } \
878 \
879 protected: \
880 type name##_;

◆ RAW_HEAP_OBJECT_IMPLEMENTATION

#define RAW_HEAP_OBJECT_IMPLEMENTATION (   object)
Value:
private: \
RAW_OBJECT_IMPLEMENTATION(object); \
friend class object##SerializationCluster; \
friend class object##DeserializationCluster; \
friend class object##MessageSerializationCluster; \
friend class object##MessageDeserializationCluster; \
friend class Serializer; \
friend class Deserializer; \
template <typename Base> \
friend class ObjectCopy; \
friend class Pass2Visitor;

Definition at line 142 of file raw_object.h.

143 : \
144 RAW_OBJECT_IMPLEMENTATION(object); \
145 friend class object##SerializationCluster; \
146 friend class object##DeserializationCluster; \
147 friend class object##MessageSerializationCluster; \
148 friend class object##MessageDeserializationCluster; \
149 friend class Serializer; \
150 friend class Deserializer; \
151 template <typename Base> \
152 friend class ObjectCopy; \
153 friend class Pass2Visitor;

◆ RAW_OBJECT_IMPLEMENTATION

#define RAW_OBJECT_IMPLEMENTATION (   object)
Value:
private: /* NOLINT */ \
VISITOR_SUPPORT(object) \
friend class object; \
friend class UntaggedObject; \
friend class OffsetsTable; \
DISALLOW_ALLOCATION(); \
DISALLOW_IMPLICIT_CONSTRUCTORS(Untagged##object)

Definition at line 133 of file raw_object.h.

134 : /* NOLINT */ \
135 VISITOR_SUPPORT(object) \
136 friend class object; \
137 friend class UntaggedObject; \
138 friend class OffsetsTable; \
139 DISALLOW_ALLOCATION(); \
140 DISALLOW_IMPLICIT_CONSTRUCTORS(Untagged##object)

◆ SMI_FIELD

#define SMI_FIELD (   type,
  name 
)
Value:
public: \
template <std::memory_order order = std::memory_order_relaxed> \
type name() const { \
type result = LoadSmi<order>(&name##_); \
ASSERT(!result.IsHeapObject()); \
return result; \
} \
template <std::memory_order order = std::memory_order_relaxed> \
void set_##name(type value) { \
ASSERT(!value.IsHeapObject()); \
StoreSmi<type, order>(&name##_, value); \
} \
\
protected: \
type name##_;

Definition at line 977 of file raw_object.h.

978 : \
979 template <std::memory_order order = std::memory_order_relaxed> \
980 type name() const { \
981 type result = LoadSmi<order>(&name##_); \
982 ASSERT(!result.IsHeapObject()); \
983 return result; \
984 } \
985 template <std::memory_order order = std::memory_order_relaxed> \
986 void set_##name(type value) { \
987 ASSERT(!value.IsHeapObject()); \
988 StoreSmi<type, order>(&name##_, value); \
989 } \
990 \
991 protected: \
992 type name##_;

◆ V

#define V (   name)    k##name##Element,

Definition at line 124 of file raw_object.h.

◆ VARIABLE_POINTER_FIELDS

#define VARIABLE_POINTER_FIELDS (   type,
  accessor_name,
  array_name 
)
Value:
public: \
template <std::memory_order order = std::memory_order_relaxed> \
type accessor_name(intptr_t index) const { \
return LoadPointer<type, order>(&array_name()[index]); \
} \
template <std::memory_order order = std::memory_order_relaxed> \
void set_##accessor_name(intptr_t index, type value) { \
StoreArrayPointer<type, order>(&array_name()[index], value); \
} \
template <std::memory_order order = std::memory_order_relaxed> \
void set_##accessor_name(intptr_t index, type value, Thread* thread) { \
StoreArrayPointer<type, order>(&array_name()[index], value, thread); \
} \
\
protected: \
type* array_name() { \
OPEN_ARRAY_START(type, type); \
} \
type const* array_name() const { \
OPEN_ARRAY_START(type, type); \
} \
VISIT_TO_PAYLOAD_END(type)

Definition at line 926 of file raw_object.h.

927 : \
928 template <std::memory_order order = std::memory_order_relaxed> \
929 type accessor_name(intptr_t index) const { \
930 return LoadPointer<type, order>(&array_name()[index]); \
931 } \
932 template <std::memory_order order = std::memory_order_relaxed> \
933 void set_##accessor_name(intptr_t index, type value) { \
934 StoreArrayPointer<type, order>(&array_name()[index], value); \
935 } \
936 template <std::memory_order order = std::memory_order_relaxed> \
937 void set_##accessor_name(intptr_t index, type value, Thread* thread) { \
938 StoreArrayPointer<type, order>(&array_name()[index], value, thread); \
939 } \
940 \
941 protected: \
942 type* array_name() { \
943 OPEN_ARRAY_START(type, type); \
944 } \
945 type const* array_name() const { \
946 OPEN_ARRAY_START(type, type); \
947 } \
948 VISIT_TO_PAYLOAD_END(type)

◆ VISIT_FROM

#define VISIT_FROM (   first)
Value:
DEFINE_CONTAINS_COMPRESSED(decltype(first##_)) \
static constexpr bool kContainsPointerFields = true; \
base_ptr_type<decltype(first##_)>::type* from() { \
return reinterpret_cast<base_ptr_type<decltype(first##_)>::type*>( \
&first##_); \
}
DEFINE_CONTAINS_COMPRESSED
#define DEFINE_CONTAINS_COMPRESSED(type)
Definition raw_object.h:48

Definition at line 60 of file raw_object.h.

63 { \
64 return reinterpret_cast<base_ptr_type<decltype(first##_)>::type*>( \
65 &first##_); \
66 }

◆ VISIT_FROM_PAYLOAD_START

#define VISIT_FROM_PAYLOAD_START (   elem_type)
Value:
static_assert(is_uncompressed_ptr<elem_type>::value || \
is_compressed_ptr<elem_type>::value, \
"Payload elements must be object pointers"); \
DEFINE_CONTAINS_COMPRESSED(elem_type) \
static constexpr bool kContainsPointerFields = true; \
base_ptr_type<elem_type>::type* from() { \
const uword payload_start = reinterpret_cast<uword>(this) + sizeof(*this); \
ASSERT(Utils::IsAligned(payload_start, sizeof(elem_type))); \
return reinterpret_cast<base_ptr_type<elem_type>::type*>(payload_start); \
}

Definition at line 68 of file raw_object.h.

74 { \
75 const uword payload_start = reinterpret_cast<uword>(this) + sizeof(*this); \
76 ASSERT(Utils::IsAligned(payload_start, sizeof(elem_type))); \
77 return reinterpret_cast<base_ptr_type<elem_type>::type*>(payload_start); \
78 }
dart::uword
uintptr_t uword
Definition globals.h:501

◆ VISIT_NOTHING

#define VISIT_NOTHING ( )    int NothingToVisit();

Definition at line 104 of file raw_object.h.

◆ VISIT_TO

#define VISIT_TO (   last)
Value:
CHECK_CONTAIN_COMPRESSED(decltype(last##_)); \
static_assert(kContainsPointerFields, \
"Must have a corresponding VISIT_FROM"); \
base_ptr_type<decltype(last##_)>::type* to(intptr_t length = 0) { \
return reinterpret_cast<base_ptr_type<decltype(last##_)>::type*>( \
&last##_); \
}
length
size_t length
Definition key_event_handler.cc:41
CHECK_CONTAIN_COMPRESSED
#define CHECK_CONTAIN_COMPRESSED(type)
Definition raw_object.h:52

Definition at line 80 of file raw_object.h.

84 { \
85 return reinterpret_cast<base_ptr_type<decltype(last##_)>::type*>( \
86 &last##_); \
87 }

◆ VISIT_TO_PAYLOAD_END

#define VISIT_TO_PAYLOAD_END (   elem_type)
Value:
static_assert(is_uncompressed_ptr<elem_type>::value || \
is_compressed_ptr<elem_type>::value, \
"Payload elements must be object pointers"); \
static_assert(kContainsPointerFields, \
"Must have a corresponding VISIT_FROM"); \
CHECK_CONTAIN_COMPRESSED(elem_type); \
base_ptr_type<elem_type>::type* to(intptr_t length) { \
const uword payload_start = reinterpret_cast<uword>(this) + sizeof(*this); \
ASSERT(Utils::IsAligned(payload_start, sizeof(elem_type))); \
const uword payload_last = \
payload_start + sizeof(elem_type) * (length - 1); \
return reinterpret_cast<base_ptr_type<elem_type>::type*>(payload_last); \
}

Definition at line 89 of file raw_object.h.

96 { \
97 const uword payload_start = reinterpret_cast<uword>(this) + sizeof(*this); \
98 ASSERT(Utils::IsAligned(payload_start, sizeof(elem_type))); \
99 const uword payload_last = \
100 payload_start + sizeof(elem_type) * (length - 1); \
101 return reinterpret_cast<base_ptr_type<elem_type>::type*>(payload_last); \
102 }

◆ VISITOR_SUPPORT

#define VISITOR_SUPPORT (   object)
Value:
static intptr_t Visit##object##Pointers(object##Ptr raw_obj, \
ObjectPointerVisitor* visitor);

Definition at line 129 of file raw_object.h.

◆ WSR_COMPRESSED_POINTER_FIELD

#define WSR_COMPRESSED_POINTER_FIELD (   Type,
  Name 
)     COMPRESSED_POINTER_FIELD(Type, Name)

Definition at line 1024 of file raw_object.h.

Generated on Fri Apr 26 2024 06:18:30 for Flutter Engine by doxygen 1.9.8