dart::TTSTestState Class Reference

Inheritance diagram for dart::TTSTestState:

Public Member Functions
	TTSTestState (Thread *thread, const AbstractType &type)
Zone *	zone () const
const SubtypeTestCache &	last_stc () const
const SubtypeTestCachePtr	current_stc () const
AbstractTypePtr	TypeToTest (const TTSTestCase &test_case) const
void	ClearCache ()
void	InvokeEagerlySpecializedStub (const TTSTestCase &test_case)
void	InvokeLazilySpecializedStub (const TTSTestCase &test_case, bool should_specialize=true)
void	InvokeExistingStub (const TTSTestCase &test_case)
Public Member Functions inherited from dart::ValueObject
	ValueObject ()
	~ValueObject ()

Detailed Description

Definition at line 396 of file type_testing_stubs_test.cc.

Constructor & Destructor Documentation

TTSTestState()

dart::TTSTestState::TTSTestState ( Thread *  thread, const AbstractType &  type  )

inline

Definition at line 398 of file type_testing_stubs_test.cc.

      : thread_(thread),
        type_(AbstractType::Handle(zone(), type.ptr())),
        modified_abi_regs_box_(Array::Handle(zone(), Array::New(1))),
        modified_rest_regs_box_(Array::Handle(zone(), Array::New(1))),
        tts_invoker_(
            Code::Handle(zone(), CreateInvocationStub(thread_, zone()))),
        pool_(ObjectPool::Handle(zone(), tts_invoker_.object_pool())),
        arguments_descriptor_(
            Array::Handle(ArgumentsDescriptor::NewBoxed(0, 6))),
        previous_tts_stub_(Code::Handle(zone())),
        previous_stc_(SubtypeTestCache::Handle(zone())),
        last_arguments_(Array::Handle(zone())),
        last_tested_type_(AbstractType::Handle(zone())),
        new_tts_stub_(Code::Handle(zone())),
        last_stc_(SubtypeTestCache::Handle(zone())),
        last_result_(Object::Handle(zone())) {
    if (FLAG_print_type_testing_stub_test_headers) {
      THR_Print("Creating test state for type %s\n", type.ToCString());
    }
  }

Member Function Documentation

ClearCache()

void dart::TTSTestState::ClearCache ( )

inline

Definition at line 435 of file type_testing_stubs_test.cc.

                    {
    pool_.SetObjectAt(kSubtypeTestCacheIndex, Object::null_object());
  }

current_stc()

const SubtypeTestCachePtr dart::TTSTestState::current_stc ( ) const

inline

Definition at line 423 of file type_testing_stubs_test.cc.

                                                {
    return SubtypeTestCache::RawCast(pool_.ObjectAt(kSubtypeTestCacheIndex));
  }

InvokeEagerlySpecializedStub()

void dart::TTSTestState::InvokeEagerlySpecializedStub ( const TTSTestCase &  test_case )

inline

Definition at line 439 of file type_testing_stubs_test.cc.

                                                                  {
    // This shouldn't be used except within InvokeLazilySpecializedStub.
    EXPECT_NE(kSpecialize, test_case.expected_result);
    // A new stub is being installed, so we won't respecialize.
    EXPECT_NE(kRespecialize, test_case.expected_result);
    last_tested_type_ = TypeToTest(test_case);
    {
      // To make sure we output the disassembled stub if desired.
      TraceStubInvocationScope scope;
      previous_tts_stub_ = TypeTestingStubGenerator::SpecializeStubFor(
          thread_, last_tested_type_);
    }
    last_tested_type_.SetTypeTestingStub(previous_tts_stub_);
    PrintInvocationHeader("eagerly specialized", test_case);
    InvokeStubHelper(test_case);
    // Treat it as a failure if the stub respecializes, since we're attempting
    // to simulate AOT mode.
    EXPECT(previous_tts_stub_.ptr() == new_tts_stub_.ptr());
  }

InvokeExistingStub()

void dart::TTSTestState::InvokeExistingStub ( const TTSTestCase &  test_case )

inline

Definition at line 484 of file type_testing_stubs_test.cc.

                                                        {
    // This shouldn't be used except within InvokeLazilySpecializedStub.
    EXPECT_NE(kSpecialize, test_case.expected_result);
    last_tested_type_ = TypeToTest(test_case);
    PrintInvocationHeader("existing", test_case);
    InvokeStubHelper(test_case);
    // Only respecialization should result in a new stub.
    EXPECT_EQ(test_case.expected_result == kRespecialize,
              previous_tts_stub_.ptr() != new_tts_stub_.ptr());
  }

InvokeLazilySpecializedStub()

void dart::TTSTestState::InvokeLazilySpecializedStub ( const TTSTestCase &  test_case, bool  should_specialize = true  )

inline

Definition at line 459 of file type_testing_stubs_test.cc.

                                                                  {
    // This is governed by the should_specialize parameter.
    EXPECT_NE(kSpecialize, test_case.expected_result);
    // A new stub is being installed, so we won't respecialize.
    EXPECT_NE(kRespecialize, test_case.expected_result);
    last_tested_type_ = TypeToTest(test_case);
    const auto& specializing_stub =
        Code::Handle(zone(), TypeTestingStubGenerator::DefaultCodeForType(
                                 last_tested_type_, /*lazy_specialize=*/true));
    last_tested_type_.SetTypeTestingStub(specializing_stub);
    const TTSTestCase initial_case{
        test_case.instance, test_case.instantiator_tav, test_case.function_tav,
        should_specialize && test_case.expected_result != kFail
            ? kSpecialize
            : test_case.expected_result};
    PrintInvocationHeader("lazy specialized", initial_case);
    InvokeStubHelper(initial_case);
    if (initial_case.expected_result == kSpecialize) {
      EXPECT(previous_tts_stub_.ptr() != new_tts_stub_.ptr());
    } else {
      EXPECT(previous_tts_stub_.ptr() == new_tts_stub_.ptr());
    }
  }

last_stc()

const SubtypeTestCache & dart::TTSTestState::last_stc ( ) const

inline

Definition at line 421 of file type_testing_stubs_test.cc.

{ return last_stc_; }

TypeToTest()

AbstractTypePtr dart::TTSTestState::TypeToTest ( const TTSTestCase &  test_case ) const

inline

Definition at line 427 of file type_testing_stubs_test.cc.

                                                                 {
    if (type_.IsTypeParameter()) {
      return TypeParameter::Cast(type_).GetFromTypeArguments(
          test_case.instantiator_tav, test_case.function_tav);
    }
    return type_.ptr();
  }

zone()

Zone * dart::TTSTestState::zone ( ) const

inline

Definition at line 420 of file type_testing_stubs_test.cc.

{ return thread_->zone(); }

---

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

• third_party/dart-lang/sdk/runtime/vm/type_testing_stubs_test.cc