#include "platform/assert.h"
#include "vm/globals.h"

Go to the source code of this file.

Namespaces
namespace	dart

Macros
#define	CLASS_LIST_INTERNAL_ONLY(V)

#define	CLASS_LIST_INSTANCE_SINGLETONS(V)

#define	CLASS_LIST_NO_OBJECT_NOR_STRING_NOR_ARRAY_NOR_MAP(V) CLASS_LIST_INTERNAL_ONLY(V) CLASS_LIST_INSTANCE_SINGLETONS(V)

#define	CLASS_LIST_MAPS(V)

#define	CLASS_LIST_SETS(V)

#define	CLASS_LIST_FIXED_LENGTH_ARRAYS(V)

#define	CLASS_LIST_ARRAYS(V)

#define	CLASS_LIST_STRINGS(V)

#define	CLASS_LIST_TYPED_DATA(V)

#define	CLASS_LIST_FFI_NUMERIC_FIXED_SIZE(V)

#define	CLASS_LIST_FFI_TYPE_MARKER(V)

#define	CLASS_LIST_FFI(V)

#define	DART_CLASS_LIST_TYPED_DATA(V)

#define	CLASS_LIST_FOR_HANDLES(V)

#define	CLASS_LIST_NO_OBJECT(V)

#define	CLASS_LIST(V)

#define	DEFINE_OBJECT_KIND(clazz) k##clazz##Cid,

#define	DEFINE_OBJECT_KIND(clazz) kFfi##clazz##Cid,

#define	DEFINE_OBJECT_KIND(clazz)

#define	CASE_FFI_CID(name) case kFfi##name##Cid:

#define	CASE_FFI_CID(name) case kFfi##name##Cid:

Typedefs
typedef int32_t	dart::ClassIdTagType

Enumerations
enum	dart::ClassId : intptr_t { dart::kIllegalCid = 0 , dart::kNativePointer , dart::kFreeListElement , dart::kForwardingCorpse , dart::kByteDataViewCid , dart::kUnmodifiableByteDataViewCid , dart::kByteBufferCid , dart::kNullCid , dart::kDynamicCid , dart::kVoidCid , dart::kNeverCid , dart::kNumPredefinedCids }

Functions
bool	dart::IsInternalOnlyClassId (intptr_t index)

bool	dart::IsErrorClassId (intptr_t index)

bool	dart::IsNumberClassId (intptr_t index)

bool	dart::IsIntegerClassId (intptr_t index)

bool	dart::IsStringClassId (intptr_t index)

bool	dart::IsOneByteStringClassId (intptr_t index)

bool	dart::IsBuiltinListClassId (intptr_t index)

bool	dart::IsTypeClassId (intptr_t index)

bool	dart::IsTypedDataBaseClassId (intptr_t index)

bool	dart::IsTypedDataClassId (intptr_t index)

bool	dart::IsTypedDataViewClassId (intptr_t index)

bool	dart::IsExternalTypedDataClassId (intptr_t index)

bool	dart::IsFfiPointerClassId (intptr_t index)

bool	dart::IsFfiTypeClassId (intptr_t index)

bool	dart::IsFfiDynamicLibraryClassId (intptr_t index)

bool	dart::IsInternalVMdefinedClassId (intptr_t index)

bool	dart::IsImplicitFieldClassId (intptr_t index)

	dart::COMPILE_ASSERT (kFirstInternalOnlyCid==kObjectCid+1)

	dart::COMPILE_ASSERT (kInstanceCid==kLastInternalOnlyCid+1)

	dart::COMPILE_ASSERT (kFirstErrorCid==kErrorCid &&kApiErrorCid==kFirstErrorCid+1 &&kLanguageErrorCid==kFirstErrorCid+2 &&kUnhandledExceptionCid==kFirstErrorCid+3 &&kUnwindErrorCid==kFirstErrorCid+4 &&kLastErrorCid==kUnwindErrorCid &&kLastInternalOnlyCid==kLastErrorCid)

bool	dart::IsConcreteTypeClassId (intptr_t index)

	dart::COMPILE_ASSERT (kOneByteStringCid==kStringCid+1 &&kTwoByteStringCid==kStringCid+2)

bool	dart::IsArrayClassId (intptr_t index)

	dart::COMPILE_ASSERT (kTypedDataCidRemainderInternal==0)

	dart::COMPILE_ASSERT (kTypedDataInt8ArrayCid+kTypedDataCidRemainderView==kTypedDataInt8ArrayViewCid)

	dart::COMPILE_ASSERT (kFirstTypedDataCid==kTypedDataInt8ArrayCid)

	dart::COMPILE_ASSERT (kFirstTypedDataCid+1 *kNumTypedDataCidRemainders==kTypedDataUint8ArrayCid)

	dart::COMPILE_ASSERT (kFirstTypedDataCid+2 *kNumTypedDataCidRemainders==kTypedDataUint8ClampedArrayCid)

	dart::COMPILE_ASSERT (kFirstTypedDataCid+3 *kNumTypedDataCidRemainders==kTypedDataInt16ArrayCid)

	dart::COMPILE_ASSERT (kFirstTypedDataCid+4 *kNumTypedDataCidRemainders==kTypedDataUint16ArrayCid)

	dart::COMPILE_ASSERT (kFirstTypedDataCid+5 *kNumTypedDataCidRemainders==kTypedDataInt32ArrayCid)

	dart::COMPILE_ASSERT (kFirstTypedDataCid+6 *kNumTypedDataCidRemainders==kTypedDataUint32ArrayCid)

	dart::COMPILE_ASSERT (kFirstTypedDataCid+7 *kNumTypedDataCidRemainders==kTypedDataInt64ArrayCid)

	dart::COMPILE_ASSERT (kFirstTypedDataCid+8 *kNumTypedDataCidRemainders==kTypedDataUint64ArrayCid)

	dart::COMPILE_ASSERT (kFirstTypedDataCid+9 *kNumTypedDataCidRemainders==kTypedDataFloat32ArrayCid)

	dart::COMPILE_ASSERT (kFirstTypedDataCid+10 *kNumTypedDataCidRemainders==kTypedDataFloat64ArrayCid)

	dart::COMPILE_ASSERT (kFirstTypedDataCid+11 *kNumTypedDataCidRemainders==kTypedDataFloat32x4ArrayCid)

	dart::COMPILE_ASSERT (kFirstTypedDataCid+12 *kNumTypedDataCidRemainders==kTypedDataInt32x4ArrayCid)

	dart::COMPILE_ASSERT (kFirstTypedDataCid+13 *kNumTypedDataCidRemainders==kTypedDataFloat64x2ArrayCid)

	dart::COMPILE_ASSERT (kFirstTypedDataCid+13 *kNumTypedDataCidRemainders+kTypedDataCidRemainderUnmodifiable==kLastTypedDataCid)

	dart::COMPILE_ASSERT (kFfiStructCid+1==kFirstTypedDataCid)

	dart::COMPILE_ASSERT (kLastTypedDataCid+1==kByteDataViewCid)

bool	dart::IsUnmodifiableTypedDataViewClassId (intptr_t index)

bool	dart::IsClampedTypedDataBaseClassId (intptr_t index)

bool	dart::IsExternalPayloadClassId (classid_t cid)

bool	dart::IsDeeplyImmutableCid (intptr_t predefined_cid)

bool	dart::IsShallowlyImmutableCid (intptr_t predefined_cid)

bool	dart::ShouldHaveImmutabilityBitSetCid (intptr_t predefined_cid)

bool	dart::IsFfiPredefinedClassId (classid_t class_id)

	dart::COMPILE_ASSERT (kByteBufferCid+1==kNullCid)

Variables
static constexpr intptr_t	dart::kClassIdTagMax = (1 << 20) - 1

const int	dart::kTypedDataCidRemainderInternal = 0

const int	dart::kTypedDataCidRemainderView = 1

const int	dart::kTypedDataCidRemainderExternal = 2

const int	dart::kTypedDataCidRemainderUnmodifiable = 3

const int	dart::kNumTypedDataCidRemainders = kTypedDataCidRemainderUnmodifiable + 1

constexpr intptr_t	dart::kFirstInternalOnlyCid = kClassCid

constexpr intptr_t	dart::kLastInternalOnlyCid = kUnwindErrorCid

static const ClassId	dart::kFirstErrorCid = kErrorCid

static const ClassId	dart::kLastErrorCid = kUnwindErrorCid

static const ClassId	dart::kFirstTypedDataCid = kTypedDataInt8ArrayCid

static const ClassId	dart::kLastTypedDataCid

Macro Definition Documentation

◆ CASE_FFI_CID [1/2]

#define CASE_FFI_CID ( name ) case kFfi##name##Cid:

◆ CASE_FFI_CID [2/2]

#define CASE_FFI_CID ( name ) case kFfi##name##Cid:

◆ CLASS_LIST

#define CLASS_LIST ( V )

Value:

V(Object) \

CLASS_LIST_NO_OBJECT(V)

V

T __attribute__((ext_vector_type(N))) V

Definition lowp_experiments.cpp:22

V

#define V(name)

Definition raw_object.h:124

Definition at line 208 of file class_id.h.

             : intptr_t {
  // Illegal class id.
  kIllegalCid = 0,
 
  // Pseudo class id for native pointers, the heap should never see an
  // object with this class id.
  kNativePointer,
 
  // The following entries describes classes for pseudo-objects in the heap
  // that should never be reachable from live objects. Free list elements
  // maintain the free list for old space, and forwarding corpses are used to
  // implement one-way become.
  kFreeListElement,
  kForwardingCorpse,
 
// List of Ids for predefined classes.
#define DEFINE_OBJECT_KIND(clazz) k##clazz##Cid,
  CLASS_LIST(DEFINE_OBJECT_KIND)
#undef DEFINE_OBJECT_KIND
 
// clang-format off
#define DEFINE_OBJECT_KIND(clazz) kFfi##clazz##Cid,
  CLASS_LIST_FFI(DEFINE_OBJECT_KIND)
#undef DEFINE_OBJECT_KIND
 
#define DEFINE_OBJECT_KIND(clazz)                                              \
  kTypedData##clazz##Cid,                                                      \
  kTypedData##clazz##ViewCid,                                                  \
  kExternalTypedData##clazz##Cid,                                              \
  kUnmodifiableTypedData##clazz##ViewCid,
  CLASS_LIST_TYPED_DATA(DEFINE_OBJECT_KIND)
#undef DEFINE_OBJECT_KIND
  kByteDataViewCid,
  kUnmodifiableByteDataViewCid,
 
  kByteBufferCid,
  // clang-format on
 
  // The following entries do not describe a predefined class, but instead
  // are class indexes for pre-allocated instances (Null, dynamic, void, Never).
  kNullCid,
  kDynamicCid,
  kVoidCid,
  kNeverCid,
 
  kNumPredefinedCids,
};
 
// Keep these in sync with the cid numbering above.
const int kTypedDataCidRemainderInternal = 0;
const int kTypedDataCidRemainderView = 1;
const int kTypedDataCidRemainderExternal = 2;
const int kTypedDataCidRemainderUnmodifiable = 3;
const int kNumTypedDataCidRemainders = kTypedDataCidRemainderUnmodifiable + 1;
 
// Class Id predicates.
 
bool IsInternalOnlyClassId(intptr_t index);
bool IsErrorClassId(intptr_t index);
bool IsNumberClassId(intptr_t index);
bool IsIntegerClassId(intptr_t index);
bool IsStringClassId(intptr_t index);
bool IsOneByteStringClassId(intptr_t index);
bool IsBuiltinListClassId(intptr_t index);
bool IsTypeClassId(intptr_t index);
bool IsTypedDataBaseClassId(intptr_t index);
bool IsTypedDataClassId(intptr_t index);
bool IsTypedDataViewClassId(intptr_t index);
bool IsExternalTypedDataClassId(intptr_t index);
bool IsFfiPointerClassId(intptr_t index);
bool IsFfiTypeClassId(intptr_t index);
bool IsFfiDynamicLibraryClassId(intptr_t index);
bool IsInternalVMdefinedClassId(intptr_t index);
bool IsImplicitFieldClassId(intptr_t index);
 
// Should be used for looping over non-Object internal-only cids.
constexpr intptr_t kFirstInternalOnlyCid = kClassCid;
constexpr intptr_t kLastInternalOnlyCid = kUnwindErrorCid;
// Use the currently surrounding cids to check that no new classes have been
// added to the beginning or end of CLASS_LIST_INTERNAL_ONLY without adjusting
// the above definitions.
COMPILE_ASSERT(kFirstInternalOnlyCid == kObjectCid + 1);
COMPILE_ASSERT(kInstanceCid == kLastInternalOnlyCid + 1);
 
// Returns true for any class id that either does not correspond to a real
// class, like kIllegalCid or kForwardingCorpse, or that is internal to the VM
// and should not be exposed directly to user code.
inline bool IsInternalOnlyClassId(intptr_t index) {
  // Fix the condition below if these become non-contiguous.
  COMPILE_ASSERT(kIllegalCid + 1 == kNativePointer &&
                 kIllegalCid + 2 == kFreeListElement &&
                 kIllegalCid + 3 == kForwardingCorpse &&
                 kIllegalCid + 4 == kObjectCid &&
                 kIllegalCid + 5 == kFirstInternalOnlyCid);
  return index <= kLastInternalOnlyCid;
}
 
// Make sure this function is updated when new Error types are added.
static const ClassId kFirstErrorCid = kErrorCid;
static const ClassId kLastErrorCid = kUnwindErrorCid;
COMPILE_ASSERT(kFirstErrorCid == kErrorCid &&
               kApiErrorCid == kFirstErrorCid + 1 &&
               kLanguageErrorCid == kFirstErrorCid + 2 &&
               kUnhandledExceptionCid == kFirstErrorCid + 3 &&
               kUnwindErrorCid == kFirstErrorCid + 4 &&
               kLastErrorCid == kUnwindErrorCid &&
               // Change if needed for detecting a new error added at the end.
               kLastInternalOnlyCid == kLastErrorCid);
 
inline bool IsErrorClassId(intptr_t index) {
  return (index >= kFirstErrorCid && index <= kLastErrorCid);
}
 
inline bool IsConcreteTypeClassId(intptr_t index) {
  // Make sure to update when new AbstractType subclasses are added.
  COMPILE_ASSERT(kFunctionTypeCid == kTypeCid + 1 &&
                 kRecordTypeCid == kTypeCid + 2 &&
                 kTypeParameterCid == kTypeCid + 3);
  return (index >= kTypeCid && index <= kTypeParameterCid);
}
 
inline bool IsNumberClassId(intptr_t index) {
  // Make sure this function is updated when new Number types are added.
  COMPILE_ASSERT(kIntegerCid == kNumberCid + 1 && kSmiCid == kNumberCid + 2 &&
                 kMintCid == kNumberCid + 3 && kDoubleCid == kNumberCid + 4);
  return (index >= kNumberCid && index <= kDoubleCid);
}
 
inline bool IsIntegerClassId(intptr_t index) {
  // Make sure this function is updated when new Integer types are added.
  COMPILE_ASSERT(kSmiCid == kIntegerCid + 1 && kMintCid == kIntegerCid + 2);
  return (index >= kIntegerCid && index <= kMintCid);
}
 
// Make sure this check is updated when new StringCid types are added.
COMPILE_ASSERT(kOneByteStringCid == kStringCid + 1 &&
               kTwoByteStringCid == kStringCid + 2);
 
inline bool IsStringClassId(intptr_t index) {
  return (index >= kStringCid && index <= kTwoByteStringCid);
}
 
inline bool IsOneByteStringClassId(intptr_t index) {
  return (index == kOneByteStringCid);
}
 
inline bool IsArrayClassId(intptr_t index) {
  COMPILE_ASSERT(kImmutableArrayCid == kArrayCid + 1);
  COMPILE_ASSERT(kGrowableObjectArrayCid == kArrayCid + 2);
  return (index >= kArrayCid && index <= kGrowableObjectArrayCid);
}
 
inline bool IsBuiltinListClassId(intptr_t index) {
  // Make sure this function is updated when new builtin List types are added.
  return (IsArrayClassId(index) || IsTypedDataBaseClassId(index) ||
          (index == kByteBufferCid));
}
 
inline bool IsTypeClassId(intptr_t index) {
  // Only Type, FunctionType and RecordType can be encountered as instance
  // types at runtime.
  return index == kTypeCid || index == kFunctionTypeCid ||
         index == kRecordTypeCid;
}
 
static const ClassId kFirstTypedDataCid = kTypedDataInt8ArrayCid;
static const ClassId kLastTypedDataCid =
    kUnmodifiableTypedDataFloat64x2ArrayViewCid;
 
// Make sure the following checks are updated when adding new TypedData types.
 
// The following asserts assume this.
COMPILE_ASSERT(kTypedDataCidRemainderInternal == 0);
// Ensure that each typed data type comes in internal/view/external variants
// next to each other.
COMPILE_ASSERT(kTypedDataInt8ArrayCid + kTypedDataCidRemainderView ==
               kTypedDataInt8ArrayViewCid);
COMPILE_ASSERT(kTypedDataInt8ArrayCid + kTypedDataCidRemainderExternal ==
               kExternalTypedDataInt8ArrayCid);
COMPILE_ASSERT(kTypedDataInt8ArrayCid + kTypedDataCidRemainderUnmodifiable ==
               kUnmodifiableTypedDataInt8ArrayViewCid);
// Ensure the order of the typed data members in 3-step.
COMPILE_ASSERT(kFirstTypedDataCid == kTypedDataInt8ArrayCid);
COMPILE_ASSERT(kFirstTypedDataCid + 1 * kNumTypedDataCidRemainders ==
               kTypedDataUint8ArrayCid);
COMPILE_ASSERT(kFirstTypedDataCid + 2 * kNumTypedDataCidRemainders ==
               kTypedDataUint8ClampedArrayCid);
COMPILE_ASSERT(kFirstTypedDataCid + 3 * kNumTypedDataCidRemainders ==
               kTypedDataInt16ArrayCid);
COMPILE_ASSERT(kFirstTypedDataCid + 4 * kNumTypedDataCidRemainders ==
               kTypedDataUint16ArrayCid);
COMPILE_ASSERT(kFirstTypedDataCid + 5 * kNumTypedDataCidRemainders ==
               kTypedDataInt32ArrayCid);
COMPILE_ASSERT(kFirstTypedDataCid + 6 * kNumTypedDataCidRemainders ==
               kTypedDataUint32ArrayCid);
COMPILE_ASSERT(kFirstTypedDataCid + 7 * kNumTypedDataCidRemainders ==
               kTypedDataInt64ArrayCid);
COMPILE_ASSERT(kFirstTypedDataCid + 8 * kNumTypedDataCidRemainders ==
               kTypedDataUint64ArrayCid);
COMPILE_ASSERT(kFirstTypedDataCid + 9 * kNumTypedDataCidRemainders ==
               kTypedDataFloat32ArrayCid);
COMPILE_ASSERT(kFirstTypedDataCid + 10 * kNumTypedDataCidRemainders ==
               kTypedDataFloat64ArrayCid);
COMPILE_ASSERT(kFirstTypedDataCid + 11 * kNumTypedDataCidRemainders ==
               kTypedDataFloat32x4ArrayCid);
COMPILE_ASSERT(kFirstTypedDataCid + 12 * kNumTypedDataCidRemainders ==
               kTypedDataInt32x4ArrayCid);
COMPILE_ASSERT(kFirstTypedDataCid + 13 * kNumTypedDataCidRemainders ==
               kTypedDataFloat64x2ArrayCid);
COMPILE_ASSERT(kFirstTypedDataCid + 13 * kNumTypedDataCidRemainders +
                   kTypedDataCidRemainderUnmodifiable ==
               kLastTypedDataCid);
// Checks for possible new typed data entries added before or after the current
// entries.
COMPILE_ASSERT(kFfiStructCid + 1 == kFirstTypedDataCid);
COMPILE_ASSERT(kLastTypedDataCid + 1 == kByteDataViewCid);
 
inline bool IsTypedDataBaseClassId(intptr_t index) {
  return index >= kFirstTypedDataCid && index <= kLastTypedDataCid;
}
 
inline bool IsTypedDataClassId(intptr_t index) {
  return IsTypedDataBaseClassId(index) &&
         ((index - kFirstTypedDataCid) % kNumTypedDataCidRemainders) ==
             kTypedDataCidRemainderInternal;
}
 
inline bool IsTypedDataViewClassId(intptr_t index) {
  const bool is_byte_data_view = index == kByteDataViewCid;
  return is_byte_data_view ||
         (IsTypedDataBaseClassId(index) &&
          ((index - kFirstTypedDataCid) % kNumTypedDataCidRemainders) ==
              kTypedDataCidRemainderView);
}
 
inline bool IsExternalTypedDataClassId(intptr_t index) {
  return IsTypedDataBaseClassId(index) &&
         ((index - kFirstTypedDataCid) % kNumTypedDataCidRemainders) ==
             kTypedDataCidRemainderExternal;
}
 
inline bool IsUnmodifiableTypedDataViewClassId(intptr_t index) {
  const bool is_byte_data_view = index == kUnmodifiableByteDataViewCid;
  return is_byte_data_view ||
         (IsTypedDataBaseClassId(index) &&
          ((index - kFirstTypedDataCid) % kNumTypedDataCidRemainders) ==
              kTypedDataCidRemainderUnmodifiable);
}
 
inline bool IsClampedTypedDataBaseClassId(intptr_t index) {
  if (!IsTypedDataBaseClassId(index)) return false;
  const intptr_t internal_cid =
      index - ((index - kFirstTypedDataCid) % kNumTypedDataCidRemainders) +
      kTypedDataCidRemainderInternal;
  // Currently, the only clamped typed data arrays are Uint8.
  return internal_cid == kTypedDataUint8ClampedArrayCid;
}
 
// Whether the given cid is an external array cid, that is, an array where
// the payload is not in GC-managed memory.
inline bool IsExternalPayloadClassId(classid_t cid) {
  return cid == kPointerCid || IsExternalTypedDataClassId(cid);
}
 
// For predefined cids only. Refer to Class::is_deeply_immutable for
// instances of non-predefined classes.
//
// Having the `@pragma('vm:deeply-immutable')`, which means statically proven
// deeply immutable, implies true for this function. The other way around is not
// guaranteed, predefined classes can be marked deeply immutable in the VM while
// not having their subtypes or super type being deeply immutable.
//
// Keep consistent with runtime/docs/deeply_immutable.md.
inline bool IsDeeplyImmutableCid(intptr_t predefined_cid) {
  ASSERT(predefined_cid < kNumPredefinedCids);
  return IsStringClassId(predefined_cid) || predefined_cid == kNumberCid ||
         predefined_cid == kIntegerCid || predefined_cid == kSmiCid ||
         predefined_cid == kMintCid || predefined_cid == kNeverCid ||
         predefined_cid == kSentinelCid || predefined_cid == kStackTraceCid ||
         predefined_cid == kDoubleCid || predefined_cid == kFloat32x4Cid ||
         predefined_cid == kFloat64x2Cid || predefined_cid == kInt32x4Cid ||
         predefined_cid == kSendPortCid || predefined_cid == kCapabilityCid ||
         predefined_cid == kRegExpCid || predefined_cid == kBoolCid ||
         predefined_cid == kNullCid || predefined_cid == kPointerCid ||
         predefined_cid == kTypeCid || predefined_cid == kRecordTypeCid ||
         predefined_cid == kFunctionTypeCid;
}
 
inline bool IsShallowlyImmutableCid(intptr_t predefined_cid) {
  ASSERT(predefined_cid < kNumPredefinedCids);
  // TODO(https://dartbug.com/55136): Mark kClosureCid as shallowly imutable.
  return IsUnmodifiableTypedDataViewClassId(predefined_cid);
}
 
// See documentation on ImmutableBit in raw_object.h
inline bool ShouldHaveImmutabilityBitSetCid(intptr_t predefined_cid) {
  ASSERT(predefined_cid < kNumPredefinedCids);
  return IsDeeplyImmutableCid(predefined_cid) ||
         IsShallowlyImmutableCid(predefined_cid);
}
 
inline bool IsFfiTypeClassId(intptr_t index) {
  switch (index) {
    case kPointerCid:
    case kFfiNativeFunctionCid:
#define CASE_FFI_CID(name) case kFfi##name##Cid:
      CLASS_LIST_FFI_TYPE_MARKER(CASE_FFI_CID)
#undef CASE_FFI_CID
      return true;
    default:
      return false;
  }
  UNREACHABLE();
}
 
inline bool IsFfiPredefinedClassId(classid_t class_id) {
  switch (class_id) {
    case kPointerCid:
    case kDynamicLibraryCid:
#define CASE_FFI_CID(name) case kFfi##name##Cid:
      CLASS_LIST_FFI(CASE_FFI_CID)
#undef CASE_FFI_CID
      return true;
    default:
      return false;
  }
  UNREACHABLE();
}
 
inline bool IsFfiPointerClassId(intptr_t index) {
  return index == kPointerCid;
}
 
inline bool IsFfiDynamicLibraryClassId(intptr_t index) {
  return index == kDynamicLibraryCid;
}
 
inline bool IsInternalVMdefinedClassId(intptr_t index) {
  return ((index < kNumPredefinedCids) && !IsImplicitFieldClassId(index));
}
 
// This is a set of classes that are not Dart classes whose representation
// is defined by the VM but are used in the VM code by computing the
// implicit field offsets of the various fields in the dart object.
inline bool IsImplicitFieldClassId(intptr_t index) {
  return index == kByteBufferCid;
}
 
COMPILE_ASSERT(kByteBufferCid + 1 == kNullCid);
 
}  // namespace dart
 
#endif  // RUNTIME_VM_CLASS_ID_H_

◆ CLASS_LIST_ARRAYS

#define CLASS_LIST_ARRAYS ( V )

Value:

CLASS_LIST_FIXED_LENGTH_ARRAYS(V) \

V(GrowableObjectArray)

CLASS_LIST_FIXED_LENGTH_ARRAYS

#define CLASS_LIST_FIXED_LENGTH_ARRAYS(V)

Definition class_id.h:124

Definition at line 128 of file class_id.h.

◆ CLASS_LIST_FFI

#define CLASS_LIST_FFI ( V )

Value:

  V(NativeFunction)                                                            \
  CLASS_LIST_FFI_TYPE_MARKER(V)                                                \
  V(NativeType)                                                                \
  V(Struct)

Definition at line 171 of file class_id.h.

◆ CLASS_LIST_FFI_NUMERIC_FIXED_SIZE

#define CLASS_LIST_FFI_NUMERIC_FIXED_SIZE ( V )

Value:

  V(Int8)                                                                      \
  V(Int16)                                                                     \
  V(Int32)                                                                     \
  V(Int64)                                                                     \
  V(Uint8)                                                                     \
  V(Uint16)                                                                    \
  V(Uint32)                                                                    \
  V(Uint64)                                                                    \
  V(Float)                                                                     \
  V(Double)

Definition at line 153 of file class_id.h.

◆ CLASS_LIST_FFI_TYPE_MARKER

#define CLASS_LIST_FFI_TYPE_MARKER ( V )

Value:

  CLASS_LIST_FFI_NUMERIC_FIXED_SIZE(V)                                         \
  V(Void)                                                                      \
  V(Handle)                                                                    \
  V(Bool)

Definition at line 165 of file class_id.h.

◆ CLASS_LIST_FIXED_LENGTH_ARRAYS

#define CLASS_LIST_FIXED_LENGTH_ARRAYS ( V )

Value:

V(Array) \

V(ImmutableArray)

Definition at line 124 of file class_id.h.

◆ CLASS_LIST_FOR_HANDLES

#define CLASS_LIST_FOR_HANDLES ( V )

Value:

  CLASS_LIST_NO_OBJECT_NOR_STRING_NOR_ARRAY_NOR_MAP(V)                         \
  V(Map)                                                                       \
  V(Set)                                                                       \
  V(Array)                                                                     \
  V(GrowableObjectArray)                                                       \
  V(String)

Definition at line 193 of file class_id.h.

◆ CLASS_LIST_INSTANCE_SINGLETONS

#define CLASS_LIST_INSTANCE_SINGLETONS ( V )

Definition at line 70 of file class_id.h.

◆ CLASS_LIST_INTERNAL_ONLY

#define CLASS_LIST_INTERNAL_ONLY ( V )

Definition at line 26 of file class_id.h.

◆ CLASS_LIST_MAPS

#define CLASS_LIST_MAPS ( V )

Value:

V(Map) \

V(ConstMap)

Definition at line 116 of file class_id.h.

◆ CLASS_LIST_NO_OBJECT

#define CLASS_LIST_NO_OBJECT ( V )

Value:

  CLASS_LIST_NO_OBJECT_NOR_STRING_NOR_ARRAY_NOR_MAP(V)                         \
  CLASS_LIST_MAPS(V)                                                           \
  CLASS_LIST_SETS(V)                                                           \
  CLASS_LIST_ARRAYS(V)                                                         \
  CLASS_LIST_STRINGS(V)

Definition at line 201 of file class_id.h.

◆ CLASS_LIST_NO_OBJECT_NOR_STRING_NOR_ARRAY_NOR_MAP

#define CLASS_LIST_NO_OBJECT_NOR_STRING_NOR_ARRAY_NOR_MAP ( V ) CLASS_LIST_INTERNAL_ONLY(V) CLASS_LIST_INSTANCE_SINGLETONS(V)

Definition at line 113 of file class_id.h.

◆ CLASS_LIST_SETS

#define CLASS_LIST_SETS ( V )

Value:

V(Set) \

V(ConstSet)

Definition at line 120 of file class_id.h.

◆ CLASS_LIST_STRINGS

#define CLASS_LIST_STRINGS ( V )

Value:

  V(String)                                                                    \
  V(OneByteString)                                                             \
  V(TwoByteString)

Definition at line 132 of file class_id.h.

◆ CLASS_LIST_TYPED_DATA

#define CLASS_LIST_TYPED_DATA ( V )

Value:

  V(Int8Array)                                                                 \
  V(Uint8Array)                                                                \
  V(Uint8ClampedArray)                                                         \
  V(Int16Array)                                                                \
  V(Uint16Array)                                                               \
  V(Int32Array)                                                                \
  V(Uint32Array)                                                               \
  V(Int64Array)                                                                \
  V(Uint64Array)                                                               \
  V(Float32Array)                                                              \
  V(Float64Array)                                                              \
  V(Float32x4Array)                                                            \
  V(Int32x4Array)                                                              \
  V(Float64x2Array)

Definition at line 137 of file class_id.h.

◆ DART_CLASS_LIST_TYPED_DATA

#define DART_CLASS_LIST_TYPED_DATA ( V )

Value:

  V(Int8)                                                                      \
  V(Uint8)                                                                     \
  V(Uint8Clamped)                                                              \
  V(Int16)                                                                     \
  V(Uint16)                                                                    \
  V(Int32)                                                                     \
  V(Uint32)                                                                    \
  V(Int64)                                                                     \
  V(Uint64)                                                                    \
  V(Float32)                                                                   \
  V(Float64)                                                                   \
  V(Float32x4)                                                                 \
  V(Int32x4)                                                                   \
  V(Float64x2)

Definition at line 177 of file class_id.h.

◆ DEFINE_OBJECT_KIND [1/3]

#define DEFINE_OBJECT_KIND ( clazz ) k##clazz##Cid,

Definition at line 228 of file class_id.h.

◆ DEFINE_OBJECT_KIND [2/3]

#define DEFINE_OBJECT_KIND ( clazz ) kFfi##clazz##Cid,

Definition at line 228 of file class_id.h.

◆ DEFINE_OBJECT_KIND [3/3]

#define DEFINE_OBJECT_KIND ( clazz )

Value:

  kTypedData##clazz##Cid,                                                      \
  kTypedData##clazz##ViewCid,                                                  \
  kExternalTypedData##clazz##Cid,                                              \
  kUnmodifiableTypedData##clazz##ViewCid,

Definition at line 228 of file class_id.h.

Namespaces

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

◆ CASE_FFI_CID [1/2]

◆ CASE_FFI_CID [2/2]

◆ CLASS_LIST

◆ CLASS_LIST_ARRAYS

◆ CLASS_LIST_FFI

◆ CLASS_LIST_FFI_NUMERIC_FIXED_SIZE

◆ CLASS_LIST_FFI_TYPE_MARKER

◆ CLASS_LIST_FIXED_LENGTH_ARRAYS

◆ CLASS_LIST_FOR_HANDLES

◆ CLASS_LIST_INSTANCE_SINGLETONS

◆ CLASS_LIST_INTERNAL_ONLY

◆ CLASS_LIST_MAPS

◆ CLASS_LIST_NO_OBJECT

◆ CLASS_LIST_NO_OBJECT_NOR_STRING_NOR_ARRAY_NOR_MAP

◆ CLASS_LIST_SETS

◆ CLASS_LIST_STRINGS

◆ CLASS_LIST_TYPED_DATA

◆ DART_CLASS_LIST_TYPED_DATA

◆ DEFINE_OBJECT_KIND [1/3]

◆ DEFINE_OBJECT_KIND [2/3]

◆ DEFINE_OBJECT_KIND [3/3]