blob: 3ebe7d8ed20b4096bb4fa9c507410d8e51701ea9 [file] [log] [blame]
// Copyright (c) 2017, the Dart project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
#include <memory>
#include "bin/snapshot_utils.h"
#include "bin/dartutils.h"
#include "bin/dfe.h"
#include "bin/elf_loader.h"
#include "bin/error_exit.h"
#include "bin/file.h"
#include "bin/platform.h"
#include "include/dart_api.h"
#if defined(DART_TARGET_OS_MACOS)
#include <platform/mach_o.h>
#endif
#if defined(DART_TARGET_OS_WINDOWS)
#include <platform/pe.h>
#endif
#include "platform/utils.h"
#define LOG_SECTION_BOUNDARIES false
namespace dart {
namespace bin {
static constexpr int64_t kAppSnapshotHeaderSize = 2 * kInt64Size;
// The largest possible page size among the platforms we support (Linux ARM64).
static constexpr int64_t kAppSnapshotPageSize = 64 * KB;
static const char kMachOAppSnapshotNoteName[] DART_UNUSED = "__dart_app_snap";
#if !defined(DART_PRECOMPILED_RUNTIME)
class DummySnapshot : public AppSnapshot {
public:
explicit DummySnapshot(DartUtils::MagicNumber num) : AppSnapshot(num) {}
~DummySnapshot() {}
void SetBuffers(const uint8_t** vm_data_buffer,
const uint8_t** vm_instructions_buffer,
const uint8_t** isolate_data_buffer,
const uint8_t** isolate_instructions_buffer) {
UNREACHABLE();
}
private:
};
#endif // !defined(DART_PRECOMPILED_RUNTIME)
class MappedAppSnapshot : public AppSnapshot {
public:
MappedAppSnapshot(MappedMemory* vm_snapshot_data,
MappedMemory* vm_snapshot_instructions,
MappedMemory* isolate_snapshot_data,
MappedMemory* isolate_snapshot_instructions)
: AppSnapshot(DartUtils::kAppJITMagicNumber),
vm_data_mapping_(vm_snapshot_data),
vm_instructions_mapping_(vm_snapshot_instructions),
isolate_data_mapping_(isolate_snapshot_data),
isolate_instructions_mapping_(isolate_snapshot_instructions) {}
~MappedAppSnapshot() {
delete vm_data_mapping_;
delete vm_instructions_mapping_;
delete isolate_data_mapping_;
delete isolate_instructions_mapping_;
}
void SetBuffers(const uint8_t** vm_data_buffer,
const uint8_t** vm_instructions_buffer,
const uint8_t** isolate_data_buffer,
const uint8_t** isolate_instructions_buffer) {
if (vm_data_mapping_ != nullptr) {
*vm_data_buffer =
reinterpret_cast<const uint8_t*>(vm_data_mapping_->address());
}
if (vm_instructions_mapping_ != nullptr) {
*vm_instructions_buffer =
reinterpret_cast<const uint8_t*>(vm_instructions_mapping_->address());
}
if (isolate_data_mapping_ != nullptr) {
*isolate_data_buffer =
reinterpret_cast<const uint8_t*>(isolate_data_mapping_->address());
}
if (isolate_instructions_mapping_ != nullptr) {
*isolate_instructions_buffer = reinterpret_cast<const uint8_t*>(
isolate_instructions_mapping_->address());
}
}
private:
MappedMemory* vm_data_mapping_;
MappedMemory* vm_instructions_mapping_;
MappedMemory* isolate_data_mapping_;
MappedMemory* isolate_instructions_mapping_;
};
static AppSnapshot* TryReadAppSnapshotBlobs(const char* script_name,
File* file) {
if ((file->Length() - file->Position()) < kAppSnapshotHeaderSize) {
return nullptr;
}
int64_t header[2];
ASSERT(sizeof(header) == kAppSnapshotHeaderSize);
if (!file->ReadFully(&header, kAppSnapshotHeaderSize)) {
return nullptr;
}
int64_t isolate_data_size = header[0];
int64_t isolate_data_position =
Utils::RoundUp(file->Position(), kAppSnapshotPageSize);
int64_t isolate_instructions_size = header[1];
int64_t isolate_instructions_position =
isolate_data_position + isolate_data_size;
if (isolate_instructions_size != 0) {
isolate_instructions_position =
Utils::RoundUp(isolate_instructions_position, kAppSnapshotPageSize);
}
MappedMemory* isolate_data_mapping = nullptr;
if (isolate_data_size != 0) {
isolate_data_mapping =
file->Map(File::kReadOnly, isolate_data_position, isolate_data_size);
if (isolate_data_mapping == nullptr) {
FATAL("Failed to memory map snapshot: %s\n", script_name);
}
}
MappedMemory* isolate_instr_mapping = nullptr;
if (isolate_instructions_size != 0) {
isolate_instr_mapping =
file->Map(File::kReadExecute, isolate_instructions_position,
isolate_instructions_size);
if (isolate_instr_mapping == nullptr) {
FATAL("Failed to memory map snapshot: %s\n", script_name);
}
}
auto app_snapshot = new MappedAppSnapshot(
nullptr, nullptr, isolate_data_mapping, isolate_instr_mapping);
return app_snapshot;
}
#if defined(DART_PRECOMPILED_RUNTIME)
class ElfAppSnapshot : public AppSnapshot {
public:
ElfAppSnapshot(Dart_LoadedElf* elf,
const uint8_t* vm_snapshot_data,
const uint8_t* vm_snapshot_instructions,
const uint8_t* isolate_snapshot_data,
const uint8_t* isolate_snapshot_instructions)
: AppSnapshot{DartUtils::kAotELFMagicNumber},
elf_(elf),
vm_snapshot_data_(vm_snapshot_data),
vm_snapshot_instructions_(vm_snapshot_instructions),
isolate_snapshot_data_(isolate_snapshot_data),
isolate_snapshot_instructions_(isolate_snapshot_instructions) {}
virtual ~ElfAppSnapshot() { Dart_UnloadELF(elf_); }
void SetBuffers(const uint8_t** vm_data_buffer,
const uint8_t** vm_instructions_buffer,
const uint8_t** isolate_data_buffer,
const uint8_t** isolate_instructions_buffer) {
*vm_data_buffer = vm_snapshot_data_;
*vm_instructions_buffer = vm_snapshot_instructions_;
*isolate_data_buffer = isolate_snapshot_data_;
*isolate_instructions_buffer = isolate_snapshot_instructions_;
}
private:
Dart_LoadedElf* elf_;
const uint8_t* vm_snapshot_data_;
const uint8_t* vm_snapshot_instructions_;
const uint8_t* isolate_snapshot_data_;
const uint8_t* isolate_snapshot_instructions_;
};
static AppSnapshot* TryReadAppSnapshotElf(
const char* script_name,
uint64_t file_offset,
bool force_load_elf_from_memory = false) {
const char* error = nullptr;
const uint8_t *vm_data_buffer = nullptr, *vm_instructions_buffer = nullptr,
*isolate_data_buffer = nullptr,
*isolate_instructions_buffer = nullptr;
Dart_LoadedElf* handle = nullptr;
#if !defined(DART_HOST_OS_FUCHSIA)
if (force_load_elf_from_memory) {
#endif
File* const file =
File::Open(/*namespc=*/nullptr, script_name, File::kRead);
if (file == nullptr) return nullptr;
MappedMemory* memory = file->Map(File::kReadOnly, /*position=*/0,
/*length=*/file->Length());
if (memory == nullptr) return nullptr;
const uint8_t* address =
reinterpret_cast<const uint8_t*>(memory->address());
handle =
Dart_LoadELF_Memory(address + file_offset, file->Length(), &error,
&vm_data_buffer, &vm_instructions_buffer,
&isolate_data_buffer, &isolate_instructions_buffer);
delete memory;
file->Release();
#if !defined(DART_HOST_OS_FUCHSIA)
} else {
handle = Dart_LoadELF(script_name, file_offset, &error, &vm_data_buffer,
&vm_instructions_buffer, &isolate_data_buffer,
&isolate_instructions_buffer);
}
#endif
if (handle == nullptr) {
Syslog::PrintErr("Loading failed: %s\n", error);
return nullptr;
}
return new ElfAppSnapshot(handle, vm_data_buffer, vm_instructions_buffer,
isolate_data_buffer, isolate_instructions_buffer);
}
#if defined(DART_TARGET_OS_MACOS)
AppSnapshot* Snapshot::TryReadAppendedAppSnapshotElfFromMachO(
const char* container_path) {
// Ensure file is actually MachO-formatted.
if (!IsMachOFormattedBinary(container_path)) {
Syslog::PrintErr("Expected a Mach-O binary.\n");
return nullptr;
}
File* file = File::Open(nullptr, container_path, File::kRead);
if (file == nullptr) {
return nullptr;
}
RefCntReleaseScope<File> rs(file);
// Read in the Mach-O header. Note that the 64-bit header is the same layout
// as the 32-bit header, just with an extra field for alignment, so we can
// safely load a 32-bit header to get all the information we need.
mach_o::mach_header header;
file->ReadFully(&header, sizeof(header));
if (header.magic == mach_o::MH_CIGAM || header.magic == mach_o::MH_CIGAM_64) {
Syslog::PrintErr(
"Expected a host endian header but found a byte-swapped header.\n");
return nullptr;
}
if (header.magic == mach_o::MH_MAGIC_64) {
// Set the file position as if we had read a 64-bit header.
file->SetPosition(sizeof(mach_o::mach_header_64));
}
// Now we search through the load commands to find our snapshot note, which
// has a data_owner field of kMachOAppSnapshotNoteName.
for (uint32_t i = 0; i < header.ncmds; ++i) {
mach_o::load_command command;
file->ReadFully(&command, sizeof(mach_o::load_command));
file->SetPosition(file->Position() - sizeof(command));
if (command.cmd != mach_o::LC_NOTE) {
file->SetPosition(file->Position() + command.cmdsize);
continue;
}
mach_o::note_command note;
file->ReadFully(&note, sizeof(note));
if (strcmp(note.data_owner, kMachOAppSnapshotNoteName) != 0) {
file->SetPosition(file->Position() + command.cmdsize);
continue;
}
// A note with the correct name was found, so we assume that the
// file contents for that note contains an ELF snapshot.
return TryReadAppSnapshotElf(container_path, note.offset);
}
return nullptr;
}
#endif // defined(DART_TARGET_OS_MACOS)
#if defined(DART_TARGET_OS_WINDOWS)
// Keep in sync with CoffSectionTable._snapshotSectionName from
// pkg/dart2native/lib/dart2native_pe.dart.
static const char kSnapshotSectionName[] = "snapshot";
// Ignore the null terminator, as it won't be present if the string length is
// exactly pe::kCoffSectionNameSize.
static_assert(sizeof(kSnapshotSectionName) - 1 <= pe::kCoffSectionNameSize,
"Section name of snapshot too large");
AppSnapshot* Snapshot::TryReadAppendedAppSnapshotElfFromPE(
const char* container_path) {
File* const file = File::Open(nullptr, container_path, File::kRead);
if (file == nullptr) {
return nullptr;
}
RefCntReleaseScope<File> rs(file);
// Ensure file is actually PE-formatted.
if (!IsPEFormattedBinary(container_path)) {
Syslog::PrintErr(
"Attempted load target was not formatted as expected: "
"expected PE32 or PE32+ image file.\n");
return nullptr;
}
// Parse the offset into the PE contents (i.e., skipping the MS-DOS stub).
uint32_t pe_offset;
file->SetPosition(pe::kPEOffsetOffset);
file->ReadFully(&pe_offset, sizeof(pe_offset));
// Skip past the magic bytes to the COFF file header and COFF optional header.
const intptr_t coff_offset = pe_offset + sizeof(pe::kPEMagic);
file->SetPosition(coff_offset);
pe::coff_file_header file_header;
file->ReadFully(&file_header, sizeof(file_header));
// The optional header follows directly after the file header.
pe::coff_optional_header opt_header;
file->ReadFully(&opt_header, sizeof(opt_header));
// Skip to the section table.
const intptr_t coff_symbol_table_offset =
coff_offset + sizeof(file_header) + file_header.optional_header_size;
file->SetPosition(coff_symbol_table_offset);
for (intptr_t i = 0; i < file_header.num_sections; i++) {
pe::coff_section_header section_header;
file->ReadFully(&section_header, sizeof(section_header));
if (strncmp(section_header.name, kSnapshotSectionName,
pe::kCoffSectionNameSize) == 0) {
// We have to do the loading manually even though currently the snapshot
// data is at the end of the file because the file alignment for
// PE sections can be less than the page size, and TryReadAppSnapshotElf
// won't work if the file offset isn't page-aligned.
const char* error = nullptr;
const uint8_t* vm_data_buffer = nullptr;
const uint8_t* vm_instructions_buffer = nullptr;
const uint8_t* isolate_data_buffer = nullptr;
const uint8_t* isolate_instructions_buffer = nullptr;
const intptr_t offset = section_header.file_offset;
const intptr_t size = section_header.file_size;
std::unique_ptr<uint8_t[]> snapshot(new uint8_t[size]);
file->SetPosition(offset);
file->ReadFully(snapshot.get(), sizeof(uint8_t) * size);
Dart_LoadedElf* const handle =
Dart_LoadELF_Memory(snapshot.get(), size, &error, &vm_data_buffer,
&vm_instructions_buffer, &isolate_data_buffer,
&isolate_instructions_buffer);
if (handle == nullptr) {
Syslog::PrintErr("Loading failed: %s\n", error);
return nullptr;
}
return new ElfAppSnapshot(handle, vm_data_buffer, vm_instructions_buffer,
isolate_data_buffer,
isolate_instructions_buffer);
}
}
return nullptr;
}
#endif // defined(DART_TARGET_OS_WINDOWS)
AppSnapshot* Snapshot::TryReadAppendedAppSnapshotElf(
const char* container_path) {
#if defined(DART_TARGET_OS_MACOS)
if (IsMachOFormattedBinary(container_path)) {
return TryReadAppendedAppSnapshotElfFromMachO(container_path);
}
#elif defined(DART_TARGET_OS_WINDOWS)
if (IsPEFormattedBinary(container_path)) {
return TryReadAppendedAppSnapshotElfFromPE(container_path);
}
#endif
File* file = File::Open(nullptr, container_path, File::kRead);
if (file == nullptr) {
return nullptr;
}
RefCntReleaseScope<File> rs(file);
// Check for payload appended at the end of the container file.
// If header is found, jump to payload offset.
int64_t appended_header[2];
if (!file->SetPosition(file->Length() - sizeof(appended_header))) {
return nullptr;
}
if (!file->ReadFully(&appended_header, sizeof(appended_header))) {
return nullptr;
}
// Length is always encoded as Little Endian.
const uint64_t appended_offset =
Utils::LittleEndianToHost64(appended_header[0]);
if (memcmp(&appended_header[1], appjit_magic_number.bytes,
appjit_magic_number.length) != 0 ||
appended_offset <= 0) {
return nullptr;
}
return TryReadAppSnapshotElf(container_path, appended_offset);
}
class DylibAppSnapshot : public AppSnapshot {
public:
DylibAppSnapshot(void* library,
const uint8_t* vm_snapshot_data,
const uint8_t* vm_snapshot_instructions,
const uint8_t* isolate_snapshot_data,
const uint8_t* isolate_snapshot_instructions)
: AppSnapshot(DartUtils::kAotELFMagicNumber),
library_(library),
vm_snapshot_data_(vm_snapshot_data),
vm_snapshot_instructions_(vm_snapshot_instructions),
isolate_snapshot_data_(isolate_snapshot_data),
isolate_snapshot_instructions_(isolate_snapshot_instructions) {}
~DylibAppSnapshot() { Utils::UnloadDynamicLibrary(library_); }
void SetBuffers(const uint8_t** vm_data_buffer,
const uint8_t** vm_instructions_buffer,
const uint8_t** isolate_data_buffer,
const uint8_t** isolate_instructions_buffer) {
*vm_data_buffer = vm_snapshot_data_;
*vm_instructions_buffer = vm_snapshot_instructions_;
*isolate_data_buffer = isolate_snapshot_data_;
*isolate_instructions_buffer = isolate_snapshot_instructions_;
}
private:
void* library_;
const uint8_t* vm_snapshot_data_;
const uint8_t* vm_snapshot_instructions_;
const uint8_t* isolate_snapshot_data_;
const uint8_t* isolate_snapshot_instructions_;
};
static AppSnapshot* TryReadAppSnapshotDynamicLibrary(const char* script_name) {
void* library = Utils::LoadDynamicLibrary(script_name);
if (library == nullptr) {
return nullptr;
}
const uint8_t* vm_data_buffer = reinterpret_cast<const uint8_t*>(
Utils::ResolveSymbolInDynamicLibrary(library, kVmSnapshotDataCSymbol));
const uint8_t* vm_instructions_buffer =
reinterpret_cast<const uint8_t*>(Utils::ResolveSymbolInDynamicLibrary(
library, kVmSnapshotInstructionsCSymbol));
const uint8_t* isolate_data_buffer =
reinterpret_cast<const uint8_t*>(Utils::ResolveSymbolInDynamicLibrary(
library, kIsolateSnapshotDataCSymbol));
if (isolate_data_buffer == nullptr) {
FATAL("Failed to resolve symbol '%s'\n", kIsolateSnapshotDataCSymbol);
}
const uint8_t* isolate_instructions_buffer =
reinterpret_cast<const uint8_t*>(Utils::ResolveSymbolInDynamicLibrary(
library, kIsolateSnapshotInstructionsCSymbol));
if (isolate_instructions_buffer == nullptr) {
FATAL("Failed to resolve symbol '%s'\n",
kIsolateSnapshotInstructionsCSymbol);
}
return new DylibAppSnapshot(library, vm_data_buffer, vm_instructions_buffer,
isolate_data_buffer, isolate_instructions_buffer);
}
#endif // defined(DART_PRECOMPILED_RUNTIME)
#if defined(DART_TARGET_OS_MACOS)
bool Snapshot::IsMachOFormattedBinary(const char* filename) {
File* file = File::Open(nullptr, filename, File::kRead);
if (file == nullptr) {
return false;
}
RefCntReleaseScope<File> rs(file);
const uint64_t size = file->Length();
// Parse the first 4 bytes and check the magic numbers.
uint32_t magic;
if (size < sizeof(magic)) {
// The file isn't long enough to contain the magic bytes.
return false;
}
file->SetPosition(0);
file->ReadFully(&magic, sizeof(magic));
// Depending on the magic numbers, check that the size of the file is
// large enough for either a 32-bit or 64-bit header.
switch (magic) {
case mach_o::MH_MAGIC:
case mach_o::MH_CIGAM:
return size >= sizeof(mach_o::mach_header);
case mach_o::MH_MAGIC_64:
case mach_o::MH_CIGAM_64:
return size >= sizeof(mach_o::mach_header_64);
default:
// Not a Mach-O formatted file.
return false;
}
}
#endif // defined(DART_TARGET_OS_MACOS)
#if defined(DART_TARGET_OS_WINDOWS)
bool Snapshot::IsPEFormattedBinary(const char* filename) {
File* file = File::Open(nullptr, filename, File::kRead);
if (file == nullptr) {
return false;
}
RefCntReleaseScope<File> rs(file);
// Parse the PE offset.
uint32_t pe_offset;
// Ensure the file is long enough to contain the PE offset.
if (file->Length() <
static_cast<intptr_t>(pe::kPEOffsetOffset + sizeof(pe_offset))) {
return false;
}
file->SetPosition(pe::kPEOffsetOffset);
file->Read(&pe_offset, sizeof(pe_offset));
// Ensure the file is long enough to contain the PE magic bytes.
if (file->Length() <
static_cast<intptr_t>(pe_offset + sizeof(pe::kPEMagic))) {
return false;
}
// Check the magic bytes.
file->SetPosition(pe_offset);
for (size_t i = 0; i < sizeof(pe::kPEMagic); i++) {
char c;
file->Read(&c, sizeof(c));
if (c != pe::kPEMagic[i]) {
return false;
}
}
// Check that there is a coff optional header.
pe::coff_file_header file_header;
pe::coff_optional_header opt_header;
file->Read(&file_header, sizeof(file_header));
if (file_header.optional_header_size < sizeof(opt_header)) {
return false;
}
file->Read(&opt_header, sizeof(opt_header));
// Check the magic bytes in the coff optional header.
if (opt_header.magic != pe::kPE32Magic &&
opt_header.magic != pe::kPE32PlusMagic) {
return false;
}
return true;
}
#endif // defined(DART_TARGET_OS_WINDOWS)
AppSnapshot* Snapshot::TryReadAppSnapshot(const char* script_uri,
bool force_load_elf_from_memory,
bool decode_uri) {
CStringUniquePtr decoded_path(nullptr);
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'.
CStringUniquePtr absolute_path(realpath(script_name, nullptr));
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;
}
#if !defined(EXCLUDE_CFE_AND_KERNEL_PLATFORM) && !defined(TESTING)
static void WriteSnapshotFile(const char* filename,
const uint8_t* buffer,
const intptr_t size) {
File* file = File::Open(nullptr, filename, File::kWriteTruncate);
if (file == nullptr) {
ErrorExit(kErrorExitCode, "Unable to open file %s for writing snapshot\n",
filename);
}
if (!file->WriteFully(buffer, size)) {
ErrorExit(kErrorExitCode, "Unable to write file %s for writing snapshot\n",
filename);
}
file->Release();
}
#endif
static bool WriteInt64(File* file, int64_t size) {
return file->WriteFully(&size, sizeof(size));
}
void Snapshot::WriteAppSnapshot(const char* filename,
uint8_t* isolate_data_buffer,
intptr_t isolate_data_size,
uint8_t* isolate_instructions_buffer,
intptr_t isolate_instructions_size) {
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, 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 ": 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();
}
void Snapshot::GenerateKernel(const char* snapshot_filename,
const char* script_name,
const char* package_config) {
#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)
}
void Snapshot::GenerateAppJIT(const char* snapshot_filename) {
#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, 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, isolate_data_buffer, isolate_data_size,
isolate_instructions_buffer, isolate_instructions_size);
#endif
}
static void StreamingWriteCallback(void* callback_data,
const uint8_t* buffer,
intptr_t size) {
File* file = reinterpret_cast<File*>(callback_data);
if (!file->WriteFully(buffer, size)) {
ErrorExit(kErrorExitCode, "Unable to write snapshot file\n");
}
}
void Snapshot::GenerateAppAOTAsAssembly(const char* snapshot_filename) {
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));
}
}
} // namespace bin
} // namespace dart