dart::TypeTestingStubGenerator Class Reference

#include <type_testing_stubs.h>

Public Member Functions
	TypeTestingStubGenerator ()
CodePtr	OptimizedCodeForType (const AbstractType &type)

Static Public Member Functions
static CodePtr	DefaultCodeForType (const AbstractType &type, bool lazy_specialize=true)
static CodePtr	SpecializeStubFor (Thread *thread, const AbstractType &type)

Detailed Description

Definition at line 42 of file type_testing_stubs.h.

Constructor & Destructor Documentation

TypeTestingStubGenerator()

dart::TypeTestingStubGenerator::TypeTestingStubGenerator

(

)

Definition at line 168 of file type_testing_stubs.cc.

    : object_store_(IsolateGroup::Current()->object_store()) {}

Member Function Documentation

DefaultCodeForType()

CodePtr dart::TypeTestingStubGenerator::DefaultCodeForType ( const AbstractType &  type, bool  lazy_specialize = true  )

static

Definition at line 114 of file type_testing_stubs.cc.

                            {
  // During bootstrapping we have no access to stubs yet, so we'll just return
  // `null` and patch these later in `Object::FinishInit()`.
  if (!StubCode::HasBeenInitialized()) {
    ASSERT(type.IsType());
    const classid_t cid = type.type_class_id();
    ASSERT(cid == kDynamicCid || cid == kVoidCid);
    return Code::null();
  }
 
  if (type.IsTopTypeForSubtyping()) {
    return StubCode::TopTypeTypeTest().ptr();
  }
  if (type.IsTypeParameter()) {
    const bool nullable = Instance::NullIsAssignableTo(type);
    if (nullable) {
      return StubCode::NullableTypeParameterTypeTest().ptr();
    } else {
      return StubCode::TypeParameterTypeTest().ptr();
    }
  }
 
  if (type.IsFunctionType()) {
    const bool nullable = Instance::NullIsAssignableTo(type);
    return nullable ? StubCode::DefaultNullableTypeTest().ptr()
                    : StubCode::DefaultTypeTest().ptr();
  }
 
  if (type.IsType() || type.IsRecordType()) {
    const bool should_specialize = !FLAG_precompiled_mode && lazy_specialize;
    const bool nullable = Instance::NullIsAssignableTo(type);
    if (should_specialize) {
      return nullable ? StubCode::LazySpecializeNullableTypeTest().ptr()
                      : StubCode::LazySpecializeTypeTest().ptr();
    } else {
      return nullable ? StubCode::DefaultNullableTypeTest().ptr()
                      : StubCode::DefaultTypeTest().ptr();
    }
  }
 
  return StubCode::UnreachableTypeTest().ptr();
}

OptimizedCodeForType()

CodePtr dart::TypeTestingStubGenerator::OptimizedCodeForType

(

const AbstractType &

type

)

Definition at line 171 of file type_testing_stubs.cc.

                              {
#if !defined(TARGET_ARCH_IA32)
  ASSERT(StubCode::HasBeenInitialized());
 
  if (type.IsTypeParameter()) {
    return TypeTestingStubGenerator::DefaultCodeForType(
        type, /*lazy_specialize=*/false);
  }
 
  if (type.IsTopTypeForSubtyping()) {
    return StubCode::TopTypeTypeTest().ptr();
  }
 
  if (type.IsCanonical()) {
    // When adding any new types that can have specialized TTSes, also update
    // CollectTypes::VisitObject appropriately.
    if (type.IsType() || type.IsRecordType()) {
#if !defined(DART_PRECOMPILED_RUNTIME)
      const Code& code =
          Code::Handle(TypeTestingStubGenerator::BuildCodeForType(type));
      if (!code.IsNull()) {
        return code.ptr();
      }
      const Error& error = Error::Handle(Thread::Current()->StealStickyError());
      if (!error.IsNull()) {
        if (error.ptr() == Object::out_of_memory_error().ptr()) {
          Exceptions::ThrowOOM();
        } else {
          UNREACHABLE();
        }
      }
 
      // Fall back to default.
#else
      // In the precompiled runtime we cannot lazily create new optimized type
      // testing stubs, so if we cannot find one, we'll just return the default
      // one.
#endif  // !defined(DART_PRECOMPILED_RUNTIME)
    }
  }
#endif  // !defined(TARGET_ARCH_IA32)
  return TypeTestingStubGenerator::DefaultCodeForType(
      type, /*lazy_specialize=*/false);
}

SpecializeStubFor()

CodePtr dart::TypeTestingStubGenerator::SpecializeStubFor ( Thread *  thread, const AbstractType &  type  )

static

Definition at line 160 of file type_testing_stubs.cc.

                                                                              {
  HierarchyInfo hi(thread);
  TypeTestingStubGenerator generator;
  return generator.OptimizedCodeForType(type);
}

---

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

• third_party/dart-lang/sdk/runtime/vm/type_testing_stubs.h
• third_party/dart-lang/sdk/runtime/vm/type_testing_stubs.cc