dart::FullSnapshotReader Class Reference

#include <app_snapshot.h>

Public Member Functions
	FullSnapshotReader (const Snapshot *snapshot, const uint8_t *instructions_buffer, Thread *thread)
	~FullSnapshotReader ()
ApiErrorPtr	ReadVMSnapshot ()
ApiErrorPtr	ReadProgramSnapshot ()
ApiErrorPtr	ReadUnitSnapshot (const LoadingUnit &unit)

Detailed Description

Definition at line 163 of file app_snapshot.h.

Constructor & Destructor Documentation

FullSnapshotReader()

dart::FullSnapshotReader::FullSnapshotReader	(	const Snapshot *	snapshot,
		const uint8_t *	instructions_buffer,
		Thread *	thread
	)

Definition at line 9828 of file app_snapshot.cc.

    : kind_(snapshot->kind()),
      thread_(thread),
      buffer_(snapshot->Addr()),
      size_(snapshot->length()),
      data_image_(snapshot->DataImage()),
      instructions_image_(instructions_buffer) {}

~FullSnapshotReader()

dart::FullSnapshotReader::~FullSnapshotReader ( )

inline

Definition at line 168 of file app_snapshot.h.

{}

Member Function Documentation

ReadProgramSnapshot()

ApiErrorPtr dart::FullSnapshotReader::ReadProgramSnapshot

(

)

Definition at line 9985 of file app_snapshot.cc.

                                                    {
  SnapshotHeaderReader header_reader(kind_, buffer_, size_);
  header_reader.SetCoverageFromSnapshotFeatures(thread_->isolate_group());
  intptr_t offset = 0;
  char* error =
      header_reader.VerifyVersionAndFeatures(thread_->isolate_group(), &offset);
  if (error != nullptr) {
    return ConvertToApiError(error);
  }
 
  // Even though there's no concurrent threads we have to guard agains, some
  // logic we do in deserialization triggers common code that asserts the
  // program lock is held.
  SafepointWriteRwLocker ml(thread_, isolate_group()->program_lock());
 
  Deserializer deserializer(thread_, kind_, buffer_, size_, data_image_,
                            instructions_image_, /*is_non_root_unit=*/false,
                            offset);
  ApiErrorPtr api_error = deserializer.VerifyImageAlignment();
  if (api_error != ApiError::null()) {
    return api_error;
  }
 
  if (Snapshot::IncludesCode(kind_)) {
    ASSERT(data_image_ != nullptr);
    thread_->isolate_group()->SetupImagePage(data_image_,
                                             /* is_executable */ false);
    ASSERT(instructions_image_ != nullptr);
    thread_->isolate_group()->SetupImagePage(instructions_image_,
                                             /* is_executable */ true);
  }
 
  ProgramDeserializationRoots roots(thread_->isolate_group()->object_store());
  deserializer.Deserialize(&roots);
 
  if (Snapshot::IncludesCode(kind_)) {
    const auto& units = Array::Handle(
        thread_->isolate_group()->object_store()->loading_units());
    if (!units.IsNull()) {
      const auto& unit = LoadingUnit::Handle(
          LoadingUnit::RawCast(units.At(LoadingUnit::kRootId)));
      // Unlike other units, we don't explicitly load the root loading unit,
      // so we mark it as loaded here, setting the instructions image as well.
      unit.set_load_outstanding();
      unit.set_instructions_image(instructions_image_);
      unit.set_loaded(true);
    }
  }
 
  InitializeBSS();
 
  return ApiError::null();
}

ReadUnitSnapshot()

ApiErrorPtr dart::FullSnapshotReader::ReadUnitSnapshot

(

const LoadingUnit &

unit

)

Definition at line 10039 of file app_snapshot.cc.

                                                                        {
  SnapshotHeaderReader header_reader(kind_, buffer_, size_);
  intptr_t offset = 0;
  char* error =
      header_reader.VerifyVersionAndFeatures(thread_->isolate_group(), &offset);
  if (error != nullptr) {
    return ConvertToApiError(error);
  }
 
  Deserializer deserializer(
      thread_, kind_, buffer_, size_, data_image_, instructions_image_,
      /*is_non_root_unit=*/unit.id() != LoadingUnit::kRootId, offset);
  ApiErrorPtr api_error = deserializer.VerifyImageAlignment();
  if (api_error != ApiError::null()) {
    return api_error;
  }
  {
    Array& units =
        Array::Handle(isolate_group()->object_store()->loading_units());
    uint32_t main_program_hash = Smi::Value(Smi::RawCast(units.At(0)));
    uint32_t unit_program_hash = deserializer.Read<uint32_t>();
    if (main_program_hash != unit_program_hash) {
      return ApiError::New(String::Handle(
          String::New("Deferred loading unit is from a different "
                      "program than the main loading unit")));
    }
  }
 
  if (Snapshot::IncludesCode(kind_)) {
    ASSERT(data_image_ != nullptr);
    thread_->isolate_group()->SetupImagePage(data_image_,
                                             /* is_executable */ false);
    ASSERT(instructions_image_ != nullptr);
    thread_->isolate_group()->SetupImagePage(instructions_image_,
                                             /* is_executable */ true);
    unit.set_instructions_image(instructions_image_);
  }
 
  UnitDeserializationRoots roots(unit);
  deserializer.Deserialize(&roots);
 
  InitializeBSS();
 
  return ApiError::null();
}

ReadVMSnapshot()

ApiErrorPtr dart::FullSnapshotReader::ReadVMSnapshot

(

)

Definition at line 9938 of file app_snapshot.cc.

                                               {
  SnapshotHeaderReader header_reader(kind_, buffer_, size_);
 
  intptr_t offset = 0;
  char* error = header_reader.VerifyVersionAndFeatures(
      /*isolate_group=*/nullptr, &offset);
  if (error != nullptr) {
    return ConvertToApiError(error);
  }
 
  // Even though there's no concurrent threads we have to guard agains, some
  // logic we do in deserialization triggers common code that asserts the
  // program lock is held.
  SafepointWriteRwLocker ml(thread_, isolate_group()->program_lock());
 
  Deserializer deserializer(thread_, kind_, buffer_, size_, data_image_,
                            instructions_image_, /*is_non_root_unit=*/false,
                            offset);
  ApiErrorPtr api_error = deserializer.VerifyImageAlignment();
  if (api_error != ApiError::null()) {
    return api_error;
  }
 
  if (Snapshot::IncludesCode(kind_)) {
    ASSERT(data_image_ != nullptr);
    thread_->isolate_group()->SetupImagePage(data_image_,
                                             /* is_executable */ false);
    ASSERT(instructions_image_ != nullptr);
    thread_->isolate_group()->SetupImagePage(instructions_image_,
                                             /* is_executable */ true);
  }
 
  VMDeserializationRoots roots;
  deserializer.Deserialize(&roots);
 
#if defined(DART_PRECOMPILED_RUNTIME)
  // Initialize entries in the VM portion of the BSS segment.
  ASSERT(Snapshot::IncludesCode(kind_));
  Image image(instructions_image_);
  if (auto const bss = image.bss()) {
    BSS::Initialize(thread_, bss, /*vm=*/true);
  }
#endif  // defined(DART_PRECOMPILED_RUNTIME)
 
  return ApiError::null();
}

---

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

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