dart::UntaggedObject Class Reference

#include <raw_object.h>

Inheritance diagram for dart::UntaggedObject:

Classes
class	AlwaysSetBit
class	CanonicalBit
class	CardRememberedBit
class	ClassIdTag
class	ImmutableBit
class	NewOrEvacuationCandidateBit
class	NotMarkedBit
class	OldAndNotRememberedBit
class	ReservedBit
class	SizeTag

Public Types
enum	TagBits {   kCardRememberedBit = 0 , kCanonicalBit = 1 , kNotMarkedBit = 2 , kNewOrEvacuationCandidateBit = 3 ,   kAlwaysSetBit = 4 , kOldAndNotRememberedBit = 5 , kImmutableBit = 6 , kReservedBit = 7 ,   kSizeTagPos = kReservedBit + 1 , kSizeTagSize = 4 , kClassIdTagPos = kSizeTagPos + kSizeTagSize , kClassIdTagSize = 20 ,   kHashTagPos = kClassIdTagPos + kClassIdTagSize , kHashTagSize = 32 }

Public Member Functions
	COMPILE_ASSERT (kNotMarkedBit+kBarrierOverlapShift==kAlwaysSetBit)
	COMPILE_ASSERT (kNewOrEvacuationCandidateBit+kBarrierOverlapShift==kOldAndNotRememberedBit)
	COMPILE_ASSERT (kCardRememberedBit==0)
	COMPILE_ASSERT (kBitsPerByte *sizeof(ClassIdTagType) >=kClassIdTagSize)
	COMPILE_ASSERT (kClassIdTagMax==(1<< kClassIdTagSize) - 1)
bool	IsNewObject () const
bool	IsOldObject () const
uword	tags () const
uword	tags_ignore_race () const
bool	IsMarked () const
void	SetMarkBit ()
void	SetMarkBitUnsynchronized ()
void	SetMarkBitRelease ()
void	ClearMarkBit ()
void	ClearMarkBitUnsynchronized ()
DART_WARN_UNUSED_RESULT bool	TryAcquireMarkBit ()
bool	IsEvacuationCandidate ()
void	SetIsEvacuationCandidate ()
void	SetIsEvacuationCandidateUnsynchronized ()
void	ClearIsEvacuationCandidateUnsynchronized ()
bool	IsCanonical () const
void	SetCanonical ()
void	ClearCanonical ()
bool	IsImmutable () const
void	SetImmutable ()
void	ClearImmutable ()
bool	InVMIsolateHeap () const
bool	IsRemembered () const
bool	TryAcquireRememberedBit ()
void	ClearRememberedBit ()
void	ClearRememberedBitUnsynchronized ()
DART_FORCE_INLINE void	EnsureInRememberedSet (Thread *thread)
bool	IsCardRemembered () const
void	SetCardRememberedBitUnsynchronized ()
intptr_t	GetClassId () const
intptr_t	HeapSize () const
intptr_t	HeapSize (uword tags) const
bool	Contains (uword addr) const
void	Validate (IsolateGroup *isolate_group) const
intptr_t	VisitPointers (ObjectPointerVisitor *visitor)
template<class V >
DART_FORCE_INLINE intptr_t	VisitPointersNonvirtual (V *visitor)
void	VisitPointersPrecise (ObjectPointerVisitor *visitor)

Static Public Member Functions
static bool	IsMarked (uword tags)
static bool	IsEvacuationCandidate (uword tags)
static ObjectPtr	FromAddr (uword addr)
static uword	ToAddr (const UntaggedObject *raw_obj)
static uword	ToAddr (const ObjectPtr raw_obj)
static bool	IsCanonical (intptr_t value)

Static Public Attributes
static constexpr intptr_t	kGenerationalBarrierMask
static constexpr intptr_t	kIncrementalBarrierMask = 1 << kNotMarkedBit
static constexpr intptr_t	kBarrierOverlapShift = 2

Protected Member Functions
template<typename type , std::memory_order order = std::memory_order_relaxed>
type	LoadPointer (type const *addr) const
template<typename type , typename compressed_type , std::memory_order order = std::memory_order_relaxed>
type	LoadCompressedPointer (compressed_type const *addr) const
uword	heap_base () const
template<typename type , std::memory_order order = std::memory_order_relaxed>
void	StorePointer (type const *addr, type value)
template<typename type , typename compressed_type , std::memory_order order = std::memory_order_relaxed>
void	StoreCompressedPointer (compressed_type const *addr, type value)
template<typename type >
void	StorePointer (type const *addr, type value, Thread *thread)
template<typename type , typename compressed_type >
void	StoreCompressedPointer (compressed_type const *addr, type value, Thread *thread)
template<typename type >
void	StorePointerUnaligned (type const *addr, type value, Thread *thread)
template<typename type , std::memory_order order = std::memory_order_relaxed, typename value_type = type>
void	StoreArrayPointer (type const *addr, value_type value)
template<typename type , typename value_type = type>
void	StoreArrayPointer (type const *addr, value_type value, Thread *thread)
template<typename type , typename compressed_type , std::memory_order order>
void	StoreCompressedArrayPointer (compressed_type const *addr, type value)
template<typename type , typename compressed_type , std::memory_order order>
void	StoreCompressedArrayPointer (compressed_type const *addr, type value, Thread *thread)
template<typename type , typename compressed_type >
void	StoreCompressedArrayPointer (compressed_type const *addr, type value, Thread *thread)
template<typename type , typename compressed_type , std::memory_order order = std::memory_order_relaxed>
type	ExchangeCompressedPointer (compressed_type const *addr, type value)
template<std::memory_order order = std::memory_order_relaxed>
SmiPtr	LoadSmi (SmiPtr const *addr) const
template<std::memory_order order = std::memory_order_relaxed>
SmiPtr	LoadCompressedSmi (CompressedSmiPtr const *addr) const
template<typename type , std::memory_order order = std::memory_order_relaxed>
void	StoreSmi (type const *addr, type value)
template<std::memory_order order = std::memory_order_relaxed>
void	StoreCompressedSmi (CompressedSmiPtr const *addr, SmiPtr value)

Static Protected Member Functions
template<typename T >
static DART_FORCE_INLINE uword	from_offset ()
template<typename T >
static DART_FORCE_INLINE uword	to_offset (intptr_t length=0)
template<>
DART_FORCE_INLINE uword	from_offset ()
template<>
DART_FORCE_INLINE uword	to_offset (intptr_t length)
template<>
DART_FORCE_INLINE uword	to_offset (intptr_t length)
template<>
DART_FORCE_INLINE uword	to_offset (intptr_t length)

Static Protected Attributes
static constexpr bool	kContainsCompressedPointers = false
static constexpr bool	kContainsPointerFields = false

Friends
class	StoreBufferUpdateVisitor
class	Array
class	ByteBuffer
class	CidRewriteVisitor
class	Closure
class	Code
class	Pointer
class	Double
class	DynamicLibrary
class	ForwardPointersVisitor
class	FreeListElement
class	Function
class	GCMarker
class	GCSweeper
class	ExternalTypedData
class	GrowableObjectArray
template<bool >
class	MarkingVisitorBase
class	Mint
class	Object
class	OneByteString
class	UntaggedInstance
class	Scavenger
template<bool >
class	ScavengerVisitorBase
class	ImageReader
class	ImageWriter
class	AssemblyImageWriter
class	BlobImageWriter
class	Deserializer
class	String
class	WeakProperty
class	Instance
class	StackFrame
class	CodeLookupTableBuilder
class	ObjectLocator
class	WriteBarrierUpdateVisitor
class	OffsetsTable
class	ObjectCopyBase
uword	TagsFromUntaggedObject (UntaggedObject *)
void	SetNewSpaceTaggingWord (ObjectPtr, classid_t, uint32_t)
void	ReportImpossibleNullError (intptr_t cid, StackFrame *caller_frame, Thread *thread)

Detailed Description

Definition at line 159 of file raw_object.h.

Member Enumeration Documentation

TagBits

enum dart::UntaggedObject::TagBits

Enumerator
kCardRememberedBit
kCanonicalBit
kNotMarkedBit
kNewOrEvacuationCandidateBit
kAlwaysSetBit
kOldAndNotRememberedBit
kImmutableBit
kReservedBit
kSizeTagPos
kSizeTagSize
kClassIdTagPos
kClassIdTagSize
kHashTagPos
kHashTagSize

Definition at line 163 of file raw_object.h.

               {
    kCardRememberedBit = 0,
    kCanonicalBit = 1,
    kNotMarkedBit = 2,                 // Incremental barrier target.
    kNewOrEvacuationCandidateBit = 3,  // Generational barrier target.
    kAlwaysSetBit = 4,                 // Incremental barrier source.
    kOldAndNotRememberedBit = 5,       // Generational barrier source.
    kImmutableBit = 6,
    kReservedBit = 7,
 
    kSizeTagPos = kReservedBit + 1,  // = 8
    kSizeTagSize = 4,
    kClassIdTagPos = kSizeTagPos + kSizeTagSize,  // = 12
    kClassIdTagSize = 20,
    kHashTagPos = kClassIdTagPos + kClassIdTagSize,  // = 32
    kHashTagSize = 32,
  };

Member Function Documentation

ClearCanonical()

void dart::UntaggedObject::ClearCanonical ( )

inline

Definition at line 352 of file raw_object.h.

{ tags_.UpdateBool<CanonicalBit>(false); }

ClearImmutable()

void dart::UntaggedObject::ClearImmutable ( )

inline

Definition at line 356 of file raw_object.h.

{ tags_.UpdateBool<ImmutableBit>(false); }

ClearIsEvacuationCandidateUnsynchronized()

void dart::UntaggedObject::ClearIsEvacuationCandidateUnsynchronized ( )

inline

Definition at line 343 of file raw_object.h.

                                                  {
    ASSERT(IsOldObject());
    tags_.UpdateUnsynchronized<NewOrEvacuationCandidateBit>(false);
  }

ClearMarkBit()

void dart::UntaggedObject::ClearMarkBit ( )

inline

Definition at line 317 of file raw_object.h.

                      {
    ASSERT(IsMarked());
    tags_.UpdateBool<NotMarkedBit>(true);
  }

ClearMarkBitUnsynchronized()

void dart::UntaggedObject::ClearMarkBitUnsynchronized ( )

inline

Definition at line 321 of file raw_object.h.

                                    {
    ASSERT(IsMarked());
    tags_.UpdateUnsynchronized<NotMarkedBit>(true);
  }

ClearRememberedBit()

void dart::UntaggedObject::ClearRememberedBit ( )

inline

Definition at line 369 of file raw_object.h.

                            {
    ASSERT(IsOldObject());
    tags_.UpdateBool<OldAndNotRememberedBit>(true);
  }

ClearRememberedBitUnsynchronized()

void dart::UntaggedObject::ClearRememberedBitUnsynchronized ( )

inline

Definition at line 373 of file raw_object.h.

                                          {
    ASSERT(IsOldObject());
    tags_.UpdateUnsynchronized<OldAndNotRememberedBit>(true);
  }

COMPILE_ASSERT() [1/5]

dart::UntaggedObject::COMPILE_ASSERT

(

kBitsPerByte *sizeof(ClassIdTagType) >=

kClassIdTagSize

)

COMPILE_ASSERT() [2/5]

dart::UntaggedObject::COMPILE_ASSERT

(

kCardRememberedBit

= =0

)

COMPILE_ASSERT() [3/5]

dart::UntaggedObject::COMPILE_ASSERT

(

kClassIdTagMax

= =(1<< kClassIdTagSize) - 1

)

COMPILE_ASSERT() [4/5]

dart::UntaggedObject::COMPILE_ASSERT

(

kNewOrEvacuationCandidateBit+

kBarrierOverlapShift = =kOldAndNotRememberedBit

)

COMPILE_ASSERT() [5/5]

dart::UntaggedObject::COMPILE_ASSERT

(

kNotMarkedBit+

kBarrierOverlapShift = =kAlwaysSetBit

)

Contains()

bool dart::UntaggedObject::Contains ( uword  addr ) const

inline

Definition at line 436 of file raw_object.h.

                                  {
    intptr_t this_size = HeapSize();
    uword this_addr = UntaggedObject::ToAddr(this);
    return (addr >= this_addr) && (addr < (this_addr + this_size));
  }

EnsureInRememberedSet()

DART_FORCE_INLINE void dart::UntaggedObject::EnsureInRememberedSet ( Thread *  thread )

inline

Definition at line 379 of file raw_object.h.

                                             {
    if (TryAcquireRememberedBit()) {
      thread->StoreBufferAddObject(ObjectPtr(this));
    }
  }

ExchangeCompressedPointer()

template<typename type , typename compressed_type , std::memory_order order = std::memory_order_relaxed>

type dart::UntaggedObject::ExchangeCompressedPointer ( compressed_type const *  addr, type  value  )

inlineprotected

Definition at line 696 of file raw_object.h.

                                                                          {
    compressed_type previous_value =
        reinterpret_cast<std::atomic<compressed_type>*>(
            const_cast<compressed_type*>(addr))
            ->exchange(static_cast<compressed_type>(value), order);
    if (value.IsHeapObject()) {
      CheckHeapPointerStore(value, Thread::Current());
    }
    return static_cast<type>(previous_value.Decompress(heap_base()));
  }

from_offset() [1/2]

template<typename T >

DART_FORCE_INLINE uword dart::UntaggedObject::from_offset

staticprotected

Definition at line 860 of file raw_object.h.

                                                    {
  if constexpr (T::kContainsPointerFields) {
    return reinterpret_cast<uword>(reinterpret_cast<T*>(kOffsetOfPtr)->from()) -
           kOffsetOfPtr;
  } else {
    // Non-zero to ensure to_offset() < from_offset() in this case, as
    // to_offset() is the offset to the last pointer field, not past it.
    return sizeof(UntaggedObject);
  }
}

from_offset() [2/2]

template<>

DART_FORCE_INLINE uword dart::UntaggedObject::from_offset ( )

staticprotected

Definition at line 1844 of file raw_object.h.

                                                                       {
  return OFFSET_OF(UntaggedWeakArray, next_seen_by_gc_);
}

FromAddr()

static ObjectPtr dart::UntaggedObject::FromAddr ( uword  addr )

inlinestatic

Definition at line 516 of file raw_object.h.

                                        {
    // We expect the untagged address here.
    ASSERT((addr & kSmiTagMask) != kHeapObjectTag);
    return static_cast<ObjectPtr>(addr + kHeapObjectTag);
  }

GetClassId()

intptr_t dart::UntaggedObject::GetClassId ( ) const

inline

Definition at line 392 of file raw_object.h.

{ return tags_.Read<ClassIdTag>(); }

heap_base()

uword dart::UntaggedObject::heap_base ( ) const

inlineprotected

Definition at line 590 of file raw_object.h.

                          {
    return reinterpret_cast<uword>(this) & kHeapBaseMask;
  }

HeapSize() [1/2]

intptr_t dart::UntaggedObject::HeapSize ( ) const

inline

Definition at line 401 of file raw_object.h.

                            {
    uword tags = tags_;
    intptr_t result = SizeTag::decode(tags);
    if (result != 0) {
#if defined(DEBUG)
      // TODO(22501) Array::MakeFixedLength has a race with this code: we might
      // have loaded tags field and then MakeFixedLength could have updated it
      // leading to inconsistency between HeapSizeFromClass() and
      // SizeTag::decode(tags). We are working around it by reloading tags_ and
      // recomputing size from tags.
      const intptr_t size_from_class = HeapSizeFromClass(tags);
      if ((result > size_from_class) && (GetClassId() == kArrayCid) &&
          (tags_ != tags)) {
        result = SizeTag::decode(tags_);
      }
      ASSERT(result == size_from_class);
#endif
      return result;
    }
    result = HeapSizeFromClass(tags);
    ASSERT(result > SizeTag::kMaxSizeTag);
    return result;
  }

HeapSize() [2/2]

intptr_t dart::UntaggedObject::HeapSize ( uword  tags ) const

inline

Definition at line 426 of file raw_object.h.

                                      {
    intptr_t result = SizeTag::decode(tags);
    if (result != 0) {
      return result;
    }
    result = HeapSizeFromClass(tags);
    ASSERT(result > SizeTag::kMaxSizeTag);
    return result;
  }

InVMIsolateHeap()

bool dart::UntaggedObject::InVMIsolateHeap

(

)

const

Definition at line 20 of file raw_object.cc.

                                           {
  // All "vm-isolate" objects are pre-marked and in old space
  // (see [Object::FinalizeVMIsolate]).
  if (!IsOldObject() || !IsMarked()) return false;
 
  auto heap = Dart::vm_isolate_group()->heap();
  ASSERT(heap->UsedInWords(Heap::kNew) == 0);
  return heap->old_space()->ContainsUnsafe(ToAddr(this));
}

IsCanonical() [1/2]

bool dart::UntaggedObject::IsCanonical ( ) const

inline

Definition at line 350 of file raw_object.h.

{ return tags_.Read<CanonicalBit>(); }

IsCanonical() [2/2]

static bool dart::UntaggedObject::IsCanonical ( intptr_t  value )

inlinestatic

Definition at line 529 of file raw_object.h.

                                          {
    return CanonicalBit::decode(value);
  }

IsCardRemembered()

bool dart::UntaggedObject::IsCardRemembered ( ) const

inline

Definition at line 385 of file raw_object.h.

{ return tags_.Read<CardRememberedBit>(); }

IsEvacuationCandidate() [1/2]

bool dart::UntaggedObject::IsEvacuationCandidate ( )

inline

Definition at line 332 of file raw_object.h.

                               {
    return tags_.Read<NewOrEvacuationCandidateBit>();
  }

IsEvacuationCandidate() [2/2]

static bool dart::UntaggedObject::IsEvacuationCandidate ( uword  tags )

inlinestatic

Definition at line 329 of file raw_object.h.

                                                {
    return NewOrEvacuationCandidateBit::decode(tags);
  }

IsImmutable()

bool dart::UntaggedObject::IsImmutable ( ) const

inline

Definition at line 354 of file raw_object.h.

{ return tags_.Read<ImmutableBit>(); }

IsMarked() [1/2]

bool dart::UntaggedObject::IsMarked ( ) const

inline

Definition at line 304 of file raw_object.h.

{ return !tags_.Read<NotMarkedBit>(); }

IsMarked() [2/2]

static bool dart::UntaggedObject::IsMarked ( uword  tags )

inlinestatic

Definition at line 303 of file raw_object.h.

{ return !NotMarkedBit::decode(tags); }

IsNewObject()

bool dart::UntaggedObject::IsNewObject ( ) const

inline

Definition at line 288 of file raw_object.h.

                           {
    uword addr = reinterpret_cast<uword>(this);
    return (addr & kObjectAlignmentMask) == kNewObjectAlignmentOffset;
  }

IsOldObject()

bool dart::UntaggedObject::IsOldObject ( ) const

inline

Definition at line 293 of file raw_object.h.

                           {
    uword addr = reinterpret_cast<uword>(this);
    return (addr & kObjectAlignmentMask) == kOldObjectAlignmentOffset;
  }

IsRemembered()

bool dart::UntaggedObject::IsRemembered ( ) const

inline

Definition at line 361 of file raw_object.h.

                            {
    ASSERT(IsOldObject());
    return !tags_.Read<OldAndNotRememberedBit>();
  }

LoadCompressedPointer()

template<typename type , typename compressed_type , std::memory_order order = std::memory_order_relaxed>

type dart::UntaggedObject::LoadCompressedPointer ( compressed_type const *  addr ) const

inlineprotected

Definition at line 583 of file raw_object.h.

                                                                {
    compressed_type v = reinterpret_cast<std::atomic<compressed_type>*>(
                            const_cast<compressed_type*>(addr))
                            ->load(order);
    return static_cast<type>(v.Decompress(heap_base()));
  }

LoadCompressedSmi()

template<std::memory_order order = std::memory_order_relaxed>

SmiPtr dart::UntaggedObject::LoadCompressedSmi ( CompressedSmiPtr const *  addr ) const

inlineprotected

Definition at line 713 of file raw_object.h.

                                                               {
    return static_cast<SmiPtr>(reinterpret_cast<std::atomic<CompressedSmiPtr>*>(
                                   const_cast<CompressedSmiPtr*>(addr))
                                   ->load(order)
                                   .DecompressSmi());
  }

LoadPointer()

template<typename type , std::memory_order order = std::memory_order_relaxed>

type dart::UntaggedObject::LoadPointer ( type const *  addr ) const

inlineprotected

Definition at line 576 of file raw_object.h.

                                           {
    return reinterpret_cast<std::atomic<type>*>(const_cast<type*>(addr))
        ->load(order);
  }

LoadSmi()

template<std::memory_order order = std::memory_order_relaxed>

SmiPtr dart::UntaggedObject::LoadSmi ( SmiPtr const *  addr ) const

inlineprotected

Definition at line 708 of file raw_object.h.

                                           {
    return reinterpret_cast<std::atomic<SmiPtr>*>(const_cast<SmiPtr*>(addr))
        ->load(order);
  }

SetCanonical()

void dart::UntaggedObject::SetCanonical ( )

inline

Definition at line 351 of file raw_object.h.

{ tags_.UpdateBool<CanonicalBit>(true); }

SetCardRememberedBitUnsynchronized()

void dart::UntaggedObject::SetCardRememberedBitUnsynchronized ( )

inline

Definition at line 386 of file raw_object.h.

                                            {
    ASSERT(!IsRemembered());
    ASSERT(!IsCardRemembered());
    tags_.UpdateUnsynchronized<CardRememberedBit>(true);
  }

SetImmutable()

void dart::UntaggedObject::SetImmutable ( )

inline

Definition at line 355 of file raw_object.h.

{ tags_.UpdateBool<ImmutableBit>(true); }

SetIsEvacuationCandidate()

void dart::UntaggedObject::SetIsEvacuationCandidate ( )

inline

Definition at line 335 of file raw_object.h.

                                  {
    ASSERT(IsOldObject());
    tags_.UpdateBool<NewOrEvacuationCandidateBit>(true);
  }

SetIsEvacuationCandidateUnsynchronized()

void dart::UntaggedObject::SetIsEvacuationCandidateUnsynchronized ( )

inline

Definition at line 339 of file raw_object.h.

                                                {
    ASSERT(IsOldObject());
    tags_.UpdateUnsynchronized<NewOrEvacuationCandidateBit>(true);
  }

SetMarkBit()

void dart::UntaggedObject::SetMarkBit ( )

inline

Definition at line 305 of file raw_object.h.

                    {
    ASSERT(!IsMarked());
    tags_.UpdateBool<NotMarkedBit>(false);
  }

SetMarkBitRelease()

void dart::UntaggedObject::SetMarkBitRelease ( )

inline

Definition at line 313 of file raw_object.h.

                           {
    ASSERT(!IsMarked());
    tags_.UpdateBool<NotMarkedBit, std::memory_order_release>(false);
  }

SetMarkBitUnsynchronized()

void dart::UntaggedObject::SetMarkBitUnsynchronized ( )

inline

Definition at line 309 of file raw_object.h.

                                  {
    ASSERT(!IsMarked());
    tags_.UpdateUnsynchronized<NotMarkedBit>(false);
  }

StoreArrayPointer() [1/2]

template<typename type , std::memory_order order = std::memory_order_relaxed, typename value_type = type>

void dart::UntaggedObject::StoreArrayPointer ( type const *  addr, value_type  value  )

inlineprotected

Definition at line 645 of file raw_object.h.

                                                             {
    reinterpret_cast<std::atomic<type>*>(const_cast<type*>(addr))
        ->store(type(value), order);
    if (value->IsHeapObject()) {
      CheckArrayPointerStore(addr, value, Thread::Current());
    }
  }

StoreArrayPointer() [2/2]

template<typename type , typename value_type = type>

void dart::UntaggedObject::StoreArrayPointer ( type const *  addr, value_type  value, Thread *  thread  )

inlineprotected

Definition at line 654 of file raw_object.h.

                                                                             {
    *const_cast<type*>(addr) = value;
    if (value->IsHeapObject()) {
      CheckArrayPointerStore(addr, value, thread);
    }
  }

StoreCompressedArrayPointer() [1/3]

template<typename type , typename compressed_type , std::memory_order order>

void dart::UntaggedObject::StoreCompressedArrayPointer ( compressed_type const *  addr, type  value  )

inlineprotected

Definition at line 662 of file raw_object.h.

                                                                            {
    reinterpret_cast<std::atomic<compressed_type>*>(
        const_cast<compressed_type*>(addr))
        ->store(static_cast<compressed_type>(value), order);
    if (value->IsHeapObject()) {
      CheckArrayPointerStore(addr, value, Thread::Current());
    }
  }

StoreCompressedArrayPointer() [2/3]

template<typename type , typename compressed_type , std::memory_order order>

void dart::UntaggedObject::StoreCompressedArrayPointer ( compressed_type const *  addr, type  value, Thread *  thread  )

inlineprotected

Definition at line 672 of file raw_object.h.

                                                   {
    reinterpret_cast<std::atomic<compressed_type>*>(
        const_cast<compressed_type*>(addr))
        ->store(static_cast<compressed_type>(value), order);
    if (value->IsHeapObject()) {
      CheckArrayPointerStore(addr, value, thread);
    }
  }

StoreCompressedArrayPointer() [3/3]

template<typename type , typename compressed_type >

void dart::UntaggedObject::StoreCompressedArrayPointer ( compressed_type const *  addr, type  value, Thread *  thread  )

inlineprotected

Definition at line 684 of file raw_object.h.

                                                   {
    *const_cast<compressed_type*>(addr) = value;
    if (value->IsHeapObject()) {
      CheckArrayPointerStore(addr, value, thread);
    }
  }

StoreCompressedPointer() [1/2]

template<typename type , typename compressed_type , std::memory_order order = std::memory_order_relaxed>

void dart::UntaggedObject::StoreCompressedPointer ( compressed_type const *  addr, type  value  )

inlineprotected

Definition at line 606 of file raw_object.h.

                                                                       {
    reinterpret_cast<std::atomic<compressed_type>*>(
        const_cast<compressed_type*>(addr))
        ->store(static_cast<compressed_type>(value), order);
    if (value.IsHeapObject()) {
      CheckHeapPointerStore(value, Thread::Current());
    }
  }

StoreCompressedPointer() [2/2]

template<typename type , typename compressed_type >

void dart::UntaggedObject::StoreCompressedPointer ( compressed_type const *  addr, type  value, Thread *  thread  )

inlineprotected

Definition at line 624 of file raw_object.h.

                                              {
    *const_cast<compressed_type*>(addr) = value;
    if (value.IsHeapObject()) {
      CheckHeapPointerStore(value, thread);
    }
  }

StoreCompressedSmi()

template<std::memory_order order = std::memory_order_relaxed>

void dart::UntaggedObject::StoreCompressedSmi ( CompressedSmiPtr const *  addr, SmiPtr  value  )

inlineprotected

Definition at line 730 of file raw_object.h.

                                                                      {
    // Can't use Contains, as array length is initialized through this method.
    ASSERT(reinterpret_cast<uword>(addr) >= UntaggedObject::ToAddr(this));
    reinterpret_cast<std::atomic<CompressedSmiPtr>*>(
        const_cast<CompressedSmiPtr*>(addr))
        ->store(static_cast<CompressedSmiPtr>(value), order);
  }

StorePointer() [1/2]

template<typename type , std::memory_order order = std::memory_order_relaxed>

void dart::UntaggedObject::StorePointer ( type const *  addr, type  value  )

inlineprotected

Definition at line 595 of file raw_object.h.

                                                  {
    reinterpret_cast<std::atomic<type>*>(const_cast<type*>(addr))
        ->store(value, order);
    if (value.IsHeapObject()) {
      CheckHeapPointerStore(value, Thread::Current());
    }
  }

StorePointer() [2/2]

template<typename type >

void dart::UntaggedObject::StorePointer ( type const *  addr, type  value, Thread *  thread  )

inlineprotected

Definition at line 616 of file raw_object.h.

                                                                  {
    *const_cast<type*>(addr) = value;
    if (value.IsHeapObject()) {
      CheckHeapPointerStore(value, thread);
    }
  }

StorePointerUnaligned()

template<typename type >

void dart::UntaggedObject::StorePointerUnaligned ( type const *  addr, type  value, Thread *  thread  )

inlineprotected

Definition at line 634 of file raw_object.h.

                                                                           {
    StoreUnaligned(const_cast<type*>(addr), value);
    if (value->IsHeapObject()) {
      CheckHeapPointerStore(value, thread);
    }
  }

StoreSmi()

template<typename type , std::memory_order order = std::memory_order_relaxed>

void dart::UntaggedObject::StoreSmi ( type const *  addr, type  value  )

inlineprotected

Definition at line 723 of file raw_object.h.

                                              {
    // Can't use Contains, as array length is initialized through this method.
    ASSERT(reinterpret_cast<uword>(addr) >= UntaggedObject::ToAddr(this));
    reinterpret_cast<std::atomic<type>*>(const_cast<type*>(addr))
        ->store(value, order);
  }

tags()

uword dart::UntaggedObject::tags ( ) const

inline

Definition at line 298 of file raw_object.h.

{ return tags_; }

tags_ignore_race()

uword dart::UntaggedObject::tags_ignore_race ( ) const

inline

Definition at line 299 of file raw_object.h.

{ return tags_.load_ignore_race(); }

to_offset() [1/4]

template<>

DART_FORCE_INLINE uword dart::UntaggedObject::to_offset ( intptr_t  length )

staticprotected

Definition at line 3587 of file raw_object.h.

                                                               {
  return OFFSET_OF(UntaggedWeakProperty, next_seen_by_gc_);
}

to_offset() [2/4]

template<>

DART_FORCE_INLINE uword dart::UntaggedObject::to_offset ( intptr_t  length )

staticprotected

Definition at line 3621 of file raw_object.h.

                                                                {
  return OFFSET_OF(UntaggedWeakReference, next_seen_by_gc_);
}

to_offset() [3/4]

template<>

DART_FORCE_INLINE uword dart::UntaggedObject::to_offset ( intptr_t  length )

staticprotected

Definition at line 3733 of file raw_object.h.

                                                                 {
  return OFFSET_OF(UntaggedFinalizerEntry, next_seen_by_gc_);
}

to_offset() [4/4]

template<typename T >

DART_FORCE_INLINE uword dart::UntaggedObject::to_offset ( intptr_t  length = 0 )

staticprotected

Definition at line 872 of file raw_object.h.

                                                                 {
  if constexpr (T::kContainsPointerFields) {
    return reinterpret_cast<uword>(
               reinterpret_cast<T*>(kOffsetOfPtr)->to(length)) -
           kOffsetOfPtr;
  } else {
    USE(length);
    // Zero to ensure to_offset() < from_offset() in this case, as
    // from_offset() is guaranteed to return an offset after the header tags.
    return 0;
  }
}

ToAddr() [1/2]

static uword dart::UntaggedObject::ToAddr ( const ObjectPtr  raw_obj )

inlinestatic

Definition at line 525 of file raw_object.h.

                                               {
    return static_cast<uword>(raw_obj) - kHeapObjectTag;
  }

ToAddr() [2/2]

static uword dart::UntaggedObject::ToAddr ( const UntaggedObject *  raw_obj )

inlinestatic

Definition at line 522 of file raw_object.h.

                                                     {
    return reinterpret_cast<uword>(raw_obj);
  }

TryAcquireMarkBit()

DART_WARN_UNUSED_RESULT bool dart::UntaggedObject::TryAcquireMarkBit ( )

inline

Definition at line 327 of file raw_object.h.

{ return tags_.TryClear<NotMarkedBit>(); }

TryAcquireRememberedBit()

bool dart::UntaggedObject::TryAcquireRememberedBit ( )

inline

Definition at line 365 of file raw_object.h.

                                 {
    ASSERT(!IsCardRemembered());
    return tags_.TryClear<OldAndNotRememberedBit>();
  }

Validate()

void dart::UntaggedObject::Validate

(

IsolateGroup *

isolate_group

)

const

Definition at line 42 of file raw_object.cc.

                                                               {
  if (static_cast<uword>(Object::void_class_) == kHeapObjectTag) {
    // Validation relies on properly initialized class classes. Skip if the
    // VM is still being initialized.
    return;
  }
  // Validate that the tags_ field is sensible.
  uword tags = tags_;
  if (IsNewObject()) {
    if (!NewOrEvacuationCandidateBit::decode(tags)) {
      FATAL("New object missing kNewBit: %" Px "\n", tags);
    }
    if (OldAndNotRememberedBit::decode(tags)) {
      FATAL("New object has kOldAndNotRememberedBit: %" Px "\n", tags);
    }
  }
  const intptr_t class_id = ClassIdTag::decode(tags);
  if (!isolate_group->class_table()->IsValidIndex(class_id)) {
    FATAL("Invalid class id encountered %" Pd "\n", class_id);
  }
  if (class_id == kNullCid &&
      isolate_group->class_table()->HasValidClassAt(class_id)) {
    // Null class not yet initialized; skip.
    return;
  }
  intptr_t size_from_tags = SizeTag::decode(tags);
  intptr_t size_from_class = HeapSizeFromClass(tags);
  if ((size_from_tags != 0) && (size_from_tags != size_from_class)) {
    FATAL(
        "Inconsistent size encountered "
        "cid: %" Pd ", size_from_tags: %" Pd ", size_from_class: %" Pd "\n",
        class_id, size_from_tags, size_from_class);
  }
}

VisitPointers()

intptr_t dart::UntaggedObject::VisitPointers ( ObjectPointerVisitor *  visitor )

inline

Definition at line 447 of file raw_object.h.

                                                        {
    // Fall back to virtual variant for predefined classes
    intptr_t class_id = GetClassId();
    if (class_id < kNumPredefinedCids) {
      return VisitPointersPredefined(visitor, class_id);
    }
 
    // Calculate the first and last raw object pointer fields.
    intptr_t instance_size = HeapSize();
    uword obj_addr = ToAddr(this);
    uword from = obj_addr + sizeof(UntaggedObject);
    uword to = obj_addr + instance_size - kCompressedWordSize;
    const auto first = reinterpret_cast<CompressedObjectPtr*>(from);
    const auto last = reinterpret_cast<CompressedObjectPtr*>(to);
 
    const auto unboxed_fields_bitmap =
        visitor->class_table()->GetUnboxedFieldsMapAt(class_id);
 
    if (!unboxed_fields_bitmap.IsEmpty()) {
      intptr_t bit = sizeof(UntaggedObject) / kCompressedWordSize;
      for (CompressedObjectPtr* current = first; current <= last; current++) {
        if (!unboxed_fields_bitmap.Get(bit++)) {
          visitor->VisitCompressedPointers(heap_base(), current, current);
        }
      }
    } else {
      visitor->VisitCompressedPointers(heap_base(), first, last);
    }
 
    return instance_size;
  }

VisitPointersNonvirtual()

template<class V >

DART_FORCE_INLINE intptr_t dart::UntaggedObject::VisitPointersNonvirtual ( V *  visitor )

inline

Definition at line 480 of file raw_object.h.

                                                                 {
    // Fall back to virtual variant for predefined classes
    intptr_t class_id = GetClassId();
    if (class_id < kNumPredefinedCids) {
      return VisitPointersPredefined(visitor, class_id);
    }
 
    // Calculate the first and last raw object pointer fields.
    intptr_t instance_size = HeapSize();
    uword obj_addr = ToAddr(this);
    uword from = obj_addr + sizeof(UntaggedObject);
    uword to = obj_addr + instance_size - kCompressedWordSize;
    const auto first = reinterpret_cast<CompressedObjectPtr*>(from);
    const auto last = reinterpret_cast<CompressedObjectPtr*>(to);
 
    const auto unboxed_fields_bitmap =
        visitor->class_table()->GetUnboxedFieldsMapAt(class_id);
 
    if (!unboxed_fields_bitmap.IsEmpty()) {
      intptr_t bit = sizeof(UntaggedObject) / kCompressedWordSize;
      for (CompressedObjectPtr* current = first; current <= last; current++) {
        if (!unboxed_fields_bitmap.Get(bit++)) {
          visitor->V::VisitCompressedPointers(heap_base(), current, current);
        }
      }
    } else {
      visitor->V::VisitCompressedPointers(heap_base(), first, last);
    }
 
    return instance_size;
  }

VisitPointersPrecise()

void dart::UntaggedObject::VisitPointersPrecise

(

ObjectPointerVisitor *

visitor

)

Definition at line 371 of file raw_object.cc.

                                                                       {
  intptr_t class_id = GetClassId();
  if ((class_id != kInstanceCid) && (class_id < kNumPredefinedCids)) {
    VisitPointersPredefined(visitor, class_id);
    return;
  }
 
  // N.B.: Not using the heap size!
  uword next_field_offset = visitor->class_table()
                                ->At(class_id)
                                ->untag()
                                ->host_next_field_offset_in_words_
                            << kCompressedWordSizeLog2;
  ASSERT(next_field_offset > 0);
  uword obj_addr = UntaggedObject::ToAddr(this);
  uword from = obj_addr + sizeof(UntaggedObject);
  uword to = obj_addr + next_field_offset - kCompressedWordSize;
  const auto first = reinterpret_cast<CompressedObjectPtr*>(from);
  const auto last = reinterpret_cast<CompressedObjectPtr*>(to);
 
  const auto unboxed_fields_bitmap =
      visitor->class_table()->GetUnboxedFieldsMapAt(class_id);
 
  if (!unboxed_fields_bitmap.IsEmpty()) {
    intptr_t bit = sizeof(UntaggedObject) / kCompressedWordSize;
    for (CompressedObjectPtr* current = first; current <= last; current++) {
      if (!unboxed_fields_bitmap.Get(bit++)) {
        visitor->VisitCompressedPointers(heap_base(), current, current);
      }
    }
  } else {
    visitor->VisitCompressedPointers(heap_base(), first, last);
  }
}

Friends And Related Function Documentation

Array

friend class Array

friend

Definition at line 805 of file raw_object.h.

AssemblyImageWriter

friend class AssemblyImageWriter

friend

Definition at line 831 of file raw_object.h.

BlobImageWriter

friend class BlobImageWriter

friend

Definition at line 832 of file raw_object.h.

ByteBuffer

friend class ByteBuffer

friend

Definition at line 806 of file raw_object.h.

CidRewriteVisitor

friend class CidRewriteVisitor

friend

Definition at line 807 of file raw_object.h.

Closure

friend class Closure

friend

Definition at line 808 of file raw_object.h.

Code

friend class Code

friend

Definition at line 809 of file raw_object.h.

CodeLookupTableBuilder

friend class CodeLookupTableBuilder

friend

Definition at line 838 of file raw_object.h.

Deserializer

friend class Deserializer

friend

Definition at line 833 of file raw_object.h.

Double

friend class Double

friend

Definition at line 811 of file raw_object.h.

DynamicLibrary

friend class DynamicLibrary

friend

Definition at line 812 of file raw_object.h.

ExternalTypedData

friend class ExternalTypedData

friend

Definition at line 818 of file raw_object.h.

ForwardPointersVisitor

friend class ForwardPointersVisitor

friend

Definition at line 813 of file raw_object.h.

FreeListElement

friend class FreeListElement

friend

Definition at line 814 of file raw_object.h.

Function

friend class Function

friend

Definition at line 815 of file raw_object.h.

GCMarker

friend class GCMarker

friend

Definition at line 816 of file raw_object.h.

GCSweeper

friend class GCSweeper

friend

Definition at line 817 of file raw_object.h.

GrowableObjectArray

friend class GrowableObjectArray

friend

Definition at line 819 of file raw_object.h.

ImageReader

friend class ImageReader

friend

Definition at line 829 of file raw_object.h.

ImageWriter

friend class ImageWriter

friend

Definition at line 830 of file raw_object.h.

Instance

friend class Instance

friend

Definition at line 836 of file raw_object.h.

MarkingVisitorBase

template<bool >

friend class MarkingVisitorBase

friend

Definition at line 821 of file raw_object.h.

Mint

friend class Mint

friend

Definition at line 822 of file raw_object.h.

Object

Object

friend

Definition at line 823 of file raw_object.h.

ObjectCopyBase

friend class ObjectCopyBase

friend

Definition at line 845 of file raw_object.h.

ObjectLocator

friend class ObjectLocator

friend

Definition at line 839 of file raw_object.h.

OffsetsTable

friend class OffsetsTable

friend

Definition at line 841 of file raw_object.h.

OneByteString

friend class OneByteString

friend

Definition at line 824 of file raw_object.h.

Pointer

friend class Pointer

friend

Definition at line 810 of file raw_object.h.

ReportImpossibleNullError

void ReportImpossibleNullError ( intptr_t  cid, StackFrame *  caller_frame, Thread *  thread  )

friend

Definition at line 273 of file runtime_entry.cc.

                                               {
  TextBuffer buffer(512);
  buffer.Printf("hit null error with cid %" Pd ", caller context: ", cid);
 
  const intptr_t kMaxSlotsCollected = 5;
  const auto slots = reinterpret_cast<ObjectPtr*>(caller_frame->sp());
  const intptr_t num_slots_in_frame =
      reinterpret_cast<ObjectPtr*>(caller_frame->fp()) - slots;
  const auto num_slots_to_collect =
      Utils::Maximum(kMaxSlotsCollected, num_slots_in_frame);
  bool comma = false;
  for (intptr_t i = 0; i < num_slots_to_collect; i++) {
    const ObjectPtr ptr = slots[i];
    buffer.Printf("%s[sp+%" Pd "] %" Pp "", comma ? ", " : "", i,
                  static_cast<uword>(ptr));
    if (ptr->IsHeapObject() &&
        (Dart::vm_isolate_group()->heap()->Contains(
             UntaggedObject::ToAddr(ptr)) ||
         thread->heap()->Contains(UntaggedObject::ToAddr(ptr)))) {
      buffer.Printf("(%" Pp ")", static_cast<uword>(ptr->untag()->tags_));
    }
    comma = true;
  }
 
  const char* message = buffer.buffer();
  FATAL("%s", message);
}

Scavenger

friend class Scavenger

friend

Definition at line 826 of file raw_object.h.

ScavengerVisitorBase

template<bool >

friend class ScavengerVisitorBase

friend

Definition at line 828 of file raw_object.h.

SetNewSpaceTaggingWord

void SetNewSpaceTaggingWord ( ObjectPtr  to, classid_t  cid, uint32_t  size  )

friend

Definition at line 229 of file object_graph_copy.cc.

                                                                        {
  uword tags = 0;
 
  tags = UntaggedObject::SizeTag::update(size, tags);
  tags = UntaggedObject::ClassIdTag::update(cid, tags);
  tags = UntaggedObject::AlwaysSetBit::update(true, tags);
  tags = UntaggedObject::NotMarkedBit::update(true, tags);
  tags = UntaggedObject::OldAndNotRememberedBit::update(false, tags);
  tags = UntaggedObject::CanonicalBit::update(false, tags);
  tags = UntaggedObject::NewOrEvacuationCandidateBit::update(true, tags);
  tags = UntaggedObject::ImmutableBit::update(
      IsUnmodifiableTypedDataViewClassId(cid), tags);
#if defined(HASH_IN_OBJECT_HEADER)
  tags = UntaggedObject::HashTag::update(0, tags);
#endif
  to.untag()->tags_ = tags;
}

StackFrame

friend class StackFrame

friend

Definition at line 837 of file raw_object.h.

StoreBufferUpdateVisitor

friend class StoreBufferUpdateVisitor

friend

Definition at line 799 of file raw_object.h.

String

friend class String

friend

Definition at line 834 of file raw_object.h.

TagsFromUntaggedObject

uword TagsFromUntaggedObject ( UntaggedObject *  obj )

friend

Definition at line 224 of file object_graph_copy.cc.

                                                  {
  return obj->tags_;
}

UntaggedInstance

friend class UntaggedInstance

friend

Definition at line 825 of file raw_object.h.

WeakProperty

friend class WeakProperty

friend

Definition at line 835 of file raw_object.h.

WriteBarrierUpdateVisitor

friend class WriteBarrierUpdateVisitor

friend

Definition at line 840 of file raw_object.h.

Member Data Documentation

kBarrierOverlapShift

constexpr intptr_t dart::UntaggedObject::kBarrierOverlapShift = 2

staticconstexpr

Definition at line 184 of file raw_object.h.

kContainsCompressedPointers

constexpr bool dart::UntaggedObject::kContainsCompressedPointers = false

staticconstexprprotected

Definition at line 548 of file raw_object.h.

kContainsPointerFields

constexpr bool dart::UntaggedObject::kContainsPointerFields = false

staticconstexprprotected

Definition at line 550 of file raw_object.h.

kGenerationalBarrierMask

constexpr intptr_t dart::UntaggedObject::kGenerationalBarrierMask

staticconstexpr

Initial value:

=
      1 << kNewOrEvacuationCandidateBit

Definition at line 181 of file raw_object.h.

kIncrementalBarrierMask

constexpr intptr_t dart::UntaggedObject::kIncrementalBarrierMask = 1 << kNotMarkedBit

staticconstexpr

Definition at line 183 of file raw_object.h.

---

The documentation for this class was generated from the following files:

• third_party/dart-lang/sdk/runtime/vm/raw_object.h
• third_party/dart-lang/sdk/runtime/vm/raw_object.cc