#include <object.h>

Inheritance diagram for dart::Array:

Classes
struct	ArrayTraits

Public Member Functions
intptr_t	Length () const

bool	Equals (const Array &other) const

template<std::memory_order order = std::memory_order_relaxed>
ObjectPtr	At (intptr_t index) const

template<std::memory_order order = std::memory_order_relaxed>
void	SetAt (intptr_t index, const Object &value) const

template<std::memory_order order = std::memory_order_relaxed>
void	SetAt (intptr_t index, const Object &value, Thread *thread) const

ObjectPtr	AtAcquire (intptr_t index) const

void	SetAtRelease (intptr_t index, const Object &value) const

bool	IsImmutable () const

virtual TypeArgumentsPtr	GetTypeArguments () const

virtual void	SetTypeArguments (const TypeArguments &value) const

virtual bool	CanonicalizeEquals (const Instance &other) const

virtual uint32_t	CanonicalizeHash () const

virtual void	CanonicalizeFieldsLocked (Thread *thread) const

void	MakeImmutable () const

void	Truncate (intptr_t new_length) const

ArrayPtr	Slice (intptr_t start, intptr_t count, bool with_type_argument) const

ArrayPtr	Copy () const

Public Member Functions inherited from dart::Instance
virtual bool	OperatorEquals (const Instance &other) const

bool	IsIdenticalTo (const Instance &other) const

intptr_t	SizeFromClass () const

InstancePtr	Canonicalize (Thread *thread) const

virtual InstancePtr	CanonicalizeLocked (Thread *thread) const

InstancePtr	CopyShallowToOldSpace (Thread *thread) const

ObjectPtr	GetField (const Field &field) const

void	SetField (const Field &field, const Object &value) const

AbstractTypePtr	GetType (Heap::Space space) const

bool	IsInstanceOf (const AbstractType &other, const TypeArguments &other_instantiator_type_arguments, const TypeArguments &other_function_type_arguments) const

bool	IsAssignableTo (const AbstractType &other, const TypeArguments &other_instantiator_type_arguments, const TypeArguments &other_function_type_arguments) const

bool	IsValidNativeIndex (int index) const

intptr_t *	NativeFieldsDataAddr () const

intptr_t	GetNativeField (int index) const

void	GetNativeFields (uint16_t num_fields, intptr_t *field_values) const

void	SetNativeFields (uint16_t num_fields, const intptr_t *field_values) const

uint16_t	NumNativeFields () const

void	SetNativeField (int index, intptr_t value) const

bool	IsCallable (Function *function) const

ObjectPtr	Invoke (const String &selector, const Array &arguments, const Array &argument_names, bool respect_reflectable=true, bool check_is_entrypoint=false) const

ObjectPtr	InvokeGetter (const String &selector, bool respect_reflectable=true, bool check_is_entrypoint=false) const

ObjectPtr	InvokeSetter (const String &selector, const Instance &argument, bool respect_reflectable=true, bool check_is_entrypoint=false) const

ObjectPtr	EvaluateCompiledExpression (const Class &klass, const ExternalTypedData &kernel_buffer, const Array &type_definitions, const Array &arguments, const TypeArguments &type_arguments) const

virtual ObjectPtr	HashCode () const

IntegerPtr	IdentityHashCode (Thread *thread) const

virtual bool	IsPointer () const

Public Member Functions inherited from dart::Object
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 constexpr bool	UseCardMarkingForAllocation (const intptr_t array_length)

static intptr_t	LengthOf (const ArrayPtr array)

static intptr_t	length_offset ()

static intptr_t	data_offset ()

static intptr_t	element_offset (intptr_t index)

static intptr_t	index_at_offset (intptr_t offset_in_bytes)

static bool	Equals (ArrayPtr a, ArrayPtr b)

static CompressedObjectPtr *	DataOf (ArrayPtr array)

static intptr_t	type_arguments_offset ()

static constexpr bool	IsValidLength (intptr_t len)

static intptr_t	InstanceSize ()

static constexpr intptr_t	UnroundedSize (intptr_t len)

static constexpr intptr_t	InstanceSize (intptr_t len)

static ArrayPtr	New (intptr_t len, Heap::Space space=Heap::kNew)

static ArrayPtr	NewUninitialized (intptr_t len, Heap::Space space=Heap::kNew)

static ArrayPtr	New (intptr_t len, const AbstractType &element_type, Heap::Space space=Heap::kNew)

static ArrayPtr	Grow (const Array &source, intptr_t new_length, Heap::Space space=Heap::kNew)

static ArrayPtr	MakeFixedLength (const GrowableObjectArray &growable_array, bool unique=false)

Static Public Member Functions inherited from dart::Instance
static bool	NullIsAssignableTo (const AbstractType &other)

static bool	NullIsAssignableTo (const AbstractType &other, const TypeArguments &other_instantiator_type_arguments, const TypeArguments &other_function_type_arguments)

static ObjectPtr	EvaluateCompiledExpression (Thread *thread, const Object &receiver, const Library &library, const Class &klass, const ExternalTypedData &kernel_buffer, const Array &type_definitions, const Array &param_values, const TypeArguments &type_param_values)

static intptr_t	UnroundedSize ()

static intptr_t	InstanceSize ()

static InstancePtr	New (const Class &cls, Heap::Space space=Heap::kNew)

static InstancePtr	NewAlreadyFinalized (const Class &cls, Heap::Space space=Heap::kNew)

static intptr_t	DataOffsetFor (intptr_t cid)

static intptr_t	ElementSizeFor (intptr_t cid)

static intptr_t	NextFieldOffset ()

static intptr_t	NativeFieldsOffset ()

Static Public Member Functions inherited from dart::Object
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	kMaxLengthForWriteBarrierElimination = 8

static constexpr intptr_t	kElementTypeTypeArgPos = 0

static constexpr intptr_t	kBytesPerElement = ArrayTraits::kElementSize

static constexpr intptr_t	kMaxElements = kSmiMax / kBytesPerElement

static constexpr intptr_t	kMaxNewSpaceElements

Static Public Attributes inherited from dart::Object
static constexpr intptr_t	kHashBits = 30

static const ClassId	kClassId = kObjectCid

Static Protected Member Functions
static ArrayPtr	New (intptr_t class_id, intptr_t len, Heap::Space space=Heap::kNew)

static ArrayPtr	NewUninitialized (intptr_t class_id, intptr_t len, Heap::Space space=Heap::kNew)

Static Protected Member Functions inherited from dart::Object
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)

Friends
class	Class

class	ImmutableArray

class	Object

class	String

class	MessageDeserializer

Additional Inherited Members
Public Types inherited from dart::Object
enum	NameVisibility { kInternalName = 0 , kScrubbedName , kUserVisibleName }

enum class	NameDisambiguation { kYes , kNo }

using	UntaggedObjectType = UntaggedObject

using	ObjectPtrType = ObjectPtr

Protected Member Functions inherited from dart::Instance
virtual void	PrintSharedInstanceJSON (JSONObject *jsobj, bool ref, bool include_id=true) const

Protected Member Functions inherited from dart::Object
	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

Protected Attributes inherited from dart::Object
ObjectPtr	ptr_

Detailed Description

Definition at line 10794 of file object.h.

Member Function Documentation

◆ At()

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

ObjectPtr dart::Array::At ( intptr_t index ) const

inline

Definition at line 10854 of file object.h.

                                     {
    return untag()->element<order>(index);
  }

◆ AtAcquire()

ObjectPtr dart::Array::AtAcquire ( intptr_t index ) const

inline

Definition at line 10867 of file object.h.

                                            {
    return untag()->element<std::memory_order_acquire>(index);
  }

◆ CanonicalizeEquals()

bool dart::Array::CanonicalizeEquals ( const Instance & other ) const

virtual

Reimplemented from dart::Instance.

Definition at line 24781 of file object.cc.

                                                          {
  if (this->ptr() == other.ptr()) {
    // Both handles point to the same raw instance.
    return true;
  }
 
  // An Array may be compared to an ImmutableArray.
  if (!other.IsArray() || other.IsNull()) {
    return false;
  }
 
  // First check if both arrays have the same length and elements.
  const Array& other_arr = Array::Cast(other);
 
  intptr_t len = this->Length();
  if (len != other_arr.Length()) {
    return false;
  }
 
  for (intptr_t i = 0; i < len; i++) {
    if (this->At(i) != other_arr.At(i)) {
      return false;
    }
  }
 
  // Now check if both arrays have the same type arguments.
  if (GetTypeArguments() == other.GetTypeArguments()) {
    return true;
  }
  const TypeArguments& type_args = TypeArguments::Handle(GetTypeArguments());
  const TypeArguments& other_type_args =
      TypeArguments::Handle(other.GetTypeArguments());
  if (!type_args.Equals(other_type_args)) {
    return false;
  }
  return true;
}

◆ CanonicalizeFieldsLocked()

void dart::Array::CanonicalizeFieldsLocked ( Thread * thread ) const

virtual

Reimplemented from dart::Instance.

Definition at line 25050 of file object.cc.

                                                         {
  ASSERT(IsImmutable());
  intptr_t len = Length();
  if (len > 0) {
    Zone* zone = thread->zone();
    Instance& obj = Instance::Handle(zone);
    for (intptr_t i = 0; i < len; i++) {
      obj ^= At(i);
      obj = obj.CanonicalizeLocked(thread);
      this->SetAt(i, obj);
    }
  }
}

◆ CanonicalizeHash()

uint32_t dart::Array::CanonicalizeHash ( ) const

virtual

Reimplemented from dart::Instance.

Definition at line 24819 of file object.cc.

                                       {
  intptr_t len = Length();
  if (len == 0) {
    return 1;
  }
  Thread* thread = Thread::Current();
  uint32_t hash = thread->heap()->GetCanonicalHash(ptr());
  if (hash != 0) {
    return hash;
  }
  hash = len;
  Instance& member = Instance::Handle(GetTypeArguments());
  hash = CombineHashes(hash, member.CanonicalizeHash());
  for (intptr_t i = 0; i < len; i++) {
    member ^= At(i);
    hash = CombineHashes(hash, member.CanonicalizeHash());
  }
  hash = FinalizeHash(hash, kHashBits);
  thread->heap()->SetCanonicalHash(ptr(), hash);
  return hash;
}

◆ Copy()

ArrayPtr dart::Array::Copy ( ) const

inline

Definition at line 10971 of file object.h.

                        {
    return Slice(0, Length(), /*with_type_argument=*/true);
  }

◆ data_offset()

static intptr_t dart::Array::data_offset ( )

inlinestatic

Definition at line 10814 of file object.h.

                                {
    return OFFSET_OF_RETURNED_VALUE(UntaggedArray, data);
  }

◆ DataOf()

static CompressedObjectPtr * dart::Array::DataOf ( ArrayPtr array )

inlinestatic

Definition at line 10849 of file object.h.

                                                     {
    return array->untag()->data();
  }

◆ element_offset()

static intptr_t dart::Array::element_offset ( intptr_t index )

inlinestatic

Definition at line 10817 of file object.h.

                                                 {
    return OFFSET_OF_RETURNED_VALUE(UntaggedArray, data) +
           kBytesPerElement * index;
  }

◆ Equals() [1/2]

static bool dart::Array::Equals	(	ArrayPtr	a,
		ArrayPtr	b
	)

inlinestatic

Definition at line 10833 of file object.h.

                                             {
    if (a == b) return true;
    if (a->IsRawNull() || b->IsRawNull()) return false;
    if (a->untag()->length() != b->untag()->length()) return false;
    if (a->untag()->type_arguments() != b->untag()->type_arguments()) {
      return false;
    }
    const intptr_t length = LengthOf(a);
    return memcmp(a->untag()->data(), b->untag()->data(),
                  kBytesPerElement * length) == 0;
  }

◆ Equals() [2/2]

bool dart::Array::Equals ( const Array & other ) const

inline

Definition at line 10844 of file object.h.

                                        {
    NoSafepointScope scope;
    return Equals(ptr(), other.ptr());
  }

◆ GetTypeArguments()

virtual TypeArgumentsPtr dart::Array::GetTypeArguments ( ) const

inlinevirtual

Reimplemented from dart::Instance.

Definition at line 10879 of file object.h.

                                                    {
    return untag()->type_arguments();
  }

◆ Grow()

ArrayPtr dart::Array::Grow	(	const Array &	source,
		intptr_t	new_length,
		Heap::Space	space = `Heap::kNew`
	)

static

Definition at line 24932 of file object.cc.

                                      {
  Thread* thread = Thread::Current();
  Zone* zone = thread->zone();
  const Array& result =
      Array::Handle(zone, Array::NewUninitialized(new_length, space));
  intptr_t old_length = 0;
  if (!source.IsNull()) {
    old_length = source.Length();
    result.SetTypeArguments(
        TypeArguments::Handle(zone, source.GetTypeArguments()));
  } else {
    result.SetTypeArguments(Object::null_type_arguments());
  }
  ASSERT(new_length > old_length);  // Unnecessary copying of array.
  if (!UseCardMarkingForAllocation(new_length)) {
    NoSafepointScope no_safepoint(thread);
    for (intptr_t i = 0; i < old_length; i++) {
      result.untag()->set_element(i, source.untag()->element(i), thread);
    }
    for (intptr_t i = old_length; i < new_length; i++) {
      ASSERT(result.untag()->element(i) == Object::null());
    }
  } else {
    for (intptr_t i = 0; i < old_length; i++) {
      result.untag()->set_element(i, source.untag()->element(i), thread);
      if (((i + 1) % KB) == 0) {
        thread->CheckForSafepoint();
      }
    }
    for (intptr_t i = old_length; i < new_length; i++) {
      result.untag()->set_element(i, Object::null(), thread);
      if (((i + 1) % KB) == 0) {
        thread->CheckForSafepoint();
      }
    }
  }
  return result.ptr();
}

◆ index_at_offset()

static intptr_t dart::Array::index_at_offset ( intptr_t offset_in_bytes )

inlinestatic

Definition at line 10821 of file object.h.

                                                            {
    intptr_t index = (offset_in_bytes - data_offset()) / kBytesPerElement;
    ASSERT(index >= 0);
    return index;
  }

◆ InstanceSize() [1/2]

static intptr_t dart::Array::InstanceSize ( )

inlinestatic

Definition at line 10910 of file object.h.

                                 {
    ASSERT(sizeof(UntaggedArray) ==
           OFFSET_OF_RETURNED_VALUE(UntaggedArray, data));
    return 0;
  }

◆ InstanceSize() [2/2]

static constexpr intptr_t dart::Array::InstanceSize ( intptr_t len )

inlinestaticconstexpr

Definition at line 10923 of file object.h.

                                                       {
    return RoundedAllocationSize(UnroundedSize(len));
  }

◆ IsImmutable()

bool dart::Array::IsImmutable ( ) const

inline

Definition at line 10874 of file object.h.

10874{ return ptr()->GetClassId() == kImmutableArrayCid; }

dart::ObjectPtr::GetClassId

intptr_t GetClassId() const

Definition raw_object.h:864

◆ IsValidLength()

static constexpr bool dart::Array::IsValidLength ( intptr_t len )

inlinestaticconstexpr

Definition at line 10906 of file object.h.

                                                    {
    return 0 <= len && len <= kMaxElements;
  }

◆ Length()

intptr_t dart::Array::Length ( ) const

inline

Definition at line 10808 of file object.h.

10808{ return LengthOf(ptr()); }

◆ length_offset()

static intptr_t dart::Array::length_offset ( )

inlinestatic

Definition at line 10813 of file object.h.

10813{ return OFFSET_OF(UntaggedArray, length_); }

OFFSET_OF

#define OFFSET_OF(type, field)

Definition globals.h:138

◆ LengthOf()

static intptr_t dart::Array::LengthOf ( const ArrayPtr array )

inlinestatic

Definition at line 10809 of file object.h.

                                                 {
    return Smi::Value(array->untag()->length());
  }

◆ MakeFixedLength()

ArrayPtr dart::Array::MakeFixedLength	(	const GrowableObjectArray &	growable_array,
		bool	unique = `false`
	)

static

Definition at line 25014 of file object.cc.

                                             {
  ASSERT(!growable_array.IsNull());
  Thread* thread = Thread::Current();
  Zone* zone = thread->zone();
  intptr_t used_len = growable_array.Length();
  // Get the type arguments and prepare to copy them.
  const TypeArguments& type_arguments =
      TypeArguments::Handle(growable_array.GetTypeArguments());
  if (used_len == 0) {
    if (type_arguments.IsNull() && !unique) {
      // This is a raw List (as in no type arguments), so we can return the
      // simple empty array.
      return Object::empty_array().ptr();
    }
 
    // The backing array may be a shared instance, or may not have correct
    // type parameters. Create a new empty array.
    Heap::Space space = thread->IsDartMutatorThread() ? Heap::kNew : Heap::kOld;
    Array& array = Array::Handle(zone, Array::New(0, space));
    array.SetTypeArguments(type_arguments);
    return array.ptr();
  }
  const Array& array = Array::Handle(zone, growable_array.data());
  ASSERT(array.IsArray());
  array.SetTypeArguments(type_arguments);
 
  // Null the GrowableObjectArray, we are removing its backing array.
  growable_array.SetLength(0);
  growable_array.SetData(Object::empty_array());
 
  // Truncate the old backing array and return it.
  array.Truncate(used_len);
  return array.ptr();
}

◆ MakeImmutable()

void dart::Array::MakeImmutable ( ) const

Definition at line 24916 of file object.cc.

                                {
  if (IsImmutable()) return;
  ASSERT(!IsCanonical());
  untag()->SetClassId(kImmutableArrayCid);
}

◆ New() [1/3]

ArrayPtr dart::Array::New	(	intptr_t	class_id,
		intptr_t	len,
		Heap::Space	space = `Heap::kNew`
	)

staticprotected

Definition at line 24871 of file object.cc.

                                                                    {
  if (!UseCardMarkingForAllocation(len)) {
    return NewUninitialized(class_id, len, space);
  }
 
  Thread* thread = Thread::Current();
  Array& result =
      Array::Handle(thread->zone(), NewUninitialized(class_id, len, space));
  result.SetTypeArguments(Object::null_type_arguments());
  for (intptr_t i = 0; i < len; i++) {
    result.SetAt(i, Object::null_object(), thread);
    if (((i + 1) % KB) == 0) {
      thread->CheckForSafepoint();
    }
  }
  return result.ptr();
}

◆ New() [2/3]

ArrayPtr dart::Array::New	(	intptr_t	len,
		const AbstractType &	element_type,
		Heap::Space	space = `Heap::kNew`
	)

static

Definition at line 24841 of file object.cc.

                                     {
  const Array& result = Array::Handle(Array::New(len, space));
  if (!element_type.IsDynamicType()) {
    TypeArguments& type_args = TypeArguments::Handle(TypeArguments::New(1));
    type_args.SetTypeAt(0, element_type);
    type_args = type_args.Canonicalize(Thread::Current());
    result.SetTypeArguments(type_args);
  }
  return result.ptr();
}

◆ New() [3/3]

static ArrayPtr dart::Array::New	(	intptr_t	len,
		Heap::Space	space = `Heap::kNew`
	)

inlinestatic

Definition at line 10933 of file object.h.

                                                                {
    return New(kArrayCid, len, space);
  }

◆ NewUninitialized() [1/2]

ArrayPtr dart::Array::NewUninitialized	(	intptr_t	class_id,
		intptr_t	len,
		Heap::Space	space = `Heap::kNew`
	)

staticprotected

Definition at line 24854 of file object.cc.

                                                  {
  if (!IsValidLength(len)) {
    // This should be caught before we reach here.
    FATAL("Fatal error in Array::New: invalid len %" Pd "\n", len);
  }
  auto raw = Object::AllocateVariant<Array>(class_id, space, len);
  NoSafepointScope no_safepoint;
  raw->untag()->set_length(Smi::New(len));
  if (UseCardMarkingForAllocation(len)) {
    ASSERT(raw->IsOldObject());
    raw->untag()->SetCardRememberedBitUnsynchronized();
  }
  return raw;
}

◆ NewUninitialized() [2/2]

static ArrayPtr dart::Array::NewUninitialized	(	intptr_t	len,
		Heap::Space	space = `Heap::kNew`
	)

inlinestatic

Definition at line 10938 of file object.h.

                                                               {
    return NewUninitialized(kArrayCid, len, space);
  }

◆ SetAt() [1/2]

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

void dart::Array::SetAt	(	intptr_t	index,
		const Object &	value
	)		const

inline

Definition at line 10858 of file object.h.

                                                        {
    untag()->set_element<order>(index, value.ptr());
  }

◆ SetAt() [2/2]

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

void dart::Array::SetAt	(	intptr_t	index,
		const Object &	value,
		Thread *	thread
	)		const

inline

Definition at line 10862 of file object.h.

                                                                        {
    untag()->set_element<order>(index, value.ptr(), thread);
  }

◆ SetAtRelease()

void dart::Array::SetAtRelease	(	intptr_t	index,
		const Object &	value
	)		const

inline

Definition at line 10870 of file object.h.

                                                               {
    untag()->set_element<std::memory_order_release>(index, value.ptr());
  }

◆ SetTypeArguments()

virtual void dart::Array::SetTypeArguments ( const TypeArguments & value ) const

inlinevirtual

Reimplemented from dart::Instance.

Definition at line 10882 of file object.h.

                                                                  {
    // An Array is raw or takes one type argument. However, its type argument
    // vector may be longer than 1 due to a type optimization reusing the type
    // argument vector of the instantiator.
    ASSERT(value.IsNull() ||
           ((value.Length() >= 1) &&
            value.IsInstantiated() /*&& value.IsCanonical()*/));
    // TODO(asiva): Values read from a message snapshot are not properly marked
    // as canonical. See for example tests/isolate/mandel_isolate_test.dart.
    StoreArrayPointer(&untag()->type_arguments_, value.ptr());
  }

◆ Slice()

ArrayPtr dart::Array::Slice	(	intptr_t	start,
		intptr_t	count,
		bool	with_type_argument
	)		const

Definition at line 24889 of file object.cc.

                                                     {
  Thread* thread = Thread::Current();
  Zone* zone = thread->zone();
  const Array& dest = Array::Handle(zone, Array::NewUninitialized(count));
  if (with_type_argument) {
    dest.SetTypeArguments(TypeArguments::Handle(zone, GetTypeArguments()));
  } else {
    dest.SetTypeArguments(Object::null_type_arguments());
  }
  if (!UseCardMarkingForAllocation(count)) {
    NoSafepointScope no_safepoint(thread);
    for (int i = 0; i < count; i++) {
      dest.untag()->set_element(i, untag()->element(i + start), thread);
    }
  } else {
    for (int i = 0; i < count; i++) {
      dest.untag()->set_element(i, untag()->element(i + start), thread);
      if (((i + 1) % KB) == 0) {
        thread->CheckForSafepoint();
      }
    }
  }
  return dest.ptr();
}

◆ Truncate()

void dart::Array::Truncate ( intptr_t new_length ) const

Definition at line 24973 of file object.cc.

                                           {
  if (IsNull()) {
    return;
  }
  Thread* thread = Thread::Current();
  Zone* zone = thread->zone();
  const Array& array = Array::Handle(zone, this->ptr());
 
  intptr_t old_len = array.Length();
  ASSERT(new_len <= old_len);
  if (old_len == new_len) {
    return;
  }
  intptr_t old_size = Array::InstanceSize(old_len);
  intptr_t new_size = Array::InstanceSize(new_len);
 
  NoSafepointScope no_safepoint;
 
  // If there is any left over space fill it with either an Array object or
  // just a plain object (depending on the amount of left over space) so
  // that it can be traversed over successfully during garbage collection.
  Object::MakeUnusedSpaceTraversable(array, old_size, new_size);
 
  // Update the size in the header field and length of the array object.
  // These release operations are balanced by acquire operations in the
  // concurrent sweeper.
  uword old_tags = array.untag()->tags_;
  uword new_tags;
  ASSERT(kArrayCid == UntaggedObject::ClassIdTag::decode(old_tags));
  do {
    new_tags = UntaggedObject::SizeTag::update(new_size, old_tags);
  } while (!array.untag()->tags_.compare_exchange_weak(
      old_tags, new_tags, std::memory_order_release));
 
  // Between the CAS of the header above and the SetLength below, the array is
  // temporarily in an inconsistent state. The header is considered the
  // overriding source of object size by UntaggedObject::HeapSize, but the
  // ASSERTs in UntaggedObject::HeapSizeFromClass must handle this special case.
  array.SetLengthRelease(new_len);
}

◆ type_arguments_offset()

static intptr_t dart::Array::type_arguments_offset ( )

inlinestatic

Definition at line 10902 of file object.h.

                                          {
    return OFFSET_OF(UntaggedArray, type_arguments_);
  }

◆ UnroundedSize()

static constexpr intptr_t dart::Array::UnroundedSize ( intptr_t len )

inlinestaticconstexpr

Definition at line 10916 of file object.h.

                                                        {
    // Ensure that variable length data is not adding to the object length.
    ASSERT(sizeof(UntaggedArray) ==
           (sizeof(UntaggedInstance) + (2 * kBytesPerElement)));
    ASSERT(IsValidLength(len));
    return sizeof(UntaggedArray) + (len * kBytesPerElement);
  }

◆ UseCardMarkingForAllocation()

static constexpr bool dart::Array::UseCardMarkingForAllocation ( const intptr_t array_length )

inlinestaticconstexpr

Definition at line 10797 of file object.h.

                                   {
    return Array::InstanceSize(array_length) > kNewAllocatableSize;
  }

Friends And Related Symbol Documentation

◆ Class

friend class Class

friend

Definition at line 11003 of file object.h.

◆ ImmutableArray

friend class ImmutableArray

friend

Definition at line 11004 of file object.h.

◆ MessageDeserializer

friend class MessageDeserializer

friend

Definition at line 11007 of file object.h.

◆ Object

friend class Object

friend

Definition at line 11005 of file object.h.

◆ String

friend class String

friend

Definition at line 11006 of file object.h.

Member Data Documentation

◆ kBytesPerElement

constexpr intptr_t dart::Array::kBytesPerElement = ArrayTraits::kElementSize

staticconstexpr

Definition at line 10897 of file object.h.

◆ kElementTypeTypeArgPos

constexpr intptr_t dart::Array::kElementTypeTypeArgPos = 0

staticconstexpr

Definition at line 10877 of file object.h.

◆ kMaxElements

constexpr intptr_t dart::Array::kMaxElements = kSmiMax / kBytesPerElement

staticconstexpr

Definition at line 10898 of file object.h.

◆ kMaxLengthForWriteBarrierElimination

constexpr intptr_t dart::Array::kMaxLengthForWriteBarrierElimination = 8

staticconstexpr

Definition at line 10806 of file object.h.

◆ kMaxNewSpaceElements

constexpr intptr_t dart::Array::kMaxNewSpaceElements

staticconstexpr

Initial value:

=

(kNewAllocatableSize - sizeof(UntaggedArray)) / kBytesPerElement

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

Classes

Public Member Functions

Static Public Member Functions

Static Public Attributes

Static Protected Member Functions

Friends

Additional Inherited Members

Detailed Description

Member Function Documentation

◆ At()

◆ AtAcquire()

◆ CanonicalizeEquals()

◆ CanonicalizeFieldsLocked()

◆ CanonicalizeHash()

◆ Copy()

◆ data_offset()

◆ DataOf()

◆ element_offset()

◆ Equals() [1/2]

◆ Equals() [2/2]

◆ GetTypeArguments()

◆ Grow()

◆ index_at_offset()

◆ InstanceSize() [1/2]

◆ InstanceSize() [2/2]

◆ IsImmutable()

◆ IsValidLength()

◆ Length()

◆ length_offset()

◆ LengthOf()

◆ MakeFixedLength()

◆ MakeImmutable()

◆ New() [1/3]

◆ New() [2/3]

◆ New() [3/3]

◆ NewUninitialized() [1/2]

◆ NewUninitialized() [2/2]

◆ SetAt() [1/2]

◆ SetAt() [2/2]

◆ SetAtRelease()

◆ SetTypeArguments()

◆ Slice()

◆ Truncate()

◆ type_arguments_offset()

◆ UnroundedSize()

◆ UseCardMarkingForAllocation()

Friends And Related Symbol Documentation

◆ Class

◆ ImmutableArray

◆ MessageDeserializer

◆ Object

◆ String

Member Data Documentation

◆ kBytesPerElement

◆ kElementTypeTypeArgPos

◆ kMaxElements

◆ kMaxLengthForWriteBarrierElimination

◆ kMaxNewSpaceElements