#include <il.h>

Inheritance diagram for dart::HierarchyInfo:

Public Member Functions
	HierarchyInfo (Thread *thread)

	~HierarchyInfo ()

const CidRangeVector &	SubtypeRangesForClass (const Class &klass, bool include_abstract, bool exclude_null)

bool	InstanceOfHasClassRange (const AbstractType &type, intptr_t lower_limit, intptr_t upper_limit)

bool	CanUseSubtypeRangeCheckFor (const AbstractType &type)

bool	CanUseGenericSubtypeRangeCheckFor (const AbstractType &type)

bool	CanUseRecordSubtypeRangeCheckFor (const AbstractType &type)

Public Member Functions inherited from dart::ThreadStackResource
	ThreadStackResource (Thread *T)

	~ThreadStackResource ()

Thread *	thread () const

Isolate *	isolate () const

IsolateGroup *	isolate_group () const

Public Member Functions inherited from dart::StackResource
	StackResource (ThreadState *thread)

virtual	~StackResource ()

ThreadState *	thread () const

Static Public Attributes
static constexpr intptr_t	kNoCompatibleTAVOffset = 0

Additional Inherited Members
Static Public Member Functions inherited from dart::StackResource
static void	Unwind (ThreadState *thread)

static void	UnwindAbove (ThreadState thread, StackResource new_top)

Detailed Description

Definition at line 267 of file il.h.

Constructor & Destructor Documentation

◆ HierarchyInfo()

dart::HierarchyInfo::HierarchyInfo ( Thread * thread )

inlineexplicit

Definition at line 269 of file il.h.

      : ThreadStackResource(thread),
        cid_subtype_ranges_nullable_(),
        cid_subtype_ranges_abstract_nullable_(),
        cid_subtype_ranges_nonnullable_(),
        cid_subtype_ranges_abstract_nonnullable_() {
    thread->set_hierarchy_info(this);
  }

◆ ~HierarchyInfo()

dart::HierarchyInfo::~HierarchyInfo ( )

inline

Definition at line 278 of file il.h.

278{ thread()->set_hierarchy_info(nullptr); }

Member Function Documentation

◆ CanUseGenericSubtypeRangeCheckFor()

bool dart::HierarchyInfo::CanUseGenericSubtypeRangeCheckFor ( const AbstractType & type )

Definition at line 344 of file il.cc.

                              {
  ASSERT(type.IsFinalized());
 
  if (!type.IsType() || type.IsDartFunctionType()) {
    return false;
  }
 
  // The FutureOr<T> type cannot be handled by checking whether the instance is
  // a subtype of FutureOr and then checking whether the type argument `T`
  // matches.
  //
  // Instead we would need to perform multiple checks:
  //
  //    instance is Null || instance is T || instance is Future<T>
  //
  if (type.IsFutureOrType()) {
    return false;
  }
 
  // NOTE: We do allow non-instantiated types here (in comparison to
  // [CanUseSubtypeRangeCheckFor], since we handle type parameters in the type
  // expression in some cases (see below).
 
  Zone* zone = thread()->zone();
  const Class& type_class = Class::Handle(zone, type.type_class());
  const intptr_t num_type_parameters = type_class.NumTypeParameters();
 
  // This function should only be called for generic classes.
  ASSERT(type_class.NumTypeParameters() > 0 &&
         Type::Cast(type).arguments() != TypeArguments::null());
 
  const TypeArguments& ta =
      TypeArguments::Handle(zone, Type::Cast(type).arguments());
  ASSERT(ta.Length() == num_type_parameters);
 
  // Ensure we can handle all type arguments
  // via [CidRange]-based checks or that it is a type parameter.
  AbstractType& type_arg = AbstractType::Handle(zone);
  for (intptr_t i = 0; i < num_type_parameters; ++i) {
    type_arg = ta.TypeAt(i);
    if (!CanUseSubtypeRangeCheckFor(type_arg) && !type_arg.IsTypeParameter()) {
      return false;
    }
  }
 
  return true;
}

◆ CanUseRecordSubtypeRangeCheckFor()

bool dart::HierarchyInfo::CanUseRecordSubtypeRangeCheckFor ( const AbstractType & type )

Definition at line 393 of file il.cc.

                                                                             {
  ASSERT(type.IsFinalized());
  if (!type.IsRecordType()) {
    return false;
  }
  const RecordType& rec = RecordType::Cast(type);
  Zone* zone = thread()->zone();
  auto& field_type = AbstractType::Handle(zone);
  for (intptr_t i = 0, n = rec.NumFields(); i < n; ++i) {
    field_type = rec.FieldTypeAt(i);
    if (!CanUseSubtypeRangeCheckFor(field_type)) {
      return false;
    }
  }
  return true;
}

◆ CanUseSubtypeRangeCheckFor()

bool dart::HierarchyInfo::CanUseSubtypeRangeCheckFor ( const AbstractType & type )

Definition at line 305 of file il.cc.

                                                                       {
  ASSERT(type.IsFinalized());
 
  if (!type.IsInstantiated() || !type.IsType()) {
    return false;
  }
 
  // The FutureOr<T> type cannot be handled by checking whether the instance is
  // a subtype of FutureOr and then checking whether the type argument `T`
  // matches.
  //
  // Instead we would need to perform multiple checks:
  //
  //    instance is Null || instance is T || instance is Future<T>
  //
  if (type.IsFutureOrType()) {
    return false;
  }
 
  Zone* zone = thread()->zone();
  const Class& type_class = Class::Handle(zone, type.type_class());
 
  // We can use class id range checks only if we don't have to test type
  // arguments.
  //
  // This is e.g. true for "String" but also for "List<dynamic>".  (A type for
  // which the type arguments vector is instantiated to bounds is known as a
  // rare type.)
  if (type_class.IsGeneric()) {
    const Type& rare_type = Type::Handle(zone, type_class.RareType());
    if (!rare_type.IsSubtypeOf(type, Heap::kNew)) {
      ASSERT(Type::Cast(type).arguments() != TypeArguments::null());
      return false;
    }
  }
 
  return true;
}

◆ InstanceOfHasClassRange()

bool dart::HierarchyInfo::InstanceOfHasClassRange	(	const AbstractType &	type,
		intptr_t *	lower_limit,
		intptr_t *	upper_limit
	)

Definition at line 410 of file il.cc.

                                                                   {
  ASSERT(CompilerState::Current().is_aot());
  if (type.IsNullable()) {
    // 'is' test for nullable types should accept null cid in addition to the
    // class range. In most cases it is not possible to extend class range to
    // include kNullCid.
    return false;
  }
  if (CanUseSubtypeRangeCheckFor(type)) {
    const Class& type_class =
        Class::Handle(thread()->zone(), type.type_class());
    const CidRangeVector& ranges =
        SubtypeRangesForClass(type_class,
                              /*include_abstract=*/false,
                              /*exclude_null=*/true);
    if (ranges.length() == 1) {
      const CidRangeValue& range = ranges[0];
      ASSERT(!range.IsIllegalRange());
      *lower_limit = range.cid_start;
      *upper_limit = range.cid_end;
      return true;
    }
  }
  return false;
}

◆ SubtypeRangesForClass()

const CidRangeVector & dart::HierarchyInfo::SubtypeRangesForClass	(	const Class &	klass,
		bool	include_abstract,
		bool	exclude_null
	)

Definition at line 110 of file il.cc.

                       {
  ClassTable* table = thread()->isolate_group()->class_table();
  const intptr_t cid_count = table->NumCids();
  std::unique_ptr<CidRangeVector[]>* cid_ranges = nullptr;
  if (include_abstract) {
    cid_ranges = exclude_null ? &cid_subtype_ranges_abstract_nonnullable_
                              : &cid_subtype_ranges_abstract_nullable_;
  } else {
    cid_ranges = exclude_null ? &cid_subtype_ranges_nonnullable_
                              : &cid_subtype_ranges_nullable_;
  }
  if (*cid_ranges == nullptr) {
    cid_ranges->reset(new CidRangeVector[cid_count]);
  }
  CidRangeVector& ranges = (*cid_ranges)[klass.id()];
  if (ranges.length() == 0) {
    BuildRangesFor(table, &ranges, klass, include_abstract, exclude_null);
  }
  return ranges;
}

Member Data Documentation

◆ kNoCompatibleTAVOffset

constexpr intptr_t dart::HierarchyInfo::kNoCompatibleTAVOffset = 0

staticconstexpr

Definition at line 282 of file il.h.

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

third_party/dart-lang/sdk/runtime/vm/compiler/backend/il.h
third_party/dart-lang/sdk/runtime/vm/compiler/backend/il.cc

Public Member Functions

Static Public Attributes

Additional Inherited Members