dart::StubCode Class Reference

#include <stub_code.h>

Inheritance diagram for dart::StubCode:

Public Member Functions
	VM_STUB_CODE_LIST (STUB_CODE_ACCESSOR)
	VM_STUB_CODE_LIST (GENERATE_STUB)

Static Public Member Functions
static void	Init ()
static void	Cleanup ()
static bool	HasBeenInitialized ()
static void	InitializationDone ()
static bool	InInvocationStub (uword pc)
static bool	InJumpToFrameStub (uword pc)
static const char *	NameOfStub (uword entry_point)
static const Code &	SubtypeTestCacheStubForUsedInputs (intptr_t i)
static CodePtr	GetAllocationStubForClass (const Class &cls)
static CodePtr	GetAllocationStubForTypedData (classid_t class_id)
static CodePtr	Generate (const char *name, compiler::ObjectPoolBuilder *object_pool_builder, void(compiler::StubCodeCompiler::*GenerateStub)())
static const Code &	UnoptimizedStaticCallEntry (intptr_t num_args_tested)
static const char *	NameAt (intptr_t index)
static const Code &	EntryAt (intptr_t index)
static void	EntryAtPut (intptr_t index, Code *entry)
static intptr_t	NumEntries ()

Friends
class	MegamorphicCacheTable

Detailed Description

Definition at line 32 of file stub_code.h.

Member Function Documentation

Cleanup()

void dart::StubCode::Cleanup ( )

static

Definition at line 124 of file stub_code.cc.

                       {
  initialized_.store(false, std::memory_order_release);
 
  for (size_t i = 0; i < ARRAY_SIZE(entries_); i++) {
    entries_[i].code = nullptr;
  }
}

EntryAt()

static const Code & dart::StubCode::EntryAt ( intptr_t  index )

inlinestatic

Definition at line 101 of file stub_code.h.

{ return *(entries_[index].code); }

EntryAtPut()

static void dart::StubCode::EntryAtPut ( intptr_t  index, Code *  entry  )

inlinestatic

Definition at line 102 of file stub_code.h.

                                                      {
    DEBUG_ASSERT(entry->IsReadOnlyHandle());
    ASSERT(entries_[index].code == nullptr);
    entries_[index].code = entry;
  }

Generate()

CodePtr dart::StubCode::Generate ( const char *  name, compiler::ObjectPoolBuilder *  object_pool_builder, void(compiler::StubCodeCompiler::*)()  GenerateStub  )

static

Definition at line 93 of file stub_code.cc.

                                                     {
  auto thread = Thread::Current();
  SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
 
  compiler::Assembler assembler(object_pool_builder);
  CompilerState compiler_state(thread, /*is_aot=*/FLAG_precompiled_mode,
                               /*is_optimizing=*/false);
  Zone* zone = thread->zone();
  auto* pc_descriptors_list = new (zone) DescriptorList(zone);
  compiler::StubCodeCompiler stubCodeCompiler(&assembler, pc_descriptors_list);
  (stubCodeCompiler.*GenerateStub)();
  const Code& code = Code::Handle(
      zone, Code::FinalizeCodeAndNotify(name, nullptr, &assembler,
                                        Code::PoolAttachment::kNotAttachPool,
                                        /*optimized=*/false));
  const PcDescriptors& descriptors = PcDescriptors::Handle(
      zone, pc_descriptors_list->FinalizePcDescriptors(code.PayloadStart()));
  code.set_pc_descriptors(descriptors);
 
#ifndef PRODUCT
  if (FLAG_support_disassembler && FLAG_disassemble_stubs) {
    Disassembler::DisassembleStub(name, code);
  }
#endif  // !PRODUCT
  return code.ptr();
}

GetAllocationStubForClass()

CodePtr dart::StubCode::GetAllocationStubForClass ( const Class &  cls )

static

Definition at line 174 of file stub_code.cc.

                                                            {
  Thread* thread = Thread::Current();
  auto object_store = thread->isolate_group()->object_store();
  Zone* zone = thread->zone();
  const Error& error =
      Error::Handle(zone, cls.EnsureIsAllocateFinalized(thread));
  ASSERT(error.IsNull());
  switch (cls.id()) {
    case kArrayCid:
      return object_store->allocate_array_stub();
#if !defined(TARGET_ARCH_IA32)
    case kGrowableObjectArrayCid:
      return object_store->allocate_growable_array_stub();
#endif  // !defined(TARGET_ARCH_IA32)
    case kContextCid:
      return object_store->allocate_context_stub();
    case kUnhandledExceptionCid:
      return object_store->allocate_unhandled_exception_stub();
    case kMintCid:
      return object_store->allocate_mint_stub();
    case kDoubleCid:
      return object_store->allocate_double_stub();
    case kFloat32x4Cid:
      return object_store->allocate_float32x4_stub();
    case kFloat64x2Cid:
      return object_store->allocate_float64x2_stub();
    case kInt32x4Cid:
      return object_store->allocate_int32x4_stub();
    case kClosureCid:
      return object_store->allocate_closure_stub();
    case kRecordCid:
      return object_store->allocate_record_stub();
  }
  Code& stub = Code::Handle(zone, cls.allocation_stub());
  if (stub.IsNull()) {
    compiler::ObjectPoolBuilder object_pool_builder;
    Precompiler* precompiler = Precompiler::Instance();
 
    compiler::ObjectPoolBuilder* wrapper =
        precompiler != nullptr ? precompiler->global_object_pool_builder()
                               : &object_pool_builder;
 
    const auto pool_attachment = FLAG_precompiled_mode
                                     ? Code::PoolAttachment::kNotAttachPool
                                     : Code::PoolAttachment::kAttachPool;
 
    auto zone = thread->zone();
    auto object_store = thread->isolate_group()->object_store();
    auto& allocate_object_stub = Code::ZoneHandle(zone);
    auto& allocate_object_parametrized_stub = Code::ZoneHandle(zone);
    if (FLAG_precompiled_mode) {
      allocate_object_stub = object_store->allocate_object_stub();
      allocate_object_parametrized_stub =
          object_store->allocate_object_parametrized_stub();
    }
 
    compiler::Assembler assembler(wrapper);
    CompilerState compiler_state(thread, /*is_aot=*/FLAG_precompiled_mode,
                                 /*is_optimizing=*/false);
    compiler::UnresolvedPcRelativeCalls unresolved_calls;
    const char* name = cls.ToCString();
    compiler::StubCodeCompiler stubCodeCompiler(&assembler, nullptr);
    stubCodeCompiler.GenerateAllocationStubForClass(
        &unresolved_calls, cls, allocate_object_stub,
        allocate_object_parametrized_stub);
 
    const auto& static_calls_table =
        Array::Handle(zone, compiler::StubCodeCompiler::BuildStaticCallsTable(
                                zone, &unresolved_calls));
 
    SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock());
 
    auto mutator_fun = [&]() {
      stub = Code::FinalizeCode(nullptr, &assembler, pool_attachment,
                                /*optimized=*/false,
                                /*stats=*/nullptr);
      // Check if some other thread has not already added the stub.
      if (cls.allocation_stub() == Code::null()) {
        stub.set_owner(cls);
        if (!static_calls_table.IsNull()) {
          stub.set_static_calls_target_table(static_calls_table);
        }
        cls.set_allocation_stub(stub);
      }
    };
 
    // We have to ensure no mutators are running, because:
    //
    //   a) We allocate an instructions object, which might cause us to
    //      temporarily flip page protections from (RX -> RW -> RX).
    thread->isolate_group()->RunWithStoppedMutators(mutator_fun,
                                                    /*use_force_growth=*/true);
 
    // We notify code observers after finalizing the code in order to be
    // outside a [SafepointOperationScope].
    Code::NotifyCodeObservers(name, stub, /*optimized=*/false);
#ifndef PRODUCT
    if (FLAG_support_disassembler && FLAG_disassemble_stubs) {
      Disassembler::DisassembleStub(name, stub);
    }
#endif  // !PRODUCT
  }
  return stub.ptr();
}

GetAllocationStubForTypedData()

CodePtr dart::StubCode::GetAllocationStubForTypedData ( classid_t  class_id )

static

Definition at line 279 of file stub_code.cc.

                                                                  {
  auto object_store = Thread::Current()->isolate_group()->object_store();
  switch (class_id) {
    case kTypedDataInt8ArrayCid:
      return object_store->allocate_int8_array_stub();
    case kTypedDataUint8ArrayCid:
      return object_store->allocate_uint8_array_stub();
    case kTypedDataUint8ClampedArrayCid:
      return object_store->allocate_uint8_clamped_array_stub();
    case kTypedDataInt16ArrayCid:
      return object_store->allocate_int16_array_stub();
    case kTypedDataUint16ArrayCid:
      return object_store->allocate_uint16_array_stub();
    case kTypedDataInt32ArrayCid:
      return object_store->allocate_int32_array_stub();
    case kTypedDataUint32ArrayCid:
      return object_store->allocate_uint32_array_stub();
    case kTypedDataInt64ArrayCid:
      return object_store->allocate_int64_array_stub();
    case kTypedDataUint64ArrayCid:
      return object_store->allocate_uint64_array_stub();
    case kTypedDataFloat32ArrayCid:
      return object_store->allocate_float32_array_stub();
    case kTypedDataFloat64ArrayCid:
      return object_store->allocate_float64_array_stub();
    case kTypedDataFloat32x4ArrayCid:
      return object_store->allocate_float32x4_array_stub();
    case kTypedDataInt32x4ArrayCid:
      return object_store->allocate_int32x4_array_stub();
    case kTypedDataFloat64x2ArrayCid:
      return object_store->allocate_float64x2_array_stub();
  }
  UNREACHABLE();
  return Code::null();
}

HasBeenInitialized()

static bool dart::StubCode::HasBeenInitialized ( )

inlinestatic

Definition at line 41 of file stub_code.h.

                                   {
    return initialized_.load(std::memory_order_acquire);
  }

InInvocationStub()

bool dart::StubCode::InInvocationStub ( uword  pc )

static

Definition at line 132 of file stub_code.cc.

                                        {
  ASSERT(HasBeenInitialized());
  uword entry = StubCode::InvokeDartCode().EntryPoint();
  uword size = StubCode::InvokeDartCodeSize();
  return (pc >= entry) && (pc < (entry + size));
}

Init()

void dart::StubCode::Init ( )

static

Definition at line 46 of file stub_code.cc.

                    {
  compiler::ObjectPoolBuilder object_pool_builder;
 
  // Generate all the stubs.
  for (size_t i = 0; i < ARRAY_SIZE(entries_); i++) {
    entries_[i].code = Code::ReadOnlyHandle();
    *(entries_[i].code) =
        Generate(entries_[i].name, &object_pool_builder, entries_[i].generator);
  }
 
  const ObjectPool& object_pool =
      ObjectPool::Handle(ObjectPool::NewFromBuilder(object_pool_builder));
 
  for (size_t i = 0; i < ARRAY_SIZE(entries_); i++) {
    entries_[i].code->set_object_pool(object_pool.ptr());
  }
 
  InitializationDone();
 
#if defined(DART_PRECOMPILER)
  {
    // Set Function owner for UnknownDartCode stub so it pretends to
    // be a Dart code.
    Zone* zone = Thread::Current()->zone();
    const auto& signature = FunctionType::Handle(zone, FunctionType::New());
    auto& owner = Object::Handle(zone);
    owner = Object::void_class();
    ASSERT(!owner.IsNull());
    owner = Function::New(signature, Object::null_string(),
                          UntaggedFunction::kRegularFunction,
                          /*is_static=*/true,
                          /*is_const=*/false,
                          /*is_abstract=*/false,
                          /*is_external=*/false,
                          /*is_native=*/false, owner, TokenPosition::kNoSource);
    StubCode::UnknownDartCode().set_owner(owner);
    StubCode::UnknownDartCode().set_exception_handlers(
        Object::empty_exception_handlers());
    StubCode::UnknownDartCode().set_pc_descriptors(Object::empty_descriptors());
    ASSERT(StubCode::UnknownDartCode().IsFunctionCode());
  }
#endif  // defined(DART_PRECOMPILER)
}

InitializationDone()

static void dart::StubCode::InitializationDone ( )

inlinestatic

Definition at line 44 of file stub_code.h.

                                   {
    initialized_.store(true, std::memory_order_release);
  }

InJumpToFrameStub()

bool dart::StubCode::InJumpToFrameStub ( uword  pc )

static

Definition at line 139 of file stub_code.cc.

                                         {
  ASSERT(HasBeenInitialized());
  uword entry = StubCode::JumpToFrame().EntryPoint();
  uword size = StubCode::JumpToFrameSize();
  return (pc >= entry) && (pc < (entry + size));
}

NameAt()

static const char * dart::StubCode::NameAt ( intptr_t  index )

inlinestatic

Definition at line 99 of file stub_code.h.

{ return entries_[index].name; }

NameOfStub()

const char * dart::StubCode::NameOfStub ( uword  entry_point )

static

Definition at line 330 of file stub_code.cc.

                                                  {
  for (size_t i = 0; i < ARRAY_SIZE(entries_); i++) {
    if ((entries_[i].code != nullptr) && !entries_[i].code->IsNull() &&
        (entries_[i].code->EntryPoint() == entry_point)) {
      return entries_[i].name;
    }
  }
 
  auto object_store = IsolateGroup::Current()->object_store();
 
#define MATCH(member, name)                                                    \
  if (object_store->member() != Code::null() &&                                \
      entry_point == Code::EntryPointOf(object_store->member())) {             \
    return "_iso_stub_" #name "Stub";                                          \
  }
  OBJECT_STORE_STUB_CODE_LIST(MATCH)
#undef MATCH
  return nullptr;
}

NumEntries()

static intptr_t dart::StubCode::NumEntries ( )

inlinestatic

Definition at line 107 of file stub_code.h.

{ return kNumStubEntries; }

SubtypeTestCacheStubForUsedInputs()

static const Code & dart::StubCode::SubtypeTestCacheStubForUsedInputs ( intptr_t  i )

inlinestatic

Definition at line 66 of file stub_code.h.

                                                                   {
    switch (i) {
      case 1:
        return StubCode::Subtype1TestCache();
      case 2:
        return StubCode::Subtype2TestCache();
      case 3:
        return StubCode::Subtype3TestCache();
      case 4:
        return StubCode::Subtype4TestCache();
      case 6:
        return StubCode::Subtype6TestCache();
      case 7:
        return StubCode::Subtype7TestCache();
      default:
        UNREACHABLE();
        return StubCode::Subtype7TestCache();
    }
  }

UnoptimizedStaticCallEntry()

const Code & dart::StubCode::UnoptimizedStaticCallEntry ( intptr_t  num_args_tested )

static

Definition at line 316 of file stub_code.cc.

                                                                         {
  switch (num_args_tested) {
    case 0:
      return ZeroArgsUnoptimizedStaticCall();
    case 1:
      return OneArgUnoptimizedStaticCall();
    case 2:
      return TwoArgsUnoptimizedStaticCall();
    default:
      UNIMPLEMENTED();
      return Code::Handle();
  }
}

VM_STUB_CODE_LIST() [1/2]

dart::StubCode::VM_STUB_CODE_LIST

(

GENERATE_STUB

)

VM_STUB_CODE_LIST() [2/2]

dart::StubCode::VM_STUB_CODE_LIST

(

STUB_CODE_ACCESSOR

)

Friends And Related Symbol Documentation

MegamorphicCacheTable

friend class MegamorphicCacheTable

friend

Definition at line 122 of file stub_code.h.

---

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

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