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	NewBit
class	NotMarkedBit
class	OldAndNotRememberedBit
class	ReservedBit
class	SizeTag

Public Types
enum	TagBits {   kCardRememberedBit = 0 , kCanonicalBit = 1 , kNotMarkedBit = 2 , kNewBit = 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 (kNewBit+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
bool	IsMarked () const
bool	IsMarkedIgnoreRace () const
void	SetMarkBit ()
void	SetMarkBitUnsynchronized ()
void	SetMarkBitRelease ()
void	ClearMarkBit ()
void	ClearMarkBitUnsynchronized ()
DART_WARN_UNUSED_RESULT bool	TryAcquireMarkBit ()
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 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 = 1 << kNewBit
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 158 of file raw_object.h.

Member Enumeration Documentation

TagBits

enum dart::UntaggedObject::TagBits

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

Definition at line 162 of file raw_object.h.

               {
    kCardRememberedBit = 0,
    kCanonicalBit = 1,
    kNotMarkedBit = 2,            // Incremental barrier target.
    kNewBit = 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 331 of file raw_object.h.

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

ClearImmutable()

void dart::UntaggedObject::ClearImmutable ( )

inline

Definition at line 335 of file raw_object.h.

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

ClearMarkBit()

void dart::UntaggedObject::ClearMarkBit ( )

inline

Definition at line 315 of file raw_object.h.

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

ClearMarkBitUnsynchronized()

void dart::UntaggedObject::ClearMarkBitUnsynchronized ( )

inline

Definition at line 319 of file raw_object.h.

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

ClearRememberedBit()

void dart::UntaggedObject::ClearRememberedBit ( )

inline

Definition at line 348 of file raw_object.h.

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

ClearRememberedBitUnsynchronized()

void dart::UntaggedObject::ClearRememberedBitUnsynchronized ( )

inline

Definition at line 352 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

(

kNewBit+

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 415 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 358 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 675 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 839 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 1823 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 495 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 371 of file raw_object.h.

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

heap_base()

uword dart::UntaggedObject::heap_base ( ) const

inlineprotected

Definition at line 569 of file raw_object.h.

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

HeapSize() [1/2]

intptr_t dart::UntaggedObject::HeapSize ( ) const

inline

Definition at line 380 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 405 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 329 of file raw_object.h.

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

IsCanonical() [2/2]

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

inlinestatic

Definition at line 508 of file raw_object.h.

                                          {
    return CanonicalBit::decode(value);
  }

IsCardRemembered()

bool dart::UntaggedObject::IsCardRemembered ( ) const

inline

Definition at line 364 of file raw_object.h.

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

IsImmutable()

bool dart::UntaggedObject::IsImmutable ( ) const

inline

Definition at line 333 of file raw_object.h.

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

IsMarked() [1/2]

bool dart::UntaggedObject::IsMarked ( ) const

inline

Definition at line 299 of file raw_object.h.

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

IsMarked() [2/2]

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

inlinestatic

Definition at line 298 of file raw_object.h.

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

IsMarkedIgnoreRace()

bool dart::UntaggedObject::IsMarkedIgnoreRace ( ) const

inline

Definition at line 300 of file raw_object.h.

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

IsNewObject()

bool dart::UntaggedObject::IsNewObject ( ) const

inline

Definition at line 284 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 289 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 340 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 562 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 692 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 555 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 687 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 330 of file raw_object.h.

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

SetCardRememberedBitUnsynchronized()

void dart::UntaggedObject::SetCardRememberedBitUnsynchronized ( )

inline

Definition at line 365 of file raw_object.h.

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

SetImmutable()

void dart::UntaggedObject::SetImmutable ( )

inline

Definition at line 334 of file raw_object.h.

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

SetMarkBit()

void dart::UntaggedObject::SetMarkBit ( )

inline

Definition at line 303 of file raw_object.h.

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

SetMarkBitRelease()

void dart::UntaggedObject::SetMarkBitRelease ( )

inline

Definition at line 311 of file raw_object.h.

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

SetMarkBitUnsynchronized()

void dart::UntaggedObject::SetMarkBitUnsynchronized ( )

inline

Definition at line 307 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 624 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 633 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 641 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 651 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 663 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 585 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 603 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 709 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 574 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 595 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 613 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 702 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 294 of file raw_object.h.

{ return tags_; }

to_offset() [1/4]

template<>

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

staticprotected

Definition at line 3564 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 3598 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 3710 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 851 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 504 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 501 of file raw_object.h.

                                                     {
    return reinterpret_cast<uword>(raw_obj);
  }

TryAcquireMarkBit()

DART_WARN_UNUSED_RESULT bool dart::UntaggedObject::TryAcquireMarkBit ( )

inline

Definition at line 325 of file raw_object.h.

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

TryAcquireRememberedBit()

bool dart::UntaggedObject::TryAcquireRememberedBit ( )

inline

Definition at line 344 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 (!NewBit::decode(tags)) {
      FATAL("New object missing kNewBit: %" Px "\n", tags);
    }
    if (OldAndNotRememberedBit::decode(tags)) {
      FATAL("New object has kOldAndNotRememberedBit: %" Px "\n", tags);
    }
  } else {
    if (NewBit::decode(tags)) {
      FATAL("Old object has kNewBit: %" 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 426 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 459 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 375 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 Symbol Documentation

Array

friend class Array

friend

Definition at line 784 of file raw_object.h.

AssemblyImageWriter

friend class AssemblyImageWriter

friend

Definition at line 810 of file raw_object.h.

BlobImageWriter

friend class BlobImageWriter

friend

Definition at line 811 of file raw_object.h.

ByteBuffer

friend class ByteBuffer

friend

Definition at line 785 of file raw_object.h.

CidRewriteVisitor

friend class CidRewriteVisitor

friend

Definition at line 786 of file raw_object.h.

Closure

friend class Closure

friend

Definition at line 787 of file raw_object.h.

Code

friend class Code

friend

Definition at line 788 of file raw_object.h.

CodeLookupTableBuilder

friend class CodeLookupTableBuilder

friend

Definition at line 817 of file raw_object.h.

Deserializer

friend class Deserializer

friend

Definition at line 812 of file raw_object.h.

Double

friend class Double

friend

Definition at line 790 of file raw_object.h.

DynamicLibrary

friend class DynamicLibrary

friend

Definition at line 791 of file raw_object.h.

ExternalTypedData

friend class ExternalTypedData

friend

Definition at line 797 of file raw_object.h.

ForwardPointersVisitor

friend class ForwardPointersVisitor

friend

Definition at line 792 of file raw_object.h.

FreeListElement

friend class FreeListElement

friend

Definition at line 793 of file raw_object.h.

Function

friend class Function

friend

Definition at line 794 of file raw_object.h.

GCMarker

friend class GCMarker

friend

Definition at line 795 of file raw_object.h.

GCSweeper

friend class GCSweeper

friend

Definition at line 796 of file raw_object.h.

GrowableObjectArray

friend class GrowableObjectArray

friend

Definition at line 798 of file raw_object.h.

ImageReader

friend class ImageReader

friend

Definition at line 808 of file raw_object.h.

ImageWriter

friend class ImageWriter

friend

Definition at line 809 of file raw_object.h.

Instance

friend class Instance

friend

Definition at line 815 of file raw_object.h.

MarkingVisitorBase

template<bool >

friend class MarkingVisitorBase

friend

Definition at line 800 of file raw_object.h.

Mint

friend class Mint

friend

Definition at line 801 of file raw_object.h.

Object

Object

friend

Definition at line 802 of file raw_object.h.

ObjectCopyBase

friend class ObjectCopyBase

friend

Definition at line 824 of file raw_object.h.

ObjectLocator

friend class ObjectLocator

friend

Definition at line 818 of file raw_object.h.

OffsetsTable

friend class OffsetsTable

friend

Definition at line 820 of file raw_object.h.

OneByteString

friend class OneByteString

friend

Definition at line 803 of file raw_object.h.

Pointer

friend class Pointer

friend

Definition at line 789 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 805 of file raw_object.h.

ScavengerVisitorBase

template<bool >

friend class ScavengerVisitorBase

friend

Definition at line 807 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::NewBit::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 816 of file raw_object.h.

StoreBufferUpdateVisitor

friend class StoreBufferUpdateVisitor

friend

Definition at line 778 of file raw_object.h.

String

friend class String

friend

Definition at line 813 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 804 of file raw_object.h.

WeakProperty

friend class WeakProperty

friend

Definition at line 814 of file raw_object.h.

WriteBarrierUpdateVisitor

friend class WriteBarrierUpdateVisitor

friend

Definition at line 819 of file raw_object.h.

Member Data Documentation

kBarrierOverlapShift

constexpr intptr_t dart::UntaggedObject::kBarrierOverlapShift = 2

staticconstexpr

Definition at line 182 of file raw_object.h.

kContainsCompressedPointers

constexpr bool dart::UntaggedObject::kContainsCompressedPointers = false

staticconstexprprotected

Definition at line 527 of file raw_object.h.

kContainsPointerFields

constexpr bool dart::UntaggedObject::kContainsPointerFields = false

staticconstexprprotected

Definition at line 529 of file raw_object.h.

kGenerationalBarrierMask

constexpr intptr_t dart::UntaggedObject::kGenerationalBarrierMask = 1 << kNewBit

staticconstexpr

Definition at line 180 of file raw_object.h.

kIncrementalBarrierMask

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

staticconstexpr

Definition at line 181 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