#include <object.h>

Inheritance diagram for dart::Object:

Public Types
enum	NameVisibility { kInternalName = 0 , kScrubbedName , kUserVisibleName }

enum class	NameDisambiguation { kYes , kNo }

using	UntaggedObjectType = UntaggedObject

using	ObjectPtrType = ObjectPtr

Public Member Functions
virtual	~Object ()

ObjectPtr	ptr () const

void	operator= (ObjectPtr value)

bool	IsCanonical () const

void	SetCanonical () const

void	ClearCanonical () const

bool	IsImmutable () const

void	SetImmutable () const

void	ClearImmutable () const

intptr_t	GetClassId () const

ClassPtr	clazz () const

	CLASS_LIST_FOR_HANDLES (DEFINE_CLASS_TESTER)

bool	IsNull () const

virtual const char *	ToCString () const

void	PrintJSON (JSONStream *stream, bool ref=true) const

virtual void	PrintJSONImpl (JSONStream *stream, bool ref) const

void	PrintImplementationFields (JSONStream *stream) const

virtual void	PrintImplementationFieldsImpl (const JSONArray &jsarr_fields) const

virtual const char *	JSONType () const

virtual StringPtr	DictionaryName () const

bool	IsNew () const

bool	IsOld () const

bool	InVMIsolateHeap () const

void	Print () const

Static Public Member Functions
static ObjectPtr	RawCast (ObjectPtr obj)

static constexpr bool	ContainsCompressedPointers ()

static intptr_t	tags_offset ()

static Object &	Handle ()

static Object &	Handle (Zone *zone)

static Object &	Handle (ObjectPtr ptr)

static Object &	Handle (Zone *zone, ObjectPtr ptr)

static Object &	ZoneHandle ()

static Object &	ZoneHandle (Zone *zone)

static Object &	ZoneHandle (ObjectPtr ptr)

static Object &	ZoneHandle (Zone *zone, ObjectPtr ptr)

static Object *	ReadOnlyHandle ()

static ObjectPtr	null ()

static void	set_vm_isolate_snapshot_object_table (const Array &table)

static ClassPtr	class_class ()

static ClassPtr	dynamic_class ()

static ClassPtr	void_class ()

static ClassPtr	type_parameters_class ()

static ClassPtr	type_arguments_class ()

static ClassPtr	patch_class_class ()

static ClassPtr	function_class ()

static ClassPtr	closure_data_class ()

static ClassPtr	ffi_trampoline_data_class ()

static ClassPtr	field_class ()

static ClassPtr	script_class ()

static ClassPtr	library_class ()

static ClassPtr	namespace_class ()

static ClassPtr	kernel_program_info_class ()

static ClassPtr	code_class ()

static ClassPtr	instructions_class ()

static ClassPtr	instructions_section_class ()

static ClassPtr	instructions_table_class ()

static ClassPtr	object_pool_class ()

static ClassPtr	pc_descriptors_class ()

static ClassPtr	code_source_map_class ()

static ClassPtr	compressed_stackmaps_class ()

static ClassPtr	var_descriptors_class ()

static ClassPtr	exception_handlers_class ()

static ClassPtr	context_class ()

static ClassPtr	context_scope_class ()

static ClassPtr	sentinel_class ()

static ClassPtr	api_error_class ()

static ClassPtr	language_error_class ()

static ClassPtr	unhandled_exception_class ()

static ClassPtr	unwind_error_class ()

static ClassPtr	singletargetcache_class ()

static ClassPtr	unlinkedcall_class ()

static ClassPtr	monomorphicsmiablecall_class ()

static ClassPtr	icdata_class ()

static ClassPtr	megamorphic_cache_class ()

static ClassPtr	subtypetestcache_class ()

static ClassPtr	loadingunit_class ()

static ClassPtr	weak_serialization_reference_class ()

static ClassPtr	weak_array_class ()

static void	InitNullAndBool (IsolateGroup *isolate_group)

static void	Init (IsolateGroup *isolate_group)

static void	InitVtables ()

static void	FinishInit (IsolateGroup *isolate_group)

static void	FinalizeVMIsolate (IsolateGroup *isolate_group)

static void	FinalizeReadOnlyObject (ObjectPtr object)

static void	Cleanup ()

static ErrorPtr	Init (IsolateGroup isolate_group, const uint8_t kernel_buffer, intptr_t kernel_buffer_size)

static void	MakeUnusedSpaceTraversable (const Object &obj, intptr_t original_size, intptr_t used_size)

static intptr_t	InstanceSize ()

template<class FakeObject >
static void	VerifyBuiltinVtable (intptr_t cid)

static void	VerifyBuiltinVtables ()

static bool	ShouldHaveImmutabilityBitSet (classid_t class_id)

Static Public Attributes
static constexpr intptr_t	kHashBits = 30

static const ClassId	kClassId = kObjectCid

Protected Member Functions
	Object ()

uword	raw_value () const

void	setPtr (ObjectPtr value, intptr_t default_cid)

void	CheckHandle () const

cpp_vtable	vtable () const

void	set_vtable (cpp_vtable value)

bool	Contains (uword addr) const

template<typename type , std::memory_order order = std::memory_order_relaxed>
type	LoadPointer (type const *addr) const

template<typename type , std::memory_order order = std::memory_order_relaxed>
void	StorePointer (type const *addr, type value) const

template<typename type , typename compressed_type , std::memory_order order = std::memory_order_relaxed>
void	StoreCompressedPointer (compressed_type const *addr, type value) const

template<typename type >
void	StorePointerUnaligned (type const addr, type value, Thread thread) const

void	StoreSmi (SmiPtr const *addr, SmiPtr value) const

template<typename FieldType >
void	StoreSimd128 (const FieldType *addr, simd128_value_t value) const

template<typename FieldType >
FieldType	LoadNonPointer (const FieldType *addr) const

template<typename FieldType , std::memory_order order>
FieldType	LoadNonPointer (const FieldType *addr) const

template<typename FieldType , typename ValueType >
void	StoreNonPointer (const FieldType *addr, ValueType value) const

template<typename FieldType , typename ValueType , std::memory_order order>
void	StoreNonPointer (const FieldType *addr, ValueType value) const

template<typename FieldType >
FieldType *	UnsafeMutableNonPointer (const FieldType *addr) const

	CLASS_LIST (STORE_NON_POINTER_ILLEGAL_TYPE)

void	UnimplementedMethod () const

void	AddCommonObjectProperties (JSONObject jsobj, const char protocol_type, bool ref) const

Static Protected Member Functions
static DART_NOINLINE Object &	HandleImpl (Zone *zone, ObjectPtr ptr, intptr_t default_cid)

static DART_NOINLINE Object &	ZoneHandleImpl (Zone *zone, ObjectPtr ptr, intptr_t default_cid)

static DART_NOINLINE Object *	ReadOnlyHandleImpl (intptr_t cid)

static ObjectPtr	Allocate (intptr_t cls_id, intptr_t size, Heap::Space space, bool compressed, uword ptr_field_start_offset, uword ptr_field_end_offset)

template<typename T >
static DART_FORCE_INLINE T::ObjectPtrType	Allocate (Heap::Space space)

template<typename T >
static DART_FORCE_INLINE T::ObjectPtrType	Allocate (Heap::Space space, intptr_t elements)

template<typename T >
static DART_FORCE_INLINE T::ObjectPtrType	AllocateVariant (intptr_t class_id, Heap::Space space)

template<typename T >
static DART_FORCE_INLINE T::ObjectPtrType	AllocateVariant (intptr_t class_id, Heap::Space space, intptr_t elements)

static constexpr intptr_t	RoundedAllocationSize (intptr_t size)

static ObjectPtr	Clone (const Object &orig, Heap::Space space, bool load_with_relaxed_atomics=false)

template<typename T >
static DART_FORCE_INLINE uword	from_offset ()

template<typename T >
static DART_FORCE_INLINE uword	to_offset (intptr_t length=0)

Protected Attributes
ObjectPtr	ptr_

Friends
class	Closure

class	InstanceDeserializationCluster

class	ObjectGraphCopier

class	Simd128MessageDeserializationCluster

class	OneByteString

class	TwoByteString

class	Thread

ObjectPtr	AllocateObject (intptr_t, intptr_t, intptr_t)

void	ClassTable::Register (const Class &cls)

void	UntaggedObject::Validate (IsolateGroup *isolate_group) const

Detailed Description

Definition at line 315 of file object.h.

Member Typedef Documentation

◆ ObjectPtrType

using dart::Object::ObjectPtrType = ObjectPtr

Definition at line 318 of file object.h.

◆ UntaggedObjectType

using dart::Object::UntaggedObjectType = UntaggedObject

Definition at line 317 of file object.h.

Member Enumeration Documentation

◆ NameDisambiguation

enum class dart::Object::NameDisambiguation

strong

Enumerator
kYes
kNo

Definition at line 657 of file object.h.

                                {
    kYes,
    kNo,
  };

◆ NameVisibility

enum dart::Object::NameVisibility

Enumerator
kInternalName
kScrubbedName
kUserVisibleName

Definition at line 609 of file object.h.

                      {
    // Internal names are the true names of classes, fields,
    // etc. inside the vm.  These names include privacy suffixes,
    // getter prefixes, and trailing dots on unnamed constructors.
    //
    // The names of core implementation classes (like _OneByteString)
    // are preserved as well.
    //
    // e.g.
    //   private getter             -> get:foo@6be832b
    //   private constructor        -> _MyClass@6b3832b.
    //   private named constructor  -> _MyClass@6b3832b.named
    //   core impl class name shown -> _OneByteString
    kInternalName = 0,
 
    // Scrubbed names drop privacy suffixes, getter prefixes, and
    // trailing dots on unnamed constructors.  These names are used in
    // the vm service.
    //
    // e.g.
    //   get:foo@6be832b        -> foo
    //   _MyClass@6b3832b.      -> _MyClass
    //   _MyClass@6b3832b.named -> _MyClass.named
    //   _OneByteString         -> _OneByteString (not remapped)
    kScrubbedName,
 
    // User visible names are appropriate for reporting type errors
    // directly to programmers.  The names have been scrubbed and
    // the names of core implementation classes are remapped to their
    // public interface names.
    //
    // e.g.
    //   get:foo@6be832b        -> foo
    //   _MyClass@6b3832b.      -> _MyClass
    //   _MyClass@6b3832b.named -> _MyClass.named
    //   _OneByteString         -> String (remapped)
    kUserVisibleName
  };

Constructor & Destructor Documentation

◆ ~Object()

virtual dart::Object::~Object ( )

inlinevirtual

Definition at line 327 of file object.h.

327{}

◆ Object()

dart::Object::Object ( )

inlineprotected

Definition at line 668 of file object.h.

668: ptr_(null_) {}

dart::Object::ptr_

ObjectPtr ptr_

Definition object.h:870

Member Function Documentation

◆ AddCommonObjectProperties()

void dart::Object::AddCommonObjectProperties	(	JSONObject *	jsobj,
		const char *	protocol_type,
		bool	ref
	)		const

protected

Definition at line 29 of file object_service.cc.

                                                       {
  const char* vm_type = JSONType();
  bool same_type = (strcmp(protocol_type, vm_type) == 0);
  if (ref) {
    jsobj->AddPropertyF("type", "@%s", protocol_type);
  } else {
    jsobj->AddProperty("type", protocol_type);
  }
  if (!same_type) {
    jsobj->AddProperty("_vmType", vm_type);
  }
  if (!ref || IsInstance() || IsNull()) {
    // TODO(turnidge): Provide the type arguments here too?
    const Class& cls = Class::Handle(this->clazz());
    jsobj->AddProperty("class", cls);
  }
  if (!ref) {
    if (ptr()->IsHeapObject()) {
      jsobj->AddProperty("size", ptr()->untag()->HeapSize());
    } else {
      jsobj->AddProperty("size", (intptr_t)0);
    }
  }
}

◆ Allocate() [1/3]

template<typename T >

static DART_FORCE_INLINE T::ObjectPtrType dart::Object::Allocate ( Heap::Space space )

inlinestaticprotected

Definition at line 722 of file object.h.

                       {
    return static_cast<typename T::ObjectPtrType>(Allocate(
        T::kClassId, T::InstanceSize(), space, T::ContainsCompressedPointers(),
        Object::from_offset<T>(), Object::to_offset<T>()));
  }

◆ Allocate() [2/3]

template<typename T >

static DART_FORCE_INLINE T::ObjectPtrType dart::Object::Allocate	(	Heap::Space	space,
		intptr_t	elements
	)

inlinestaticprotected

Definition at line 729 of file object.h.

                         {
    return static_cast<typename T::ObjectPtrType>(
        Allocate(T::kClassId, T::InstanceSize(elements), space,
                 T::ContainsCompressedPointers(), Object::from_offset<T>(),
                 Object::to_offset<T>(elements)));
  }

◆ Allocate() [3/3]

ObjectPtr dart::Object::Allocate	(	intptr_t	cls_id,
		intptr_t	size,
		Heap::Space	space,
		bool	compressed,
		uword	ptr_field_start_offset,
		uword	ptr_field_end_offset
	)

staticprotected

Definition at line 2820 of file object.cc.

                                                       {
  ASSERT(Utils::IsAligned(size, kObjectAlignment));
  Thread* thread = Thread::Current();
  ASSERT(thread->execution_state() == Thread::kThreadInVM);
  ASSERT(thread->no_safepoint_scope_depth() == 0);
  ASSERT(thread->no_callback_scope_depth() == 0);
  Heap* heap = thread->heap();
 
  uword address = heap->Allocate(thread, size, space);
  if (UNLIKELY(address == 0)) {
    // SuspendLongJumpScope during Dart entry ensures that if a longjmp base is
    // available, it is the innermost error handler, so check for a longjmp base
    // before checking for an exit frame.
    if (thread->long_jump_base() != nullptr) {
      Report::LongJump(Object::out_of_memory_error());
      UNREACHABLE();
    } else if (thread->top_exit_frame_info() != 0) {
      // Use the preallocated out of memory exception to avoid calling
      // into dart code or allocating any code.
      Exceptions::ThrowOOM();
      UNREACHABLE();
    } else {
      // Nowhere to propagate an exception to.
      OUT_OF_MEMORY();
    }
  }
 
  ObjectPtr raw_obj;
  NoSafepointScope no_safepoint(thread);
  InitializeObject(address, cls_id, size, compressed, ptr_field_start_offset,
                   ptr_field_end_offset);
  raw_obj = static_cast<ObjectPtr>(address + kHeapObjectTag);
  ASSERT(cls_id == UntaggedObject::ClassIdTag::decode(raw_obj->untag()->tags_));
  if (raw_obj->IsOldObject() && UNLIKELY(thread->is_marking())) {
    // Black allocation. Prevents a data race between the mutator and
    // concurrent marker on ARM and ARM64 (the marker may observe a
    // publishing store of this object before the stores that initialize its
    // slots), and helps the collection to finish sooner.
    // release: Setting the mark bit must not be ordered after a publishing
    // store of this object. Compare Scavenger::ScavengePointer.
    raw_obj->untag()->SetMarkBitRelease();
    heap->old_space()->AllocateBlack(size);
  }
 
#if !defined(PRODUCT) || defined(FORCE_INCLUDE_SAMPLING_HEAP_PROFILER)
  HeapProfileSampler& heap_sampler = thread->heap_sampler();
  if (heap_sampler.HasOutstandingSample()) {
    thread->IncrementNoCallbackScopeDepth();
    void* data = heap_sampler.InvokeCallbackForLastSample(cls_id);
    heap->SetHeapSamplingData(raw_obj, data);
    thread->DecrementNoCallbackScopeDepth();
  }
#endif  // !defined(PRODUCT) || defined(FORCE_INCLUDE_SAMPLING_HEAP_PROFILER)
 
#if !defined(PRODUCT)
  auto class_table = thread->isolate_group()->class_table();
  if (class_table->ShouldTraceAllocationFor(cls_id)) {
    uint32_t hash =
        HeapSnapshotWriter::GetHeapSnapshotIdentityHash(thread, raw_obj);
    Profiler::SampleAllocation(thread, cls_id, hash);
  }
#endif  // !defined(PRODUCT)
  return raw_obj;
}

◆ AllocateVariant() [1/2]

template<typename T >

static DART_FORCE_INLINE T::ObjectPtrType dart::Object::AllocateVariant	(	intptr_t	class_id,
		Heap::Space	space
	)

inlinestaticprotected

Definition at line 742 of file object.h.

                       {
    return static_cast<typename T::ObjectPtrType>(Allocate(
        class_id, T::InstanceSize(), space, T::ContainsCompressedPointers(),
        Object::from_offset<T>(), Object::to_offset<T>()));
  }

◆ AllocateVariant() [2/2]

template<typename T >

static DART_FORCE_INLINE T::ObjectPtrType dart::Object::AllocateVariant	(	intptr_t	class_id,
		Heap::Space	space,
		intptr_t	elements
	)

inlinestaticprotected

Definition at line 751 of file object.h.

                                                                         {
    return static_cast<typename T::ObjectPtrType>(
        Allocate(class_id, T::InstanceSize(elements), space,
                 T::ContainsCompressedPointers(), Object::from_offset<T>(),
                 Object::to_offset<T>(elements)));
  }

◆ api_error_class()

static ClassPtr dart::Object::api_error_class ( )

inlinestatic

Definition at line 552 of file object.h.

552{ return api_error_class_; }

◆ CheckHandle()

void dart::Object::CheckHandle ( ) const

protected

Definition at line 2808 of file object.cc.

                               {
#if defined(DEBUG)
  if (ptr_ != Object::null()) {
    intptr_t cid = ptr_->GetClassIdMayBeSmi();
    if (cid >= kNumPredefinedCids) {
      cid = kInstanceCid;
    }
    ASSERT(vtable() == builtin_vtables_[cid]);
  }
#endif
}

◆ class_class()

static ClassPtr dart::Object::class_class ( )

inlinestatic

Definition at line 513 of file object.h.

513{ return class_class_; }

◆ CLASS_LIST()

dart::Object::CLASS_LIST ( STORE_NON_POINTER_ILLEGAL_TYPE )

protected

◆ CLASS_LIST_FOR_HANDLES()

dart::Object::CLASS_LIST_FOR_HANDLES ( DEFINE_CLASS_TESTER )

◆ clazz()

ClassPtr dart::Object::clazz ( ) const

inline

Definition at line 13192 of file object.h.

                             {
  uword raw_value = static_cast<uword>(ptr_);
  if ((raw_value & kSmiTagMask) == kSmiTag) {
    return Smi::Class();
  }
  return IsolateGroup::Current()->class_table()->At(ptr()->GetClassId());
}

◆ Cleanup()

void dart::Object::Cleanup ( )

static

Definition at line 1364 of file object.cc.

                     {
  null_ = static_cast<ObjectPtr>(RAW_NULL);
  true_ = static_cast<BoolPtr>(RAW_NULL);
  false_ = static_cast<BoolPtr>(RAW_NULL);
  class_class_ = static_cast<ClassPtr>(RAW_NULL);
  dynamic_class_ = static_cast<ClassPtr>(RAW_NULL);
  void_class_ = static_cast<ClassPtr>(RAW_NULL);
  type_parameters_class_ = static_cast<ClassPtr>(RAW_NULL);
  type_arguments_class_ = static_cast<ClassPtr>(RAW_NULL);
  patch_class_class_ = static_cast<ClassPtr>(RAW_NULL);
  function_class_ = static_cast<ClassPtr>(RAW_NULL);
  closure_data_class_ = static_cast<ClassPtr>(RAW_NULL);
  ffi_trampoline_data_class_ = static_cast<ClassPtr>(RAW_NULL);
  field_class_ = static_cast<ClassPtr>(RAW_NULL);
  script_class_ = static_cast<ClassPtr>(RAW_NULL);
  library_class_ = static_cast<ClassPtr>(RAW_NULL);
  namespace_class_ = static_cast<ClassPtr>(RAW_NULL);
  kernel_program_info_class_ = static_cast<ClassPtr>(RAW_NULL);
  code_class_ = static_cast<ClassPtr>(RAW_NULL);
  instructions_class_ = static_cast<ClassPtr>(RAW_NULL);
  instructions_section_class_ = static_cast<ClassPtr>(RAW_NULL);
  instructions_table_class_ = static_cast<ClassPtr>(RAW_NULL);
  object_pool_class_ = static_cast<ClassPtr>(RAW_NULL);
  pc_descriptors_class_ = static_cast<ClassPtr>(RAW_NULL);
  code_source_map_class_ = static_cast<ClassPtr>(RAW_NULL);
  compressed_stackmaps_class_ = static_cast<ClassPtr>(RAW_NULL);
  var_descriptors_class_ = static_cast<ClassPtr>(RAW_NULL);
  exception_handlers_class_ = static_cast<ClassPtr>(RAW_NULL);
  context_class_ = static_cast<ClassPtr>(RAW_NULL);
  context_scope_class_ = static_cast<ClassPtr>(RAW_NULL);
  singletargetcache_class_ = static_cast<ClassPtr>(RAW_NULL);
  unlinkedcall_class_ = static_cast<ClassPtr>(RAW_NULL);
  monomorphicsmiablecall_class_ = static_cast<ClassPtr>(RAW_NULL);
  icdata_class_ = static_cast<ClassPtr>(RAW_NULL);
  megamorphic_cache_class_ = static_cast<ClassPtr>(RAW_NULL);
  subtypetestcache_class_ = static_cast<ClassPtr>(RAW_NULL);
  loadingunit_class_ = static_cast<ClassPtr>(RAW_NULL);
  api_error_class_ = static_cast<ClassPtr>(RAW_NULL);
  language_error_class_ = static_cast<ClassPtr>(RAW_NULL);
  unhandled_exception_class_ = static_cast<ClassPtr>(RAW_NULL);
  unwind_error_class_ = static_cast<ClassPtr>(RAW_NULL);
}

◆ ClearCanonical()

void dart::Object::ClearCanonical ( ) const

inline

Definition at line 337 of file object.h.

337{ ptr()->untag()->ClearCanonical(); }

dart::ObjectPtr::untag

UntaggedObject * untag() const

Definition tagged_pointer.h:105

dart::UntaggedObject::ClearCanonical

void ClearCanonical()

Definition raw_object.h:331

◆ ClearImmutable()

void dart::Object::ClearImmutable ( ) const

inline

Definition at line 340 of file object.h.

340{ ptr()->untag()->ClearImmutable(); }

dart::UntaggedObject::ClearImmutable

void ClearImmutable()

Definition raw_object.h:335

◆ Clone()

ObjectPtr dart::Object::Clone	(	const Object &	orig,
		Heap::Space	space,
		bool	load_with_relaxed_atomics = `false`
	)

staticprotected

Definition at line 2960 of file object.cc.

                                                        {
  // Generic function types should be cloned with FunctionType::Clone.
  ASSERT(!orig.IsFunctionType() || !FunctionType::Cast(orig).IsGeneric());
  const Class& cls = Class::Handle(orig.clazz());
  intptr_t size = orig.ptr()->untag()->HeapSize();
  // All fields (including non-SmiPtr fields) will be initialized with Smi 0,
  // but the contents of the original object are copied over before the thread
  // is allowed to reach a safepoint.
  ObjectPtr raw_clone =
      Object::Allocate(cls.id(), size, space, cls.HasCompressedPointers(),
                       from_offset<Object>(), to_offset<Object>());
  NoSafepointScope no_safepoint;
  // Copy the body of the original into the clone.
  uword orig_addr = UntaggedObject::ToAddr(orig.ptr());
  uword clone_addr = UntaggedObject::ToAddr(raw_clone);
  const intptr_t kHeaderSizeInBytes = sizeof(UntaggedObject);
  if (load_with_relaxed_atomics) {
    auto orig_atomics_ptr = reinterpret_cast<std::atomic<uword>*>(orig_addr);
    auto clone_ptr = reinterpret_cast<uword*>(clone_addr);
    for (intptr_t i = kHeaderSizeInBytes / kWordSize; i < size / kWordSize;
         i++) {
      *(clone_ptr + i) =
          (orig_atomics_ptr + i)->load(std::memory_order_relaxed);
    }
  } else {
    memmove(reinterpret_cast<uint8_t*>(clone_addr + kHeaderSizeInBytes),
            reinterpret_cast<uint8_t*>(orig_addr + kHeaderSizeInBytes),
            size - kHeaderSizeInBytes);
  }
 
  if (IsTypedDataClassId(raw_clone->GetClassId())) {
    auto raw_typed_data = TypedData::RawCast(raw_clone);
    raw_typed_data.untag()->RecomputeDataField();
  }
 
  // Add clone to store buffer, if needed.
  if (!raw_clone->IsOldObject()) {
    // No need to remember an object in new space.
    return raw_clone;
  }
  WriteBarrierUpdateVisitor visitor(Thread::Current(), raw_clone);
  raw_clone->untag()->VisitPointers(&visitor);
  return raw_clone;
}

◆ closure_data_class()

static ClassPtr dart::Object::closure_data_class ( )

inlinestatic

Definition at line 520 of file object.h.

520{ return closure_data_class_; }

◆ code_class()

static ClassPtr dart::Object::code_class ( )

inlinestatic

Definition at line 531 of file object.h.

531{ return code_class_; }

◆ code_source_map_class()

static ClassPtr dart::Object::code_source_map_class ( )

inlinestatic

Definition at line 541 of file object.h.

541{ return code_source_map_class_; }

◆ compressed_stackmaps_class()

static ClassPtr dart::Object::compressed_stackmaps_class ( )

inlinestatic

Definition at line 542 of file object.h.

                                               {
    return compressed_stackmaps_class_;
  }

◆ Contains()

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

inlineprotected

Definition at line 762 of file object.h.

762{ return ptr()->untag()->Contains(addr); }

dart::UntaggedObject::Contains

bool Contains(uword addr) const

Definition raw_object.h:415

◆ ContainsCompressedPointers()

static constexpr bool dart::Object::ContainsCompressedPointers ( )

inlinestaticconstexpr

Definition at line 329 of file object.h.

                                                     {
    return UntaggedObject::kContainsCompressedPointers;
  }

◆ context_class()

static ClassPtr dart::Object::context_class ( )

inlinestatic

Definition at line 549 of file object.h.

549{ return context_class_; }

◆ context_scope_class()

static ClassPtr dart::Object::context_scope_class ( )

inlinestatic

Definition at line 550 of file object.h.

550{ return context_scope_class_; }

◆ DictionaryName()

StringPtr dart::Object::DictionaryName ( ) const

virtual

Reimplemented in dart::Class, dart::Function, dart::Field, and dart::LibraryPrefix.

Definition at line 2685 of file object.cc.

                                       {
  return String::null();
}

◆ dynamic_class()

static ClassPtr dart::Object::dynamic_class ( )

inlinestatic

Definition at line 514 of file object.h.

514{ return dynamic_class_; }

◆ exception_handlers_class()

static ClassPtr dart::Object::exception_handlers_class ( )

inlinestatic

Definition at line 546 of file object.h.

                                             {
    return exception_handlers_class_;
  }

◆ ffi_trampoline_data_class()

static ClassPtr dart::Object::ffi_trampoline_data_class ( )

inlinestatic

Definition at line 521 of file object.h.

                                              {
    return ffi_trampoline_data_class_;
  }

◆ field_class()

static ClassPtr dart::Object::field_class ( )

inlinestatic

Definition at line 524 of file object.h.

524{ return field_class_; }

◆ FinalizeReadOnlyObject()

void dart::Object::FinalizeReadOnlyObject ( ObjectPtr object )

static

Definition at line 1556 of file object.cc.

                                                    {
  NoSafepointScope no_safepoint;
  intptr_t cid = object->GetClassId();
  if (cid == kOneByteStringCid) {
    OneByteStringPtr str = static_cast<OneByteStringPtr>(object);
    if (String::GetCachedHash(str) == 0) {
      intptr_t hash = String::Hash(str);
      String::SetCachedHashIfNotSet(str, hash);
    }
    intptr_t size = OneByteString::UnroundedSize(str);
    ASSERT(size <= str->untag()->HeapSize());
    memset(reinterpret_cast<void*>(UntaggedObject::ToAddr(str) + size), 0,
           str->untag()->HeapSize() - size);
  } else if (cid == kTwoByteStringCid) {
    TwoByteStringPtr str = static_cast<TwoByteStringPtr>(object);
    if (String::GetCachedHash(str) == 0) {
      intptr_t hash = String::Hash(str);
      String::SetCachedHashIfNotSet(str, hash);
    }
    ASSERT(String::GetCachedHash(str) != 0);
    intptr_t size = TwoByteString::UnroundedSize(str);
    ASSERT(size <= str->untag()->HeapSize());
    memset(reinterpret_cast<void*>(UntaggedObject::ToAddr(str) + size), 0,
           str->untag()->HeapSize() - size);
  } else if (cid == kCodeSourceMapCid) {
    CodeSourceMapPtr map = CodeSourceMap::RawCast(object);
    intptr_t size = CodeSourceMap::UnroundedSize(map);
    ASSERT(size <= map->untag()->HeapSize());
    memset(reinterpret_cast<void*>(UntaggedObject::ToAddr(map) + size), 0,
           map->untag()->HeapSize() - size);
  } else if (cid == kCompressedStackMapsCid) {
    CompressedStackMapsPtr maps = CompressedStackMaps::RawCast(object);
    intptr_t size = CompressedStackMaps::UnroundedSize(maps);
    ASSERT(size <= maps->untag()->HeapSize());
    memset(reinterpret_cast<void*>(UntaggedObject::ToAddr(maps) + size), 0,
           maps->untag()->HeapSize() - size);
  } else if (cid == kPcDescriptorsCid) {
    PcDescriptorsPtr desc = PcDescriptors::RawCast(object);
    intptr_t size = PcDescriptors::UnroundedSize(desc);
    ASSERT(size <= desc->untag()->HeapSize());
    memset(reinterpret_cast<void*>(UntaggedObject::ToAddr(desc) + size), 0,
           desc->untag()->HeapSize() - size);
  }
}

◆ FinalizeVMIsolate()

void dart::Object::FinalizeVMIsolate ( IsolateGroup * isolate_group )

static

Definition at line 1470 of file object.cc.

                                                          {
  // Should only be run by the vm isolate.
  ASSERT(isolate_group == Dart::vm_isolate_group());
 
  // Finish initialization of synthetic_getter_parameter_names_ which was
  // Started in Object::InitOnce()
  synthetic_getter_parameter_names_->SetAt(0, Symbols::This());
 
  // Set up names for all VM singleton classes.
  Class& cls = Class::Handle();
 
  SET_CLASS_NAME(class, Class);
  SET_CLASS_NAME(dynamic, Dynamic);
  SET_CLASS_NAME(void, Void);
  SET_CLASS_NAME(type_parameters, TypeParameters);
  SET_CLASS_NAME(type_arguments, TypeArguments);
  SET_CLASS_NAME(patch_class, PatchClass);
  SET_CLASS_NAME(function, Function);
  SET_CLASS_NAME(closure_data, ClosureData);
  SET_CLASS_NAME(ffi_trampoline_data, FfiTrampolineData);
  SET_CLASS_NAME(field, Field);
  SET_CLASS_NAME(script, Script);
  SET_CLASS_NAME(library, LibraryClass);
  SET_CLASS_NAME(namespace, Namespace);
  SET_CLASS_NAME(kernel_program_info, KernelProgramInfo);
  SET_CLASS_NAME(weak_serialization_reference, WeakSerializationReference);
  SET_CLASS_NAME(weak_array, WeakArray);
  SET_CLASS_NAME(code, Code);
  SET_CLASS_NAME(instructions, Instructions);
  SET_CLASS_NAME(instructions_section, InstructionsSection);
  SET_CLASS_NAME(instructions_table, InstructionsTable);
  SET_CLASS_NAME(object_pool, ObjectPool);
  SET_CLASS_NAME(code_source_map, CodeSourceMap);
  SET_CLASS_NAME(pc_descriptors, PcDescriptors);
  SET_CLASS_NAME(compressed_stackmaps, CompressedStackMaps);
  SET_CLASS_NAME(var_descriptors, LocalVarDescriptors);
  SET_CLASS_NAME(exception_handlers, ExceptionHandlers);
  SET_CLASS_NAME(context, Context);
  SET_CLASS_NAME(context_scope, ContextScope);
  SET_CLASS_NAME(sentinel, Sentinel);
  SET_CLASS_NAME(singletargetcache, SingleTargetCache);
  SET_CLASS_NAME(unlinkedcall, UnlinkedCall);
  SET_CLASS_NAME(monomorphicsmiablecall, MonomorphicSmiableCall);
  SET_CLASS_NAME(icdata, ICData);
  SET_CLASS_NAME(megamorphic_cache, MegamorphicCache);
  SET_CLASS_NAME(subtypetestcache, SubtypeTestCache);
  SET_CLASS_NAME(loadingunit, LoadingUnit);
  SET_CLASS_NAME(api_error, ApiError);
  SET_CLASS_NAME(language_error, LanguageError);
  SET_CLASS_NAME(unhandled_exception, UnhandledException);
  SET_CLASS_NAME(unwind_error, UnwindError);
 
  // Set up names for classes which are also pre-allocated in the vm isolate.
  cls = isolate_group->object_store()->array_class();
  cls.set_name(Symbols::_List());
  cls = isolate_group->object_store()->one_byte_string_class();
  cls.set_name(Symbols::OneByteString());
  cls = isolate_group->object_store()->never_class();
  cls.set_name(Symbols::Never());
 
  // Set up names for the pseudo-classes for free list elements and forwarding
  // corpses. Mainly this makes VM debugging easier.
  cls = isolate_group->class_table()->At(kFreeListElement);
  cls.set_name(Symbols::FreeListElement());
  cls = isolate_group->class_table()->At(kForwardingCorpse);
  cls.set_name(Symbols::ForwardingCorpse());
 
#if defined(DART_PRECOMPILER)
  const auto& function =
      Function::Handle(StubCode::UnknownDartCode().function());
  function.set_name(Symbols::OptimizedOut());
#endif  // defined(DART_PRECOMPILER)
 
  {
    ASSERT(isolate_group == Dart::vm_isolate_group());
    Thread* thread = Thread::Current();
    WritableVMIsolateScope scope(thread);
    HeapIterationScope iteration(thread);
    FinalizeVMIsolateVisitor premarker;
    ASSERT(isolate_group->heap()->UsedInWords(Heap::kNew) == 0);
    iteration.IterateOldObjectsNoImagePages(&premarker);
    // Make the VM isolate read-only again after setting all objects as marked.
    // Note objects in image pages are already pre-marked.
  }
}

◆ FinishInit()

void dart::Object::FinishInit ( IsolateGroup * isolate_group )

static

Definition at line 1351 of file object.cc.

                                                   {
  // The type testing stubs we initialize in AbstractType objects for the
  // canonical type of kDynamicCid/kVoidCid need to be set in this
  // method, which is called after StubCode::InitOnce().
  Code& code = Code::Handle();
 
  code = TypeTestingStubGenerator::DefaultCodeForType(*dynamic_type_);
  dynamic_type_->InitializeTypeTestingStubNonAtomic(code);
 
  code = TypeTestingStubGenerator::DefaultCodeForType(*void_type_);
  void_type_->InitializeTypeTestingStubNonAtomic(code);
}

◆ from_offset()

template<typename T >

static DART_FORCE_INLINE uword dart::Object::from_offset ( )

inlinestaticprotected

Definition at line 879 of file object.h.

                                               {
    return UntaggedObject::from_offset<typename T::UntaggedObjectType>();
  }

◆ function_class()

static ClassPtr dart::Object::function_class ( )

inlinestatic

Definition at line 519 of file object.h.

519{ return function_class_; }

◆ GetClassId()

intptr_t dart::Object::GetClassId ( ) const

inline

Definition at line 341 of file object.h.

                              {
    return !ptr()->IsHeapObject() ? static_cast<intptr_t>(kSmiCid)
                                  : ptr()->untag()->GetClassId();
  }

◆ Handle() [1/4]

static Object & dart::Object::Handle ( )

inlinestatic

Definition at line 407 of file object.h.

                          {
    return HandleImpl(Thread::Current()->zone(), null_, kObjectCid);
  }

◆ Handle() [2/4]

static Object & dart::Object::Handle ( ObjectPtr ptr )

inlinestatic

Definition at line 413 of file object.h.

                                       {
    return HandleImpl(Thread::Current()->zone(), ptr, kObjectCid);
  }

◆ Handle() [3/4]

static Object & dart::Object::Handle ( Zone * zone )

inlinestatic

Definition at line 410 of file object.h.

                                    {
    return HandleImpl(zone, null_, kObjectCid);
  }

◆ Handle() [4/4]

static Object & dart::Object::Handle	(	Zone *	zone,
		ObjectPtr	ptr
	)

inlinestatic

Definition at line 416 of file object.h.

                                                   {
    return HandleImpl(zone, ptr, kObjectCid);
  }

◆ HandleImpl()

static DART_NOINLINE Object & dart::Object::HandleImpl	(	Zone *	zone,
		ObjectPtr	ptr,
		intptr_t	default_cid
	)

inlinestaticprotected

Definition at line 674 of file object.h.

                                                                {
    Object* obj = reinterpret_cast<Object*>(VMHandles::AllocateHandle(zone));
    obj->setPtr(ptr, default_cid);
    return *obj;
  }

◆ icdata_class()

static ClassPtr dart::Object::icdata_class ( )

inlinestatic

Definition at line 563 of file object.h.

563{ return icdata_class_; }

◆ Init() [1/2]

void dart::Object::Init ( IsolateGroup * isolate_group )

static

Definition at line 721 of file object.cc.

                                             {
  // Should only be run by the vm isolate.
  ASSERT(isolate_group == Dart::vm_isolate_group());
  Heap* heap = isolate_group->heap();
  Thread* thread = Thread::Current();
  ASSERT(thread != nullptr);
  // Ensure lock checks in setters are happy.
  SafepointWriteRwLocker ml(thread, isolate_group->program_lock());
 
  InitVtables();
 
// Allocate the read only object handles here.
#define INITIALIZE_SHARED_READONLY_HANDLE(Type, name)                          \
  name##_ = Type::ReadOnlyHandle();
  SHARED_READONLY_HANDLES_LIST(INITIALIZE_SHARED_READONLY_HANDLE)
#undef INITIALIZE_SHARED_READONLY_HANDLE
 
  *null_object_ = Object::null();
  *null_class_ = Class::null();
  *null_array_ = Array::null();
  *null_string_ = String::null();
  *null_instance_ = Instance::null();
  *null_function_ = Function::null();
  *null_function_type_ = FunctionType::null();
  *null_record_type_ = RecordType::null();
  *null_type_arguments_ = TypeArguments::null();
  *null_closure_ = Closure::null();
  *empty_type_arguments_ = TypeArguments::null();
  *null_abstract_type_ = AbstractType::null();
  *null_compressed_stackmaps_ = CompressedStackMaps::null();
  *bool_true_ = true_;
  *bool_false_ = false_;
 
  // Initialize the empty array and empty instantiations cache array handles to
  // null_ in order to be able to check if the empty and zero arrays were
  // allocated (RAW_NULL is not available).
  *empty_array_ = Array::null();
  *empty_instantiations_cache_array_ = Array::null();
  *empty_subtype_test_cache_array_ = Array::null();
 
  Class& cls = Class::Handle();
 
  // Allocate and initialize the class class.
  {
    intptr_t size = Class::InstanceSize();
    uword address = heap->Allocate(thread, size, Heap::kOld);
    class_class_ = static_cast<ClassPtr>(address + kHeapObjectTag);
    InitializeObject<Class>(address);
 
    Class fake;
    // Initialization from Class::New<Class>.
    // Directly set ptr_ to break a circular dependency: SetRaw will attempt
    // to lookup class class in the class table where it is not registered yet.
    cls.ptr_ = class_class_;
    ASSERT(builtin_vtables_[kClassCid] == fake.vtable());
    cls.set_instance_size(
        Class::InstanceSize(),
        compiler::target::RoundedAllocationSize(RTN::Class::InstanceSize()));
    const intptr_t host_next_field_offset = Class::NextFieldOffset();
    const intptr_t target_next_field_offset = RTN::Class::NextFieldOffset();
    cls.set_next_field_offset(host_next_field_offset, target_next_field_offset);
    cls.set_id(Class::kClassId);
    cls.set_state_bits(0);
    cls.set_is_allocate_finalized();
    cls.set_is_declaration_loaded();
    cls.set_is_type_finalized();
    cls.set_type_arguments_field_offset_in_words(Class::kNoTypeArguments,
                                                 RTN::Class::kNoTypeArguments);
    cls.set_num_type_arguments_unsafe(0);
    cls.set_num_native_fields(0);
    cls.InitEmptyFields();
    isolate_group->class_table()->Register(cls);
  }
 
  // Allocate and initialize the null class.
  cls = Class::New<Instance, RTN::Instance>(kNullCid, isolate_group);
  cls.set_num_type_arguments_unsafe(0);
  isolate_group->object_store()->set_null_class(cls);
 
  // Allocate and initialize Never class.
  cls = Class::New<Instance, RTN::Instance>(kNeverCid, isolate_group);
  cls.set_num_type_arguments_unsafe(0);
  cls.set_is_allocate_finalized();
  cls.set_is_declaration_loaded();
  cls.set_is_type_finalized();
  isolate_group->object_store()->set_never_class(cls);
 
  // Allocate and initialize the free list element class.
  cls = Class::New<FreeListElement::FakeInstance,
                   RTN::FreeListElement::FakeInstance>(kFreeListElement,
                                                       isolate_group);
  cls.set_num_type_arguments_unsafe(0);
  cls.set_is_allocate_finalized();
  cls.set_is_declaration_loaded();
  cls.set_is_type_finalized();
 
  // Allocate and initialize the forwarding corpse class.
  cls = Class::New<ForwardingCorpse::FakeInstance,
                   RTN::ForwardingCorpse::FakeInstance>(kForwardingCorpse,
                                                        isolate_group);
  cls.set_num_type_arguments_unsafe(0);
  cls.set_is_allocate_finalized();
  cls.set_is_declaration_loaded();
  cls.set_is_type_finalized();
 
  // Allocate and initialize Sentinel class.
  cls = Class::New<Sentinel, RTN::Sentinel>(isolate_group);
  sentinel_class_ = cls.ptr();
 
  // Allocate and initialize the sentinel values.
  {
    *sentinel_ ^= Sentinel::New();
    *transition_sentinel_ ^= Sentinel::New();
  }
 
  // Allocate and initialize optimizing compiler constants.
  {
    *unknown_constant_ ^= Sentinel::New();
    *non_constant_ ^= Sentinel::New();
    *optimized_out_ ^= Sentinel::New();
  }
 
  // Allocate the remaining VM internal classes.
  cls = Class::New<TypeParameters, RTN::TypeParameters>(isolate_group);
  type_parameters_class_ = cls.ptr();
 
  cls = Class::New<TypeArguments, RTN::TypeArguments>(isolate_group);
  type_arguments_class_ = cls.ptr();
 
  cls = Class::New<PatchClass, RTN::PatchClass>(isolate_group);
  patch_class_class_ = cls.ptr();
 
  cls = Class::New<Function, RTN::Function>(isolate_group);
  function_class_ = cls.ptr();
 
  cls = Class::New<ClosureData, RTN::ClosureData>(isolate_group);
  closure_data_class_ = cls.ptr();
 
  cls = Class::New<FfiTrampolineData, RTN::FfiTrampolineData>(isolate_group);
  ffi_trampoline_data_class_ = cls.ptr();
 
  cls = Class::New<Field, RTN::Field>(isolate_group);
  field_class_ = cls.ptr();
 
  cls = Class::New<Script, RTN::Script>(isolate_group);
  script_class_ = cls.ptr();
 
  cls = Class::New<Library, RTN::Library>(isolate_group);
  library_class_ = cls.ptr();
 
  cls = Class::New<Namespace, RTN::Namespace>(isolate_group);
  namespace_class_ = cls.ptr();
 
  cls = Class::New<KernelProgramInfo, RTN::KernelProgramInfo>(isolate_group);
  kernel_program_info_class_ = cls.ptr();
 
  cls = Class::New<Code, RTN::Code>(isolate_group);
  code_class_ = cls.ptr();
 
  cls = Class::New<Instructions, RTN::Instructions>(isolate_group);
  instructions_class_ = cls.ptr();
 
  cls =
      Class::New<InstructionsSection, RTN::InstructionsSection>(isolate_group);
  instructions_section_class_ = cls.ptr();
 
  cls = Class::New<InstructionsTable, RTN::InstructionsTable>(isolate_group);
  instructions_table_class_ = cls.ptr();
 
  cls = Class::New<ObjectPool, RTN::ObjectPool>(isolate_group);
  object_pool_class_ = cls.ptr();
 
  cls = Class::New<PcDescriptors, RTN::PcDescriptors>(isolate_group);
  pc_descriptors_class_ = cls.ptr();
 
  cls = Class::New<CodeSourceMap, RTN::CodeSourceMap>(isolate_group);
  code_source_map_class_ = cls.ptr();
 
  cls =
      Class::New<CompressedStackMaps, RTN::CompressedStackMaps>(isolate_group);
  compressed_stackmaps_class_ = cls.ptr();
 
  cls =
      Class::New<LocalVarDescriptors, RTN::LocalVarDescriptors>(isolate_group);
  var_descriptors_class_ = cls.ptr();
 
  cls = Class::New<ExceptionHandlers, RTN::ExceptionHandlers>(isolate_group);
  exception_handlers_class_ = cls.ptr();
 
  cls = Class::New<Context, RTN::Context>(isolate_group);
  context_class_ = cls.ptr();
 
  cls = Class::New<ContextScope, RTN::ContextScope>(isolate_group);
  context_scope_class_ = cls.ptr();
 
  cls = Class::New<SingleTargetCache, RTN::SingleTargetCache>(isolate_group);
  singletargetcache_class_ = cls.ptr();
 
  cls = Class::New<UnlinkedCall, RTN::UnlinkedCall>(isolate_group);
  unlinkedcall_class_ = cls.ptr();
 
  cls = Class::New<MonomorphicSmiableCall, RTN::MonomorphicSmiableCall>(
      isolate_group);
  monomorphicsmiablecall_class_ = cls.ptr();
 
  cls = Class::New<ICData, RTN::ICData>(isolate_group);
  icdata_class_ = cls.ptr();
 
  cls = Class::New<MegamorphicCache, RTN::MegamorphicCache>(isolate_group);
  megamorphic_cache_class_ = cls.ptr();
 
  cls = Class::New<SubtypeTestCache, RTN::SubtypeTestCache>(isolate_group);
  subtypetestcache_class_ = cls.ptr();
 
  cls = Class::New<LoadingUnit, RTN::LoadingUnit>(isolate_group);
  loadingunit_class_ = cls.ptr();
 
  cls = Class::New<ApiError, RTN::ApiError>(isolate_group);
  api_error_class_ = cls.ptr();
 
  cls = Class::New<LanguageError, RTN::LanguageError>(isolate_group);
  language_error_class_ = cls.ptr();
 
  cls = Class::New<UnhandledException, RTN::UnhandledException>(isolate_group);
  unhandled_exception_class_ = cls.ptr();
 
  cls = Class::New<UnwindError, RTN::UnwindError>(isolate_group);
  unwind_error_class_ = cls.ptr();
 
  cls = Class::New<WeakSerializationReference, RTN::WeakSerializationReference>(
      isolate_group);
  weak_serialization_reference_class_ = cls.ptr();
 
  cls = Class::New<WeakArray, RTN::WeakArray>(isolate_group);
  weak_array_class_ = cls.ptr();
 
  ASSERT(class_class() != null_);
 
  // Pre-allocate classes in the vm isolate so that we can for example create a
  // symbol table and populate it with some frequently used strings as symbols.
  cls = Class::New<Array, RTN::Array>(isolate_group);
  isolate_group->object_store()->set_array_class(cls);
  cls.set_type_arguments_field_offset(Array::type_arguments_offset(),
                                      RTN::Array::type_arguments_offset());
  cls.set_num_type_arguments_unsafe(1);
  cls = Class::New<Array, RTN::Array>(kImmutableArrayCid, isolate_group);
  isolate_group->object_store()->set_immutable_array_class(cls);
  cls.set_type_arguments_field_offset(Array::type_arguments_offset(),
                                      RTN::Array::type_arguments_offset());
  cls.set_num_type_arguments_unsafe(1);
  // In order to be able to canonicalize arguments descriptors early.
  cls.set_is_prefinalized();
  cls =
      Class::New<GrowableObjectArray, RTN::GrowableObjectArray>(isolate_group);
  isolate_group->object_store()->set_growable_object_array_class(cls);
  cls.set_type_arguments_field_offset(
      GrowableObjectArray::type_arguments_offset(),
      RTN::GrowableObjectArray::type_arguments_offset());
  cls.set_num_type_arguments_unsafe(1);
  cls = Class::NewStringClass(kOneByteStringCid, isolate_group);
  isolate_group->object_store()->set_one_byte_string_class(cls);
  cls = Class::NewStringClass(kTwoByteStringCid, isolate_group);
  isolate_group->object_store()->set_two_byte_string_class(cls);
  cls = Class::New<Mint, RTN::Mint>(isolate_group);
  isolate_group->object_store()->set_mint_class(cls);
  cls = Class::New<Double, RTN::Double>(isolate_group);
  isolate_group->object_store()->set_double_class(cls);
  cls = Class::New<Float32x4, RTN::Float32x4>(isolate_group);
  isolate_group->object_store()->set_float32x4_class(cls);
  cls = Class::New<Float64x2, RTN::Float64x2>(isolate_group);
  isolate_group->object_store()->set_float64x2_class(cls);
  cls = Class::New<Int32x4, RTN::Int32x4>(isolate_group);
  isolate_group->object_store()->set_int32x4_class(cls);
 
  // Ensure that class kExternalTypedDataUint8ArrayCid is registered as we
  // need it when reading in the token stream of bootstrap classes in the VM
  // isolate.
  Class::NewExternalTypedDataClass(kExternalTypedDataUint8ArrayCid,
                                   isolate_group);
 
  // Needed for object pools of VM isolate stubs.
  Class::NewTypedDataClass(kTypedDataInt8ArrayCid, isolate_group);
 
  // Allocate and initialize the empty_array instance.
  {
    uword address = heap->Allocate(thread, Array::InstanceSize(0), Heap::kOld);
    InitializeObjectVariant<Array>(address, kImmutableArrayCid, 0);
    Array::initializeHandle(empty_array_,
                            static_cast<ArrayPtr>(address + kHeapObjectTag));
    empty_array_->untag()->set_length(Smi::New(0));
    empty_array_->SetCanonical();
  }
 
  Smi& smi = Smi::Handle();
  // Allocate and initialize the empty instantiations cache array instance,
  // which contains metadata as the first element and a sentinel value
  // at the start of the first entry.
  {
    const intptr_t array_size =
        TypeArguments::Cache::kHeaderSize + TypeArguments::Cache::kEntrySize;
    uword address =
        heap->Allocate(thread, Array::InstanceSize(array_size), Heap::kOld);
    InitializeObjectVariant<Array>(address, kImmutableArrayCid, array_size);
    Array::initializeHandle(empty_instantiations_cache_array_,
                            static_cast<ArrayPtr>(address + kHeapObjectTag));
    empty_instantiations_cache_array_->untag()->set_length(
        Smi::New(array_size));
    // The empty cache has no occupied entries and is not a hash-based cache.
    smi = Smi::New(0);
    empty_instantiations_cache_array_->SetAt(
        TypeArguments::Cache::kMetadataIndex, smi);
    // Make the first (and only) entry unoccupied by setting its first element
    // to the sentinel value.
    smi = TypeArguments::Cache::Sentinel();
    InstantiationsCacheTable table(*empty_instantiations_cache_array_);
    table.At(0).Set<TypeArguments::Cache::kSentinelIndex>(smi);
    // The other contents of the array are immaterial.
    empty_instantiations_cache_array_->SetCanonical();
  }
 
  // Allocate and initialize the empty subtype test cache array instance,
  // which contains a single unoccupied entry.
  {
    const intptr_t array_size = SubtypeTestCache::kTestEntryLength;
    uword address =
        heap->Allocate(thread, Array::InstanceSize(array_size), Heap::kOld);
    InitializeObjectVariant<Array>(address, kImmutableArrayCid, array_size);
    Array::initializeHandle(empty_subtype_test_cache_array_,
                            static_cast<ArrayPtr>(address + kHeapObjectTag));
    empty_subtype_test_cache_array_->untag()->set_length(Smi::New(array_size));
    // Make the first (and only) entry unoccupied by setting its first element
    // to the null value.
    empty_subtype_test_cache_array_->SetAt(
        SubtypeTestCache::kInstanceCidOrSignature, Object::null_object());
    smi = TypeArguments::Cache::Sentinel();
    SubtypeTestCacheTable table(*empty_subtype_test_cache_array_);
    table.At(0).Set<SubtypeTestCache::kInstanceCidOrSignature>(
        Object::null_object());
    // The other contents of the array are immaterial.
    empty_subtype_test_cache_array_->SetCanonical();
  }
 
  // Allocate and initialize the canonical empty context scope object.
  {
    uword address =
        heap->Allocate(thread, ContextScope::InstanceSize(0), Heap::kOld);
    InitializeObject<ContextScope>(address, 0);
    ContextScope::initializeHandle(
        empty_context_scope_,
        static_cast<ContextScopePtr>(address + kHeapObjectTag));
    empty_context_scope_->StoreNonPointer(
        &empty_context_scope_->untag()->num_variables_, 0);
    empty_context_scope_->StoreNonPointer(
        &empty_context_scope_->untag()->is_implicit_, true);
    empty_context_scope_->SetCanonical();
  }
 
  // Allocate and initialize the canonical empty object pool object.
  {
    uword address =
        heap->Allocate(thread, ObjectPool::InstanceSize(0), Heap::kOld);
    InitializeObject<ObjectPool>(address, 0);
    ObjectPool::initializeHandle(
        empty_object_pool_,
        static_cast<ObjectPoolPtr>(address + kHeapObjectTag));
    empty_object_pool_->StoreNonPointer(&empty_object_pool_->untag()->length_,
                                        0);
    empty_object_pool_->SetCanonical();
  }
 
  // Allocate and initialize the empty_compressed_stackmaps instance.
  {
    const intptr_t instance_size = CompressedStackMaps::InstanceSize(0);
    uword address = heap->Allocate(thread, instance_size, Heap::kOld);
    InitializeObject<CompressedStackMaps>(address, 0);
    CompressedStackMaps::initializeHandle(
        empty_compressed_stackmaps_,
        static_cast<CompressedStackMapsPtr>(address + kHeapObjectTag));
    empty_compressed_stackmaps_->untag()->payload()->set_flags_and_size(0);
    empty_compressed_stackmaps_->SetCanonical();
  }
 
  // Allocate and initialize the empty_descriptors instance.
  {
    uword address =
        heap->Allocate(thread, PcDescriptors::InstanceSize(0), Heap::kOld);
    InitializeObject<PcDescriptors>(address, 0);
    PcDescriptors::initializeHandle(
        empty_descriptors_,
        static_cast<PcDescriptorsPtr>(address + kHeapObjectTag));
    empty_descriptors_->StoreNonPointer(&empty_descriptors_->untag()->length_,
                                        0);
    empty_descriptors_->SetCanonical();
  }
 
  // Allocate and initialize the canonical empty variable descriptor object.
  {
    uword address = heap->Allocate(thread, LocalVarDescriptors::InstanceSize(0),
                                   Heap::kOld);
    InitializeObject<LocalVarDescriptors>(address, 0);
    LocalVarDescriptors::initializeHandle(
        empty_var_descriptors_,
        static_cast<LocalVarDescriptorsPtr>(address + kHeapObjectTag));
    empty_var_descriptors_->StoreNonPointer(
        &empty_var_descriptors_->untag()->num_entries_, 0);
    empty_var_descriptors_->SetCanonical();
  }
 
  // Allocate and initialize the canonical empty exception handler info object.
  // The vast majority of all functions do not contain an exception handler
  // and can share this canonical descriptor.
  {
    uword address =
        heap->Allocate(thread, ExceptionHandlers::InstanceSize(0), Heap::kOld);
    InitializeObject<ExceptionHandlers>(address, 0);
    ExceptionHandlers::initializeHandle(
        empty_exception_handlers_,
        static_cast<ExceptionHandlersPtr>(address + kHeapObjectTag));
    empty_exception_handlers_->StoreNonPointer(
        &empty_exception_handlers_->untag()->packed_fields_, 0);
    empty_exception_handlers_->SetCanonical();
  }
 
  // Empty exception handlers for async/async* functions.
  {
    uword address =
        heap->Allocate(thread, ExceptionHandlers::InstanceSize(0), Heap::kOld);
    InitializeObject<ExceptionHandlers>(address, 0);
    ExceptionHandlers::initializeHandle(
        empty_async_exception_handlers_,
        static_cast<ExceptionHandlersPtr>(address + kHeapObjectTag));
    empty_async_exception_handlers_->StoreNonPointer(
        &empty_async_exception_handlers_->untag()->packed_fields_,
        UntaggedExceptionHandlers::AsyncHandlerBit::update(true, 0));
    empty_async_exception_handlers_->SetCanonical();
  }
 
  // Allocate and initialize the canonical empty type arguments object.
  {
    uword address =
        heap->Allocate(thread, TypeArguments::InstanceSize(0), Heap::kOld);
    InitializeObject<TypeArguments>(address, 0);
    TypeArguments::initializeHandle(
        empty_type_arguments_,
        static_cast<TypeArgumentsPtr>(address + kHeapObjectTag));
    empty_type_arguments_->untag()->set_length(Smi::New(0));
    empty_type_arguments_->untag()->set_hash(Smi::New(0));
    empty_type_arguments_->ComputeHash();
    empty_type_arguments_->SetCanonical();
  }
 
  // The VM isolate snapshot object table is initialized to an empty array
  // as we do not have any VM isolate snapshot at this time.
  *vm_isolate_snapshot_object_table_ = Object::empty_array().ptr();
 
  cls = Class::New<Instance, RTN::Instance>(kDynamicCid, isolate_group);
  cls.set_is_abstract();
  cls.set_num_type_arguments_unsafe(0);
  cls.set_is_allocate_finalized();
  cls.set_is_declaration_loaded();
  cls.set_is_type_finalized();
  dynamic_class_ = cls.ptr();
 
  cls = Class::New<Instance, RTN::Instance>(kVoidCid, isolate_group);
  cls.set_num_type_arguments_unsafe(0);
  cls.set_is_allocate_finalized();
  cls.set_is_declaration_loaded();
  cls.set_is_type_finalized();
  void_class_ = cls.ptr();
 
  cls = Class::New<Type, RTN::Type>(isolate_group);
  cls.set_is_allocate_finalized();
  cls.set_is_declaration_loaded();
  cls.set_is_type_finalized();
 
  cls = Class::New<FunctionType, RTN::FunctionType>(isolate_group);
  cls.set_is_allocate_finalized();
  cls.set_is_declaration_loaded();
  cls.set_is_type_finalized();
 
  cls = Class::New<RecordType, RTN::RecordType>(isolate_group);
  cls.set_is_allocate_finalized();
  cls.set_is_declaration_loaded();
  cls.set_is_type_finalized();
 
  cls = dynamic_class_;
  *dynamic_type_ =
      Type::New(cls, Object::null_type_arguments(), Nullability::kNullable);
  dynamic_type_->SetIsFinalized();
  dynamic_type_->ComputeHash();
  dynamic_type_->SetCanonical();
 
  cls = void_class_;
  *void_type_ =
      Type::New(cls, Object::null_type_arguments(), Nullability::kNullable);
  void_type_->SetIsFinalized();
  void_type_->ComputeHash();
  void_type_->SetCanonical();
 
  // Since TypeArguments objects are passed as function arguments, make them
  // behave as Dart instances, although they are just VM objects.
  // Note that we cannot set the super type to ObjectType, which does not live
  // in the vm isolate. See special handling in Class::SuperClass().
  cls = type_arguments_class_;
  cls.set_interfaces(Object::empty_array());
  cls.SetFields(Object::empty_array());
  cls.SetFunctions(Object::empty_array());
 
  cls = Class::New<Bool, RTN::Bool>(isolate_group);
  isolate_group->object_store()->set_bool_class(cls);
 
  *smi_illegal_cid_ = Smi::New(kIllegalCid);
  *smi_zero_ = Smi::New(0);
 
  String& error_str = String::Handle();
  error_str = String::New(
      "Callbacks into the Dart VM are currently prohibited. Either there are "
      "outstanding pointers from Dart_TypedDataAcquireData that have not been "
      "released with Dart_TypedDataReleaseData, or a finalizer is running.",
      Heap::kOld);
  *no_callbacks_error_ = ApiError::New(error_str, Heap::kOld);
  error_str = String::New(
      "No api calls are allowed while unwind is in progress", Heap::kOld);
  *unwind_in_progress_error_ = UnwindError::New(error_str, Heap::kOld);
  error_str = String::New("SnapshotWriter Error", Heap::kOld);
  *snapshot_writer_error_ =
      LanguageError::New(error_str, Report::kError, Heap::kOld);
  error_str = String::New("Branch offset overflow", Heap::kOld);
  *branch_offset_error_ =
      LanguageError::New(error_str, Report::kBailout, Heap::kOld);
  error_str = String::New("Speculative inlining failed", Heap::kOld);
  *speculative_inlining_error_ =
      LanguageError::New(error_str, Report::kBailout, Heap::kOld);
  error_str = String::New("Background Compilation Failed", Heap::kOld);
  *background_compilation_error_ =
      LanguageError::New(error_str, Report::kBailout, Heap::kOld);
  error_str = String::New("Out of memory", Heap::kOld);
  *out_of_memory_error_ =
      LanguageError::New(error_str, Report::kError, Heap::kOld);
 
  // Allocate the parameter types and names for synthetic getters.
  *synthetic_getter_parameter_types_ = Array::New(1, Heap::kOld);
  synthetic_getter_parameter_types_->SetAt(0, Object::dynamic_type());
  *synthetic_getter_parameter_names_ = Array::New(1, Heap::kOld);
  // Fill in synthetic_getter_parameter_names_ later, after symbols are
  // initialized (in Object::FinalizeVMIsolate).
  // synthetic_getter_parameter_names_ object needs to be created earlier as
  // VM isolate snapshot reader references it before Object::FinalizeVMIsolate.
 
  // Some thread fields need to be reinitialized as null constants have not been
  // initialized until now.
  thread->ClearStickyError();
 
  ASSERT(!null_object_->IsSmi());
  ASSERT(!null_class_->IsSmi());
  ASSERT(null_class_->IsClass());
  ASSERT(!null_array_->IsSmi());
  ASSERT(null_array_->IsArray());
  ASSERT(!null_string_->IsSmi());
  ASSERT(null_string_->IsString());
  ASSERT(!null_instance_->IsSmi());
  ASSERT(null_instance_->IsInstance());
  ASSERT(!null_function_->IsSmi());
  ASSERT(null_function_->IsFunction());
  ASSERT(!null_function_type_->IsSmi());
  ASSERT(null_function_type_->IsFunctionType());
  ASSERT(!null_record_type_->IsSmi());
  ASSERT(null_record_type_->IsRecordType());
  ASSERT(!null_type_arguments_->IsSmi());
  ASSERT(null_type_arguments_->IsTypeArguments());
  ASSERT(!null_compressed_stackmaps_->IsSmi());
  ASSERT(null_compressed_stackmaps_->IsCompressedStackMaps());
  ASSERT(!empty_array_->IsSmi());
  ASSERT(empty_array_->IsArray());
  ASSERT(!empty_instantiations_cache_array_->IsSmi());
  ASSERT(empty_instantiations_cache_array_->IsArray());
  ASSERT(!empty_subtype_test_cache_array_->IsSmi());
  ASSERT(empty_subtype_test_cache_array_->IsArray());
  ASSERT(!empty_type_arguments_->IsSmi());
  ASSERT(empty_type_arguments_->IsTypeArguments());
  ASSERT(!empty_context_scope_->IsSmi());
  ASSERT(empty_context_scope_->IsContextScope());
  ASSERT(!empty_compressed_stackmaps_->IsSmi());
  ASSERT(empty_compressed_stackmaps_->IsCompressedStackMaps());
  ASSERT(!empty_descriptors_->IsSmi());
  ASSERT(empty_descriptors_->IsPcDescriptors());
  ASSERT(!empty_var_descriptors_->IsSmi());
  ASSERT(empty_var_descriptors_->IsLocalVarDescriptors());
  ASSERT(!empty_exception_handlers_->IsSmi());
  ASSERT(empty_exception_handlers_->IsExceptionHandlers());
  ASSERT(!empty_async_exception_handlers_->IsSmi());
  ASSERT(empty_async_exception_handlers_->IsExceptionHandlers());
  ASSERT(!sentinel_->IsSmi());
  ASSERT(sentinel_->IsSentinel());
  ASSERT(!transition_sentinel_->IsSmi());
  ASSERT(transition_sentinel_->IsSentinel());
  ASSERT(!unknown_constant_->IsSmi());
  ASSERT(unknown_constant_->IsSentinel());
  ASSERT(!non_constant_->IsSmi());
  ASSERT(non_constant_->IsSentinel());
  ASSERT(!optimized_out_->IsSmi());
  ASSERT(optimized_out_->IsSentinel());
  ASSERT(!bool_true_->IsSmi());
  ASSERT(bool_true_->IsBool());
  ASSERT(!bool_false_->IsSmi());
  ASSERT(bool_false_->IsBool());
  ASSERT(smi_illegal_cid_->IsSmi());
  ASSERT(smi_zero_->IsSmi());
  ASSERT(!no_callbacks_error_->IsSmi());
  ASSERT(no_callbacks_error_->IsApiError());
  ASSERT(!unwind_in_progress_error_->IsSmi());
  ASSERT(unwind_in_progress_error_->IsUnwindError());
  ASSERT(!snapshot_writer_error_->IsSmi());
  ASSERT(snapshot_writer_error_->IsLanguageError());
  ASSERT(!branch_offset_error_->IsSmi());
  ASSERT(branch_offset_error_->IsLanguageError());
  ASSERT(!speculative_inlining_error_->IsSmi());
  ASSERT(speculative_inlining_error_->IsLanguageError());
  ASSERT(!background_compilation_error_->IsSmi());
  ASSERT(background_compilation_error_->IsLanguageError());
  ASSERT(!out_of_memory_error_->IsSmi());
  ASSERT(out_of_memory_error_->IsLanguageError());
  ASSERT(!vm_isolate_snapshot_object_table_->IsSmi());
  ASSERT(vm_isolate_snapshot_object_table_->IsArray());
  ASSERT(!synthetic_getter_parameter_types_->IsSmi());
  ASSERT(synthetic_getter_parameter_types_->IsArray());
  ASSERT(!synthetic_getter_parameter_names_->IsSmi());
  ASSERT(synthetic_getter_parameter_names_->IsArray());
}

◆ Init() [2/2]

ErrorPtr dart::Object::Init	(	IsolateGroup *	isolate_group,
		const uint8_t *	kernel_buffer,
		intptr_t	kernel_buffer_size
	)

static

Definition at line 1721 of file object.cc.

                                                   {
  Thread* thread = Thread::Current();
  Zone* zone = thread->zone();
  ASSERT(isolate_group == thread->isolate_group());
  TIMELINE_DURATION(thread, Isolate, "Object::Init");
 
#if defined(DART_PRECOMPILED_RUNTIME)
  const bool bootstrapping = false;
#else
  const bool is_kernel = (kernel_buffer != nullptr);
  const bool bootstrapping =
      (Dart::vm_snapshot_kind() == Snapshot::kNone) || is_kernel;
#endif  // defined(DART_PRECOMPILED_RUNTIME).
 
  if (bootstrapping) {
#if !defined(DART_PRECOMPILED_RUNTIME)
    // Object::Init version when we are bootstrapping from source or from a
    // Kernel binary.
    // This will initialize isolate group object_store, shared by all isolates
    // running in the isolate group.
    ObjectStore* object_store = isolate_group->object_store();
    SafepointWriteRwLocker ml(thread, isolate_group->program_lock());
 
    Class& cls = Class::Handle(zone);
    Type& type = Type::Handle(zone);
    Array& array = Array::Handle(zone);
    WeakArray& weak_array = WeakArray::Handle(zone);
    Library& lib = Library::Handle(zone);
    TypeArguments& type_args = TypeArguments::Handle(zone);
 
    // All RawArray fields will be initialized to an empty array, therefore
    // initialize array class first.
    cls = Class::New<Array, RTN::Array>(isolate_group);
    ASSERT(object_store->array_class() == Class::null());
    object_store->set_array_class(cls);
 
    // VM classes that are parameterized (Array, ImmutableArray,
    // GrowableObjectArray, Map, ConstMap,
    // Set, ConstSet) are also pre-finalized, so
    // CalculateFieldOffsets() is not called, so we need to set the offset
    // of their type_arguments_ field, which is explicitly
    // declared in their respective Raw* classes.
    cls.set_type_arguments_field_offset(Array::type_arguments_offset(),
                                        RTN::Array::type_arguments_offset());
    cls.set_num_type_arguments_unsafe(1);
 
    // Set up the growable object array class (Has to be done after the array
    // class is setup as one of its field is an array object).
    cls = Class::New<GrowableObjectArray, RTN::GrowableObjectArray>(
        isolate_group);
    object_store->set_growable_object_array_class(cls);
    cls.set_type_arguments_field_offset(
        GrowableObjectArray::type_arguments_offset(),
        RTN::GrowableObjectArray::type_arguments_offset());
    cls.set_num_type_arguments_unsafe(1);
 
    // Initialize hash set for regexp_table_.
    const intptr_t kInitialCanonicalRegExpSize = 4;
    weak_array = HashTables::New<CanonicalRegExpSet>(
        kInitialCanonicalRegExpSize, Heap::kOld);
    object_store->set_regexp_table(weak_array);
 
    // Initialize hash set for canonical types.
    const intptr_t kInitialCanonicalTypeSize = 16;
    array = HashTables::New<CanonicalTypeSet>(kInitialCanonicalTypeSize,
                                              Heap::kOld);
    object_store->set_canonical_types(array);
 
    // Initialize hash set for canonical function types.
    const intptr_t kInitialCanonicalFunctionTypeSize = 16;
    array = HashTables::New<CanonicalFunctionTypeSet>(
        kInitialCanonicalFunctionTypeSize, Heap::kOld);
    object_store->set_canonical_function_types(array);
 
    // Initialize hash set for canonical record types.
    const intptr_t kInitialCanonicalRecordTypeSize = 16;
    array = HashTables::New<CanonicalRecordTypeSet>(
        kInitialCanonicalRecordTypeSize, Heap::kOld);
    object_store->set_canonical_record_types(array);
 
    // Initialize hash set for canonical type parameters.
    const intptr_t kInitialCanonicalTypeParameterSize = 4;
    array = HashTables::New<CanonicalTypeParameterSet>(
        kInitialCanonicalTypeParameterSize, Heap::kOld);
    object_store->set_canonical_type_parameters(array);
 
    // Initialize hash set for canonical_type_arguments_.
    const intptr_t kInitialCanonicalTypeArgumentsSize = 4;
    array = HashTables::New<CanonicalTypeArgumentsSet>(
        kInitialCanonicalTypeArgumentsSize, Heap::kOld);
    object_store->set_canonical_type_arguments(array);
 
    // Setup type class early in the process.
    const Class& type_cls =
        Class::Handle(zone, Class::New<Type, RTN::Type>(isolate_group));
    const Class& function_type_cls = Class::Handle(
        zone, Class::New<FunctionType, RTN::FunctionType>(isolate_group));
    const Class& record_type_cls = Class::Handle(
        zone, Class::New<RecordType, RTN::RecordType>(isolate_group));
    const Class& type_parameter_cls = Class::Handle(
        zone, Class::New<TypeParameter, RTN::TypeParameter>(isolate_group));
    const Class& library_prefix_cls = Class::Handle(
        zone, Class::New<LibraryPrefix, RTN::LibraryPrefix>(isolate_group));
 
    // Pre-allocate the OneByteString class needed by the symbol table.
    cls = Class::NewStringClass(kOneByteStringCid, isolate_group);
    object_store->set_one_byte_string_class(cls);
 
    // Pre-allocate the TwoByteString class needed by the symbol table.
    cls = Class::NewStringClass(kTwoByteStringCid, isolate_group);
    object_store->set_two_byte_string_class(cls);
 
    // Setup the symbol table for the symbols created in the isolate.
    Symbols::SetupSymbolTable(isolate_group);
 
    // Set up the libraries array before initializing the core library.
    const GrowableObjectArray& libraries =
        GrowableObjectArray::Handle(zone, GrowableObjectArray::New(Heap::kOld));
    object_store->set_libraries(libraries);
 
    // Pre-register the core library.
    Library::InitCoreLibrary(isolate_group);
 
    // Basic infrastructure has been setup, initialize the class dictionary.
    const Library& core_lib = Library::Handle(zone, Library::CoreLibrary());
    ASSERT(!core_lib.IsNull());
 
    const GrowableObjectArray& pending_classes =
        GrowableObjectArray::Handle(zone, GrowableObjectArray::New());
    object_store->set_pending_classes(pending_classes);
 
    // Now that the symbol table is initialized and that the core dictionary as
    // well as the core implementation dictionary have been setup, preallocate
    // remaining classes and register them by name in the dictionaries.
    String& name = String::Handle(zone);
    cls = object_store->array_class();  // Was allocated above.
    RegisterPrivateClass(cls, Symbols::_List(), core_lib);
    pending_classes.Add(cls);
    // We cannot use NewNonParameterizedType(), because Array is
    // parameterized.  Warning: class _List has not been patched yet. Its
    // declared number of type parameters is still 0. It will become 1 after
    // patching. The array type allocated below represents the raw type _List
    // and not _List<E> as we could expect. Use with caution.
    type = Type::New(Class::Handle(zone, cls.ptr()),
                     Object::null_type_arguments(), Nullability::kNonNullable);
    type.SetIsFinalized();
    type ^= type.Canonicalize(thread);
    object_store->set_array_type(type);
 
    cls = object_store->growable_object_array_class();  // Was allocated above.
    RegisterPrivateClass(cls, Symbols::_GrowableList(), core_lib);
    pending_classes.Add(cls);
 
    cls = Class::New<Array, RTN::Array>(kImmutableArrayCid, isolate_group);
    object_store->set_immutable_array_class(cls);
    cls.set_type_arguments_field_offset(Array::type_arguments_offset(),
                                        RTN::Array::type_arguments_offset());
    cls.set_num_type_arguments_unsafe(1);
    ASSERT(object_store->immutable_array_class() !=
           object_store->array_class());
    cls.set_is_prefinalized();
    RegisterPrivateClass(cls, Symbols::_ImmutableList(), core_lib);
    pending_classes.Add(cls);
 
    cls = object_store->one_byte_string_class();  // Was allocated above.
    RegisterPrivateClass(cls, Symbols::OneByteString(), core_lib);
    pending_classes.Add(cls);
 
    cls = object_store->two_byte_string_class();  // Was allocated above.
    RegisterPrivateClass(cls, Symbols::TwoByteString(), core_lib);
    pending_classes.Add(cls);
 
    // Pre-register the isolate library so the native class implementations can
    // be hooked up before compiling it.
    Library& isolate_lib = Library::Handle(
        zone, Library::LookupLibrary(thread, Symbols::DartIsolate()));
    if (isolate_lib.IsNull()) {
      isolate_lib = Library::NewLibraryHelper(Symbols::DartIsolate(), true);
      isolate_lib.SetLoadRequested();
      isolate_lib.Register(thread);
    }
    object_store->set_bootstrap_library(ObjectStore::kIsolate, isolate_lib);
    ASSERT(!isolate_lib.IsNull());
    ASSERT(isolate_lib.ptr() == Library::IsolateLibrary());
 
    cls = Class::New<Capability, RTN::Capability>(isolate_group);
    RegisterPrivateClass(cls, Symbols::_Capability(), isolate_lib);
    pending_classes.Add(cls);
 
    cls = Class::New<ReceivePort, RTN::ReceivePort>(isolate_group);
    RegisterPrivateClass(cls, Symbols::_RawReceivePort(), isolate_lib);
    pending_classes.Add(cls);
 
    cls = Class::New<SendPort, RTN::SendPort>(isolate_group);
    RegisterPrivateClass(cls, Symbols::_SendPort(), isolate_lib);
    pending_classes.Add(cls);
 
    cls = Class::New<TransferableTypedData, RTN::TransferableTypedData>(
        isolate_group);
    RegisterPrivateClass(cls, Symbols::_TransferableTypedDataImpl(),
                         isolate_lib);
    pending_classes.Add(cls);
 
    const Class& stacktrace_cls = Class::Handle(
        zone, Class::New<StackTrace, RTN::StackTrace>(isolate_group));
    RegisterPrivateClass(stacktrace_cls, Symbols::_StackTrace(), core_lib);
    pending_classes.Add(stacktrace_cls);
    // Super type set below, after Object is allocated.
 
    cls = Class::New<RegExp, RTN::RegExp>(isolate_group);
    RegisterPrivateClass(cls, Symbols::_RegExp(), core_lib);
    pending_classes.Add(cls);
 
    // Initialize the base interfaces used by the core VM classes.
 
    // Allocate and initialize the pre-allocated classes in the core library.
    // The script and token index of these pre-allocated classes is set up when
    // the corelib script is compiled.
    cls = Class::New<Instance, RTN::Instance>(kInstanceCid, isolate_group);
    object_store->set_object_class(cls);
    cls.set_name(Symbols::Object());
    cls.set_num_type_arguments_unsafe(0);
    cls.set_is_prefinalized();
    cls.set_is_const();
    core_lib.AddClass(cls);
    pending_classes.Add(cls);
    type = Type::NewNonParameterizedType(cls);
    ASSERT(type.IsCanonical());
    object_store->set_object_type(type);
    type = type.ToNullability(Nullability::kLegacy, Heap::kOld);
    ASSERT(type.IsCanonical());
    object_store->set_legacy_object_type(type);
    type = type.ToNullability(Nullability::kNonNullable, Heap::kOld);
    ASSERT(type.IsCanonical());
    object_store->set_non_nullable_object_type(type);
    type = type.ToNullability(Nullability::kNullable, Heap::kOld);
    ASSERT(type.IsCanonical());
    object_store->set_nullable_object_type(type);
 
    cls = Class::New<Bool, RTN::Bool>(isolate_group);
    object_store->set_bool_class(cls);
    RegisterClass(cls, Symbols::Bool(), core_lib);
    pending_classes.Add(cls);
 
    cls = Class::New<Instance, RTN::Instance>(kNullCid, isolate_group);
    object_store->set_null_class(cls);
    cls.set_num_type_arguments_unsafe(0);
    cls.set_is_prefinalized();
    RegisterClass(cls, Symbols::Null(), core_lib);
    pending_classes.Add(cls);
 
    cls = Class::New<Instance, RTN::Instance>(kNeverCid, isolate_group);
    cls.set_num_type_arguments_unsafe(0);
    cls.set_is_allocate_finalized();
    cls.set_is_declaration_loaded();
    cls.set_is_type_finalized();
    cls.set_name(Symbols::Never());
    object_store->set_never_class(cls);
 
    ASSERT(!library_prefix_cls.IsNull());
    RegisterPrivateClass(library_prefix_cls, Symbols::_LibraryPrefix(),
                         core_lib);
    pending_classes.Add(library_prefix_cls);
 
    RegisterPrivateClass(type_cls, Symbols::_Type(), core_lib);
    pending_classes.Add(type_cls);
 
    RegisterPrivateClass(function_type_cls, Symbols::_FunctionType(), core_lib);
    pending_classes.Add(function_type_cls);
 
    RegisterPrivateClass(record_type_cls, Symbols::_RecordType(), core_lib);
    pending_classes.Add(record_type_cls);
 
    RegisterPrivateClass(type_parameter_cls, Symbols::_TypeParameter(),
                         core_lib);
    pending_classes.Add(type_parameter_cls);
 
    cls = Class::New<Integer, RTN::Integer>(isolate_group);
    object_store->set_integer_implementation_class(cls);
    RegisterPrivateClass(cls, Symbols::_IntegerImplementation(), core_lib);
    pending_classes.Add(cls);
 
    cls = Class::New<Smi, RTN::Smi>(isolate_group);
    object_store->set_smi_class(cls);
    RegisterPrivateClass(cls, Symbols::_Smi(), core_lib);
    pending_classes.Add(cls);
 
    cls = Class::New<Mint, RTN::Mint>(isolate_group);
    object_store->set_mint_class(cls);
    RegisterPrivateClass(cls, Symbols::_Mint(), core_lib);
    pending_classes.Add(cls);
 
    cls = Class::New<Double, RTN::Double>(isolate_group);
    object_store->set_double_class(cls);
    RegisterPrivateClass(cls, Symbols::_Double(), core_lib);
    pending_classes.Add(cls);
 
    // Class that represents the Dart class _Closure and C++ class Closure.
    cls = Class::New<Closure, RTN::Closure>(isolate_group);
    object_store->set_closure_class(cls);
    RegisterPrivateClass(cls, Symbols::_Closure(), core_lib);
    pending_classes.Add(cls);
 
    cls = Class::New<Record, RTN::Record>(isolate_group);
    RegisterPrivateClass(cls, Symbols::_Record(), core_lib);
    pending_classes.Add(cls);
 
    cls = Class::New<WeakProperty, RTN::WeakProperty>(isolate_group);
    object_store->set_weak_property_class(cls);
    RegisterPrivateClass(cls, Symbols::_WeakProperty(), core_lib);
 
    cls = Class::New<WeakReference, RTN::WeakReference>(isolate_group);
    cls.set_type_arguments_field_offset(
        WeakReference::type_arguments_offset(),
        RTN::WeakReference::type_arguments_offset());
    cls.set_num_type_arguments_unsafe(1);
    object_store->set_weak_reference_class(cls);
    RegisterPrivateClass(cls, Symbols::_WeakReference(), core_lib);
 
    // Pre-register the mirrors library so we can place the vm class
    // MirrorReference there rather than the core library.
    lib = Library::LookupLibrary(thread, Symbols::DartMirrors());
    if (lib.IsNull()) {
      lib = Library::NewLibraryHelper(Symbols::DartMirrors(), true);
      lib.SetLoadRequested();
      lib.Register(thread);
    }
    object_store->set_bootstrap_library(ObjectStore::kMirrors, lib);
    ASSERT(!lib.IsNull());
    ASSERT(lib.ptr() == Library::MirrorsLibrary());
 
    cls = Class::New<MirrorReference, RTN::MirrorReference>(isolate_group);
    RegisterPrivateClass(cls, Symbols::_MirrorReference(), lib);
 
    // Pre-register the collection library so we can place the vm class
    // Map there rather than the core library.
    lib = Library::LookupLibrary(thread, Symbols::DartCollection());
    if (lib.IsNull()) {
      lib = Library::NewLibraryHelper(Symbols::DartCollection(), true);
      lib.SetLoadRequested();
      lib.Register(thread);
    }
 
    object_store->set_bootstrap_library(ObjectStore::kCollection, lib);
    ASSERT(!lib.IsNull());
    ASSERT(lib.ptr() == Library::CollectionLibrary());
    cls = Class::New<Map, RTN::Map>(isolate_group);
    object_store->set_map_impl_class(cls);
    cls.set_type_arguments_field_offset(Map::type_arguments_offset(),
                                        RTN::Map::type_arguments_offset());
    cls.set_num_type_arguments_unsafe(2);
    RegisterPrivateClass(cls, Symbols::_Map(), lib);
    pending_classes.Add(cls);
 
    cls = Class::New<Map, RTN::Map>(kConstMapCid, isolate_group);
    object_store->set_const_map_impl_class(cls);
    cls.set_type_arguments_field_offset(Map::type_arguments_offset(),
                                        RTN::Map::type_arguments_offset());
    cls.set_num_type_arguments_unsafe(2);
    cls.set_is_prefinalized();
    RegisterPrivateClass(cls, Symbols::_ConstMap(), lib);
    pending_classes.Add(cls);
 
    cls = Class::New<Set, RTN::Set>(isolate_group);
    object_store->set_set_impl_class(cls);
    cls.set_type_arguments_field_offset(Set::type_arguments_offset(),
                                        RTN::Set::type_arguments_offset());
    cls.set_num_type_arguments_unsafe(1);
    RegisterPrivateClass(cls, Symbols::_Set(), lib);
    pending_classes.Add(cls);
 
    cls = Class::New<Set, RTN::Set>(kConstSetCid, isolate_group);
    object_store->set_const_set_impl_class(cls);
    cls.set_type_arguments_field_offset(Set::type_arguments_offset(),
                                        RTN::Set::type_arguments_offset());
    cls.set_num_type_arguments_unsafe(1);
    cls.set_is_prefinalized();
    RegisterPrivateClass(cls, Symbols::_ConstSet(), lib);
    pending_classes.Add(cls);
 
    // Pre-register the async library so we can place the vm class
    // FutureOr there rather than the core library.
    lib = Library::LookupLibrary(thread, Symbols::DartAsync());
    if (lib.IsNull()) {
      lib = Library::NewLibraryHelper(Symbols::DartAsync(), true);
      lib.SetLoadRequested();
      lib.Register(thread);
    }
    object_store->set_bootstrap_library(ObjectStore::kAsync, lib);
    ASSERT(!lib.IsNull());
    ASSERT(lib.ptr() == Library::AsyncLibrary());
    cls = Class::New<FutureOr, RTN::FutureOr>(isolate_group);
    cls.set_type_arguments_field_offset(FutureOr::type_arguments_offset(),
                                        RTN::FutureOr::type_arguments_offset());
    cls.set_num_type_arguments_unsafe(1);
    RegisterClass(cls, Symbols::FutureOr(), lib);
    pending_classes.Add(cls);
    object_store->set_future_or_class(cls);
 
    cls = Class::New<SuspendState, RTN::SuspendState>(isolate_group);
    RegisterPrivateClass(cls, Symbols::_SuspendState(), lib);
    pending_classes.Add(cls);
 
    // Pre-register the developer library so we can place the vm class
    // UserTag there rather than the core library.
    lib = Library::LookupLibrary(thread, Symbols::DartDeveloper());
    if (lib.IsNull()) {
      lib = Library::NewLibraryHelper(Symbols::DartDeveloper(), true);
      lib.SetLoadRequested();
      lib.Register(thread);
    }
    object_store->set_bootstrap_library(ObjectStore::kDeveloper, lib);
    ASSERT(!lib.IsNull());
    ASSERT(lib.ptr() == Library::DeveloperLibrary());
    cls = Class::New<UserTag, RTN::UserTag>(isolate_group);
    RegisterPrivateClass(cls, Symbols::_UserTag(), lib);
    pending_classes.Add(cls);
 
    // Setup some default native field classes which can be extended for
    // specifying native fields in dart classes.
    Library::InitNativeWrappersLibrary(isolate_group, is_kernel);
    ASSERT(object_store->native_wrappers_library() != Library::null());
 
    // Pre-register the typed_data library so the native class implementations
    // can be hooked up before compiling it.
    lib = Library::LookupLibrary(thread, Symbols::DartTypedData());
    if (lib.IsNull()) {
      lib = Library::NewLibraryHelper(Symbols::DartTypedData(), true);
      lib.SetLoadRequested();
      lib.Register(thread);
    }
    object_store->set_bootstrap_library(ObjectStore::kTypedData, lib);
    ASSERT(!lib.IsNull());
    ASSERT(lib.ptr() == Library::TypedDataLibrary());
#define REGISTER_TYPED_DATA_CLASS(clazz)                                       \
  cls = Class::NewTypedDataClass(kTypedData##clazz##ArrayCid, isolate_group);  \
  RegisterPrivateClass(cls, Symbols::_##clazz##List(), lib);
 
    DART_CLASS_LIST_TYPED_DATA(REGISTER_TYPED_DATA_CLASS);
#undef REGISTER_TYPED_DATA_CLASS
#define REGISTER_TYPED_DATA_VIEW_CLASS(clazz)                                  \
  cls =                                                                        \
      Class::NewTypedDataViewClass(kTypedData##clazz##ViewCid, isolate_group); \
  RegisterPrivateClass(cls, Symbols::_##clazz##View(), lib);                   \
  pending_classes.Add(cls);                                                    \
  cls = Class::NewUnmodifiableTypedDataViewClass(                              \
      kUnmodifiableTypedData##clazz##ViewCid, isolate_group);                  \
  RegisterPrivateClass(cls, Symbols::_Unmodifiable##clazz##View(), lib);       \
  pending_classes.Add(cls);
 
    CLASS_LIST_TYPED_DATA(REGISTER_TYPED_DATA_VIEW_CLASS);
 
    cls = Class::NewTypedDataViewClass(kByteDataViewCid, isolate_group);
    RegisterPrivateClass(cls, Symbols::_ByteDataView(), lib);
    pending_classes.Add(cls);
    cls = Class::NewUnmodifiableTypedDataViewClass(kUnmodifiableByteDataViewCid,
                                                   isolate_group);
    RegisterPrivateClass(cls, Symbols::_UnmodifiableByteDataView(), lib);
    pending_classes.Add(cls);
 
#undef REGISTER_TYPED_DATA_VIEW_CLASS
#define REGISTER_EXT_TYPED_DATA_CLASS(clazz)                                   \
  cls = Class::NewExternalTypedDataClass(kExternalTypedData##clazz##Cid,       \
                                         isolate_group);                       \
  RegisterPrivateClass(cls, Symbols::_External##clazz(), lib);
 
    cls = Class::New<Instance, RTN::Instance>(kByteBufferCid, isolate_group,
                                              /*register_class=*/false);
    cls.set_instance_size(0, 0);
    cls.set_next_field_offset(-kWordSize, -compiler::target::kWordSize);
    isolate_group->class_table()->Register(cls);
    RegisterPrivateClass(cls, Symbols::_ByteBuffer(), lib);
    pending_classes.Add(cls);
 
    CLASS_LIST_TYPED_DATA(REGISTER_EXT_TYPED_DATA_CLASS);
#undef REGISTER_EXT_TYPED_DATA_CLASS
    // Register Float32x4, Int32x4, and Float64x2 in the object store.
    cls = Class::New<Float32x4, RTN::Float32x4>(isolate_group);
    RegisterPrivateClass(cls, Symbols::_Float32x4(), lib);
    pending_classes.Add(cls);
    object_store->set_float32x4_class(cls);
 
    cls = Class::New<Instance, RTN::Instance>(kIllegalCid, isolate_group,
                                              /*register_class=*/true,
                                              /*is_abstract=*/true);
    RegisterClass(cls, Symbols::Float32x4(), lib);
    cls.set_num_type_arguments_unsafe(0);
    cls.set_is_prefinalized();
    type = Type::NewNonParameterizedType(cls);
    object_store->set_float32x4_type(type);
 
    cls = Class::New<Int32x4, RTN::Int32x4>(isolate_group);
    RegisterPrivateClass(cls, Symbols::_Int32x4(), lib);
    pending_classes.Add(cls);
    object_store->set_int32x4_class(cls);
 
    cls = Class::New<Instance, RTN::Instance>(kIllegalCid, isolate_group,
                                              /*register_class=*/true,
                                              /*is_abstract=*/true);
    RegisterClass(cls, Symbols::Int32x4(), lib);
    cls.set_num_type_arguments_unsafe(0);
    cls.set_is_prefinalized();
    type = Type::NewNonParameterizedType(cls);
    object_store->set_int32x4_type(type);
 
    cls = Class::New<Float64x2, RTN::Float64x2>(isolate_group);
    RegisterPrivateClass(cls, Symbols::_Float64x2(), lib);
    pending_classes.Add(cls);
    object_store->set_float64x2_class(cls);
 
    cls = Class::New<Instance, RTN::Instance>(kIllegalCid, isolate_group,
                                              /*register_class=*/true,
                                              /*is_abstract=*/true);
    RegisterClass(cls, Symbols::Float64x2(), lib);
    cls.set_num_type_arguments_unsafe(0);
    cls.set_is_prefinalized();
    type = Type::NewNonParameterizedType(cls);
    object_store->set_float64x2_type(type);
 
    // Set the super type of class StackTrace to Object type so that the
    // 'toString' method is implemented.
    type = object_store->object_type();
    stacktrace_cls.set_super_type(type);
 
    // Abstract class that represents the Dart class Type.
    // Note that this class is implemented by Dart class _AbstractType.
    cls = Class::New<Instance, RTN::Instance>(kIllegalCid, isolate_group,
                                              /*register_class=*/true,
                                              /*is_abstract=*/true);
    cls.set_num_type_arguments_unsafe(0);
    cls.set_is_prefinalized();
    RegisterClass(cls, Symbols::Type(), core_lib);
    pending_classes.Add(cls);
    type = Type::NewNonParameterizedType(cls);
    object_store->set_type_type(type);
 
    // Abstract class that represents the Dart class Function.
    cls = Class::New<Instance, RTN::Instance>(kIllegalCid, isolate_group,
                                              /*register_class=*/true,
                                              /*is_abstract=*/true);
    cls.set_num_type_arguments_unsafe(0);
    cls.set_is_prefinalized();
    RegisterClass(cls, Symbols::Function(), core_lib);
    pending_classes.Add(cls);
    type = Type::NewNonParameterizedType(cls);
    object_store->set_function_type(type);
 
    // Abstract class that represents the Dart class Record.
    cls = Class::New<Instance, RTN::Instance>(kIllegalCid, isolate_group,
                                              /*register_class=*/true,
                                              /*is_abstract=*/true);
    RegisterClass(cls, Symbols::Record(), core_lib);
    pending_classes.Add(cls);
    object_store->set_record_class(cls);
 
    cls = Class::New<Number, RTN::Number>(isolate_group);
    RegisterClass(cls, Symbols::Number(), core_lib);
    pending_classes.Add(cls);
    type = Type::NewNonParameterizedType(cls);
    object_store->set_number_type(type);
    type = type.ToNullability(Nullability::kNullable, Heap::kOld);
    object_store->set_nullable_number_type(type);
 
    cls = Class::New<Instance, RTN::Instance>(kIllegalCid, isolate_group,
                                              /*register_class=*/true,
                                              /*is_abstract=*/true);
    RegisterClass(cls, Symbols::Int(), core_lib);
    cls.set_num_type_arguments_unsafe(0);
    cls.set_is_prefinalized();
    pending_classes.Add(cls);
    type = Type::NewNonParameterizedType(cls);
    object_store->set_int_type(type);
    type = type.ToNullability(Nullability::kLegacy, Heap::kOld);
    object_store->set_legacy_int_type(type);
    type = type.ToNullability(Nullability::kNonNullable, Heap::kOld);
    object_store->set_non_nullable_int_type(type);
    type = type.ToNullability(Nullability::kNullable, Heap::kOld);
    object_store->set_nullable_int_type(type);
 
    cls = Class::New<Instance, RTN::Instance>(kIllegalCid, isolate_group,
                                              /*register_class=*/true,
                                              /*is_abstract=*/true);
    RegisterClass(cls, Symbols::Double(), core_lib);
    cls.set_num_type_arguments_unsafe(0);
    cls.set_is_prefinalized();
    pending_classes.Add(cls);
    type = Type::NewNonParameterizedType(cls);
    object_store->set_double_type(type);
    type = type.ToNullability(Nullability::kNullable, Heap::kOld);
    object_store->set_nullable_double_type(type);
 
    name = Symbols::_String().ptr();
    cls = Class::New<Instance, RTN::Instance>(kIllegalCid, isolate_group,
                                              /*register_class=*/true,
                                              /*is_abstract=*/true);
    RegisterClass(cls, name, core_lib);
    cls.set_num_type_arguments_unsafe(0);
    cls.set_is_prefinalized();
    pending_classes.Add(cls);
    type = Type::NewNonParameterizedType(cls);
    object_store->set_string_type(type);
    type = type.ToNullability(Nullability::kLegacy, Heap::kOld);
    object_store->set_legacy_string_type(type);
 
    cls = object_store->bool_class();
    type = Type::NewNonParameterizedType(cls);
    object_store->set_bool_type(type);
 
    cls = object_store->smi_class();
    type = Type::NewNonParameterizedType(cls);
    object_store->set_smi_type(type);
    type = type.ToNullability(Nullability::kLegacy, Heap::kOld);
 
    cls = object_store->mint_class();
    type = Type::NewNonParameterizedType(cls);
    object_store->set_mint_type(type);
 
    // The classes 'void' and 'dynamic' are phony classes to make type checking
    // more regular; they live in the VM isolate. The class 'void' is not
    // registered in the class dictionary because its name is a reserved word.
    // The class 'dynamic' is registered in the class dictionary because its
    // name is a built-in identifier (this is wrong).  The corresponding types
    // are stored in the object store.
    cls = object_store->null_class();
    type =
        Type::New(cls, Object::null_type_arguments(), Nullability::kNullable);
    type.SetIsFinalized();
    type ^= type.Canonicalize(thread);
    object_store->set_null_type(type);
    cls.set_declaration_type(type);
    ASSERT(type.IsNullable());
 
    // Consider removing when/if Null becomes an ordinary class.
    type = object_store->object_type();
    cls.set_super_type(type);
 
    cls = object_store->never_class();
    type = Type::New(cls, Object::null_type_arguments(),
                     Nullability::kNonNullable);
    type.SetIsFinalized();
    type ^= type.Canonicalize(thread);
    object_store->set_never_type(type);
    type_args = TypeArguments::New(1);
    type_args.SetTypeAt(0, type);
    type_args = type_args.Canonicalize(thread);
    object_store->set_type_argument_never(type_args);
 
    // Create and cache commonly used type arguments <int>, <double>,
    // <String>, <String, dynamic> and <String, String>.
    type_args = TypeArguments::New(1);
    type = object_store->int_type();
    type_args.SetTypeAt(0, type);
    type_args = type_args.Canonicalize(thread);
    object_store->set_type_argument_int(type_args);
    type_args = TypeArguments::New(1);
    type = object_store->legacy_int_type();
    type_args.SetTypeAt(0, type);
    type_args = type_args.Canonicalize(thread);
    object_store->set_type_argument_legacy_int(type_args);
 
    type_args = TypeArguments::New(1);
    type = object_store->double_type();
    type_args.SetTypeAt(0, type);
    type_args = type_args.Canonicalize(thread);
    object_store->set_type_argument_double(type_args);
 
    type_args = TypeArguments::New(1);
    type = object_store->string_type();
    type_args.SetTypeAt(0, type);
    type_args = type_args.Canonicalize(thread);
    object_store->set_type_argument_string(type_args);
    type_args = TypeArguments::New(1);
    type = object_store->legacy_string_type();
    type_args.SetTypeAt(0, type);
    type_args = type_args.Canonicalize(thread);
    object_store->set_type_argument_legacy_string(type_args);
 
    type_args = TypeArguments::New(2);
    type = object_store->string_type();
    type_args.SetTypeAt(0, type);
    type_args.SetTypeAt(1, Object::dynamic_type());
    type_args = type_args.Canonicalize(thread);
    object_store->set_type_argument_string_dynamic(type_args);
 
    type_args = TypeArguments::New(2);
    type = object_store->string_type();
    type_args.SetTypeAt(0, type);
    type_args.SetTypeAt(1, type);
    type_args = type_args.Canonicalize(thread);
    object_store->set_type_argument_string_string(type_args);
 
    lib = Library::LookupLibrary(thread, Symbols::DartFfi());
    if (lib.IsNull()) {
      lib = Library::NewLibraryHelper(Symbols::DartFfi(), true);
      lib.SetLoadRequested();
      lib.Register(thread);
    }
    object_store->set_bootstrap_library(ObjectStore::kFfi, lib);
 
    cls = Class::New<Instance, RTN::Instance>(kFfiNativeTypeCid, isolate_group);
    cls.set_num_type_arguments_unsafe(0);
    cls.set_is_prefinalized();
    pending_classes.Add(cls);
    object_store->set_ffi_native_type_class(cls);
    RegisterClass(cls, Symbols::FfiNativeType(), lib);
 
#define REGISTER_FFI_TYPE_MARKER(clazz)                                        \
  cls = Class::New<Instance, RTN::Instance>(kFfi##clazz##Cid, isolate_group);  \
  cls.set_num_type_arguments_unsafe(0);                                        \
  cls.set_is_prefinalized();                                                   \
  pending_classes.Add(cls);                                                    \
  RegisterClass(cls, Symbols::Ffi##clazz(), lib);
    CLASS_LIST_FFI_TYPE_MARKER(REGISTER_FFI_TYPE_MARKER);
#undef REGISTER_FFI_TYPE_MARKER
 
    cls = Class::New<Instance, RTN::Instance>(kFfiNativeFunctionCid,
                                              isolate_group);
    cls.set_type_arguments_field_offset(Instance::NextFieldOffset(),
                                        RTN::Instance::NextFieldOffset());
    cls.set_num_type_arguments_unsafe(1);
    cls.set_is_prefinalized();
    pending_classes.Add(cls);
    RegisterClass(cls, Symbols::FfiNativeFunction(), lib);
 
    cls = Class::NewPointerClass(kPointerCid, isolate_group);
    object_store->set_ffi_pointer_class(cls);
    pending_classes.Add(cls);
    RegisterClass(cls, Symbols::FfiPointer(), lib);
 
    cls = Class::New<DynamicLibrary, RTN::DynamicLibrary>(kDynamicLibraryCid,
                                                          isolate_group);
    cls.set_instance_size(DynamicLibrary::InstanceSize(),
                          compiler::target::RoundedAllocationSize(
                              RTN::DynamicLibrary::InstanceSize()));
    cls.set_is_prefinalized();
    pending_classes.Add(cls);
    RegisterClass(cls, Symbols::FfiDynamicLibrary(), lib);
 
    cls = Class::New<NativeFinalizer, RTN::NativeFinalizer>(isolate_group);
    object_store->set_native_finalizer_class(cls);
    RegisterPrivateClass(cls, Symbols::_NativeFinalizer(), lib);
 
    cls = Class::New<Finalizer, RTN::Finalizer>(isolate_group);
    cls.set_type_arguments_field_offset(
        Finalizer::type_arguments_offset(),
        RTN::Finalizer::type_arguments_offset());
    cls.set_num_type_arguments_unsafe(1);
    object_store->set_finalizer_class(cls);
    pending_classes.Add(cls);
    RegisterPrivateClass(cls, Symbols::_FinalizerImpl(), core_lib);
 
    // Pre-register the internal library so we can place the vm class
    // FinalizerEntry there rather than the core library.
    lib = Library::LookupLibrary(thread, Symbols::DartInternal());
    if (lib.IsNull()) {
      lib = Library::NewLibraryHelper(Symbols::DartInternal(), true);
      lib.SetLoadRequested();
      lib.Register(thread);
    }
    object_store->set_bootstrap_library(ObjectStore::kInternal, lib);
    ASSERT(!lib.IsNull());
    ASSERT(lib.ptr() == Library::InternalLibrary());
 
    cls = Class::New<FinalizerEntry, RTN::FinalizerEntry>(isolate_group);
    object_store->set_finalizer_entry_class(cls);
    pending_classes.Add(cls);
    RegisterClass(cls, Symbols::FinalizerEntry(), lib);
 
    // Finish the initialization by compiling the bootstrap scripts containing
    // the base interfaces and the implementation of the internal classes.
    const Error& error = Error::Handle(
        zone, Bootstrap::DoBootstrapping(kernel_buffer, kernel_buffer_size));
    if (!error.IsNull()) {
      return error.ptr();
    }
 
    isolate_group->class_table()->CopySizesFromClassObjects();
 
    ClassFinalizer::VerifyBootstrapClasses();
 
    // Set up the intrinsic state of all functions (core, math and typed data).
    compiler::Intrinsifier::InitializeState();
 
    // Adds static const fields (class ids) to the class 'ClassID');
    lib = Library::LookupLibrary(thread, Symbols::DartInternal());
    ASSERT(!lib.IsNull());
    cls = lib.LookupClassAllowPrivate(Symbols::ClassID());
    ASSERT(!cls.IsNull());
    const bool injected = cls.InjectCIDFields();
    ASSERT(injected);
 
    // Set up recognized state of all functions (core, math and typed data).
    MethodRecognizer::InitializeState();
#endif  // !defined(DART_PRECOMPILED_RUNTIME)
  } else {
    // Object::Init version when we are running in a version of dart that has a
    // full snapshot linked in and an isolate is initialized using the full
    // snapshot.
    ObjectStore* object_store = isolate_group->object_store();
    SafepointWriteRwLocker ml(thread, isolate_group->program_lock());
 
    Class& cls = Class::Handle(zone);
 
    // Set up empty classes in the object store, these will get initialized
    // correctly when we read from the snapshot.  This is done to allow
    // bootstrapping of reading classes from the snapshot.  Some classes are not
    // stored in the object store. Yet we still need to create their Class
    // object so that they get put into the class_table (as a side effect of
    // Class::New()).
    cls = Class::New<Instance, RTN::Instance>(kInstanceCid, isolate_group);
    object_store->set_object_class(cls);
 
    cls = Class::New<LibraryPrefix, RTN::LibraryPrefix>(isolate_group);
    cls = Class::New<Type, RTN::Type>(isolate_group);
    cls = Class::New<FunctionType, RTN::FunctionType>(isolate_group);
    cls = Class::New<RecordType, RTN::RecordType>(isolate_group);
    cls = Class::New<TypeParameter, RTN::TypeParameter>(isolate_group);
 
    cls = Class::New<Array, RTN::Array>(isolate_group);
    object_store->set_array_class(cls);
 
    cls = Class::New<Array, RTN::Array>(kImmutableArrayCid, isolate_group);
    object_store->set_immutable_array_class(cls);
 
    cls = Class::New<GrowableObjectArray, RTN::GrowableObjectArray>(
        isolate_group);
    object_store->set_growable_object_array_class(cls);
 
    cls = Class::New<Map, RTN::Map>(isolate_group);
    object_store->set_map_impl_class(cls);
 
    cls = Class::New<Map, RTN::Map>(kConstMapCid, isolate_group);
    object_store->set_const_map_impl_class(cls);
 
    cls = Class::New<Set, RTN::Set>(isolate_group);
    object_store->set_set_impl_class(cls);
 
    cls = Class::New<Set, RTN::Set>(kConstSetCid, isolate_group);
    object_store->set_const_set_impl_class(cls);
 
    cls = Class::New<Float32x4, RTN::Float32x4>(isolate_group);
    object_store->set_float32x4_class(cls);
 
    cls = Class::New<Int32x4, RTN::Int32x4>(isolate_group);
    object_store->set_int32x4_class(cls);
 
    cls = Class::New<Float64x2, RTN::Float64x2>(isolate_group);
    object_store->set_float64x2_class(cls);
 
#define REGISTER_TYPED_DATA_CLASS(clazz)                                       \
  cls = Class::NewTypedDataClass(kTypedData##clazz##Cid, isolate_group);
    CLASS_LIST_TYPED_DATA(REGISTER_TYPED_DATA_CLASS);
#undef REGISTER_TYPED_DATA_CLASS
#define REGISTER_TYPED_DATA_VIEW_CLASS(clazz)                                  \
  cls =                                                                        \
      Class::NewTypedDataViewClass(kTypedData##clazz##ViewCid, isolate_group); \
  cls = Class::NewUnmodifiableTypedDataViewClass(                              \
      kUnmodifiableTypedData##clazz##ViewCid, isolate_group);
    CLASS_LIST_TYPED_DATA(REGISTER_TYPED_DATA_VIEW_CLASS);
#undef REGISTER_TYPED_DATA_VIEW_CLASS
    cls = Class::NewTypedDataViewClass(kByteDataViewCid, isolate_group);
    cls = Class::NewUnmodifiableTypedDataViewClass(kUnmodifiableByteDataViewCid,
                                                   isolate_group);
#define REGISTER_EXT_TYPED_DATA_CLASS(clazz)                                   \
  cls = Class::NewExternalTypedDataClass(kExternalTypedData##clazz##Cid,       \
                                         isolate_group);
    CLASS_LIST_TYPED_DATA(REGISTER_EXT_TYPED_DATA_CLASS);
#undef REGISTER_EXT_TYPED_DATA_CLASS
 
    cls = Class::New<Instance, RTN::Instance>(kFfiNativeTypeCid, isolate_group);
    object_store->set_ffi_native_type_class(cls);
 
#define REGISTER_FFI_CLASS(clazz)                                              \
  cls = Class::New<Instance, RTN::Instance>(kFfi##clazz##Cid, isolate_group);
    CLASS_LIST_FFI_TYPE_MARKER(REGISTER_FFI_CLASS);
#undef REGISTER_FFI_CLASS
 
    cls = Class::New<Instance, RTN::Instance>(kFfiNativeFunctionCid,
                                              isolate_group);
 
    cls = Class::NewPointerClass(kPointerCid, isolate_group);
    object_store->set_ffi_pointer_class(cls);
 
    cls = Class::New<DynamicLibrary, RTN::DynamicLibrary>(kDynamicLibraryCid,
                                                          isolate_group);
 
    cls = Class::New<Instance, RTN::Instance>(kByteBufferCid, isolate_group,
                                              /*register_isolate_group=*/false);
    cls.set_instance_size_in_words(0, 0);
    isolate_group->class_table()->Register(cls);
 
    cls = Class::New<Integer, RTN::Integer>(isolate_group);
    object_store->set_integer_implementation_class(cls);
 
    cls = Class::New<Smi, RTN::Smi>(isolate_group);
    object_store->set_smi_class(cls);
 
    cls = Class::New<Mint, RTN::Mint>(isolate_group);
    object_store->set_mint_class(cls);
 
    cls = Class::New<Double, RTN::Double>(isolate_group);
    object_store->set_double_class(cls);
 
    cls = Class::New<Closure, RTN::Closure>(isolate_group);
    object_store->set_closure_class(cls);
 
    cls = Class::New<Record, RTN::Record>(isolate_group);
 
    cls = Class::NewStringClass(kOneByteStringCid, isolate_group);
    object_store->set_one_byte_string_class(cls);
 
    cls = Class::NewStringClass(kTwoByteStringCid, isolate_group);
    object_store->set_two_byte_string_class(cls);
 
    cls = Class::New<Bool, RTN::Bool>(isolate_group);
    object_store->set_bool_class(cls);
 
    cls = Class::New<Instance, RTN::Instance>(kNullCid, isolate_group);
    object_store->set_null_class(cls);
 
    cls = Class::New<Instance, RTN::Instance>(kNeverCid, isolate_group);
    object_store->set_never_class(cls);
 
    cls = Class::New<Capability, RTN::Capability>(isolate_group);
    cls = Class::New<ReceivePort, RTN::ReceivePort>(isolate_group);
    cls = Class::New<SendPort, RTN::SendPort>(isolate_group);
    cls = Class::New<StackTrace, RTN::StackTrace>(isolate_group);
    cls = Class::New<SuspendState, RTN::SuspendState>(isolate_group);
    cls = Class::New<RegExp, RTN::RegExp>(isolate_group);
    cls = Class::New<Number, RTN::Number>(isolate_group);
 
    cls = Class::New<WeakProperty, RTN::WeakProperty>(isolate_group);
    object_store->set_weak_property_class(cls);
    cls = Class::New<WeakReference, RTN::WeakReference>(isolate_group);
    object_store->set_weak_reference_class(cls);
    cls = Class::New<Finalizer, RTN::Finalizer>(isolate_group);
    object_store->set_finalizer_class(cls);
    cls = Class::New<NativeFinalizer, RTN::NativeFinalizer>(isolate_group);
    object_store->set_native_finalizer_class(cls);
    cls = Class::New<FinalizerEntry, RTN::FinalizerEntry>(isolate_group);
    object_store->set_finalizer_entry_class(cls);
 
    cls = Class::New<MirrorReference, RTN::MirrorReference>(isolate_group);
    cls = Class::New<UserTag, RTN::UserTag>(isolate_group);
    cls = Class::New<FutureOr, RTN::FutureOr>(isolate_group);
    object_store->set_future_or_class(cls);
    cls = Class::New<TransferableTypedData, RTN::TransferableTypedData>(
        isolate_group);
  }
  return Error::null();
}

◆ InitNullAndBool()

void dart::Object::InitNullAndBool ( IsolateGroup * isolate_group )

static

Definition at line 554 of file object.cc.

                                                        {
  // Should only be run by the vm isolate.
  ASSERT(isolate_group == Dart::vm_isolate_group());
  Thread* thread = Thread::Current();
  auto heap = isolate_group->heap();
 
  // TODO(iposva): NoSafepointScope needs to be added here.
  ASSERT(class_class() == null_);
 
  // Allocate and initialize the null instance.
  // 'null_' must be the first object allocated as it is used in allocation to
  // clear the pointer fields of objects.
  {
    uword address =
        heap->Allocate(thread, Instance::InstanceSize(), Heap::kOld);
    null_ = static_cast<InstancePtr>(address + kHeapObjectTag);
    InitializeObjectVariant<Instance>(address, kNullCid);
    null_->untag()->SetCanonical();
  }
 
  // Allocate and initialize the bool instances.
  // These must be allocated such that at kBoolValueBitPosition, the address
  // of true is 0 and the address of false is 1, and their addresses are
  // otherwise identical.
  {
    // Allocate a dummy bool object to give true the desired alignment.
    uword address = heap->Allocate(thread, Bool::InstanceSize(), Heap::kOld);
    InitializeObject<Bool>(address);
    static_cast<BoolPtr>(address + kHeapObjectTag)->untag()->value_ = false;
  }
  {
    // Allocate true.
    uword address = heap->Allocate(thread, Bool::InstanceSize(), Heap::kOld);
    true_ = static_cast<BoolPtr>(address + kHeapObjectTag);
    InitializeObject<Bool>(address);
    true_->untag()->value_ = true;
    true_->untag()->SetCanonical();
  }
  {
    // Allocate false.
    uword address = heap->Allocate(thread, Bool::InstanceSize(), Heap::kOld);
    false_ = static_cast<BoolPtr>(address + kHeapObjectTag);
    InitializeObject<Bool>(address);
    false_->untag()->value_ = false;
    false_->untag()->SetCanonical();
  }
 
  // Check that the objects have been allocated at appropriate addresses.
  ASSERT(static_cast<uword>(true_) ==
         static_cast<uword>(null_) + kTrueOffsetFromNull);
  ASSERT(static_cast<uword>(false_) ==
         static_cast<uword>(null_) + kFalseOffsetFromNull);
  ASSERT((static_cast<uword>(true_) & kBoolValueMask) == 0);
  ASSERT((static_cast<uword>(false_) & kBoolValueMask) != 0);
  ASSERT(static_cast<uword>(false_) ==
         (static_cast<uword>(true_) | kBoolValueMask));
  ASSERT((static_cast<uword>(null_) & kBoolVsNullMask) == 0);
  ASSERT((static_cast<uword>(true_) & kBoolVsNullMask) != 0);
  ASSERT((static_cast<uword>(false_) & kBoolVsNullMask) != 0);
}

◆ InitVtables()

void dart::Object::InitVtables ( )

static

Definition at line 615 of file object.cc.

                         {
  {
    Object fake_handle;
    builtin_vtables_[kObjectCid] = fake_handle.vtable();
  }
 
#define INIT_VTABLE(clazz)                                                     \
  {                                                                            \
    clazz fake_handle;                                                         \
    builtin_vtables_[k##clazz##Cid] = fake_handle.vtable();                    \
  }
  CLASS_LIST_NO_OBJECT_NOR_STRING_NOR_ARRAY_NOR_MAP(INIT_VTABLE)
  INIT_VTABLE(GrowableObjectArray)
#undef INIT_VTABLE
 
#define INIT_VTABLE(clazz)                                                     \
  {                                                                            \
    Map fake_handle;                                                           \
    builtin_vtables_[k##clazz##Cid] = fake_handle.vtable();                    \
  }
  CLASS_LIST_MAPS(INIT_VTABLE)
#undef INIT_VTABLE
 
#define INIT_VTABLE(clazz)                                                     \
  {                                                                            \
    Set fake_handle;                                                           \
    builtin_vtables_[k##clazz##Cid] = fake_handle.vtable();                    \
  }
  CLASS_LIST_SETS(INIT_VTABLE)
#undef INIT_VTABLE
 
#define INIT_VTABLE(clazz)                                                     \
  {                                                                            \
    Array fake_handle;                                                         \
    builtin_vtables_[k##clazz##Cid] = fake_handle.vtable();                    \
  }
  CLASS_LIST_FIXED_LENGTH_ARRAYS(INIT_VTABLE)
#undef INIT_VTABLE
 
#define INIT_VTABLE(clazz)                                                     \
  {                                                                            \
    String fake_handle;                                                        \
    builtin_vtables_[k##clazz##Cid] = fake_handle.vtable();                    \
  }
  CLASS_LIST_STRINGS(INIT_VTABLE)
#undef INIT_VTABLE
 
  {
    Instance fake_handle;
    builtin_vtables_[kFfiNativeTypeCid] = fake_handle.vtable();
  }
 
#define INIT_VTABLE(clazz)                                                     \
  {                                                                            \
    Instance fake_handle;                                                      \
    builtin_vtables_[kFfi##clazz##Cid] = fake_handle.vtable();                 \
  }
  CLASS_LIST_FFI_TYPE_MARKER(INIT_VTABLE)
#undef INIT_VTABLE
 
  {
    Instance fake_handle;
    builtin_vtables_[kFfiNativeFunctionCid] = fake_handle.vtable();
  }
 
  {
    Pointer fake_handle;
    builtin_vtables_[kPointerCid] = fake_handle.vtable();
  }
 
  {
    DynamicLibrary fake_handle;
    builtin_vtables_[kDynamicLibraryCid] = fake_handle.vtable();
  }
 
#define INIT_VTABLE(clazz)                                                     \
  {                                                                            \
    TypedData fake_internal_handle;                                            \
    builtin_vtables_[kTypedData##clazz##Cid] = fake_internal_handle.vtable();  \
    TypedDataView fake_view_handle;                                            \
    builtin_vtables_[kTypedData##clazz##ViewCid] = fake_view_handle.vtable();  \
    builtin_vtables_[kUnmodifiableTypedData##clazz##ViewCid] =                 \
        fake_view_handle.vtable();                                             \
    ExternalTypedData fake_external_handle;                                    \
    builtin_vtables_[kExternalTypedData##clazz##Cid] =                         \
        fake_external_handle.vtable();                                         \
  }
  CLASS_LIST_TYPED_DATA(INIT_VTABLE)
#undef INIT_VTABLE
 
  {
    TypedDataView fake_handle;
    builtin_vtables_[kByteDataViewCid] = fake_handle.vtable();
    builtin_vtables_[kUnmodifiableByteDataViewCid] = fake_handle.vtable();
  }
 
  {
    Instance fake_handle;
    builtin_vtables_[kByteBufferCid] = fake_handle.vtable();
    builtin_vtables_[kNullCid] = fake_handle.vtable();
    builtin_vtables_[kDynamicCid] = fake_handle.vtable();
    builtin_vtables_[kVoidCid] = fake_handle.vtable();
    builtin_vtables_[kNeverCid] = fake_handle.vtable();
  }
}

◆ InstanceSize()

static intptr_t dart::Object::InstanceSize ( )

inlinestatic

Definition at line 592 of file object.h.

                                 {
    return RoundedAllocationSize(sizeof(UntaggedObject));
  }

◆ instructions_class()

static ClassPtr dart::Object::instructions_class ( )

inlinestatic

Definition at line 532 of file object.h.

532{ return instructions_class_; }

◆ instructions_section_class()

static ClassPtr dart::Object::instructions_section_class ( )

inlinestatic

Definition at line 533 of file object.h.

                                               {
    return instructions_section_class_;
  }

◆ instructions_table_class()

static ClassPtr dart::Object::instructions_table_class ( )

inlinestatic

Definition at line 536 of file object.h.

                                             {
    return instructions_table_class_;
  }

◆ InVMIsolateHeap()

bool dart::Object::InVMIsolateHeap ( ) const

inline

Definition at line 395 of file object.h.

395{ return ptr()->untag()->InVMIsolateHeap(); }

dart::UntaggedObject::InVMIsolateHeap

bool InVMIsolateHeap() const

Definition raw_object.cc:20

◆ IsCanonical()

bool dart::Object::IsCanonical ( ) const

inline

Definition at line 335 of file object.h.

335{ return ptr()->untag()->IsCanonical(); }

dart::UntaggedObject::IsCanonical

bool IsCanonical() const

Definition raw_object.h:329

◆ IsImmutable()

bool dart::Object::IsImmutable ( ) const

inline

Definition at line 338 of file object.h.

338{ return ptr()->untag()->IsImmutable(); }

dart::UntaggedObject::IsImmutable

bool IsImmutable() const

Definition raw_object.h:333

◆ IsNew()

bool dart::Object::IsNew ( ) const

inline

Definition at line 390 of file object.h.

390{ return ptr()->IsNewObject(); }

◆ IsNull()

bool dart::Object::IsNull ( ) const

inline

Definition at line 363 of file object.h.

363{ return ptr_ == null_; }

◆ IsOld()

bool dart::Object::IsOld ( ) const

inline

Definition at line 391 of file object.h.

391{ return ptr()->IsOldObject(); }

◆ JSONType()

virtual const char * dart::Object::JSONType ( ) const

inlinevirtual

Definition at line 380 of file object.h.

380{ return IsNull() ? "null" : "Object"; }

◆ kernel_program_info_class()

static ClassPtr dart::Object::kernel_program_info_class ( )

inlinestatic

Definition at line 528 of file object.h.

                                              {
    return kernel_program_info_class_;
  }

◆ language_error_class()

static ClassPtr dart::Object::language_error_class ( )

inlinestatic

Definition at line 553 of file object.h.

553{ return language_error_class_; }

◆ library_class()

static ClassPtr dart::Object::library_class ( )

inlinestatic

Definition at line 526 of file object.h.

526{ return library_class_; }

◆ loadingunit_class()

static ClassPtr dart::Object::loadingunit_class ( )

inlinestatic

Definition at line 566 of file object.h.

566{ return loadingunit_class_; }

◆ LoadNonPointer() [1/2]

template<typename FieldType >

FieldType dart::Object::LoadNonPointer ( const FieldType * addr ) const

inlineprotected

Definition at line 806 of file object.h.

                                                        {
    return *const_cast<FieldType*>(addr);
  }

◆ LoadNonPointer() [2/2]

template<typename FieldType , std::memory_order order>

FieldType dart::Object::LoadNonPointer ( const FieldType * addr ) const

inlineprotected

Definition at line 811 of file object.h.

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

◆ LoadPointer()

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

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

inlineprotected

Definition at line 771 of file object.h.

                                           {
    return ptr()->untag()->LoadPointer<type, order>(addr);
  }

◆ MakeUnusedSpaceTraversable()

void dart::Object::MakeUnusedSpaceTraversable	(	const Object &	obj,
		intptr_t	original_size,
		intptr_t	used_size
	)

static

Definition at line 1610 of file object.cc.

                                                            {
  ASSERT(Thread::Current()->no_safepoint_scope_depth() > 0);
  ASSERT(!obj.IsNull());
  ASSERT(original_size >= used_size);
  if (original_size > used_size) {
    intptr_t leftover_size = original_size - used_size;
 
    uword addr = UntaggedObject::ToAddr(obj.ptr()) + used_size;
    if (leftover_size >= TypedData::InstanceSize(0)) {
      // Update the leftover space as a TypedDataInt8Array object.
      TypedDataPtr raw =
          static_cast<TypedDataPtr>(UntaggedObject::FromAddr(addr));
      uword new_tags =
          UntaggedObject::ClassIdTag::update(kTypedDataInt8ArrayCid, 0);
      new_tags = UntaggedObject::SizeTag::update(leftover_size, new_tags);
      const bool is_old = obj.ptr()->IsOldObject();
      new_tags = UntaggedObject::AlwaysSetBit::update(true, new_tags);
      new_tags = UntaggedObject::NotMarkedBit::update(true, new_tags);
      new_tags =
          UntaggedObject::OldAndNotRememberedBit::update(is_old, new_tags);
      new_tags = UntaggedObject::NewBit::update(!is_old, new_tags);
      // On architectures with a relaxed memory model, the concurrent marker may
      // observe the write of the filler object's header before observing the
      // new array length, and so treat it as a pointer. Ensure it is a Smi so
      // the marker won't dereference it.
      ASSERT((new_tags & kSmiTagMask) == kSmiTag);
 
      intptr_t leftover_len = (leftover_size - TypedData::InstanceSize(0));
      ASSERT(TypedData::InstanceSize(leftover_len) == leftover_size);
      raw->untag()->set_length<std::memory_order_release>(
          Smi::New(leftover_len));
      raw->untag()->tags_ = new_tags;
      raw->untag()->RecomputeDataField();
    } else {
      // Update the leftover space as a basic object.
      ASSERT(leftover_size == Object::InstanceSize());
      ObjectPtr raw = static_cast<ObjectPtr>(UntaggedObject::FromAddr(addr));
      uword new_tags = UntaggedObject::ClassIdTag::update(kInstanceCid, 0);
      new_tags = UntaggedObject::SizeTag::update(leftover_size, new_tags);
      const bool is_old = obj.ptr()->IsOldObject();
      new_tags = UntaggedObject::AlwaysSetBit::update(true, new_tags);
      new_tags = UntaggedObject::NotMarkedBit::update(true, new_tags);
      new_tags =
          UntaggedObject::OldAndNotRememberedBit::update(is_old, new_tags);
      new_tags = UntaggedObject::NewBit::update(!is_old, new_tags);
      // On architectures with a relaxed memory model, the concurrent marker may
      // observe the write of the filler object's header before observing the
      // new array length, and so treat it as a pointer. Ensure it is a Smi so
      // the marker won't dereference it.
      ASSERT((new_tags & kSmiTagMask) == kSmiTag);
 
      // The array might have an uninitialized alignment gap since the visitors
      // for Arrays are precise based on element count, but the visitors for
      // Instance are based on the size rounded to the allocation unit, so we
      // need to ensure the alignment gap is initialized.
      for (intptr_t offset = Instance::UnroundedSize();
           offset < Instance::InstanceSize(); offset += sizeof(uword)) {
        reinterpret_cast<std::atomic<uword>*>(addr + offset)
            ->store(0, std::memory_order_release);
      }
      raw->untag()->tags_ = new_tags;
    }
  }
}

◆ megamorphic_cache_class()

static ClassPtr dart::Object::megamorphic_cache_class ( )

inlinestatic

Definition at line 564 of file object.h.

564{ return megamorphic_cache_class_; }

◆ monomorphicsmiablecall_class()

static ClassPtr dart::Object::monomorphicsmiablecall_class ( )

inlinestatic

Definition at line 560 of file object.h.

                                                 {
    return monomorphicsmiablecall_class_;
  }

◆ namespace_class()

static ClassPtr dart::Object::namespace_class ( )

inlinestatic

Definition at line 527 of file object.h.

527{ return namespace_class_; }

◆ null()

static ObjectPtr dart::Object::null ( )

inlinestatic

Definition at line 433 of file object.h.

433{ return null_; }

◆ object_pool_class()

static ClassPtr dart::Object::object_pool_class ( )

inlinestatic

Definition at line 539 of file object.h.

539{ return object_pool_class_; }

◆ operator=()

void dart::Object::operator= ( ObjectPtr value )

inline

Definition at line 333 of file object.h.

333{ initializeHandle(this, value); }

◆ patch_class_class()

static ClassPtr dart::Object::patch_class_class ( )

inlinestatic

Definition at line 518 of file object.h.

518{ return patch_class_class_; }

◆ pc_descriptors_class()

static ClassPtr dart::Object::pc_descriptors_class ( )

inlinestatic

Definition at line 540 of file object.h.

540{ return pc_descriptors_class_; }

◆ Print()

void dart::Object::Print ( ) const

Definition at line 2681 of file object.cc.

                         {
  THR_Print("%s\n", ToCString());
}

◆ PrintImplementationFields()

void dart::Object::PrintImplementationFields ( JSONStream * stream ) const

Definition at line 82 of file object_service.cc.

                                                               {
  JSONObject jsobj(stream);
  jsobj.AddProperty("type", "ImplementationFields");
  JSONArray jsarr_fields(&jsobj, "fields");
  if (!IsNull()) {
    PrintImplementationFieldsImpl(jsarr_fields);
  }
}

◆ PrintImplementationFieldsImpl()

void dart::Object::PrintImplementationFieldsImpl ( const JSONArray & jsarr_fields ) const

virtual

Definition at line 77 of file object_service.cc.

                                         {
  UNREACHABLE();
}

◆ PrintJSON()

void dart::Object::PrintJSON	(	JSONStream *	stream,
		bool	ref = `true`
	)		const

Definition at line 65 of file object_service.cc.

                                                         {
  if (IsNull()) {
    JSONObject jsobj(stream);
    AddCommonObjectProperties(&jsobj, "Instance", ref);
    jsobj.AddProperty("kind", "Null");
    jsobj.AddFixedServiceId("objects/null");
    jsobj.AddProperty("valueAsString", "null");
  } else {
    PrintJSONImpl(stream, ref);
  }
}

◆ PrintJSONImpl()

void dart::Object::PrintJSONImpl	(	JSONStream *	stream,
		bool	ref
	)		const

virtual

Definition at line 56 of file object_service.cc.

                                                             {
  JSONObject jsobj(stream);
  AddCommonObjectProperties(&jsobj, "Object", ref);
  jsobj.AddServiceId(*this);
  if (ref) {
    return;
  }
}

◆ ptr()

ObjectPtr dart::Object::ptr ( ) const

inline

Definition at line 332 of file object.h.

332{ return ptr_; }

◆ raw_value()

uword dart::Object::raw_value ( ) const

inlineprotected

Definition at line 670 of file object.h.

670{ return static_cast<uword>(ptr()); }

◆ RawCast()

static ObjectPtr dart::Object::RawCast ( ObjectPtr obj )

inlinestatic

Definition at line 325 of file object.h.

325{ return obj; }

◆ ReadOnlyHandle()

static Object * dart::Object::ReadOnlyHandle ( )

inlinestatic

Definition at line 431 of file object.h.

431{ return ReadOnlyHandleImpl(kObjectCid); }

dart::Object::ReadOnlyHandleImpl

static DART_NOINLINE Object * ReadOnlyHandleImpl(intptr_t cid)

Definition object.h:689

◆ ReadOnlyHandleImpl()

static DART_NOINLINE Object * dart::Object::ReadOnlyHandleImpl ( intptr_t cid )

inlinestaticprotected

Definition at line 689 of file object.h.

                                                                {
    Object* obj = reinterpret_cast<Object*>(Dart::AllocateReadOnlyHandle());
    obj->setPtr(Object::null(), cid);
    return obj;
  }

◆ RoundedAllocationSize()

static constexpr intptr_t dart::Object::RoundedAllocationSize ( intptr_t size )

inlinestaticconstexprprotected

Definition at line 758 of file object.h.

                                                                 {
    return Utils::RoundUp(size, kObjectAlignment);
  }

◆ script_class()

static ClassPtr dart::Object::script_class ( )

inlinestatic

Definition at line 525 of file object.h.

525{ return script_class_; }

◆ sentinel_class()

static ClassPtr dart::Object::sentinel_class ( )

inlinestatic

Definition at line 551 of file object.h.

551{ return sentinel_class_; }

◆ set_vm_isolate_snapshot_object_table()

void dart::Object::set_vm_isolate_snapshot_object_table ( const Array & table )

static

Definition at line 1601 of file object.cc.

                                                                    {
  ASSERT(Isolate::Current() == Dart::vm_isolate());
  *vm_isolate_snapshot_object_table_ = table.ptr();
}

◆ set_vtable()

void dart::Object::set_vtable ( cpp_vtable value )

inlineprotected

Definition at line 706 of file object.h.

                                    {
    memcpy(reinterpret_cast<void*>(this), &value,  // NOLINT
           sizeof(cpp_vtable));
  }

◆ SetCanonical()

void dart::Object::SetCanonical ( ) const

inline

Definition at line 336 of file object.h.

336{ ptr()->untag()->SetCanonical(); }

◆ SetImmutable()

void dart::Object::SetImmutable ( ) const

inline

Definition at line 339 of file object.h.

339{ ptr()->untag()->SetImmutable(); }

dart::UntaggedObject::SetImmutable

void SetImmutable()

Definition raw_object.h:334

◆ setPtr()

DART_FORCE_INLINE void dart::Object::setPtr	(	ObjectPtr	value,
		intptr_t	default_cid
	)

inlineprotected

Definition at line 13201 of file object.h.

                                                         {
  ptr_ = value;
  intptr_t cid = value->GetClassIdMayBeSmi();
  // Free-list elements cannot be wrapped in a handle.
  ASSERT(cid != kFreeListElement);
  ASSERT(cid != kForwardingCorpse);
  if (cid == kNullCid) {
    cid = default_cid;
  } else if (cid >= kNumPredefinedCids) {
    cid = kInstanceCid;
  }
  set_vtable(builtin_vtables_[cid]);
}

◆ ShouldHaveImmutabilityBitSet()

bool dart::Object::ShouldHaveImmutabilityBitSet ( classid_t class_id )

static

Definition at line 2689 of file object.cc.

                                                            {
  if (class_id < kNumPredefinedCids) {
    return ShouldHaveImmutabilityBitSetCid(class_id);
  } else {
    return Class::IsDeeplyImmutable(
        IsolateGroup::Current()->class_table()->At(class_id));
  }
}

◆ singletargetcache_class()

static ClassPtr dart::Object::singletargetcache_class ( )

inlinestatic

Definition at line 558 of file object.h.

558{ return singletargetcache_class_; }

◆ StoreCompressedPointer()

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

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

inlineprotected

Definition at line 782 of file object.h.

                                                                             {
    ptr()->untag()->StoreCompressedPointer<type, compressed_type, order>(addr,
                                                                         value);
  }

◆ StoreNonPointer() [1/2]

template<typename FieldType , typename ValueType >

void dart::Object::StoreNonPointer	(	const FieldType *	addr,
		ValueType	value
	)		const

inlineprotected

Definition at line 819 of file object.h.

                                                                     {
    // Can't use Contains, as it uses tags_, which is set through this method.
    ASSERT(reinterpret_cast<uword>(addr) >= UntaggedObject::ToAddr(ptr()));
    *const_cast<FieldType*>(addr) = value;
  }

◆ StoreNonPointer() [2/2]

template<typename FieldType , typename ValueType , std::memory_order order>

void dart::Object::StoreNonPointer	(	const FieldType *	addr,
		ValueType	value
	)		const

inlineprotected

Definition at line 826 of file object.h.

                                                                     {
    // Can't use Contains, as it uses tags_, which is set through this method.
    ASSERT(reinterpret_cast<uword>(addr) >= UntaggedObject::ToAddr(ptr()));
    reinterpret_cast<std::atomic<FieldType>*>(const_cast<FieldType*>(addr))
        ->store(value, order);
  }

◆ StorePointer()

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

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

inlineprotected

Definition at line 776 of file object.h.

                                                        {
    ptr()->untag()->StorePointer<type, order>(addr, value);
  }

◆ StorePointerUnaligned()

template<typename type >

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

inlineprotected

Definition at line 787 of file object.h.

                                                   {
    ptr()->untag()->StorePointerUnaligned<type>(addr, value, thread);
  }

◆ StoreSimd128()

template<typename FieldType >

void dart::Object::StoreSimd128	(	const FieldType *	addr,
		simd128_value_t	value
	)		const

inlineprotected

Definition at line 800 of file object.h.

                                                                        {
    ASSERT(Contains(reinterpret_cast<uword>(addr)));
    value.writeTo(const_cast<FieldType*>(addr));
  }

◆ StoreSmi()

void dart::Object::StoreSmi	(	SmiPtr const *	addr,
		SmiPtr	value
	)		const

inlineprotected

Definition at line 795 of file object.h.

                                                        {
    ptr()->untag()->StoreSmi(addr, value);
  }

◆ subtypetestcache_class()

static ClassPtr dart::Object::subtypetestcache_class ( )

inlinestatic

Definition at line 565 of file object.h.

565{ return subtypetestcache_class_; }

◆ tags_offset()

static intptr_t dart::Object::tags_offset ( )

inlinestatic

Definition at line 346 of file object.h.

346{ return OFFSET_OF(UntaggedObject, tags_); }

OFFSET_OF

#define OFFSET_OF(type, field)

Definition globals.h:138

◆ to_offset()

template<typename T >

static DART_FORCE_INLINE uword dart::Object::to_offset ( intptr_t length = 0 )

inlinestaticprotected

Definition at line 893 of file object.h.

                                                                {
    return UntaggedObject::to_offset<typename T::UntaggedObjectType>(length);
  }

◆ ToCString()

virtual const char * dart::Object::ToCString ( ) const

inlinevirtual

Definition at line 366 of file object.h.

                                        {
    if (IsNull()) {
      return "null";
    } else {
      return "Object";
    }
  }

◆ type_arguments_class()

static ClassPtr dart::Object::type_arguments_class ( )

inlinestatic

Definition at line 517 of file object.h.

517{ return type_arguments_class_; }

◆ type_parameters_class()

static ClassPtr dart::Object::type_parameters_class ( )

inlinestatic

Definition at line 516 of file object.h.

516{ return type_parameters_class_; }

◆ unhandled_exception_class()

static ClassPtr dart::Object::unhandled_exception_class ( )

inlinestatic

Definition at line 554 of file object.h.

                                              {
    return unhandled_exception_class_;
  }

◆ UnimplementedMethod()

void dart::Object::UnimplementedMethod ( ) const

protected

◆ unlinkedcall_class()

static ClassPtr dart::Object::unlinkedcall_class ( )

inlinestatic

Definition at line 559 of file object.h.

559{ return unlinkedcall_class_; }

◆ UnsafeMutableNonPointer()

template<typename FieldType >

FieldType * dart::Object::UnsafeMutableNonPointer ( const FieldType * addr ) const

inlineprotected

Definition at line 837 of file object.h.

                                                                  {
    // Allow pointers at the end of variable-length data, and disallow pointers
    // within the header word.
    ASSERT(Contains(reinterpret_cast<uword>(addr) - 1) &&
           Contains(reinterpret_cast<uword>(addr) - kWordSize));
    // At least check that there is a NoSafepointScope and hope it's big enough.
    ASSERT(Thread::Current()->no_safepoint_scope_depth() > 0);
    return const_cast<FieldType*>(addr);
  }

◆ unwind_error_class()

static ClassPtr dart::Object::unwind_error_class ( )

inlinestatic

Definition at line 557 of file object.h.

557{ return unwind_error_class_; }

◆ var_descriptors_class()

static ClassPtr dart::Object::var_descriptors_class ( )

inlinestatic

Definition at line 545 of file object.h.

545{ return var_descriptors_class_; }

◆ VerifyBuiltinVtable()

template<class FakeObject >

static void dart::Object::VerifyBuiltinVtable ( intptr_t cid )

inlinestatic

Definition at line 597 of file object.h.

                                                {
    FakeObject fake;
    if (cid >= kNumPredefinedCids) {
      cid = kInstanceCid;
    }
    ASSERT(builtin_vtables_[cid] == fake.vtable());
  }

◆ VerifyBuiltinVtables()

void dart::Object::VerifyBuiltinVtables ( )

static

Definition at line 1677 of file object.cc.

                                  {
#if defined(DEBUG)
  ASSERT(builtin_vtables_[kIllegalCid] == 0);
  ASSERT(builtin_vtables_[kFreeListElement] == 0);
  ASSERT(builtin_vtables_[kForwardingCorpse] == 0);
  ClassTable* table = IsolateGroup::Current()->class_table();
  for (intptr_t cid = kObjectCid; cid < kNumPredefinedCids; cid++) {
    if (table->HasValidClassAt(cid)) {
      ASSERT(builtin_vtables_[cid] != 0);
    }
  }
#endif
}

◆ void_class()

static ClassPtr dart::Object::void_class ( )

inlinestatic

Definition at line 515 of file object.h.

515{ return void_class_; }

◆ vtable()

cpp_vtable dart::Object::vtable ( ) const

inlineprotected

Definition at line 700 of file object.h.

                            {
    cpp_vtable result;
    memcpy(&result, reinterpret_cast<const void*>(this),  // NOLINT
           sizeof(result));
    return result;
  }

◆ weak_array_class()

static ClassPtr dart::Object::weak_array_class ( )

inlinestatic

Definition at line 570 of file object.h.

570{ return weak_array_class_; }

◆ weak_serialization_reference_class()

static ClassPtr dart::Object::weak_serialization_reference_class ( )

inlinestatic

Definition at line 567 of file object.h.

                                                       {
    return weak_serialization_reference_class_;
  }

◆ ZoneHandle() [1/4]

static Object & dart::Object::ZoneHandle ( )

inlinestatic

Definition at line 419 of file object.h.

                              {
    return ZoneHandleImpl(Thread::Current()->zone(), null_, kObjectCid);
  }

◆ ZoneHandle() [2/4]

static Object & dart::Object::ZoneHandle ( ObjectPtr ptr )

inlinestatic

Definition at line 425 of file object.h.

                                           {
    return ZoneHandleImpl(Thread::Current()->zone(), ptr, kObjectCid);
  }

◆ ZoneHandle() [3/4]

static Object & dart::Object::ZoneHandle ( Zone * zone )

inlinestatic

Definition at line 422 of file object.h.

                                        {
    return ZoneHandleImpl(zone, null_, kObjectCid);
  }

◆ ZoneHandle() [4/4]

static Object & dart::Object::ZoneHandle	(	Zone *	zone,
		ObjectPtr	ptr
	)

inlinestatic

Definition at line 428 of file object.h.

                                                       {
    return ZoneHandleImpl(zone, ptr, kObjectCid);
  }

◆ ZoneHandleImpl()

static DART_NOINLINE Object & dart::Object::ZoneHandleImpl	(	Zone *	zone,
		ObjectPtr	ptr,
		intptr_t	default_cid
	)

inlinestaticprotected

Definition at line 681 of file object.h.

                                                                    {
    Object* obj =
        reinterpret_cast<Object*>(VMHandles::AllocateZoneHandle(zone));
    obj->setPtr(ptr, default_cid);
    return *obj;
  }

Friends And Related Symbol Documentation

◆ AllocateObject

ObjectPtr AllocateObject	(	intptr_t	cid,
		intptr_t	size,
		intptr_t	allocated_bytes
	)

friend

Definition at line 248 of file object_graph_copy.cc.

                                                   {
#if defined(DART_COMPRESSED_POINTERS)
  const bool compressed = true;
#else
  const bool compressed = false;
#endif
  const intptr_t kLargeMessageThreshold = 16 * MB;
  const Heap::Space space =
      allocated_bytes > kLargeMessageThreshold ? Heap::kOld : Heap::kNew;
  // Mimic the old initialization behavior of Object::InitializeObject where
  // the contents are initialized to Object::null(), except for TypedDataBase
  // subclasses which are initialized to 0, as the contents of the original
  // are translated and copied over prior to returning the object graph root.
  if (IsTypedDataBaseClassId(cid)) {
    return Object::Allocate(cid, size, space, compressed,
                            Object::from_offset<TypedDataBase>(),
                            Object::to_offset<TypedDataBase>());
 
  } else {
    // Remember that ptr_field_end_offset is the offset to the last Ptr
    // field, not the offset just past it.
    const uword ptr_field_end_offset =
        size - (compressed ? kCompressedWordSize : kWordSize);
    return Object::Allocate(cid, size, space, compressed,
                            Object::from_offset<Object>(),
                            ptr_field_end_offset);
  }
}

◆ ClassTable::Register

void ClassTable::Register ( const Class & cls )

friend

◆ Closure

friend class Closure

friend

Definition at line 1019 of file object.h.

◆ InstanceDeserializationCluster

friend class InstanceDeserializationCluster

friend

Definition at line 1020 of file object.h.

◆ ObjectGraphCopier

friend class ObjectGraphCopier

friend

Definition at line 1021 of file object.h.

◆ OneByteString

friend class OneByteString

friend

Definition at line 1023 of file object.h.

◆ Simd128MessageDeserializationCluster

friend class Simd128MessageDeserializationCluster

friend

Definition at line 1022 of file object.h.

◆ Thread

friend class Thread

friend

Definition at line 1025 of file object.h.

◆ TwoByteString

friend class TwoByteString

friend

Definition at line 1024 of file object.h.

◆ UntaggedObject::Validate

void UntaggedObject::Validate ( IsolateGroup * isolate_group ) const

friend

Member Data Documentation

◆ kClassId

const ClassId dart::Object::kClassId = kObjectCid

static

Definition at line 606 of file object.h.

◆ kHashBits

constexpr intptr_t dart::Object::kHashBits = 30

staticconstexpr

Definition at line 323 of file object.h.

◆ ptr_

ObjectPtr dart::Object::ptr_

protected

Definition at line 870 of file object.h.

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

third_party/dart-lang/sdk/runtime/vm/object.h
third_party/dart-lang/sdk/runtime/vm/object.cc
third_party/dart-lang/sdk/runtime/vm/object_service.cc

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ ObjectPtrType

◆ UntaggedObjectType

Member Enumeration Documentation

◆ NameDisambiguation

◆ NameVisibility

Constructor & Destructor Documentation

◆ ~Object()

◆ Object()

Member Function Documentation

◆ AddCommonObjectProperties()

◆ Allocate() [1/3]

◆ Allocate() [2/3]

◆ Allocate() [3/3]

◆ AllocateVariant() [1/2]

◆ AllocateVariant() [2/2]

◆ api_error_class()

◆ CheckHandle()

◆ class_class()

◆ CLASS_LIST()

◆ CLASS_LIST_FOR_HANDLES()

◆ clazz()

◆ Cleanup()

◆ ClearCanonical()

◆ ClearImmutable()

◆ Clone()

◆ closure_data_class()

◆ code_class()

◆ code_source_map_class()

◆ compressed_stackmaps_class()

◆ Contains()

◆ ContainsCompressedPointers()

◆ context_class()

◆ context_scope_class()

◆ DictionaryName()

◆ dynamic_class()

◆ exception_handlers_class()

◆ ffi_trampoline_data_class()

◆ field_class()

◆ FinalizeReadOnlyObject()

◆ FinalizeVMIsolate()

◆ FinishInit()

◆ from_offset()

◆ function_class()

◆ GetClassId()

◆ Handle() [1/4]

◆ Handle() [2/4]

◆ Handle() [3/4]

◆ Handle() [4/4]

◆ HandleImpl()

◆ icdata_class()

◆ Init() [1/2]

◆ Init() [2/2]

◆ InitNullAndBool()

◆ InitVtables()

◆ InstanceSize()

◆ instructions_class()

◆ instructions_section_class()

◆ instructions_table_class()

◆ InVMIsolateHeap()

◆ IsCanonical()

◆ IsImmutable()

◆ IsNew()

◆ IsNull()

◆ IsOld()

◆ JSONType()

◆ kernel_program_info_class()

◆ language_error_class()

◆ library_class()

◆ loadingunit_class()

◆ LoadNonPointer() [1/2]