dart::bin::Snapshot Class Reference

#include <snapshot_utils.h>

Static Public Member Functions
static void	GenerateKernel (const char *snapshot_filename, const char *script_name, const char *package_config)
static void	GenerateAppJIT (const char *snapshot_filename)
static void	GenerateAppAOTAsAssembly (const char *snapshot_filename)
static AppSnapshot *	TryReadAppendedAppSnapshotElf (const char *container_path)
static AppSnapshot *	TryReadAppSnapshot (const char *script_uri, bool force_load_elf_from_memory=false, bool decode_uri=true)
static void	WriteAppSnapshot (const char *filename, uint8_t *vm_data_buffer, intptr_t vm_data_size, uint8_t *vm_instructions_buffer, intptr_t vm_instructions_size, uint8_t *isolate_data_buffer, intptr_t isolate_data_size, uint8_t *isolate_instructions_buffer, intptr_t isolate_instructions_size)

Detailed Description

Definition at line 41 of file snapshot_utils.h.

Member Function Documentation

GenerateAppAOTAsAssembly()

void dart::bin::Snapshot::GenerateAppAOTAsAssembly ( const char *  snapshot_filename )

static

Definition at line 817 of file snapshot_utils.cc.

                                                                     {
  File* file = File::Open(nullptr, snapshot_filename, File::kWriteTruncate);
  RefCntReleaseScope<File> rs(file);
  if (file == nullptr) {
    ErrorExit(kErrorExitCode, "Unable to open file %s for writing snapshot\n",
              snapshot_filename);
  }
  Dart_Handle result = Dart_CreateAppAOTSnapshotAsAssembly(
      StreamingWriteCallback, file, /*strip=*/false,
      /*debug_callback_data=*/nullptr);
  if (Dart_IsError(result)) {
    ErrorExit(kErrorExitCode, "%s\n", Dart_GetError(result));
  }
}

GenerateAppJIT()

void dart::bin::Snapshot::GenerateAppJIT ( const char *  snapshot_filename )

static

Definition at line 777 of file snapshot_utils.cc.

                                                           {
#if defined(TARGET_ARCH_IA32)
  // Snapshots with code are not supported on IA32.
  uint8_t* isolate_buffer = nullptr;
  intptr_t isolate_size = 0;
 
  Dart_Handle result = Dart_CreateSnapshot(nullptr, nullptr, &isolate_buffer,
                                           &isolate_size, /*is_core=*/false);
  if (Dart_IsError(result)) {
    ErrorExit(kErrorExitCode, "%s\n", Dart_GetError(result));
  }
 
  WriteAppSnapshot(snapshot_filename, nullptr, 0, nullptr, 0, isolate_buffer,
                   isolate_size, nullptr, 0);
#else
  uint8_t* isolate_data_buffer = nullptr;
  intptr_t isolate_data_size = 0;
  uint8_t* isolate_instructions_buffer = nullptr;
  intptr_t isolate_instructions_size = 0;
  Dart_Handle result = Dart_CreateAppJITSnapshotAsBlobs(
      &isolate_data_buffer, &isolate_data_size, &isolate_instructions_buffer,
      &isolate_instructions_size);
  if (Dart_IsError(result)) {
    ErrorExit(kErrorExitCode, "%s\n", Dart_GetError(result));
  }
  WriteAppSnapshot(snapshot_filename, nullptr, 0, nullptr, 0,
                   isolate_data_buffer, isolate_data_size,
                   isolate_instructions_buffer, isolate_instructions_size);
#endif
}

GenerateKernel()

void dart::bin::Snapshot::GenerateKernel ( const char *  snapshot_filename, const char *  script_name, const char *  package_config  )

static

Definition at line 749 of file snapshot_utils.cc.

                                                          {
#if !defined(EXCLUDE_CFE_AND_KERNEL_PLATFORM) && !defined(TESTING)
  ASSERT(Dart_CurrentIsolate() == nullptr);
 
  uint8_t* kernel_buffer = nullptr;
  intptr_t kernel_buffer_size = 0;
  dfe.ReadScript(script_name, nullptr, &kernel_buffer, &kernel_buffer_size);
  if (kernel_buffer != nullptr) {
    WriteSnapshotFile(snapshot_filename, kernel_buffer, kernel_buffer_size);
    free(kernel_buffer);
  } else {
    Dart_KernelCompilationResult result =
        dfe.CompileScript(script_name, /*incremental*/ false, package_config,
                          /*snapshot=*/true, /*embedd_sources=*/true);
    if (result.status != Dart_KernelCompilationStatus_Ok) {
      Syslog::PrintErr("%s\n", result.error);
      Platform::Exit(kCompilationErrorExitCode);
    }
    WriteSnapshotFile(snapshot_filename, result.kernel, result.kernel_size);
    free(result.kernel);
  }
#else
  UNREACHABLE();
#endif  // !defined(EXCLUDE_CFE_AND_KERNEL_PLATFORM) && !defined(TESTING)
}

TryReadAppendedAppSnapshotElf()

static AppSnapshot * dart::bin::Snapshot::TryReadAppendedAppSnapshotElf ( const char *  container_path )

static

TryReadAppSnapshot()

AppSnapshot * dart::bin::Snapshot::TryReadAppSnapshot ( const char *  script_uri, bool  force_load_elf_from_memory = false, bool  decode_uri = true  )

static

Definition at line 588 of file snapshot_utils.cc.

                                                           {
  Utils::CStringUniquePtr decoded_path(nullptr, std::free);
  const char* script_name = nullptr;
  if (decode_uri) {
    decoded_path = File::UriToPath(script_uri);
    if (decoded_path == nullptr) {
      return nullptr;
    }
    script_name = decoded_path.get();
  } else {
    script_name = script_uri;
  }
  if (File::GetType(nullptr, script_name, true) != File::kIsFile) {
    // If 'script_name' refers to a pipe, don't read to check for an app
    // snapshot since we cannot rewind if it isn't (and couldn't mmap it in
    // anyway if it was).
    return nullptr;
  }
  File* file = File::Open(nullptr, script_name, File::kRead);
  if (file == nullptr) {
    return nullptr;
  }
  RefCntReleaseScope<File> rs(file);
  if ((file->Length() - file->Position()) < DartUtils::kMaxMagicNumberSize) {
    return nullptr;
  }
 
  uint8_t header[DartUtils::kMaxMagicNumberSize];
  ASSERT(sizeof(header) == DartUtils::kMaxMagicNumberSize);
  if (!file->ReadFully(&header, DartUtils::kMaxMagicNumberSize)) {
    return nullptr;
  }
  DartUtils::MagicNumber magic_number =
      DartUtils::SniffForMagicNumber(header, sizeof(header));
  if (magic_number == DartUtils::kAppJITMagicNumber) {
    // Return the JIT snapshot.
    return TryReadAppSnapshotBlobs(script_name, file);
  }
#if defined(DART_PRECOMPILED_RUNTIME)
  if (!DartUtils::IsAotMagicNumber(magic_number)) {
    return nullptr;
  }
 
  // For testing AOT with the standalone embedder, we also support loading
  // from a dynamic library to simulate what happens on iOS.
 
#if defined(DART_TARGET_OS_LINUX) || defined(DART_TARGET_OS_MACOS)
  // On Linux and OSX, resolve the script path before passing into dlopen()
  // since dlopen will not search the filesystem for paths like 'libtest.so'.
  std::unique_ptr<char, decltype(std::free)*> absolute_path{
      realpath(script_name, nullptr), std::free};
  script_name = absolute_path.get();
#endif
 
  AppSnapshot* snapshot = nullptr;
  if (!force_load_elf_from_memory) {
    snapshot = TryReadAppSnapshotDynamicLibrary(script_name);
    if (snapshot != nullptr) {
      return snapshot;
    }
  }
  return TryReadAppSnapshotElf(script_name, /*file_offset=*/0,
                               force_load_elf_from_memory);
#else
  // We create a dummy snapshot object just to remember the type which
  // has already been identified by sniffing the magic number.
  return new DummySnapshot(magic_number);
#endif  // defined(DART_PRECOMPILED_RUNTIME)
 
  return nullptr;
}

WriteAppSnapshot()

void dart::bin::Snapshot::WriteAppSnapshot ( const char *  filename, uint8_t *  vm_data_buffer, intptr_t  vm_data_size, uint8_t *  vm_instructions_buffer, intptr_t  vm_instructions_size, uint8_t *  isolate_data_buffer, intptr_t  isolate_data_size, uint8_t *  isolate_instructions_buffer, intptr_t  isolate_instructions_size  )

static

Definition at line 684 of file snapshot_utils.cc.

                                                                    {
  File* file = File::Open(nullptr, filename, File::kWriteTruncate);
  if (file == nullptr) {
    ErrorExit(kErrorExitCode, "Unable to write snapshot file '%s'\n", filename);
  }
 
  file->WriteFully(appjit_magic_number.bytes, appjit_magic_number.length);
  WriteInt64(file, vm_data_size);
  WriteInt64(file, vm_instructions_size);
  WriteInt64(file, isolate_data_size);
  WriteInt64(file, isolate_instructions_size);
  ASSERT(file->Position() ==
         (kAppSnapshotHeaderSize + DartUtils::kMaxMagicNumberSize));
 
  file->SetPosition(Utils::RoundUp(file->Position(), kAppSnapshotPageSize));
  if (LOG_SECTION_BOUNDARIES) {
    Syslog::PrintErr("%" Px64 ": VM Data\n", file->Position());
  }
  if (!file->WriteFully(vm_data_buffer, vm_data_size)) {
    ErrorExit(kErrorExitCode, "Unable to write snapshot file '%s'\n", filename);
  }
 
  if (vm_instructions_size != 0) {
    file->SetPosition(Utils::RoundUp(file->Position(), kAppSnapshotPageSize));
    if (LOG_SECTION_BOUNDARIES) {
      Syslog::PrintErr("%" Px64 ": VM Instructions\n", file->Position());
    }
    if (!file->WriteFully(vm_instructions_buffer, vm_instructions_size)) {
      ErrorExit(kErrorExitCode, "Unable to write snapshot file '%s'\n",
                filename);
    }
  }
 
  file->SetPosition(Utils::RoundUp(file->Position(), kAppSnapshotPageSize));
  if (LOG_SECTION_BOUNDARIES) {
    Syslog::PrintErr("%" Px64 ": Isolate Data\n", file->Position());
  }
  if (!file->WriteFully(isolate_data_buffer, isolate_data_size)) {
    ErrorExit(kErrorExitCode, "Unable to write snapshot file '%s'\n", filename);
  }
 
  if (isolate_instructions_size != 0) {
    file->SetPosition(Utils::RoundUp(file->Position(), kAppSnapshotPageSize));
    if (LOG_SECTION_BOUNDARIES) {
      Syslog::PrintErr("%" Px64 ": Isolate Instructions\n", file->Position());
    }
    if (!file->WriteFully(isolate_instructions_buffer,
                          isolate_instructions_size)) {
      ErrorExit(kErrorExitCode, "Unable to write snapshot file '%s'\n",
                filename);
    }
  }
 
  file->Flush();
  file->Release();
}

---

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

• third_party/dart-lang/sdk/runtime/bin/snapshot_utils.h
• third_party/dart-lang/sdk/runtime/bin/snapshot_utils.cc