dart::Dart Class Reference

#include <dart.h>

Inheritance diagram for dart::Dart:

Static Public Member Functions
static char *	Init (const Dart_InitializeParams *params)
static char *	Cleanup ()
static bool	IsInitialized ()
static bool	SetActiveApiCall ()
static void	ResetActiveApiCall ()
static Isolate *	CreateIsolate (const char *name_prefix, const Dart_IsolateFlags &api_flags, IsolateGroup *isolate_group)
static ErrorPtr	InitializeIsolateGroup (Thread *T, const uint8_t *snapshot_data, const uint8_t *snapshot_instructions, const uint8_t *kernel_buffer, intptr_t kernel_buffer_size)
static ErrorPtr	InitIsolateGroupFromSnapshot (Thread *T, const uint8_t *snapshot_data, const uint8_t *snapshot_instructions, const uint8_t *kernel_buffer, intptr_t kernel_buffer_size)
static ErrorPtr	InitializeIsolate (Thread *T, bool is_first_isolate_in_group, void *isolate_data)
static void	RunShutdownCallback ()
static void	ShutdownIsolate (Thread *T)
static Isolate *	vm_isolate ()
static IsolateGroup *	vm_isolate_group ()
static ThreadPool *	thread_pool ()
static int64_t	UptimeMicros ()
static int64_t	UptimeMillis ()
static void	set_pprof_symbol_generator (DebugInfo *value)
static DebugInfo *	pprof_symbol_generator ()
static LocalHandle *	AllocateReadOnlyApiHandle ()
static bool	IsReadOnlyApiHandle (Dart_Handle handle)
static uword	AllocateReadOnlyHandle ()
static bool	IsReadOnlyHandle (uword address)
static char *	FeaturesString (IsolateGroup *isolate_group, bool is_vm_snapshot, Snapshot::Kind kind)
static Snapshot::Kind	vm_snapshot_kind ()
static Dart_ThreadStartCallback	thread_start_callback ()
static void	set_thread_start_callback (Dart_ThreadStartCallback cback)
static Dart_ThreadExitCallback	thread_exit_callback ()
static void	set_thread_exit_callback (Dart_ThreadExitCallback cback)
static void	SetFileCallbacks (Dart_FileOpenCallback file_open, Dart_FileReadCallback file_read, Dart_FileWriteCallback file_write, Dart_FileCloseCallback file_close)
static Dart_FileOpenCallback	file_open_callback ()
static Dart_FileReadCallback	file_read_callback ()
static Dart_FileWriteCallback	file_write_callback ()
static Dart_FileCloseCallback	file_close_callback ()
static void	set_entropy_source_callback (Dart_EntropySource entropy_source)
static Dart_EntropySource	entropy_source_callback ()
static void	set_dwarf_stacktrace_footnote_callback (Dart_DwarfStackTraceFootnoteCallback cb)
static Dart_DwarfStackTraceFootnoteCallback	dwarf_stacktrace_footnote_callback ()

Detailed Description

Definition at line 28 of file dart.h.

Member Function Documentation

AllocateReadOnlyApiHandle()

LocalHandle * dart::Dart::AllocateReadOnlyApiHandle ( )

static

Definition at line 1141 of file dart.cc.

                                             {
  ASSERT(Isolate::Current() == Dart::vm_isolate());
  ASSERT(predefined_handles_ != nullptr);
  return predefined_handles_->api_handles_.AllocateHandle();
}

AllocateReadOnlyHandle()

uword dart::Dart::AllocateReadOnlyHandle ( )

static

Definition at line 1131 of file dart.cc.

                                   {
  ASSERT(Isolate::Current() == Dart::vm_isolate());
  ASSERT(predefined_handles_ != nullptr);
  uword handle = predefined_handles_->handles_.AllocateScopedHandle();
#if defined(DEBUG)
  *reinterpret_cast<uword*>(handle + kOffsetOfIsZoneHandle * kWordSize) = 0;
#endif
  return handle;
}

Cleanup()

char * dart::Dart::Cleanup ( )

static

Definition at line 629 of file dart.cc.

                    {
  ASSERT(Isolate::Current() == nullptr);
  if (!DartInitializationState::SetCleaningup()) {
    return Utils::StrDup("VM already terminated.");
  }
  ASSERT(vm_isolate_ != nullptr);
 
  if (FLAG_trace_shutdown) {
    OS::PrintErr("[+%" Pd64 "ms] SHUTDOWN: Starting shutdown\n",
                 UptimeMillis());
  }
 
#if !defined(PRODUCT)
  if (FLAG_trace_shutdown) {
    OS::PrintErr("[+%" Pd64 "ms] SHUTDOWN: Shutting down profiling\n",
                 UptimeMillis());
  }
  Profiler::Cleanup();
#endif  // !defined(PRODUCT)
 
  NativeSymbolResolver::Cleanup();
 
  // Disable the creation of new isolates.
  if (FLAG_trace_shutdown) {
    OS::PrintErr("[+%" Pd64 "ms] SHUTDOWN: Disabling isolate creation\n",
                 UptimeMillis());
  }
  Isolate::DisableIsolateCreation();
 
  // Send the OOB Kill message to all remaining application isolates.
  if (FLAG_trace_shutdown) {
    OS::PrintErr("[+%" Pd64 "ms] SHUTDOWN: Killing all app isolates\n",
                 UptimeMillis());
  }
  Isolate::KillAllIsolates(Isolate::kInternalKillMsg);
 
  // Wait for all isolates, but the service and the vm isolate to shut down.
  // Only do that if there is a service isolate running.
  if (ServiceIsolate::IsRunning() || KernelIsolate::IsRunning()) {
    if (FLAG_trace_shutdown) {
      OS::PrintErr("[+%" Pd64 "ms] SHUTDOWN: Shutting down app isolates\n",
                   UptimeMillis());
    }
    WaitForApplicationIsolateShutdown();
    if (FLAG_trace_shutdown) {
      OS::PrintErr("[+%" Pd64 "ms] SHUTDOWN: Done shutting down app isolates\n",
                   UptimeMillis());
    }
  }
 
  Isolate::KillAllSystemIsolates(Isolate::kInternalKillMsg);
 
  // Shutdown the kernel isolate.
  if (FLAG_trace_shutdown) {
    OS::PrintErr("[+%" Pd64 "ms] SHUTDOWN: Shutting down kernel isolate\n",
                 UptimeMillis());
  }
  KernelIsolate::Shutdown();
 
  // Shutdown the service isolate.
  if (FLAG_trace_shutdown) {
    OS::PrintErr("[+%" Pd64 "ms] SHUTDOWN: Shutting down service isolate\n",
                 UptimeMillis());
  }
  ServiceIsolate::Shutdown();
 
  // Wait for the remaining isolate (service/kernel isolate) to shutdown
  // before shutting down the thread pool.
  WaitForIsolateShutdown();
 
  // Shutdown the thread pool. On return, all thread pool threads have exited.
  if (FLAG_trace_shutdown) {
    OS::PrintErr("[+%" Pd64 "ms] SHUTDOWN: Deleting thread pool\n",
                 UptimeMillis());
  }
  DartInitializationState::SetUnInitialized();
  thread_pool_->Shutdown();
  delete thread_pool_;
  thread_pool_ = nullptr;
  if (FLAG_trace_shutdown) {
    OS::PrintErr("[+%" Pd64 "ms] SHUTDOWN: Done deleting thread pool\n",
                 UptimeMillis());
  }
 
  Api::Cleanup();
  delete predefined_handles_;
  predefined_handles_ = nullptr;
 
  // Set the VM isolate as current isolate.
  if (FLAG_trace_shutdown) {
    OS::PrintErr("[+%" Pd64 "ms] SHUTDOWN: Cleaning up vm isolate\n",
                 UptimeMillis());
  }
 
  // If Dart_Cleanup() is called on a thread which hasn't invoked any Dart API
  // functions before, entering the "vm-isolate" will cause lazy creation of a
  // OSThread (which is attached to the current thread via TLS).
  //
  // If we run in PRODUCT mode this lazy creation of OSThread can happen here,
  // which is why disabling the OSThread creation has to come after entering the
  // "vm-isolate".
  Thread::EnterIsolate(vm_isolate_);
 
  // Disable creation of any new OSThread structures which means no more new
  // threads can do an EnterIsolate. This must come after isolate shutdown
  // because new threads may need to be spawned to shutdown the isolates.
  // This must come after deletion of the thread pool to avoid a race in which
  // a thread spawned by the thread pool does not exit through the thread
  // pool, messing up its bookkeeping.
  if (FLAG_trace_shutdown) {
    OS::PrintErr("[+%" Pd64 "ms] SHUTDOWN: Disabling OS Thread creation\n",
                 UptimeMillis());
  }
  OSThread::DisableOSThreadCreation();
 
  ShutdownIsolate(Thread::Current());
  vm_isolate_ = nullptr;
  ASSERT(Isolate::IsolateListLength() == 0);
  Service::Cleanup();
  PortMap::Cleanup();
  UserTags::Cleanup();
  IsolateGroup::Cleanup();
  ICData::Cleanup();
  ArgumentsDescriptor::Cleanup();
  OffsetsTable::Cleanup();
  FfiCallbackMetadata::Cleanup();
  TargetCPUFeatures::Cleanup();
  MarkingStack::Cleanup();
  StoreBuffer::Cleanup();
  Object::Cleanup();
  Page::Cleanup();
  StubCode::Cleanup();
#if defined(SUPPORT_TIMELINE)
  if (FLAG_trace_shutdown) {
    OS::PrintErr("[+%" Pd64 "ms] SHUTDOWN: Shutting down timeline\n",
                 UptimeMillis());
  }
  Timeline::Cleanup();
#endif
  Zone::Cleanup();
  Random::Cleanup();
  // Delete the current thread's TLS and set it's TLS to null.
  // If it is the last thread then the destructor would call
  // OSThread::Cleanup.
  OSThread* os_thread = OSThread::Current();
  OSThread::SetCurrent(nullptr);
  delete os_thread;
  if (FLAG_trace_shutdown) {
    OS::PrintErr("[+%" Pd64 "ms] SHUTDOWN: Deleted os_thread\n",
                 UptimeMillis());
  }
 
  if (FLAG_trace_shutdown) {
    OS::PrintErr("[+%" Pd64 "ms] SHUTDOWN: Deleting code observers\n",
                 UptimeMillis());
  }
  NOT_IN_PRODUCT(CodeObservers::Cleanup());
  OS::Cleanup();
  if (FLAG_trace_shutdown) {
    OS::PrintErr("[+%" Pd64 "ms] SHUTDOWN: Done\n", UptimeMillis());
  }
  Flags::Cleanup();
#if !defined(PRODUCT) && !defined(DART_PRECOMPILED_RUNTIME)
  IsolateGroupReloadContext::SetFileModifiedCallback(nullptr);
  Service::SetEmbedderStreamCallbacks(nullptr, nullptr);
#endif  // !defined(PRODUCT) && !defined(DART_PRECOMPILED_RUNTIME)
  VirtualMemory::Cleanup();
  return nullptr;
}

CreateIsolate()

Isolate * dart::Dart::CreateIsolate ( const char *  name_prefix, const Dart_IsolateFlags &  api_flags, IsolateGroup *  isolate_group  )

static

Definition at line 811 of file dart.cc.

                                                          {
  // Create a new isolate.
  Isolate* isolate =
      Isolate::InitIsolate(name_prefix, isolate_group, api_flags);
  return isolate;
}

dwarf_stacktrace_footnote_callback()

static Dart_DwarfStackTraceFootnoteCallback dart::Dart::dwarf_stacktrace_footnote_callback ( )

inlinestatic

Definition at line 145 of file dart.h.

                                       {
    return dwarf_stacktrace_footnote_callback_;
  }

entropy_source_callback()

static Dart_EntropySource dart::Dart::entropy_source_callback ( )

inlinestatic

Definition at line 135 of file dart.h.

                                                      {
    return entropy_source_callback_;
  }

FeaturesString()

char * dart::Dart::FeaturesString ( IsolateGroup *  isolate_group, bool  is_vm_snapshot, Snapshot::Kind  kind  )

static

Definition at line 1004 of file dart.cc.

                                              {
  TextBuffer buffer(64);
 
// Different fields are included for DEBUG/RELEASE/PRODUCT.
#if defined(DEBUG)
  buffer.AddString("debug");
#elif defined(PRODUCT)
  buffer.AddString("product");
#else
  buffer.AddString("release");
#endif
 
#define ADD_FLAG(name, value)                                                  \
  do {                                                                         \
    buffer.AddString(value ? (" " #name) : (" no-" #name));                    \
  } while (0);
#define ADD_P(name, T, DV, C) ADD_FLAG(name, FLAG_##name)
#define ADD_R(name, PV, T, DV, C) ADD_FLAG(name, FLAG_##name)
#define ADD_C(name, PCV, PV, T, DV, C) ADD_FLAG(name, FLAG_##name)
#define ADD_D(name, T, DV, C) ADD_FLAG(name, FLAG_##name)
 
#define ADD_ISOLATE_GROUP_FLAG(name, isolate_flag, flag)                       \
  do {                                                                         \
    const bool value =                                                         \
        isolate_group != nullptr ? isolate_group->name() : flag;               \
    ADD_FLAG(name, value);                                                     \
  } while (0);
 
  if (Snapshot::IncludesCode(kind)) {
    VM_GLOBAL_FLAG_LIST(ADD_P, ADD_R, ADD_C, ADD_D);
 
    ADD_FLAG(tsan, FLAG_target_thread_sanitizer)
    ADD_FLAG(msan, FLAG_target_memory_sanitizer)
 
    if (kind == Snapshot::kFullJIT) {
      // Enabling assertions affects deopt ids.
      //
      // This flag is only used at compile time for AOT, so it's only relevant
      // when running JIT snapshots. We can omit this flag for AOT snapshots so
      // feature verification won't fail if --enable-snapshots isn't provided
      // at runtime.
      ADD_ISOLATE_GROUP_FLAG(asserts, enable_asserts, FLAG_enable_asserts);
      ADD_ISOLATE_GROUP_FLAG(use_field_guards, use_field_guards,
                             FLAG_use_field_guards);
      ADD_ISOLATE_GROUP_FLAG(use_osr, use_osr, FLAG_use_osr);
      ADD_ISOLATE_GROUP_FLAG(branch_coverage, branch_coverage,
                             FLAG_branch_coverage);
      ADD_ISOLATE_GROUP_FLAG(coverage, coverage, FLAG_coverage);
    }
 
    // Generated code must match the host architecture and ABI. We check the
    // strong condition of matching on operating system so that
    // Platform.isAndroid etc can be compile-time constants.
#if defined(TARGET_ARCH_IA32)
    buffer.AddString(" ia32");
#elif defined(TARGET_ARCH_X64)
    buffer.AddString(" x64");
#elif defined(TARGET_ARCH_ARM)
    buffer.AddString(" arm");
#elif defined(TARGET_ARCH_ARM64)
    buffer.AddString(" arm64");
#elif defined(TARGET_ARCH_RISCV32)
    buffer.AddString(" riscv32");
#elif defined(TARGET_ARCH_RISCV64)
    buffer.AddString(" riscv64");
#else
#error What architecture?
#endif
 
#if defined(DART_TARGET_OS_ANDROID)
    buffer.AddString(" android");
#elif defined(DART_TARGET_OS_FUCHSIA)
    buffer.AddString(" fuchsia");
#elif defined(DART_TARGET_OS_MACOS)
#if defined(DART_TARGET_OS_MACOS_IOS)
    buffer.AddString(" ios");
#else
    buffer.AddString(" macos");
#endif
#elif defined(DART_TARGET_OS_LINUX)
    buffer.AddString(" linux");
#elif defined(DART_TARGET_OS_WINDOWS)
    buffer.AddString(" windows");
#else
#error What operating system?
#endif
 
#if defined(DART_COMPRESSED_POINTERS)
    buffer.AddString(" compressed-pointers");
#else
    buffer.AddString(" no-compressed-pointers");
#endif
  }
 
#undef ADD_ISOLATE_FLAG
#undef ADD_D
#undef ADD_C
#undef ADD_R
#undef ADD_P
#undef ADD_FLAG
 
  return buffer.Steal();
}

file_close_callback()

static Dart_FileCloseCallback dart::Dart::file_close_callback ( )

inlinestatic

Definition at line 128 of file dart.h.

                                                      {
    return file_close_callback_;
  }

file_open_callback()

static Dart_FileOpenCallback dart::Dart::file_open_callback ( )

inlinestatic

Definition at line 119 of file dart.h.

                                                    {
    return file_open_callback_;
  }

file_read_callback()

static Dart_FileReadCallback dart::Dart::file_read_callback ( )

inlinestatic

Definition at line 122 of file dart.h.

                                                    {
    return file_read_callback_;
  }

file_write_callback()

static Dart_FileWriteCallback dart::Dart::file_write_callback ( )

inlinestatic

Definition at line 125 of file dart.h.

                                                      {
    return file_write_callback_;
  }

Init()

char * dart::Dart::Init ( const Dart_InitializeParams *  params )

static

Definition at line 526 of file dart.cc.

                                                    {
  if (!DartInitializationState::SetInitializing()) {
    return Utils::StrDup(
        "Bad VM initialization state, "
        "already initialized or "
        "multiple threads initializing the VM.");
  }
  char* retval = DartInit(params);
  if (retval != nullptr) {
    DartInitializationState::ResetInitializing();
    return retval;
  }
  DartInitializationState::SetInitialized();
  return nullptr;
}

InitializeIsolate()

ErrorPtr dart::Dart::InitializeIsolate ( Thread *  T, bool  is_first_isolate_in_group, void *  isolate_data  )

static

Definition at line 950 of file dart.cc.

                                                     {
  auto I = T->isolate();
  auto IG = T->isolate_group();
  auto Z = T->zone();
 
  // If a static field gets registered in [IsolateGroup::RegisterStaticField]:
  //
  //   * before this block it will ignore this isolate. The [Clone] of the
  //     initial field table will pick up the new value.
  //   * after this block it will add the new static field to this isolate.
  {
    SafepointReadRwLocker reader(T, IG->program_lock());
    I->set_field_table(T, IG->initial_field_table()->Clone(I));
    I->field_table()->MarkReadyToUse();
  }
 
  const auto& out_of_memory =
      Object::Handle(IG->object_store()->out_of_memory());
  const auto& error = Error::Handle(
      Z, I->isolate_object_store()->PreallocateObjects(out_of_memory));
  if (!error.IsNull()) {
    return error.ptr();
  }
 
  I->set_init_callback_data(isolate_data);
 
#if !defined(PRODUCT)
  if (Isolate::IsSystemIsolate(I)) {
    ServiceIsolate::MaybeMakeServiceIsolate(I);
  } else {
    I->message_handler()->set_should_pause_on_start(
        FLAG_pause_isolates_on_start);
    I->message_handler()->set_should_pause_on_exit(FLAG_pause_isolates_on_exit);
  }
#endif  // !defined(PRODUCT)
 
  ServiceIsolate::SendIsolateStartupMessage();
#if !defined(PRODUCT)
  I->debugger()->NotifyIsolateCreated();
#endif
 
  // Create tag table.
  I->set_tag_table(GrowableObjectArray::Handle(GrowableObjectArray::New()));
  // Set up default UserTag.
  const UserTag& default_tag = UserTag::Handle(UserTag::DefaultTag());
  I->set_current_tag(default_tag);
 
  I->init_loaded_prefixes_set_storage();
 
  return Error::null();
}

InitializeIsolateGroup()

ErrorPtr dart::Dart::InitializeIsolateGroup ( Thread *  T, const uint8_t *  snapshot_data, const uint8_t *  snapshot_instructions, const uint8_t *  kernel_buffer, intptr_t  kernel_buffer_size  )

static

Definition at line 908 of file dart.cc.

                                                                   {
  auto& error = Error::Handle(
      InitIsolateGroupFromSnapshot(T, snapshot_data, snapshot_instructions,
                                   kernel_buffer, kernel_buffer_size));
  if (!error.IsNull()) {
    return error.ptr();
  }
 
  Object::VerifyBuiltinVtables();
 
  auto IG = T->isolate_group();
  {
    SafepointReadRwLocker reader(T, IG->program_lock());
    IG->set_shared_field_table(T, IG->shared_initial_field_table()->Clone(
                                      /*for_isolate=*/nullptr,
                                      /*for_isolate_group=*/IG));
  }
  DEBUG_ONLY(IG->heap()->Verify("InitializeIsolate", kForbidMarked));
 
#if !defined(DART_PRECOMPILED_RUNTIME)
  FinalizeBuiltinClasses(T);
#endif
 
  if (snapshot_data == nullptr || kernel_buffer != nullptr) {
    auto object_store = IG->object_store();
    error ^= object_store->PreallocateObjects();
    if (!error.IsNull()) {
      return error.ptr();
    }
  }
 
  if (FLAG_print_class_table) {
    IG->class_table()->Print();
  }
 
  return Error::null();
}

InitIsolateGroupFromSnapshot()

ErrorPtr dart::Dart::InitIsolateGroupFromSnapshot ( Thread *  T, const uint8_t *  snapshot_data, const uint8_t *  snapshot_instructions, const uint8_t *  kernel_buffer, intptr_t  kernel_buffer_size  )

static

Definition at line 820 of file dart.cc.

                                 {
  auto IG = T->isolate_group();
  Error& error = Error::Handle(T->zone());
  error = Object::Init(IG, kernel_buffer, kernel_buffer_size);
  if (!error.IsNull()) {
    return error.ptr();
  }
  if (snapshot_data != nullptr && kernel_buffer == nullptr) {
    // Read the snapshot and setup the initial state.
#if defined(SUPPORT_TIMELINE)
    TimelineBeginEndScope tbes(T, Timeline::GetIsolateStream(),
                               "ReadProgramSnapshot");
#endif  // defined(SUPPORT_TIMELINE)
    const Snapshot* snapshot = Snapshot::SetupFromBuffer(snapshot_data);
    if (snapshot == nullptr) {
      const String& message = String::Handle(String::New("Invalid snapshot"));
      return ApiError::New(message);
    }
    if (!IsSnapshotCompatible(vm_snapshot_kind_, snapshot->kind())) {
      const String& message = String::Handle(String::NewFormatted(
          "Incompatible snapshot kinds: vm '%s', isolate '%s'",
          Snapshot::KindToCString(vm_snapshot_kind_),
          Snapshot::KindToCString(snapshot->kind())));
      return ApiError::New(message);
    }
    if (FLAG_trace_isolates) {
      OS::PrintErr("Size of isolate snapshot = %" Pd "\n", snapshot->length());
    }
    FullSnapshotReader reader(snapshot, snapshot_instructions, T);
    const Error& error = Error::Handle(reader.ReadProgramSnapshot());
    if (!error.IsNull()) {
      return error.ptr();
    }
 
    T->SetupDartMutatorStateDependingOnSnapshot(IG);
 
#if defined(SUPPORT_TIMELINE)
    if (tbes.enabled()) {
      tbes.SetNumArguments(2);
      tbes.FormatArgument(0, "snapshotSize", "%" Pd, snapshot->length());
      tbes.FormatArgument(1, "heapSize", "%" Pd,
                          IG->heap()->UsedInWords(Heap::kOld) * kWordSize);
    }
#endif  // defined(SUPPORT_TIMELINE)
    if (FLAG_trace_isolates) {
      IG->heap()->PrintSizes();
      MegamorphicCacheTable::PrintSizes(T);
    }
  } else {
    if ((vm_snapshot_kind_ != Snapshot::kNone) && kernel_buffer == nullptr) {
      const String& message =
          String::Handle(String::New("Missing isolate snapshot"));
      return ApiError::New(message);
    }
  }
#if !defined(PRODUCT) || defined(FORCE_INCLUDE_SAMPLING_HEAP_PROFILER)
  IG->class_table()->PopulateUserVisibleNames();
#endif
 
  return Error::null();
}

IsInitialized()

bool dart::Dart::IsInitialized ( )

static

Definition at line 799 of file dart.cc.

                         {
  return DartInitializationState::IsInitialized();
}

IsReadOnlyApiHandle()

bool dart::Dart::IsReadOnlyApiHandle ( Dart_Handle  handle )

static

Definition at line 1152 of file dart.cc.

                                                 {
  ASSERT(predefined_handles_ != nullptr);
  return predefined_handles_->api_handles_.IsValidHandle(handle);
}

IsReadOnlyHandle()

bool dart::Dart::IsReadOnlyHandle ( uword  address )

static

Definition at line 1147 of file dart.cc.

                                         {
  ASSERT(predefined_handles_ != nullptr);
  return predefined_handles_->handles_.IsValidScopedHandle(address);
}

pprof_symbol_generator()

static DebugInfo * dart::Dart::pprof_symbol_generator ( )

inlinestatic

Definition at line 83 of file dart.h.

{ return pprof_symbol_generator_; }

ResetActiveApiCall()

void dart::Dart::ResetActiveApiCall ( )

static

Definition at line 807 of file dart.cc.

                              {
  DartInitializationState::ResetInUse();
}

RunShutdownCallback()

void dart::Dart::RunShutdownCallback ( )

static

Definition at line 1110 of file dart.cc.

                               {
  Thread* thread = Thread::Current();
  ASSERT(thread->execution_state() == Thread::kThreadInVM);
  Isolate* isolate = thread->isolate();
  void* isolate_group_data = isolate->group()->embedder_data();
  void* isolate_data = isolate->init_callback_data();
  Dart_IsolateShutdownCallback callback = isolate->on_shutdown_callback();
  if (callback != nullptr) {
    TransitionVMToNative transition(thread);
    (callback)(isolate_group_data, isolate_data);
  }
}

set_dwarf_stacktrace_footnote_callback()

static void dart::Dart::set_dwarf_stacktrace_footnote_callback ( Dart_DwarfStackTraceFootnoteCallback  cb )

inlinestatic

Definition at line 139 of file dart.h.

                                               {
    dwarf_stacktrace_footnote_callback_ = cb;
  }

set_entropy_source_callback()

static void dart::Dart::set_entropy_source_callback ( Dart_EntropySource  entropy_source )

inlinestatic

Definition at line 132 of file dart.h.

                                                                             {
    entropy_source_callback_ = entropy_source;
  }

set_pprof_symbol_generator()

static void dart::Dart::set_pprof_symbol_generator ( DebugInfo *  value )

inlinestatic

Definition at line 80 of file dart.h.

                                                           {
    pprof_symbol_generator_ = value;
  }

set_thread_exit_callback()

static void dart::Dart::set_thread_exit_callback ( Dart_ThreadExitCallback  cback )

inlinestatic

Definition at line 106 of file dart.h.

                                                                      {
    thread_exit_callback_ = cback;
  }

set_thread_start_callback()

static void dart::Dart::set_thread_start_callback ( Dart_ThreadStartCallback  cback )

inlinestatic

Definition at line 100 of file dart.h.

                                                                        {
    thread_start_callback_ = cback;
  }

SetActiveApiCall()

bool dart::Dart::SetActiveApiCall ( )

static

Definition at line 803 of file dart.cc.

                            {
  return DartInitializationState::SetInUse();
}

SetFileCallbacks()

static void dart::Dart::SetFileCallbacks ( Dart_FileOpenCallback  file_open, Dart_FileReadCallback  file_read, Dart_FileWriteCallback  file_write, Dart_FileCloseCallback  file_close  )

inlinestatic

Definition at line 109 of file dart.h.

                                                                  {
    file_open_callback_ = file_open;
    file_read_callback_ = file_read;
    file_write_callback_ = file_write;
    file_close_callback_ = file_close;
  }

ShutdownIsolate()

void dart::Dart::ShutdownIsolate ( Thread *  T )

static

Definition at line 1123 of file dart.cc.

                                    {
  T->isolate()->Shutdown();
}

thread_exit_callback()

static Dart_ThreadExitCallback dart::Dart::thread_exit_callback ( )

inlinestatic

Definition at line 103 of file dart.h.

                                                        {
    return thread_exit_callback_;
  }

thread_pool()

static ThreadPool * dart::Dart::thread_pool ( )

inlinestatic

Definition at line 73 of file dart.h.

{ return thread_pool_; }

thread_start_callback()

static Dart_ThreadStartCallback dart::Dart::thread_start_callback ( )

inlinestatic

Definition at line 97 of file dart.h.

                                                          {
    return thread_start_callback_;
  }

UptimeMicros()

int64_t dart::Dart::UptimeMicros ( )

static

Definition at line 1127 of file dart.cc.

                           {
  return OS::GetCurrentMonotonicMicros() - Dart::start_time_micros_;
}

UptimeMillis()

static int64_t dart::Dart::UptimeMillis ( )

inlinestatic

Definition at line 76 of file dart.h.

                                {
    return UptimeMicros() / kMicrosecondsPerMillisecond;
  }

vm_isolate()

static Isolate * dart::Dart::vm_isolate ( )

inlinestatic

Definition at line 68 of file dart.h.

{ return vm_isolate_; }

vm_isolate_group()

static IsolateGroup * dart::Dart::vm_isolate_group ( )

inlinestatic

Definition at line 69 of file dart.h.

                                          {
    if (vm_isolate_ == nullptr) return nullptr;
    return vm_isolate_->group();
  }

vm_snapshot_kind()

static Snapshot::Kind dart::Dart::vm_snapshot_kind ( )

inlinestatic

Definition at line 95 of file dart.h.

{ return vm_snapshot_kind_; }

---

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

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