v8::internal::Serializer::ObjectSerializer Class Reference

#include <serialize.h>

Inheritance diagram for v8::internal::Serializer::ObjectSerializer:

Collaboration diagram for v8::internal::Serializer::ObjectSerializer:

Public Member Functions
	ObjectSerializer (Serializer *serializer, Object *o, SnapshotByteSink *sink, HowToCode how_to_code, WhereToPoint where_to_point)
void	Serialize ()
void	VisitPointers (Object **start, Object **end)
void	VisitEmbeddedPointer (RelocInfo *target)
void	VisitExternalReference (Address *p)
void	VisitExternalReference (RelocInfo *rinfo)
void	VisitCodeTarget (RelocInfo *target)
void	VisitCodeEntry (Address entry_address)
void	VisitCell (RelocInfo *rinfo)
void	VisitRuntimeEntry (RelocInfo *reloc)
void	VisitExternalOneByteString (v8::String::ExternalOneByteStringResource **resource)
void	VisitExternalTwoByteString (v8::String::ExternalStringResource **resource)

Private Types
enum	ReturnSkip { kCanReturnSkipInsteadOfSkipping , kIgnoringReturn }

Private Member Functions
int	OutputRawData (Address up_to, ReturnSkip return_skip=kIgnoringReturn)

Private Attributes
Serializer *	serializer_
HeapObject *	object_
SnapshotByteSink *	sink_
int	reference_representation_
int	bytes_processed_so_far_
bool	code_object_
bool	code_has_been_output_

Detailed Description

Definition at line 409 of file serialize.h.

Member Enumeration Documentation

ReturnSkip

enum v8::internal::Serializer::ObjectSerializer::ReturnSkip

private

Enumerator
kCanReturnSkipInsteadOfSkipping
kIgnoringReturn

Definition at line 442 of file serialize.h.

{ kCanReturnSkipInsteadOfSkipping, kIgnoringReturn };

Constructor & Destructor Documentation

ObjectSerializer()

v8::internal::Serializer::ObjectSerializer::ObjectSerializer ( Serializer *  serializer, Object *  o, SnapshotByteSink *  sink, HowToCode  how_to_code, WhereToPoint  where_to_point  )

inline

Definition at line 411 of file serialize.h.

      : serializer_(serializer),
        object_(HeapObject::cast(o)),
        sink_(sink),
        reference_representation_(how_to_code + where_to_point),
        bytes_processed_so_far_(0),
        code_object_(o->IsCode()),
        code_has_been_output_(false) { }

Member Function Documentation

OutputRawData()

int v8::internal::Serializer::ObjectSerializer::OutputRawData ( Address  up_to, ReturnSkip  return_skip = kIgnoringReturn  )

private

Definition at line 1726 of file serialize.cc.

                                                                     {
  Address object_start = object_->address();
  int base = bytes_processed_so_far_;
  int up_to_offset = static_cast<int>(up_to - object_start);
  int to_skip = up_to_offset - bytes_processed_so_far_;
  int bytes_to_output = to_skip;
  bytes_processed_so_far_ += to_skip;
  // This assert will fail if the reloc info gives us the target_address_address
  // locations in a non-ascending order.  Luckily that doesn't happen.
  DCHECK(to_skip >= 0);
  bool outputting_code = false;
  if (to_skip != 0 && code_object_ && !code_has_been_output_) {
    // Output the code all at once and fix later.
    bytes_to_output = object_->Size() + to_skip - bytes_processed_so_far_;
    outputting_code = true;
    code_has_been_output_ = true;
  }
  if (bytes_to_output != 0 &&
      (!code_object_ || outputting_code)) {
#define RAW_CASE(index)                                                        \
    if (!outputting_code && bytes_to_output == index * kPointerSize &&         \
        index * kPointerSize == to_skip) {                                     \
      sink_->PutSection(kRawData + index, "RawDataFixed");                     \
      to_skip = 0;  /* This insn already skips. */                             \
    } else  /* NOLINT */
    COMMON_RAW_LENGTHS(RAW_CASE)
#undef RAW_CASE
    {  /* NOLINT */
      // We always end up here if we are outputting the code of a code object.
      sink_->Put(kRawData, "RawData");
      sink_->PutInt(bytes_to_output, "length");
    }
 
    // To make snapshots reproducible, we need to wipe out all pointers in code.
    if (code_object_) {
      Code* code = CloneCodeObject(object_);
      WipeOutRelocations(code);
      // We need to wipe out the header fields *after* wiping out the
      // relocations, because some of these fields are needed for the latter.
      code->WipeOutHeader();
      object_start = code->address();
    }
 
    const char* description = code_object_ ? "Code" : "Byte";
    for (int i = 0; i < bytes_to_output; i++) {
      sink_->PutSection(object_start[base + i], description);
    }
    if (code_object_) delete[] object_start;
  }
  if (to_skip != 0 && return_skip == kIgnoringReturn) {
    sink_->Put(kSkip, "Skip");
    sink_->PutInt(to_skip, "SkipDistance");
    to_skip = 0;
  }
  return to_skip;
}

References v8::internal::HeapObject::address(), v8::internal::CloneCodeObject(), COMMON_RAW_LENGTHS, DCHECK, v8::internal::SerializerDeserializer::kRawData, v8::internal::SerializerDeserializer::kSkip, v8::internal::SnapshotByteSink::Put(), v8::internal::SnapshotByteSink::PutInt(), v8::internal::SnapshotByteSink::PutSection(), RAW_CASE, v8::internal::Serializer::sink_, v8::internal::Code::WipeOutHeader(), and v8::internal::WipeOutRelocations().

Referenced by Serialize().

Here is the call graph for this function:

Here is the caller graph for this function:

Serialize()

void v8::internal::Serializer::ObjectSerializer::Serialize

(

)

Definition at line 1517 of file serialize.cc.

                                           {
  int space = Serializer::SpaceOfObject(object_);
  int size = object_->Size();
 
  sink_->Put(kNewObject + reference_representation_ + space,
             "ObjectSerialization");
  sink_->PutInt(size >> kObjectAlignmentBits, "Size in words");
 
  if (serializer_->code_address_map_) {
    const char* code_name =
        serializer_->code_address_map_->Lookup(object_->address());
    LOG(serializer_->isolate_,
        CodeNameEvent(object_->address(), sink_->Position(), code_name));
    LOG(serializer_->isolate_,
        SnapshotPositionEvent(object_->address(), sink_->Position()));
  }
 
  // Mark this object as already serialized.
  if (space == LO_SPACE) {
    if (object_->IsCode()) {
      sink_->PutInt(EXECUTABLE, "executable large object");
    } else {
      sink_->PutInt(NOT_EXECUTABLE, "not executable large object");
    }
    int index = serializer_->AllocateLargeObject(size);
    serializer_->address_mapper()->AddMapping(object_, index);
  } else {
    int offset = serializer_->Allocate(space, size);
    serializer_->address_mapper()->AddMapping(object_, offset);
  }
 
  // Serialize the map (first word of the object).
  serializer_->SerializeObject(object_->map(), kPlain, kStartOfObject, 0);
 
  // Serialize the rest of the object.
  CHECK_EQ(0, bytes_processed_so_far_);
  bytes_processed_so_far_ = kPointerSize;
  object_->IterateBody(object_->map()->instance_type(), size, this);
  OutputRawData(object_->address() + size);
}

References v8::internal::SerializationAddressMapper::AddMapping(), v8::internal::HeapObject::address(), v8::internal::Serializer::address_mapper(), v8::internal::Serializer::Allocate(), v8::internal::Serializer::AllocateLargeObject(), bytes_processed_so_far_, CHECK_EQ, v8::internal::Serializer::code_address_map_, v8::internal::EXECUTABLE, v8::internal::Map::instance_type(), v8::internal::Serializer::isolate_, v8::internal::HeapObject::IterateBody(), v8::internal::SerializerDeserializer::kNewObject, v8::internal::kObjectAlignmentBits, v8::internal::SerializerDeserializer::kPlain, v8::internal::kPointerSize, v8::internal::SerializerDeserializer::kStartOfObject, v8::internal::LO_SPACE, LOG, v8::internal::CodeAddressMap::Lookup(), v8::internal::HeapObject::map(), v8::internal::NOT_EXECUTABLE, object_, OutputRawData(), v8::internal::SnapshotByteSink::Position(), v8::internal::SnapshotByteSink::Put(), v8::internal::SnapshotByteSink::PutInt(), reference_representation_, v8::internal::Serializer::SerializeObject(), serializer_, sink_, size, v8::internal::HeapObject::Size(), space(), and v8::internal::Serializer::SpaceOfObject().

Referenced by v8::internal::CodeSerializer::SerializeHeapObject(), v8::internal::PartialSerializer::SerializeObject(), and v8::internal::StartupSerializer::SerializeObject().

Here is the call graph for this function:

Here is the caller graph for this function:

VisitCell()

void v8::internal::Serializer::ObjectSerializer::VisitCell

(

RelocInfo *

rinfo

)

Definition at line 1669 of file serialize.cc.

                                                           {
  // Out-of-line constant pool entries will be visited by the ConstantPoolArray.
  if (FLAG_enable_ool_constant_pool && rinfo->IsInConstantPool()) return;
 
  int skip = OutputRawData(rinfo->pc(), kCanReturnSkipInsteadOfSkipping);
  Cell* object = Cell::cast(rinfo->target_cell());
  serializer_->SerializeObject(object, kPlain, kInnerPointer, skip);
  bytes_processed_so_far_ += kPointerSize;
}

References v8::internal::RelocInfo::IsInConstantPool(), v8::internal::SerializerDeserializer::kInnerPointer, v8::internal::SerializerDeserializer::kPlain, v8::internal::kPointerSize, and v8::internal::RelocInfo::pc().

Here is the call graph for this function:

VisitCodeEntry()

void v8::internal::Serializer::ObjectSerializer::VisitCodeEntry

(

Address

entry_address

)

Definition at line 1661 of file serialize.cc.

                                                                     {
  int skip = OutputRawData(entry_address, kCanReturnSkipInsteadOfSkipping);
  Code* object = Code::cast(Code::GetObjectFromEntryAddress(entry_address));
  serializer_->SerializeObject(object, kPlain, kInnerPointer, skip);
  bytes_processed_so_far_ += kPointerSize;
}

References v8::internal::Code::GetObjectFromEntryAddress(), v8::internal::SerializerDeserializer::kInnerPointer, v8::internal::SerializerDeserializer::kPlain, and v8::internal::kPointerSize.

Here is the call graph for this function:

VisitCodeTarget()

void v8::internal::Serializer::ObjectSerializer::VisitCodeTarget

(

RelocInfo *

target

)

Definition at line 1649 of file serialize.cc.

                                                                 {
  // Out-of-line constant pool entries will be visited by the ConstantPoolArray.
  if (FLAG_enable_ool_constant_pool && rinfo->IsInConstantPool()) return;
 
  int skip = OutputRawData(rinfo->target_address_address(),
                           kCanReturnSkipInsteadOfSkipping);
  Code* object = Code::GetCodeFromTargetAddress(rinfo->target_address());
  serializer_->SerializeObject(object, kFromCode, kInnerPointer, skip);
  bytes_processed_so_far_ += rinfo->target_address_size();
}

References v8::internal::Code::GetCodeFromTargetAddress(), v8::internal::RelocInfo::IsInConstantPool(), v8::internal::SerializerDeserializer::kFromCode, and v8::internal::SerializerDeserializer::kInnerPointer.

Here is the call graph for this function:

VisitEmbeddedPointer()

void v8::internal::Serializer::ObjectSerializer::VisitEmbeddedPointer

(

RelocInfo *

target

)

Definition at line 1601 of file serialize.cc.

                                                                      {
  // Out-of-line constant pool entries will be visited by the ConstantPoolArray.
  if (FLAG_enable_ool_constant_pool && rinfo->IsInConstantPool()) return;
 
  int skip = OutputRawData(rinfo->target_address_address(),
                           kCanReturnSkipInsteadOfSkipping);
  HowToCode how_to_code = rinfo->IsCodedSpecially() ? kFromCode : kPlain;
  Object* object = rinfo->target_object();
  serializer_->SerializeObject(object, how_to_code, kStartOfObject, skip);
  bytes_processed_so_far_ += rinfo->target_address_size();
}

References v8::internal::RelocInfo::IsCodedSpecially(), v8::internal::RelocInfo::IsInConstantPool(), v8::internal::SerializerDeserializer::kFromCode, v8::internal::SerializerDeserializer::kPlain, and v8::internal::SerializerDeserializer::kStartOfObject.

Here is the call graph for this function:

VisitExternalOneByteString()

void v8::internal::Serializer::ObjectSerializer::VisitExternalOneByteString

(

v8::String::ExternalOneByteStringResource **

resource

)

Definition at line 1680 of file serialize.cc.

                                                              {
  Address references_start = reinterpret_cast<Address>(resource_pointer);
  OutputRawData(references_start);
  for (int i = 0; i < Natives::GetBuiltinsCount(); i++) {
    Object* source =
        serializer_->isolate()->heap()->natives_source_cache()->get(i);
    if (!source->IsUndefined()) {
      ExternalOneByteString* string = ExternalOneByteString::cast(source);
      typedef v8::String::ExternalOneByteStringResource Resource;
      const Resource* resource = string->resource();
      if (resource == *resource_pointer) {
        sink_->Put(kNativesStringResource, "NativesStringResource");
        sink_->PutSection(i, "NativesStringResourceEnd");
        bytes_processed_so_far_ += sizeof(resource);
        return;
      }
    }
  }
  // One of the strings in the natives cache should match the resource.  We
  // can't serialize any other kinds of external strings.
  UNREACHABLE();
}

References v8::internal::NativesCollection< type >::GetBuiltinsCount(), v8::internal::SerializerDeserializer::kNativesStringResource, v8::internal::SnapshotByteSink::Put(), v8::internal::SnapshotByteSink::PutSection(), v8::internal::Serializer::sink_, and UNREACHABLE.

Here is the call graph for this function:

VisitExternalReference() [1/2]

void v8::internal::Serializer::ObjectSerializer::VisitExternalReference

(

Address *

p

)

Definition at line 1614 of file serialize.cc.

                                                                  {
  int skip = OutputRawData(reinterpret_cast<Address>(p),
                           kCanReturnSkipInsteadOfSkipping);
  sink_->Put(kExternalReference + kPlain + kStartOfObject, "ExternalRef");
  sink_->PutInt(skip, "SkipB4ExternalRef");
  Address target = *p;
  sink_->PutInt(serializer_->EncodeExternalReference(target), "reference id");
  bytes_processed_so_far_ += kPointerSize;
}

References v8::internal::SerializerDeserializer::kExternalReference, v8::internal::SerializerDeserializer::kPlain, v8::internal::kPointerSize, v8::internal::SerializerDeserializer::kStartOfObject, v8::internal::SnapshotByteSink::Put(), v8::internal::SnapshotByteSink::PutInt(), and v8::internal::Serializer::sink_.

Here is the call graph for this function:

VisitExternalReference() [2/2]

void v8::internal::Serializer::ObjectSerializer::VisitExternalReference

(

RelocInfo *

rinfo

)

Definition at line 1625 of file serialize.cc.

                                                                        {
  int skip = OutputRawData(rinfo->target_address_address(),
                           kCanReturnSkipInsteadOfSkipping);
  HowToCode how_to_code = rinfo->IsCodedSpecially() ? kFromCode : kPlain;
  sink_->Put(kExternalReference + how_to_code + kStartOfObject, "ExternalRef");
  sink_->PutInt(skip, "SkipB4ExternalRef");
  Address target = rinfo->target_reference();
  sink_->PutInt(serializer_->EncodeExternalReference(target), "reference id");
  bytes_processed_so_far_ += rinfo->target_address_size();
}

References v8::internal::RelocInfo::IsCodedSpecially(), v8::internal::SerializerDeserializer::kExternalReference, v8::internal::SerializerDeserializer::kFromCode, v8::internal::SerializerDeserializer::kPlain, v8::internal::SerializerDeserializer::kStartOfObject, v8::internal::SnapshotByteSink::Put(), v8::internal::SnapshotByteSink::PutInt(), and v8::internal::Serializer::sink_.

Here is the call graph for this function:

VisitExternalTwoByteString()

void v8::internal::Serializer::ObjectSerializer::VisitExternalTwoByteString ( v8::String::ExternalStringResource **  resource )

inline

Definition at line 436 of file serialize.h.

                                                   {
      UNREACHABLE();
    }

References UNREACHABLE.

VisitPointers()

void v8::internal::Serializer::ObjectSerializer::VisitPointers	(	Object **	start,
		Object **	end
	)

Definition at line 1559 of file serialize.cc.

                                                               {
  Object** current = start;
  while (current < end) {
    while (current < end && (*current)->IsSmi()) current++;
    if (current < end) OutputRawData(reinterpret_cast<Address>(current));
 
    while (current < end && !(*current)->IsSmi()) {
      HeapObject* current_contents = HeapObject::cast(*current);
      int root_index = serializer_->RootIndex(current_contents, kPlain);
      // Repeats are not subject to the write barrier so there are only some
      // objects that can be used in a repeat encoding.  These are the early
      // ones in the root array that are never in new space.
      if (current != start &&
          root_index != kInvalidRootIndex &&
          root_index < kRootArrayNumberOfConstantEncodings &&
          current_contents == current[-1]) {
        DCHECK(!serializer_->isolate()->heap()->InNewSpace(current_contents));
        int repeat_count = 1;
        while (&current[repeat_count] < end - 1 &&
               current[repeat_count] == current_contents) {
          repeat_count++;
        }
        current += repeat_count;
        bytes_processed_so_far_ += repeat_count * kPointerSize;
        if (repeat_count > kMaxRepeats) {
          sink_->Put(kRepeat, "SerializeRepeats");
          sink_->PutInt(repeat_count, "SerializeRepeats");
        } else {
          sink_->Put(CodeForRepeats(repeat_count), "SerializeRepeats");
        }
      } else {
        serializer_->SerializeObject(
                current_contents, kPlain, kStartOfObject, 0);
        bytes_processed_so_far_ += kPointerSize;
        current++;
      }
    }
  }
}

References v8::internal::SerializerDeserializer::CodeForRepeats(), DCHECK, v8::internal::Serializer::kInvalidRootIndex, v8::internal::SerializerDeserializer::kMaxRepeats, v8::internal::SerializerDeserializer::kPlain, v8::internal::kPointerSize, v8::internal::SerializerDeserializer::kRepeat, v8::internal::SerializerDeserializer::kRootArrayNumberOfConstantEncodings, v8::internal::SerializerDeserializer::kStartOfObject, v8::internal::SnapshotByteSink::Put(), v8::internal::SnapshotByteSink::PutInt(), and v8::internal::Serializer::sink_.

Here is the call graph for this function:

VisitRuntimeEntry()

void v8::internal::Serializer::ObjectSerializer::VisitRuntimeEntry

(

RelocInfo *

reloc

)

Definition at line 1637 of file serialize.cc.

                                                                   {
  int skip = OutputRawData(rinfo->target_address_address(),
                           kCanReturnSkipInsteadOfSkipping);
  HowToCode how_to_code = rinfo->IsCodedSpecially() ? kFromCode : kPlain;
  sink_->Put(kExternalReference + how_to_code + kStartOfObject, "ExternalRef");
  sink_->PutInt(skip, "SkipB4ExternalRef");
  Address target = rinfo->target_address();
  sink_->PutInt(serializer_->EncodeExternalReference(target), "reference id");
  bytes_processed_so_far_ += rinfo->target_address_size();
}

References v8::internal::RelocInfo::IsCodedSpecially(), v8::internal::SerializerDeserializer::kExternalReference, v8::internal::SerializerDeserializer::kFromCode, v8::internal::SerializerDeserializer::kPlain, v8::internal::SerializerDeserializer::kStartOfObject, v8::internal::SnapshotByteSink::Put(), v8::internal::SnapshotByteSink::PutInt(), and v8::internal::Serializer::sink_.

Here is the call graph for this function:

Member Data Documentation

bytes_processed_so_far_

int v8::internal::Serializer::ObjectSerializer::bytes_processed_so_far_

private

Definition at line 453 of file serialize.h.

Referenced by Serialize().

code_has_been_output_

bool v8::internal::Serializer::ObjectSerializer::code_has_been_output_

private

Definition at line 455 of file serialize.h.

code_object_

bool v8::internal::Serializer::ObjectSerializer::code_object_

private

Definition at line 454 of file serialize.h.

object_

HeapObject* v8::internal::Serializer::ObjectSerializer::object_

private

Definition at line 450 of file serialize.h.

Referenced by Serialize().

reference_representation_

int v8::internal::Serializer::ObjectSerializer::reference_representation_

private

Definition at line 452 of file serialize.h.

Referenced by Serialize().

serializer_

Serializer* v8::internal::Serializer::ObjectSerializer::serializer_

private

Definition at line 449 of file serialize.h.

Referenced by Serialize().

sink_

SnapshotByteSink* v8::internal::Serializer::ObjectSerializer::sink_

private

Definition at line 451 of file serialize.h.

Referenced by Serialize().

---

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

• /mnt/V8SourceCode/src/serialize.h
• /mnt/V8SourceCode/src/serialize.cc