#include <object.h>

Inheritance diagram for dart::SubtypeTestCache:

Public Types
enum	Entries { kInstanceCidOrSignature = 0 , kInstanceTypeArguments = 1 , kInstantiatorTypeArguments = 2 , kFunctionTypeArguments = 3 , kInstanceParentFunctionTypeArguments = 4 , kInstanceDelayedFunctionTypeArguments = 5 , kDestinationType = 6 , kTestResult = 7 , kTestEntryLength = 8 }

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

enum class	NameDisambiguation { kYes , kNo }

using	UntaggedObjectType = UntaggedObject

using	ObjectPtrType = ObjectPtr

Public Member Functions
intptr_t	NumberOfChecks () const

intptr_t	NumEntries () const

intptr_t	AddCheck (const Object &instance_class_id_or_signature, const AbstractType &destination_type, const TypeArguments &instance_type_arguments, const TypeArguments &instantiator_type_arguments, const TypeArguments &function_type_arguments, const TypeArguments &instance_parent_function_type_arguments, const TypeArguments &instance_delayed_type_arguments, const Bool &test_result) const

void	GetCheck (intptr_t ix, Object instance_class_id_or_signature, AbstractType destination_type, TypeArguments instance_type_arguments, TypeArguments instantiator_type_arguments, TypeArguments function_type_arguments, TypeArguments instance_parent_function_type_arguments, TypeArguments instance_delayed_type_arguments, Bool test_result) const

void	GetCurrentCheck (intptr_t ix, Object instance_class_id_or_signature, AbstractType destination_type, TypeArguments instance_type_arguments, TypeArguments instantiator_type_arguments, TypeArguments function_type_arguments, TypeArguments instance_parent_function_type_arguments, TypeArguments instance_delayed_type_arguments, Bool test_result) const

bool	GetNextCheck (intptr_t ix, Object instance_class_id_or_signature, AbstractType destination_type, TypeArguments instance_type_arguments, TypeArguments instantiator_type_arguments, TypeArguments function_type_arguments, TypeArguments instance_parent_function_type_arguments, TypeArguments instance_delayed_type_arguments, Bool *test_result) const

bool	HasCheck (const Object &instance_class_id_or_signature, const AbstractType &destination_type, const TypeArguments &instance_type_arguments, const TypeArguments &instantiator_type_arguments, const TypeArguments &function_type_arguments, const TypeArguments &instance_parent_function_type_arguments, const TypeArguments &instance_delayed_type_arguments, intptr_t index, Bool result) const

void	WriteEntryToBuffer (Zone zone, BaseTextBuffer buffer, intptr_t index, const char *line_prefix=nullptr) const

void	WriteToBuffer (Zone zone, BaseTextBuffer buffer, const char *line_prefix=nullptr) const

void	Reset () const

bool	Equals (const SubtypeTestCache &other) const

bool	IsHash () const

SubtypeTestCachePtr	Copy (Thread *thread) const

ArrayPtr	cache () const

intptr_t	num_inputs () const

intptr_t	num_occupied () const

bool	IsOccupied (intptr_t index) 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 SubtypeTestCachePtr	New (intptr_t num_inputs)

static intptr_t	InstanceSize ()

static intptr_t	cache_offset ()

static intptr_t	num_inputs_offset ()

static intptr_t	UsedInputsForType (const AbstractType &type)

static constexpr intptr_t	MaxEntriesForCacheAllocatedFor (intptr_t count)

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	kMaxInputs = kTestResult

static constexpr intptr_t	kMaxLinearCacheEntries = 30

static constexpr intptr_t	kMaxLinearCacheSize

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

static const ClassId	kClassId = kObjectCid

Friends
class	Class

class	FieldInvalidator

class	VMSerializationRoots

class	VMDeserializationRoots

Additional Inherited Members
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

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)

Protected Attributes inherited from dart::Object
ObjectPtr	ptr_

Detailed Description

Definition at line 7634 of file object.h.

Member Enumeration Documentation

◆ Entries

enum dart::SubtypeTestCache::Entries

Enumerator
kInstanceCidOrSignature
kInstanceTypeArguments
kInstantiatorTypeArguments
kFunctionTypeArguments
kInstanceParentFunctionTypeArguments
kInstanceDelayedFunctionTypeArguments
kDestinationType
kTestResult
kTestEntryLength

Definition at line 7659 of file object.h.

               {
    kInstanceCidOrSignature = 0,
    kInstanceTypeArguments = 1,
    kInstantiatorTypeArguments = 2,
    kFunctionTypeArguments = 3,
    kInstanceParentFunctionTypeArguments = 4,
    kInstanceDelayedFunctionTypeArguments = 5,
    kDestinationType = 6,
    kTestResult = 7,
    kTestEntryLength = 8,
  };

Member Function Documentation

◆ AddCheck()

intptr_t dart::SubtypeTestCache::AddCheck	(	const Object &	instance_class_id_or_signature,
		const AbstractType &	destination_type,
		const TypeArguments &	instance_type_arguments,
		const TypeArguments &	instantiator_type_arguments,
		const TypeArguments &	function_type_arguments,
		const TypeArguments &	instance_parent_function_type_arguments,
		const TypeArguments &	instance_delayed_type_arguments,
		const Bool &	test_result
	)		const

Definition at line 19028 of file object.cc.

                                   {
  ASSERT(Thread::Current()
             ->isolate_group()
             ->subtype_test_cache_mutex()
             ->IsOwnedByCurrentThread());
  ASSERT(!test_result.IsNull());
  ASSERT(Smi::New(kRecordCid) != instance_class_id_or_signature.ptr());
 
  const intptr_t old_num = NumberOfChecks();
  Zone* const zone = Thread::Current()->zone();
  Array& data = Array::Handle(zone, cache());
  bool was_grown;
  data = EnsureCapacity(zone, data, old_num + 1, &was_grown);
  ASSERT(data.ptr() != Object::empty_subtype_test_cache_array().ptr());
 
  const auto& loc = FindKeyOrUnused(
      data, num_inputs(), instance_class_id_or_signature, destination_type,
      instance_type_arguments, instantiator_type_arguments,
      function_type_arguments, instance_parent_function_type_arguments,
      instance_delayed_type_arguments);
  SubtypeTestCacheTable entries(data);
  const auto& entry = entries[loc.entry];
  if (loc.present) {
    if (entry.Get<kTestResult>() != test_result.ptr()) {
      const auto& old_result = Bool::Handle(zone, entry.Get<kTestResult>());
      FATAL("Existing subtype test cache entry has result %s, not %s",
            old_result.ToCString(), test_result.ToCString());
    }
    return loc.entry;
  }
 
  // Set the used elements in the entry in reverse order, so that the instance
  // cid or signature is last, then increment the number of entries.
  entry.Set<kTestResult>(test_result);
  switch (num_inputs()) {
    case 7:
      entry.Set<kDestinationType>(destination_type);
      FALL_THROUGH;
    case 6:
      entry.Set<kInstanceDelayedFunctionTypeArguments>(
          instance_delayed_type_arguments);
      FALL_THROUGH;
    case 5:
      entry.Set<kInstanceParentFunctionTypeArguments>(
          instance_parent_function_type_arguments);
      FALL_THROUGH;
    case 4:
      entry.Set<kFunctionTypeArguments>(function_type_arguments);
      FALL_THROUGH;
    case 3:
      entry.Set<kInstantiatorTypeArguments>(instantiator_type_arguments);
      FALL_THROUGH;
    case 2:
      entry.Set<kInstanceTypeArguments>(instance_type_arguments);
      FALL_THROUGH;
    case 1:
      // If this is a new backing array, we don't need store-release barriers,
      // as no reader has access to the array until it is set as the backing
      // store (which is done with a store-release barrier).
      //
      // Otherwise, the instance cid or signature must be set last with a
      // store-release barrier, so concurrent readers can depend on a non-null
      // value meaning the rest of the entry is safe to load without barriers.
      if (was_grown) {
        entry.Set<kInstanceCidOrSignature>(instance_class_id_or_signature);
      } else {
        entry.Set<kInstanceCidOrSignature, std::memory_order_release>(
            instance_class_id_or_signature);
      }
      break;
    default:
      UNREACHABLE();
  }
  set_num_occupied(old_num + 1);
  if (was_grown) {
    set_cache(data);
  }
  return loc.entry;
}

◆ cache()

ArrayPtr dart::SubtypeTestCache::cache ( ) const

Definition at line 18988 of file object.cc.

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

◆ cache_offset()

static intptr_t dart::SubtypeTestCache::cache_offset ( )

inlinestatic

Definition at line 7782 of file object.h.

                                 {
    return OFFSET_OF(UntaggedSubtypeTestCache, cache_);
  }

◆ Copy()

SubtypeTestCachePtr dart::SubtypeTestCache::Copy ( Thread * thread ) const

Definition at line 19689 of file object.cc.

                                                               {
  ASSERT(thread->isolate_group()
             ->subtype_test_cache_mutex()
             ->IsOwnedByCurrentThread());
  if (IsNull()) {
    return SubtypeTestCache::null();
  }
  Zone* const zone = thread->zone();
  // STC caches are only copied on write if there are not enough unoccupied
  // entries to store a new one, so we need to copy the array.
  const auto& result =
      SubtypeTestCache::Handle(zone, SubtypeTestCache::New(num_inputs()));
  auto& entry_cache = Array::Handle(zone, cache());
  entry_cache = entry_cache.Copy();
  result.set_cache(entry_cache);
  result.set_num_occupied(num_occupied());
  return result.ptr();
}

◆ Equals()

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

Definition at line 19676 of file object.cc.

                                                                 {
  ASSERT(Thread::Current()
             ->isolate_group()
             ->subtype_test_cache_mutex()
             ->IsOwnedByCurrentThread());
  if (ptr() == other.ptr()) {
    return true;
  }
  if (num_inputs() != other.num_inputs()) return false;
  if (num_occupied() != other.num_occupied()) return false;
  return Array::Handle(cache()).Equals(Array::Handle(other.cache()));
}

◆ GetCheck()

void dart::SubtypeTestCache::GetCheck	(	intptr_t	ix,
		Object *	instance_class_id_or_signature,
		AbstractType *	destination_type,
		TypeArguments *	instance_type_arguments,
		TypeArguments *	instantiator_type_arguments,
		TypeArguments *	function_type_arguments,
		TypeArguments *	instance_parent_function_type_arguments,
		TypeArguments *	instance_delayed_type_arguments,
		Bool *	test_result
	)		const

Definition at line 19396 of file object.cc.

                             {
  ASSERT(Thread::Current()
             ->isolate_group()
             ->subtype_test_cache_mutex()
             ->IsOwnedByCurrentThread());
  GetCurrentCheck(ix, instance_class_id_or_signature, destination_type,
                  instance_type_arguments, instantiator_type_arguments,
                  function_type_arguments,
                  instance_parent_function_type_arguments,
                  instance_delayed_type_arguments, test_result);
}

◆ GetCurrentCheck()

void dart::SubtypeTestCache::GetCurrentCheck	(	intptr_t	ix,
		Object *	instance_class_id_or_signature,
		AbstractType *	destination_type,
		TypeArguments *	instance_type_arguments,
		TypeArguments *	instantiator_type_arguments,
		TypeArguments *	function_type_arguments,
		TypeArguments *	instance_parent_function_type_arguments,
		TypeArguments *	instance_delayed_type_arguments,
		Bool *	test_result
	)		const

Definition at line 19417 of file object.cc.

                             {
  const Array& array = Array::Handle(cache());
  GetCheckFromArray(array, num_inputs(), ix, instance_class_id_or_signature,
                    destination_type, instance_type_arguments,
                    instantiator_type_arguments, function_type_arguments,
                    instance_parent_function_type_arguments,
                    instance_delayed_type_arguments, test_result);
}

◆ GetNextCheck()

bool dart::SubtypeTestCache::GetNextCheck	(	intptr_t *	ix,
		Object *	instance_class_id_or_signature,
		AbstractType *	destination_type,
		TypeArguments *	instance_type_arguments,
		TypeArguments *	instantiator_type_arguments,
		TypeArguments *	function_type_arguments,
		TypeArguments *	instance_parent_function_type_arguments,
		TypeArguments *	instance_delayed_type_arguments,
		Bool *	test_result
	)		const

Definition at line 19485 of file object.cc.

                             {
  ASSERT(ix != nullptr);
  for (intptr_t i = *ix; i < NumEntries(); i++) {
    ASSERT(Thread::Current()
               ->isolate_group()
               ->subtype_test_cache_mutex()
               ->IsOwnedByCurrentThread());
    if (IsOccupied(i)) {
      GetCurrentCheck(i, instance_class_id_or_signature, destination_type,
                      instance_type_arguments, instantiator_type_arguments,
                      function_type_arguments,
                      instance_parent_function_type_arguments,
                      instance_delayed_type_arguments, test_result);
      *ix = i + 1;
      return true;
    }
  }
  return false;
}

◆ HasCheck()

bool dart::SubtypeTestCache::HasCheck	(	const Object &	instance_class_id_or_signature,
		const AbstractType &	destination_type,
		const TypeArguments &	instance_type_arguments,
		const TypeArguments &	instantiator_type_arguments,
		const TypeArguments &	function_type_arguments,
		const TypeArguments &	instance_parent_function_type_arguments,
		const TypeArguments &	instance_delayed_type_arguments,
		intptr_t *	index,
		Bool *	result
	)		const

Definition at line 19514 of file object.cc.

                        {
  const auto& data = Array::Handle(cache());
  auto loc = FindKeyOrUnused(
      data, num_inputs(), instance_class_id_or_signature, destination_type,
      instance_type_arguments, instantiator_type_arguments,
      function_type_arguments, instance_parent_function_type_arguments,
      instance_delayed_type_arguments);
  if (loc.present) {
    if (index != nullptr) {
      *index = loc.entry;
    }
    if (result != nullptr) {
      SubtypeTestCacheTable entries(data);
      const auto& entry = entries[loc.entry];
      // A positive result from FindKeyOrUnused means that load-acquire is not
      // needed, as an occupied entry never changes for a given backing array.
      *result = entry.Get<kTestResult>();
      ASSERT(!result->IsNull());
    }
  }
  return loc.present;
}

◆ InstanceSize()

static intptr_t dart::SubtypeTestCache::InstanceSize ( )

inlinestatic

Definition at line 7778 of file object.h.

                                 {
    return RoundedAllocationSize(sizeof(UntaggedSubtypeTestCache));
  }

◆ IsHash()

bool dart::SubtypeTestCache::IsHash ( ) const

Definition at line 19019 of file object.cc.

                                    {
  if (IsNull()) return false;
  return Array::LengthOf(cache()) > kMaxLinearCacheSize;
}

◆ IsOccupied()

bool dart::SubtypeTestCache::IsOccupied ( intptr_t index ) const

Definition at line 19708 of file object.cc.

                                                      {
  ASSERT(!IsNull());
  ASSERT(index < NumEntries());
  const intptr_t cache_index =
      index * kTestEntryLength + kInstanceCidOrSignature;
  NoSafepointScope no_safepoint;
  return cache()->untag()->element<std::memory_order_acquire>(cache_index) !=
         Object::null();
}

◆ MaxEntriesForCacheAllocatedFor()

static constexpr intptr_t dart::SubtypeTestCache::MaxEntriesForCacheAllocatedFor ( intptr_t count )

inlinestaticconstexpr

Definition at line 7814 of file object.h.

                                                                           {
    // If the cache would be linear, just return the count unchanged.
    if (count <= kMaxLinearCacheEntries) return count;
    intptr_t allocated_entries = Utils::RoundUpToPowerOfTwo(count);
    if (LoadFactor(count, allocated_entries) >= kMaxLoadFactor) {
      allocated_entries *= 2;
    }
    const intptr_t max_entries =
        static_cast<intptr_t>(kMaxLoadFactor * allocated_entries);
    assert(LoadFactor(max_entries, allocated_entries) < kMaxLoadFactor);
    assert(max_entries >= count);
    return max_entries;
  }

◆ New()

SubtypeTestCachePtr dart::SubtypeTestCache::New ( intptr_t num_inputs )

static

Definition at line 18974 of file object.cc.

                                                             {
  ASSERT(Object::subtypetestcache_class() != Class::null());
  ASSERT(num_inputs >= 1);
  ASSERT(num_inputs <= kMaxInputs);
  // SubtypeTestCache objects are long living objects, allocate them in the
  // old generation.
  const auto& result =
      SubtypeTestCache::Handle(Object::Allocate<SubtypeTestCache>(Heap::kOld));
  ASSERT_EQUAL(result.num_occupied(), 0);
  result.untag()->num_inputs_ = num_inputs;
  result.set_cache(Object::empty_subtype_test_cache_array());
  return result.ptr();
}

◆ num_inputs()

intptr_t dart::SubtypeTestCache::num_inputs ( ) const

inline

Definition at line 7790 of file object.h.

7790{ return untag()->num_inputs_; }

◆ num_inputs_offset()

static intptr_t dart::SubtypeTestCache::num_inputs_offset ( )

inlinestatic

Definition at line 7787 of file object.h.

                                      {
    return OFFSET_OF(UntaggedSubtypeTestCache, num_inputs_);
  }

◆ num_occupied()

intptr_t dart::SubtypeTestCache::num_occupied ( ) const

inline

Definition at line 7792 of file object.h.

7792{ return untag()->num_occupied_; }

◆ NumberOfChecks()

intptr_t dart::SubtypeTestCache::NumberOfChecks ( ) const

Definition at line 19004 of file object.cc.

                                                {
  ASSERT(!IsNull());
  return num_occupied();
}

◆ NumEntries()

intptr_t dart::SubtypeTestCache::NumEntries ( ) const

Definition at line 19009 of file object.cc.

                                            {
  ASSERT(!IsNull());
  return Array::LengthOf(cache()) / kTestEntryLength;
}

◆ Reset()

void dart::SubtypeTestCache::Reset ( ) const

Definition at line 19671 of file object.cc.

                                   {
  set_num_occupied(0);
  set_cache(Object::empty_subtype_test_cache_array());
}

◆ UsedInputsForType()

intptr_t dart::SubtypeTestCache::UsedInputsForType ( const AbstractType & type )

static

Definition at line 19718 of file object.cc.

                                                                     {
  if (type.IsType()) {
    if (type.IsInstantiated()) return 2;
    if (type.IsInstantiated(kFunctions)) return 3;
    return 4;
  }
  // Default to all inputs except for the destination type, which must be
  // statically known, otherwise this method wouldn't be called.
  static_assert(kDestinationType == kMaxInputs - 1,
                "destination type is not last input");
  return kMaxInputs - 1;
}

◆ WriteEntryToBuffer()

void dart::SubtypeTestCache::WriteEntryToBuffer	(	Zone *	zone,
		BaseTextBuffer *	buffer,
		intptr_t	index,
		const char *	line_prefix = `nullptr`
	)		const

Definition at line 19546 of file object.cc.

                                                                         {
  ASSERT(Thread::Current()
             ->isolate_group()
             ->subtype_test_cache_mutex()
             ->IsOwnedByCurrentThread());
  WriteCurrentEntryToBuffer(zone, buffer, index, line_prefix);
}

◆ WriteToBuffer()

void dart::SubtypeTestCache::WriteToBuffer	(	Zone *	zone,
		BaseTextBuffer *	buffer,
		const char *	line_prefix = `nullptr`
	)		const

Definition at line 19557 of file object.cc.

                                                                    {
  ASSERT(Thread::Current()
             ->isolate_group()
             ->subtype_test_cache_mutex()
             ->IsOwnedByCurrentThread());
  WriteToBufferUnlocked(zone, buffer, line_prefix);
}

Friends And Related Symbol Documentation

◆ Class

friend class Class

friend

Definition at line 7930 of file object.h.

◆ FieldInvalidator

friend class FieldInvalidator

friend

Definition at line 7931 of file object.h.

◆ VMDeserializationRoots

friend class VMDeserializationRoots

friend

Definition at line 7933 of file object.h.

◆ VMSerializationRoots

friend class VMSerializationRoots

friend

Definition at line 7932 of file object.h.

Member Data Documentation

◆ kMaxInputs

constexpr intptr_t dart::SubtypeTestCache::kMaxInputs = kTestResult

staticconstexpr

Definition at line 7676 of file object.h.

◆ kMaxLinearCacheEntries

constexpr intptr_t dart::SubtypeTestCache::kMaxLinearCacheEntries = 30

staticconstexpr

Definition at line 7801 of file object.h.

◆ kMaxLinearCacheSize

constexpr intptr_t dart::SubtypeTestCache::kMaxLinearCacheSize

staticconstexpr

Initial value:

=

(kMaxLinearCacheEntries + 1) * kTestEntryLength

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

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Friends

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ Entries

Member Function Documentation

◆ AddCheck()

◆ cache()

◆ cache_offset()

◆ Copy()

◆ Equals()

◆ GetCheck()

◆ GetCurrentCheck()

◆ GetNextCheck()

◆ HasCheck()

◆ InstanceSize()

◆ IsHash()

◆ IsOccupied()

◆ MaxEntriesForCacheAllocatedFor()

◆ New()

◆ num_inputs()

◆ num_inputs_offset()

◆ num_occupied()

◆ NumberOfChecks()

◆ NumEntries()

◆ Reset()

◆ UsedInputsForType()

◆ WriteEntryToBuffer()

◆ WriteToBuffer()

Friends And Related Symbol Documentation

◆ Class

◆ FieldInvalidator

◆ VMDeserializationRoots

◆ VMSerializationRoots

Member Data Documentation

◆ kMaxInputs

◆ kMaxLinearCacheEntries

◆ kMaxLinearCacheSize