dart::ImageWriter Class Reference

#include <image_snapshot.h>

Inheritance diagram for dart::ImageWriter:

Classes
struct	InstructionsData
struct	ObjectData

Public Types
enum class	ProgramSection { Text , Data , Bss , BuildId }

Public Member Functions
	ImageWriter (Thread *thread, bool generates_assembly)
virtual	~ImageWriter ()
void	ResetOffsets ()
void	PrepareForSerialization (GrowableArray< ImageWriterCommand > *commands)
bool	IsROSpace () const
int32_t	GetTextOffsetFor (InstructionsPtr instructions, CodePtr code)
uint32_t	GetDataOffsetFor (ObjectPtr raw_object)
uint32_t	AddBytesToData (uint8_t *bytes, intptr_t length)
void	Write (NonStreamingWriteStream *clustered_stream, bool vm)
intptr_t	data_size () const
intptr_t	text_size () const
intptr_t	GetTextObjectCount () const
void	GetTrampolineInfo (intptr_t *count, intptr_t *size) const
void	DumpStatistics ()
void	SetProfileWriter (V8SnapshotProfileWriter *profile_writer)
void	ClearProfileWriter ()
void	TraceInstructions (const Instructions &instructions)
const char *	ObjectTypeForProfile (const Object &object) const
Public Member Functions inherited from dart::ValueObject
	ValueObject ()
	~ValueObject ()

Static Public Member Functions
static intptr_t	SizeInSnapshot (ObjectPtr object)
static intptr_t	SizeInSnapshot (const Object &object)
static const char *	TagObjectTypeAsReadOnly (Zone *zone, const char *type)

Static Public Attributes
static constexpr intptr_t	kBssAlignment = compiler::target::kWordSize
static constexpr intptr_t	kRODataAlignment = kObjectStartAlignment
static constexpr intptr_t	kTextAlignment = kObjectStartAlignment
static constexpr intptr_t	kNumProgramSections

Protected Member Functions
virtual void	WriteBss (bool vm)=0
virtual void	WriteROData (NonStreamingWriteStream *clustered_stream, bool vm)
void	WriteText (bool vm)
void	DumpInstructionStats ()
void	DumpInstructionsSizes ()
virtual bool	EnterSection (ProgramSection name, bool vm, intptr_t alignment, intptr_t *alignment_padding=nullptr)=0
virtual void	ExitSection (ProgramSection name, bool vm, intptr_t size)=0
virtual void	FrameUnwindPrologue ()=0
virtual void	FrameUnwindEpilogue ()=0
virtual intptr_t	WriteTargetWord (word value)=0
virtual intptr_t	WriteBytes (const void *bytes, intptr_t size)=0
virtual intptr_t	Align (intptr_t alignment, intptr_t offset, intptr_t position)=0
template<typename T >
intptr_t	WriteFixed (T value)
intptr_t	AlignWithBreakInstructions (intptr_t alignment, intptr_t offset)

Static Protected Member Functions
static const char *	SectionSymbol (ProgramSection section, bool vm)
static uword	GetMarkedTags (classid_t cid, intptr_t size, bool is_canonical=false)
static uword	GetMarkedTags (const Object &obj)

Protected Attributes
Thread *const	thread_
Zone *const	zone_
intptr_t	next_data_offset_
intptr_t	next_text_offset_
GrowableArray< ObjectData >	objects_
GrowableArray< InstructionsData >	instructions_
IdSpace	offset_space_ = IdSpace::kSnapshot
V8SnapshotProfileWriter *	profile_writer_ = nullptr
const char *const	image_type_
const char *const	instructions_section_type_
const char *const	instructions_type_
const char *const	trampoline_type_
const char *const	padding_type_

Friends
template<class T >
class	TraceImageObjectScope

Detailed Description

Definition at line 366 of file image_snapshot.h.

Member Enumeration Documentation

ProgramSection

enum class dart::ImageWriter::ProgramSection

strong

Enumerator
Text
Data
Bss
BuildId

Definition at line 446 of file image_snapshot.h.

                            {
    Text,     // Instructions.
    Data,     // Read-only data.
    Bss,      // Statically allocated variables initialized at load.
    BuildId,  // GNU build ID (when applicable)
    // Adjust kNumProgramSections below to use last enum value added.
  };

Constructor & Destructor Documentation

ImageWriter()

dart::ImageWriter::ImageWriter	(	Thread *	thread,
		bool	generates_assembly
	)

Definition at line 174 of file image_snapshot.cc.

    : thread_(ASSERT_NOTNULL(t)),
      zone_(t->zone()),
      next_data_offset_(0),
      next_text_offset_(0),
      objects_(),
      instructions_(),
#if defined(DART_PRECOMPILER)
      namer_(t->zone(),
             deobfuscation_trie,
             /*for_assembly=*/generates_assembly),
#endif
      image_type_(TagObjectTypeAsReadOnly(zone_, "Image")),
      instructions_section_type_(
          TagObjectTypeAsReadOnly(zone_, "InstructionsSection")),
      instructions_type_(TagObjectTypeAsReadOnly(zone_, "Instructions")),
      trampoline_type_(TagObjectTypeAsReadOnly(zone_, "Trampoline")),
      padding_type_(TagObjectTypeAsReadOnly(zone_, "Padding")) {
  ResetOffsets();
}

~ImageWriter()

virtual dart::ImageWriter::~ImageWriter ( )

inlinevirtual

Definition at line 375 of file image_snapshot.h.

{}

Member Function Documentation

AddBytesToData()

uint32_t dart::ImageWriter::AddBytesToData	(	uint8_t *	bytes,
		intptr_t	length
	)

Definition at line 319 of file image_snapshot.cc.

                                                                    {
  const intptr_t snap_size = SizeInSnapshotForBytes(length);
  const intptr_t offset = next_data_offset_;
  next_data_offset_ += snap_size;
  objects_.Add(ObjectData(bytes, length));
  return offset;
}

Align()

virtual intptr_t dart::ImageWriter::Align ( intptr_t  alignment, intptr_t  offset, intptr_t  position  )

protectedpure virtual

Implemented in dart::BlobImageWriter.

AlignWithBreakInstructions()

intptr_t dart::ImageWriter::AlignWithBreakInstructions ( intptr_t  alignment, intptr_t  offset  )

protected

Definition at line 965 of file image_snapshot.cc.

                                                                  {
  intptr_t bytes_written = 0;
  uword remaining;
  for (remaining = Utils::RoundUp(offset, alignment) - offset;
       remaining >= compiler::target::kWordSize;
       remaining -= compiler::target::kWordSize) {
    bytes_written += WriteTargetWord(kBreakInstructionFiller);
  }
  // clang-format off
#if defined(TARGET_ARCH_ARM)
  // All instructions are 4 bytes long on ARM architectures, so on 32-bit ARM
  // there won't be any padding.
  ASSERT_EQUAL(remaining, 0);
#elif defined(TARGET_ARCH_ARM64)
  // All instructions are 4 bytes long on ARM architectures, so on 64-bit ARM
  // there is only 0 or 4 bytes of padding.
  if (remaining != 0) {
    ASSERT_EQUAL(remaining, 4);
    bytes_written += WriteBytes(&kBreakInstructionFiller, remaining);
  }
#elif defined(TARGET_ARCH_X64) || defined(TARGET_ARCH_IA32) ||                 \
    defined(TARGET_ARCH_RISCV32) || defined(TARGET_ARCH_RISCV64)
  // The break instruction is a single byte, repeated to fill a word.
  bytes_written += WriteBytes(&kBreakInstructionFiller, remaining);
#else
#error Unexpected architecture.
#endif
  // clang-format on
  ASSERT_EQUAL(bytes_written, Utils::RoundUp(offset, alignment) - offset);
  return bytes_written;
}

ClearProfileWriter()

void dart::ImageWriter::ClearProfileWriter ( )

inline

Definition at line 433 of file image_snapshot.h.

{ profile_writer_ = nullptr; }

data_size()

intptr_t dart::ImageWriter::data_size ( ) const

inline

Definition at line 422 of file image_snapshot.h.

{ return next_data_offset_; }

DumpInstructionsSizes()

void dart::ImageWriter::DumpInstructionsSizes ( )

protected

DumpInstructionStats()

void dart::ImageWriter::DumpInstructionStats ( )

protected

DumpStatistics()

void dart::ImageWriter::DumpStatistics

(

)

EnterSection()

virtual bool dart::ImageWriter::EnterSection ( ProgramSection  name, bool  vm, intptr_t  alignment, intptr_t *  alignment_padding = nullptr  )

protectedpure virtual

Implemented in dart::BlobImageWriter.

ExitSection()

virtual void dart::ImageWriter::ExitSection ( ProgramSection  name, bool  vm, intptr_t  size  )

protectedpure virtual

Implemented in dart::BlobImageWriter.

FrameUnwindEpilogue()

virtual void dart::ImageWriter::FrameUnwindEpilogue ( )

protectedpure virtual

Implemented in dart::BlobImageWriter.

FrameUnwindPrologue()

virtual void dart::ImageWriter::FrameUnwindPrologue ( )

protectedpure virtual

Implemented in dart::BlobImageWriter.

GetDataOffsetFor()

uint32_t dart::ImageWriter::GetDataOffsetFor

(

ObjectPtr

raw_object

)

Definition at line 306 of file image_snapshot.cc.

                                                           {
#endif
  const intptr_t snap_size = SizeInSnapshot(raw_object);
  const intptr_t offset = next_data_offset_;
  next_data_offset_ += snap_size;
#if defined(SNAPSHOT_BACKTRACE)
  objects_.Add(ObjectData(raw_object, raw_parent));
#else
  objects_.Add(ObjectData(raw_object));
#endif
  return offset;
}

GetMarkedTags() [1/2]

uword dart::ImageWriter::GetMarkedTags ( classid_t  cid, intptr_t  size, bool  is_canonical = false  )

staticprotected

Definition at line 606 of file image_snapshot.cc.

                                                      {
  // UntaggedObject::SizeTag expects a size divisible by kObjectAlignment and
  // checks this in debug mode, but the size on the target machine may not be
  // divisible by the host machine's object alignment if they differ.
  //
  // We define [adjusted_size] as [size] * m, where m is the host alignment
  // divided by the target alignment. This means [adjusted_size] encodes on the
  // host machine to the same bits that decode to [size] on the target machine.
  // That is,
  //    [adjusted_size] / host align ==
  //    [size] * (host align / target align) / host align ==
  //    [size] / target align
  //
  // Since alignments are always powers of 2, we use shifts and logs.
  const intptr_t adjusted_size =
      size << (kObjectAlignmentLog2 -
               compiler::target::ObjectAlignment::kObjectAlignmentLog2);
 
  return kReadOnlyGCBits | UntaggedObject::ClassIdTag::encode(cid) |
         UntaggedObject::SizeTag::encode(adjusted_size) |
         UntaggedObject::CanonicalBit::encode(is_canonical);
}

GetMarkedTags() [2/2]

uword dart::ImageWriter::GetMarkedTags ( const Object &  obj )

staticprotected

Definition at line 631 of file image_snapshot.cc.

                                                  {
  uword tags = GetMarkedTags(obj.ptr()->untag()->GetClassId(),
                             SizeInSnapshot(obj), obj.IsCanonical());
#if defined(HASH_IN_OBJECT_HEADER)
  tags = UntaggedObject::HashTag::update(obj.ptr()->untag()->GetHeaderHash(),
                                         tags);
#endif
  return tags;
}

GetTextObjectCount()

intptr_t dart::ImageWriter::GetTextObjectCount

(

)

const

Definition at line 327 of file image_snapshot.cc.

                                               {
  return instructions_.length();
}

GetTextOffsetFor()

int32_t dart::ImageWriter::GetTextOffsetFor	(	InstructionsPtr	instructions,
		CodePtr	code
	)

Definition at line 237 of file image_snapshot.cc.

                                                    {
  Heap* const heap = thread_->heap();
  intptr_t offset = heap->GetObjectId(instructions);
  if (offset != 0) {
    return offset;
  }
 
  offset = next_text_offset_;
  heap->SetObjectId(instructions, offset);
  next_text_offset_ += SizeInSnapshot(instructions);
  instructions_.Add(InstructionsData(instructions, code, offset));
 
  ASSERT(offset != 0);
  return offset;
}

GetTrampolineInfo()

void dart::ImageWriter::GetTrampolineInfo	(	intptr_t *	count,
		intptr_t *	size
	)		const

Definition at line 331 of file image_snapshot.cc.

                                                                         {
  ASSERT(count != nullptr && size != nullptr);
  *count = 0;
  *size = 0;
  for (auto const& data : instructions_) {
    if (data.trampoline_length != 0) {
      *count += 1;
      *size += data.trampoline_length;
    }
  }
}

IsROSpace()

bool dart::ImageWriter::IsROSpace ( ) const

inline

Definition at line 406 of file image_snapshot.h.

                         {
    return offset_space_ == IdSpace::kVmData ||
           offset_space_ == IdSpace::kVmText ||
           offset_space_ == IdSpace::kIsolateData ||
           offset_space_ == IdSpace::kIsolateText;
  }

ObjectTypeForProfile()

const char * dart::ImageWriter::ObjectTypeForProfile

(

const Object &

object

)

const

Definition at line 344 of file image_snapshot.cc.

                                                                        {
  if (profile_writer_ == nullptr) return nullptr;
  ASSERT(IsROSpace());
  REUSABLE_CLASS_HANDLESCOPE(thread_);
  REUSABLE_STRING_HANDLESCOPE(thread_);
  Class& klass = thread_->ClassHandle();
  String& name = thread_->StringHandle();
  klass = object.clazz();
  name = klass.UserVisibleName();
  auto const name_str = name.ToCString();
  return TagObjectTypeAsReadOnly(zone_, name_str);
}

PrepareForSerialization()

void dart::ImageWriter::PrepareForSerialization

(

GrowableArray< ImageWriterCommand > *

commands

)

Definition at line 196 of file image_snapshot.cc.

                                                 {
  if (commands != nullptr) {
    const intptr_t initial_offset = next_text_offset_;
    for (auto& inst : *commands) {
      ASSERT((initial_offset + inst.expected_offset) == next_text_offset_);
      switch (inst.op) {
        case ImageWriterCommand::InsertInstructionOfCode: {
          Heap* const heap = thread_->heap();
          CodePtr code = inst.insert_instruction_of_code.code;
          InstructionsPtr instructions = Code::InstructionsOf(code);
          const intptr_t offset = next_text_offset_;
          instructions_.Add(InstructionsData(instructions, code, offset));
          next_text_offset_ += SizeInSnapshot(instructions);
          ASSERT(heap->GetObjectId(instructions) == 0);
          heap->SetObjectId(instructions, offset);
          break;
        }
        case ImageWriterCommand::InsertBytesOfTrampoline: {
          auto trampoline_bytes = inst.insert_trampoline_bytes.buffer;
          auto trampoline_length = inst.insert_trampoline_bytes.buffer_length;
          const intptr_t offset = next_text_offset_;
          instructions_.Add(
              InstructionsData(trampoline_bytes, trampoline_length, offset));
          next_text_offset_ += trampoline_length;
          break;
        }
        case ImageWriterCommand::InsertPadding: {
          auto padding_length = inst.insert_padding.padding_length;
          const intptr_t offset = next_text_offset_;
          instructions_.Add(InstructionsData(nullptr, padding_length, offset));
          next_text_offset_ += padding_length;
          break;
        }
        default:
          UNREACHABLE();
      }
    }
  }
}

ResetOffsets()

void dart::ImageWriter::ResetOffsets ( )

inline

Definition at line 387 of file image_snapshot.h.

                      {
    next_data_offset_ = Image::kHeaderSize;
    next_text_offset_ = Image::kHeaderSize;
#if defined(DART_PRECOMPILER)
    if (FLAG_precompiled_mode) {
      // We reserve space for the initial InstructionsSection object. It is
      // manually serialized since it includes offsets to other snapshot parts.
      // It contains all the payloads which start directly after the header.
      next_text_offset_ += compiler::target::InstructionsSection::HeaderSize();
    }
#endif
    objects_.Clear();
    instructions_.Clear();
  }

SectionSymbol()

const char * dart::ImageWriter::SectionSymbol ( ProgramSection  section, bool  vm  )

staticprotected

Definition at line 641 of file image_snapshot.cc.

                                                                      {
  switch (section) {
    case ProgramSection::Text:
      return vm ? kVmSnapshotInstructionsAsmSymbol
                : kIsolateSnapshotInstructionsAsmSymbol;
    case ProgramSection::Data:
      return vm ? kVmSnapshotDataAsmSymbol : kIsolateSnapshotDataAsmSymbol;
    case ProgramSection::Bss:
      return vm ? kVmSnapshotBssAsmSymbol : kIsolateSnapshotBssAsmSymbol;
    case ProgramSection::BuildId:
      return kSnapshotBuildIdAsmSymbol;
  }
  UNREACHABLE();
  return nullptr;
}

SetProfileWriter()

void dart::ImageWriter::SetProfileWriter ( V8SnapshotProfileWriter *  profile_writer )

inline

Definition at line 429 of file image_snapshot.h.

                                                                 {
    profile_writer_ = profile_writer;
  }

SizeInSnapshot() [1/2]

static intptr_t dart::ImageWriter::SizeInSnapshot ( const Object &  object )

inlinestatic

Definition at line 438 of file image_snapshot.h.

                                                       {
    return SizeInSnapshot(object.ptr());
  }

SizeInSnapshot() [2/2]

intptr_t dart::ImageWriter::SizeInSnapshot ( ObjectPtr  object )

static

Definition at line 260 of file image_snapshot.cc.

                                                         {
  const classid_t cid = raw_object->GetClassId();
 
  switch (cid) {
    case kCompressedStackMapsCid: {
      auto raw_maps = CompressedStackMaps::RawCast(raw_object);
      return compiler::target::CompressedStackMaps::InstanceSize(
          CompressedStackMaps::PayloadSizeOf(raw_maps));
    }
    case kCodeSourceMapCid: {
      auto raw_map = CodeSourceMap::RawCast(raw_object);
      return compiler::target::CodeSourceMap::InstanceSize(
          raw_map->untag()->length_);
    }
    case kPcDescriptorsCid: {
      auto raw_desc = PcDescriptors::RawCast(raw_object);
      return compiler::target::PcDescriptors::InstanceSize(
          raw_desc->untag()->length_);
    }
    case kInstructionsCid: {
      auto raw_insns = Instructions::RawCast(raw_object);
      return compiler::target::Instructions::InstanceSize(
          Instructions::Size(raw_insns));
    }
    case kOneByteStringCid: {
      auto raw_str = String::RawCast(raw_object);
      return compiler::target::String::InstanceSize(
          String::LengthOf(raw_str) * OneByteString::kBytesPerElement);
    }
    case kTwoByteStringCid: {
      auto raw_str = String::RawCast(raw_object);
      return compiler::target::String::InstanceSize(
          String::LengthOf(raw_str) * TwoByteString::kBytesPerElement);
    }
    default: {
      const Class& clazz = Class::Handle(Object::Handle(raw_object).clazz());
      FATAL("Unsupported class %s in rodata section.\n", clazz.ToCString());
      return 0;
    }
  }
}

TagObjectTypeAsReadOnly()

const char * dart::ImageWriter::TagObjectTypeAsReadOnly ( Zone *  zone, const char *  type  )

static

Definition at line 357 of file image_snapshot.cc.

                                                                             {
  ASSERT(zone != nullptr && type != nullptr);
  return OS::SCreate(zone, "(RO) %s", type);
}

text_size()

intptr_t dart::ImageWriter::text_size ( ) const

inline

Definition at line 423 of file image_snapshot.h.

{ return next_text_offset_; }

TraceInstructions()

void dart::ImageWriter::TraceInstructions

(

const Instructions &

instructions

)

Write()

void dart::ImageWriter::Write	(	NonStreamingWriteStream *	clustered_stream,
		bool	vm
	)

Definition at line 461 of file image_snapshot.cc.

                                                                          {
  Heap* heap = thread_->heap();
  TIMELINE_DURATION(thread_, Isolate, "WriteInstructions");
 
  // Handlify collected raw pointers as building the names below
  // will allocate on the Dart heap.
  for (intptr_t i = 0; i < instructions_.length(); i++) {
    InstructionsData& data = instructions_[i];
    if (data.trampoline_length != 0) continue;
 
    data.insns_ = &Instructions::Handle(zone_, data.raw_insns_);
    ASSERT(data.raw_code_ != nullptr);
    data.code_ = &Code::Handle(zone_, data.raw_code_);
 
    // Reset object id as an isolate snapshot after a VM snapshot will not use
    // the VM snapshot's text image.
    heap->SetObjectId(data.insns_->ptr(), 0);
  }
  for (auto& data : objects_) {
    if (data.is_object()) {
      data.obj = &Object::Handle(zone_, data.raw_obj);
#if defined(SNAPSHOT_BACKTRACE)
      data.parent = &Object::Handle(zone_, data.raw_parent);
#endif
    }
  }
 
  // Once we have everything handlified we are going to do convert raw bytes
  // to string objects. String is used for simplicity as a bit container,
  // can't use TypedData because it has an internal pointer (data_) field.
  for (auto& data : objects_) {
    if (!data.is_object()) {
      const auto bytes = data.bytes;
      data.obj = &Object::Handle(
          zone_, OneByteString::New(bytes.buf, bytes.length, Heap::kOld));
#if defined(SNAPSHOT_BACKTRACE)
      data.parent = &Object::null_object();
#endif
      data.set_is_object(true);
      String::Cast(*data.obj).Hash();
      free(bytes.buf);
    }
  }
 
  // Needs to happen before WriteText, as we add information about the
  // BSSsection in the text section as an initial InstructionsSection object.
  WriteBss(vm);
 
  offset_space_ = vm ? IdSpace::kVmText : IdSpace::kIsolateText;
  WriteText(vm);
 
  // Append the direct-mapped RO data objects after the clustered snapshot
  // and then for ELF and assembly outputs, add appropriate sections with
  // that combined data.
  offset_space_ = vm ? IdSpace::kVmData : IdSpace::kIsolateData;
  WriteROData(clustered_stream, vm);
}

WriteBss()

virtual void dart::ImageWriter::WriteBss ( bool  vm )

protectedpure virtual

Implemented in dart::BlobImageWriter.

WriteBytes()

virtual intptr_t dart::ImageWriter::WriteBytes ( const void *  bytes, intptr_t  size  )

protectedpure virtual

Implemented in dart::BlobImageWriter.

WriteFixed()

template<typename T >

intptr_t dart::ImageWriter::WriteFixed ( T  value )

inlineprotected

Definition at line 639 of file image_snapshot.h.

                               {
    return WriteBytes(&value, sizeof(value));
  }

WriteROData()

void dart::ImageWriter::WriteROData ( NonStreamingWriteStream *  clustered_stream, bool  vm  )

protectedvirtual

Reimplemented in dart::BlobImageWriter.

Definition at line 519 of file image_snapshot.cc.

                                                                      {
  ASSERT(Utils::IsAligned(stream->Position(), kRODataAlignment));
  // Heap page starts here.
  intptr_t section_start = stream->Position();
 
  stream->WriteWord(next_data_offset_);  // Data length.
  stream->WriteWord(Image::kNoInstructionsSection);
  // Zero values for the rest of the Image object header bytes.
  stream->Align(Image::kHeaderSize);
  ASSERT_EQUAL(stream->Position() - section_start, Image::kHeaderSize);
#if defined(DART_PRECOMPILER)
  if (profile_writer_ != nullptr) {
    // Attribute the Image header to the artificial root.
    profile_writer_->AttributeBytesTo(
        V8SnapshotProfileWriter::kArtificialRootId, Image::kHeaderSize);
  }
#endif
 
  // Heap page objects start here.
 
  for (auto entry : objects_) {
    ASSERT(entry.is_object());
    const Object& obj = *entry.obj;
#if defined(DART_PRECOMPILER)
    AutoTraceImage(obj, section_start, stream);
    const char* object_name = namer_.SnapshotNameFor(entry);
#endif
    auto const object_start = stream->Position();
 
    NoSafepointScope no_safepoint;
 
    // Write object header with the mark and read-only bits set.
    stream->WriteTargetWord(GetMarkedTags(obj));
    if (obj.IsCompressedStackMaps()) {
      const CompressedStackMaps& map = CompressedStackMaps::Cast(obj);
      const intptr_t payload_size = map.payload_size();
      stream->WriteFixed<uint32_t>(
          map.ptr()->untag()->payload()->flags_and_size());
      stream->WriteBytes(map.ptr()->untag()->payload()->data(), payload_size);
    } else if (obj.IsCodeSourceMap()) {
      const CodeSourceMap& map = CodeSourceMap::Cast(obj);
      stream->WriteTargetWord(map.Length());
      ASSERT_EQUAL(stream->Position() - object_start,
                   compiler::target::CodeSourceMap::HeaderSize());
      stream->WriteBytes(map.Data(), map.Length());
    } else if (obj.IsPcDescriptors()) {
      const PcDescriptors& desc = PcDescriptors::Cast(obj);
      stream->WriteTargetWord(desc.Length());
      ASSERT_EQUAL(stream->Position() - object_start,
                   compiler::target::PcDescriptors::HeaderSize());
      stream->WriteBytes(desc.ptr()->untag()->data(), desc.Length());
    } else if (obj.IsString()) {
      const String& str = String::Cast(obj);
      RELEASE_ASSERT(String::GetCachedHash(str.ptr()) != 0);
      RELEASE_ASSERT(str.IsOneByteString() || str.IsTwoByteString());
 
#if !defined(HASH_IN_OBJECT_HEADER)
      stream->WriteTargetWord(static_cast<uword>(str.ptr()->untag()->hash()));
#endif
      stream->WriteTargetWord(static_cast<uword>(str.ptr()->untag()->length()));
      ASSERT_EQUAL(stream->Position() - object_start,
                   compiler::target::String::InstanceSize());
      stream->WriteBytes(
          str.IsOneByteString()
              ? static_cast<const void*>(OneByteString::DataStart(str))
              : static_cast<const void*>(TwoByteString::DataStart(str)),
          str.Length() * (str.IsOneByteString()
                              ? OneByteString::kBytesPerElement
                              : TwoByteString::kBytesPerElement));
    } else {
      const Class& clazz = Class::Handle(obj.clazz());
      FATAL("Unsupported class %s in rodata section.\n", clazz.ToCString());
    }
    stream->Align(compiler::target::ObjectAlignment::kObjectAlignment);
    ASSERT_EQUAL(stream->Position() - object_start, SizeInSnapshot(obj));
#if defined(DART_PRECOMPILER)
    AddDataSymbol(object_name, object_start, stream->Position() - object_start);
#endif
  }
}

WriteTargetWord()

virtual intptr_t dart::ImageWriter::WriteTargetWord ( word  value )

protectedpure virtual

Implemented in dart::BlobImageWriter.

WriteText()

void dart::ImageWriter::WriteText ( bool  vm )

protected

Definition at line 695 of file image_snapshot.cc.

                                   {
  const bool bare_instruction_payloads = FLAG_precompiled_mode;
 
  // Start snapshot at page boundary.
  intptr_t alignment_padding = 0;
  if (!EnterSection(ProgramSection::Text, vm, ImageWriter::kTextAlignment,
                    &alignment_padding)) {
    return;
  }
 
  intptr_t text_offset = 0;
#if defined(DART_PRECOMPILER)
  // Parent used for later profile objects. Starts off as the Image. When
  // writing bare instructions payloads, this is later updated with the
  // InstructionsSection object which contains all the bare payloads.
  V8SnapshotProfileWriter::ObjectId parent_id(offset_space_, text_offset);
#endif
 
  // This head also provides the gap to make the instructions snapshot
  // look like a Page.
  const intptr_t image_size = Utils::RoundUp(
      next_text_offset_, compiler::target::ObjectAlignment::kObjectAlignment);
  text_offset += WriteTargetWord(image_size);
  // Output the offset to the InstructionsSection object from the start of the
  // image, if any.
  text_offset +=
      WriteTargetWord(FLAG_precompiled_mode ? Image::kHeaderSize
                                            : Image::kNoInstructionsSection);
  // Zero values for the rest of the Image object header bytes.
  text_offset += Align(Image::kHeaderSize, 0, text_offset);
  ASSERT_EQUAL(text_offset, Image::kHeaderSize);
 
#if defined(DART_PRECOMPILER)
  const char* instructions_symbol = SectionSymbol(ProgramSection::Text, vm);
  ASSERT(instructions_symbol != nullptr);
  intptr_t instructions_label = SectionLabel(ProgramSection::Text, vm);
  ASSERT(instructions_label > 0);
  const char* bss_symbol = SectionSymbol(ProgramSection::Bss, vm);
  ASSERT(bss_symbol != nullptr);
  intptr_t bss_label = SectionLabel(ProgramSection::Bss, vm);
  ASSERT(bss_label > 0);
 
  if (profile_writer_ != nullptr) {
    profile_writer_->SetObjectTypeAndName(parent_id, image_type_,
                                          instructions_symbol);
    profile_writer_->AttributeBytesTo(
        parent_id, ImageWriter::kTextAlignment + alignment_padding);
    profile_writer_->AddRoot(parent_id);
  }
 
  if (FLAG_precompiled_mode) {
    const intptr_t section_header_length =
        compiler::target::InstructionsSection::HeaderSize();
    // Calculated using next_text_offset_, which doesn't include post-payload
    // padding to object alignment. Note that if not in bare instructions mode,
    // the section has no contents, instead the instructions objects follow it.
    const intptr_t section_payload_length =
        bare_instruction_payloads
            ? next_text_offset_ - text_offset - section_header_length
            : 0;
    const intptr_t section_size =
        compiler::target::InstructionsSection::InstanceSize(
            section_payload_length);
 
    const V8SnapshotProfileWriter::ObjectId id(offset_space_, text_offset);
    if (profile_writer_ != nullptr) {
      profile_writer_->SetObjectTypeAndName(id, instructions_section_type_,
                                            instructions_symbol);
      profile_writer_->AttributeBytesTo(id,
                                        section_size - section_payload_length);
      const intptr_t element_offset = id.nonce() - parent_id.nonce();
      profile_writer_->AttributeReferenceTo(
          parent_id,
          V8SnapshotProfileWriter::Reference::Element(element_offset), id);
      // Later objects will have the InstructionsSection as a parent if in
      // bare instructions mode, otherwise the image.
      if (bare_instruction_payloads) {
        parent_id = id;
      }
    }
 
    // Add the RawInstructionsSection header.
    text_offset +=
        WriteTargetWord(GetMarkedTags(kInstructionsSectionCid, section_size));
    // An InstructionsSection has five fields:
    // 1) The length of the payload.
    text_offset += WriteTargetWord(section_payload_length);
    // 2) The BSS offset from this section.
    text_offset += Relocation(text_offset, instructions_label, bss_label);
    // 3) The relocated address of the instructions.
    text_offset += RelocatedAddress(text_offset, instructions_label);
    // 4) The GNU build ID note offset from this section.
    text_offset += Relocation(text_offset, instructions_label,
                              SectionLabel(ProgramSection::BuildId, vm));
 
    const intptr_t section_contents_alignment =
        bare_instruction_payloads
            ? InstructionsSection::kPayloadAlignment
            : compiler::target::ObjectAlignment::kObjectAlignment;
    const intptr_t alignment_offset =
        compiler::target::ObjectAlignment::kOldObjectAlignmentOffset;
    const intptr_t expected_size =
        bare_instruction_payloads
            ? compiler::target::InstructionsSection::HeaderSize()
            : compiler::target::InstructionsSection::InstanceSize(0);
    text_offset +=
        Align(section_contents_alignment, alignment_offset, text_offset);
    ASSERT_EQUAL(text_offset - id.nonce(), expected_size);
  }
#endif
 
#if !defined(EMIT_UNWIND_DIRECTIVES_PER_FUNCTION)
  FrameUnwindPrologue();
#endif
 
#if defined(DART_PRECOMPILER)
  PcDescriptors& descriptors = PcDescriptors::Handle(zone_);
#endif
 
  // We don't expect more than 64 bytes of padding.
  uint8_t padding_bytes[64];
  memset(&padding_bytes[0], 0, sizeof(padding_bytes));
 
  ASSERT(offset_space_ != IdSpace::kSnapshot);
  for (intptr_t i = 0; i < instructions_.length(); i++) {
    auto& data = instructions_[i];
    const bool is_trampoline = data.trampoline_bytes != nullptr;
    const bool is_padding =
        data.trampoline_bytes == nullptr && data.trampoline_length != 0;
    ASSERT_EQUAL(data.text_offset_, text_offset);
 
#if defined(DART_PRECOMPILER)
    const char* object_name = namer_.SnapshotNameFor(data);
 
    if (profile_writer_ != nullptr) {
      const V8SnapshotProfileWriter::ObjectId id(offset_space_, text_offset);
      auto const type = is_trampoline ? trampoline_type_
                        : is_padding  ? padding_type_
                                      : instructions_type_;
      const intptr_t size = (is_trampoline || is_padding)
                                ? data.trampoline_length
                                : SizeInSnapshot(data.insns_->ptr());
      profile_writer_->SetObjectTypeAndName(id, type, object_name);
      profile_writer_->AttributeBytesTo(id, size);
      const intptr_t element_offset = id.nonce() - parent_id.nonce();
      profile_writer_->AttributeReferenceTo(
          parent_id,
          V8SnapshotProfileWriter::Reference::Element(element_offset), id);
    }
#endif
 
    if (is_trampoline) {
      text_offset += WriteBytes(data.trampoline_bytes, data.trampoline_length);
      delete[] data.trampoline_bytes;
      data.trampoline_bytes = nullptr;
      continue;
    }
 
    if (is_padding) {
      text_offset += WriteBytes(padding_bytes, data.trampoline_length);
      continue;
    }
 
    const intptr_t instr_start = text_offset;
    const auto& insns = *data.insns_;
 
    // 1. Write from the object start to the payload start. This includes the
    // object header and the fixed fields.  Not written for AOT snapshots using
    // bare instructions.
    if (!bare_instruction_payloads) {
      NoSafepointScope no_safepoint;
 
      // Write Instructions with the mark and read-only bits set.
      text_offset += WriteTargetWord(GetMarkedTags(insns));
      text_offset += WriteFixed(insns.untag()->size_and_flags_);
      text_offset +=
          Align(compiler::target::Instructions::kNonBarePayloadAlignment,
                compiler::target::ObjectAlignment::kOldObjectAlignmentOffset,
                text_offset);
    }
 
    ASSERT_EQUAL(text_offset - instr_start,
                 compiler::target::Instructions::HeaderSize());
 
#if defined(DART_PRECOMPILER)
    const auto& code = *data.code_;
    // 2. Add a symbol for the code at the entry point in precompiled snapshots.
    // Linux's perf uses these labels.
    AddCodeSymbol(code, object_name, text_offset);
#endif
 
#if defined(EMIT_UNWIND_DIRECTIVES_PER_FUNCTION)
    FrameUnwindPrologue();
#endif
 
    {
      NoSafepointScope no_safepoint;
 
      // 3. Write from the payload start to payload end. For AOT snapshots
      // with bare instructions, this is the only part serialized other than
      // any padding needed for alignment.
      auto const payload_start =
          reinterpret_cast<const uint8_t*>(insns.PayloadStart());
      // Double-check the payload alignment, since we will load and write
      // target-sized words starting from that address.
      ASSERT(Utils::IsAligned(payload_start, compiler::target::kWordSize));
      const uword payload_size = insns.Size();
      auto const payload_end = payload_start + payload_size;
      auto cursor = payload_start;
#if defined(DART_PRECOMPILER)
      descriptors = code.pc_descriptors();
      PcDescriptors::Iterator iterator(
          descriptors, /*kind_mask=*/UntaggedPcDescriptors::kBSSRelocation);
      while (iterator.MoveNext()) {
        // We only generate BSS relocations in the precompiler.
        ASSERT(FLAG_precompiled_mode);
        auto const next_reloc_offset = iterator.PcOffset();
        auto const next_reloc_address = payload_start + next_reloc_offset;
        // We only generate BSS relocations that are target word-sized and at
        // target word-aligned offsets in the payload. Double-check this.
        ASSERT(
            Utils::IsAligned(next_reloc_address, compiler::target::kWordSize));
        text_offset += WriteBytes(cursor, next_reloc_address - cursor);
 
        // The instruction stream at the relocation position holds the target
        // offset into the BSS section.
        const auto target_offset =
            *reinterpret_cast<const compiler::target::word*>(
                next_reloc_address);
        text_offset += Relocation(text_offset, instructions_label, text_offset,
                                  bss_label, target_offset);
        cursor = next_reloc_address + compiler::target::kWordSize;
      }
#endif
      text_offset += WriteBytes(cursor, payload_end - cursor);
    }
 
    // 4. Add appropriate padding. Note we can't simply copy from the object
    // because the host object may have less alignment filler than the target
    // object in the cross-word case.
    const intptr_t alignment =
        bare_instruction_payloads
            ? compiler::target::Instructions::kBarePayloadAlignment
            : compiler::target::ObjectAlignment::kObjectAlignment;
    text_offset += AlignWithBreakInstructions(alignment, text_offset);
 
    ASSERT_EQUAL(text_offset - instr_start, SizeInSnapshot(insns.ptr()));
#if defined(EMIT_UNWIND_DIRECTIVES_PER_FUNCTION)
    FrameUnwindEpilogue();
#endif
  }
 
  // Should be a no-op unless writing bare instruction payloads, in which case
  // we need to add post-payload padding for the InstructionsSection object.
  // Since this follows instructions, we'll use break instructions for padding.
  ASSERT(bare_instruction_payloads ||
         Utils::IsAligned(text_offset,
                          compiler::target::ObjectAlignment::kObjectAlignment));
  text_offset += AlignWithBreakInstructions(
      compiler::target::ObjectAlignment::kObjectAlignment, text_offset);
 
  ASSERT_EQUAL(text_offset, image_size);
 
#if !defined(EMIT_UNWIND_DIRECTIVES_PER_FUNCTION)
  FrameUnwindEpilogue();
#endif
 
  ExitSection(ProgramSection::Text, vm, text_offset);
}

Friends And Related Function Documentation

TraceImageObjectScope

template<class T >

friend class TraceImageObjectScope

friend

Definition at line 724 of file image_snapshot.h.

Member Data Documentation

image_type_

const char* const dart::ImageWriter::image_type_

protected

Definition at line 717 of file image_snapshot.h.

instructions_

GrowableArray<InstructionsData> dart::ImageWriter::instructions_

protected

Definition at line 651 of file image_snapshot.h.

instructions_section_type_

const char* const dart::ImageWriter::instructions_section_type_

protected

Definition at line 718 of file image_snapshot.h.

instructions_type_

const char* const dart::ImageWriter::instructions_type_

protected

Definition at line 719 of file image_snapshot.h.

kBssAlignment

constexpr intptr_t dart::ImageWriter::kBssAlignment = compiler::target::kWordSize

staticconstexpr

Definition at line 380 of file image_snapshot.h.

kNumProgramSections

constexpr intptr_t dart::ImageWriter::kNumProgramSections

staticconstexpr

Initial value:

=
      static_cast<int>(ProgramSection::BuildId) + 1

Definition at line 454 of file image_snapshot.h.

kRODataAlignment

constexpr intptr_t dart::ImageWriter::kRODataAlignment = kObjectStartAlignment

staticconstexpr

Definition at line 382 of file image_snapshot.h.

kTextAlignment

constexpr intptr_t dart::ImageWriter::kTextAlignment = kObjectStartAlignment

staticconstexpr

Definition at line 385 of file image_snapshot.h.

next_data_offset_

intptr_t dart::ImageWriter::next_data_offset_

protected

Definition at line 648 of file image_snapshot.h.

next_text_offset_

intptr_t dart::ImageWriter::next_text_offset_

protected

Definition at line 649 of file image_snapshot.h.

objects_

GrowableArray<ObjectData> dart::ImageWriter::objects_

protected

Definition at line 650 of file image_snapshot.h.

offset_space_

IdSpace dart::ImageWriter::offset_space_ = IdSpace::kSnapshot

protected

Definition at line 715 of file image_snapshot.h.

padding_type_

const char* const dart::ImageWriter::padding_type_

protected

Definition at line 721 of file image_snapshot.h.

profile_writer_

V8SnapshotProfileWriter* dart::ImageWriter::profile_writer_ = nullptr

protected

Definition at line 716 of file image_snapshot.h.

thread_

Thread* const dart::ImageWriter::thread_

protected

Definition at line 646 of file image_snapshot.h.

trampoline_type_

const char* const dart::ImageWriter::trampoline_type_

protected

Definition at line 720 of file image_snapshot.h.

zone_

Zone* const dart::ImageWriter::zone_

protected

Definition at line 647 of file image_snapshot.h.

---

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

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