Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(79)

Unified Diff: src/serialize.cc

Issue 2069013: Orthogonalize the byte codes used for the snapshot so that... (Closed) Base URL: http://v8.googlecode.com/svn/branches/bleeding_edge/
Patch Set: '' Created 10 years, 7 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « src/serialize.h ('k') | src/x64/assembler-x64.cc » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: src/serialize.cc
===================================================================
--- src/serialize.cc (revision 4681)
+++ src/serialize.cc (working copy)
@@ -660,27 +660,164 @@
}
-#define ONE_CASE_PER_SPACE(base_tag) \
- case (base_tag) + NEW_SPACE: /* NOLINT */ \
- case (base_tag) + OLD_POINTER_SPACE: /* NOLINT */ \
- case (base_tag) + OLD_DATA_SPACE: /* NOLINT */ \
- case (base_tag) + CODE_SPACE: /* NOLINT */ \
- case (base_tag) + MAP_SPACE: /* NOLINT */ \
- case (base_tag) + CELL_SPACE: /* NOLINT */ \
- case (base_tag) + kLargeData: /* NOLINT */ \
- case (base_tag) + kLargeCode: /* NOLINT */ \
- case (base_tag) + kLargeFixedArray: /* NOLINT */
+// This macro is always used with a constant argument so it should all fold
+// away to almost nothing in the generated code. It might be nicer to do this
+// with the ternary operator but there are type issues with that.
+#define ASSIGN_DEST_SPACE(space_number) \
+ Space* dest_space; \
+ if (space_number == NEW_SPACE) { \
+ dest_space = Heap::new_space(); \
+ } else if (space_number == OLD_POINTER_SPACE) { \
+ dest_space = Heap::old_pointer_space(); \
+ } else if (space_number == OLD_DATA_SPACE) { \
+ dest_space = Heap::old_data_space(); \
+ } else if (space_number == CODE_SPACE) { \
+ dest_space = Heap::code_space(); \
+ } else if (space_number == MAP_SPACE) { \
+ dest_space = Heap::map_space(); \
+ } else if (space_number == CELL_SPACE) { \
+ dest_space = Heap::cell_space(); \
+ } else { \
+ ASSERT(space_number >= LO_SPACE); \
+ dest_space = Heap::lo_space(); \
+ }
+static const int kUnknownOffsetFromStart = -1;
+
+
void Deserializer::ReadChunk(Object** current,
Object** limit,
- int space,
+ int source_space,
Address address) {
while (current < limit) {
int data = source_->Get();
switch (data) {
+#define CASE_STATEMENT(where, how, within, space_number) \
+ case where + how + within + space_number: \
+ ASSERT((where & ~kPointedToMask) == 0); \
+ ASSERT((how & ~kHowToCodeMask) == 0); \
+ ASSERT((within & ~kWhereToPointMask) == 0); \
+ ASSERT((space_number & ~kSpaceMask) == 0);
+
+#define CASE_BODY(where, how, within, space_number_if_any, offset_from_start) \
+ { \
+ bool emit_write_barrier = false; \
+ bool current_was_incremented = false; \
+ int space_number = space_number_if_any == kAnyOldSpace ? \
+ (data & kSpaceMask) : space_number_if_any; \
+ if (where == kNewObject && how == kPlain && within == kStartOfObject) {\
+ ASSIGN_DEST_SPACE(space_number) \
+ ReadObject(space_number, dest_space, current); \
+ emit_write_barrier = \
+ (space_number == NEW_SPACE && source_space != NEW_SPACE); \
+ } else { \
+ Object* new_object = NULL; /* May not be a real Object pointer. */ \
+ if (where == kNewObject) { \
+ ASSIGN_DEST_SPACE(space_number) \
+ ReadObject(space_number, dest_space, &new_object); \
+ } else if (where == kRootArray) { \
+ int root_id = source_->GetInt(); \
+ new_object = Heap::roots_address()[root_id]; \
+ } else if (where == kPartialSnapshotCache) { \
+ int cache_index = source_->GetInt(); \
+ new_object = partial_snapshot_cache_[cache_index]; \
+ } else if (where == kExternalReference) { \
+ int reference_id = source_->GetInt(); \
+ Address address = \
+ external_reference_decoder_->Decode(reference_id); \
+ new_object = reinterpret_cast<Object*>(address); \
+ } else if (where == kBackref) { \
+ emit_write_barrier = \
+ (space_number == NEW_SPACE && source_space != NEW_SPACE); \
+ new_object = GetAddressFromEnd(data & kSpaceMask); \
+ } else { \
+ ASSERT(where == kFromStart); \
+ if (offset_from_start == kUnknownOffsetFromStart) { \
+ emit_write_barrier = \
+ (space_number == NEW_SPACE && source_space != NEW_SPACE); \
+ new_object = GetAddressFromStart(data & kSpaceMask); \
+ } else { \
+ Address object_address = pages_[space_number][0] + \
+ (offset_from_start << kObjectAlignmentBits); \
+ new_object = HeapObject::FromAddress(object_address); \
+ } \
+ } \
+ if (within == kFirstInstruction) { \
+ Code* new_code_object = reinterpret_cast<Code*>(new_object); \
+ new_object = reinterpret_cast<Object*>( \
+ new_code_object->instruction_start()); \
+ } \
+ if (how == kFromCode) { \
+ Address location_of_branch_data = \
+ reinterpret_cast<Address>(current); \
+ Assembler::set_target_at(location_of_branch_data, \
+ reinterpret_cast<Address>(new_object)); \
+ if (within == kFirstInstruction) { \
+ location_of_branch_data += Assembler::kCallTargetSize; \
+ current = reinterpret_cast<Object**>(location_of_branch_data); \
+ current_was_incremented = true; \
+ } \
+ } else { \
+ *current = new_object; \
+ } \
+ } \
+ if (emit_write_barrier) { \
+ Heap::RecordWrite(address, static_cast<int>( \
+ reinterpret_cast<Address>(current) - address)); \
+ } \
+ if (!current_was_incremented) { \
+ current++; /* Increment current if it wasn't done above. */ \
+ } \
+ break; \
+ } \
+
+// This generates a case and a body for each space. The large object spaces are
+// very rare in snapshots so they are grouped in one body.
+#define ONE_PER_SPACE(where, how, within) \
+ CASE_STATEMENT(where, how, within, NEW_SPACE) \
+ CASE_BODY(where, how, within, NEW_SPACE, kUnknownOffsetFromStart) \
+ CASE_STATEMENT(where, how, within, OLD_DATA_SPACE) \
+ CASE_BODY(where, how, within, OLD_DATA_SPACE, kUnknownOffsetFromStart) \
+ CASE_STATEMENT(where, how, within, OLD_POINTER_SPACE) \
+ CASE_BODY(where, how, within, OLD_POINTER_SPACE, kUnknownOffsetFromStart) \
+ CASE_STATEMENT(where, how, within, CODE_SPACE) \
+ CASE_BODY(where, how, within, CODE_SPACE, kUnknownOffsetFromStart) \
+ CASE_STATEMENT(where, how, within, CELL_SPACE) \
+ CASE_BODY(where, how, within, CELL_SPACE, kUnknownOffsetFromStart) \
+ CASE_STATEMENT(where, how, within, MAP_SPACE) \
+ CASE_BODY(where, how, within, MAP_SPACE, kUnknownOffsetFromStart) \
+ CASE_STATEMENT(where, how, within, kLargeData) \
+ CASE_STATEMENT(where, how, within, kLargeCode) \
+ CASE_STATEMENT(where, how, within, kLargeFixedArray) \
+ CASE_BODY(where, how, within, kAnyOldSpace, kUnknownOffsetFromStart)
+
+// This generates a case and a body for the new space (which has to do extra
+// write barrier handling) and handles the other spaces with 8 fall-through
+// cases and one body.
+#define ALL_SPACES(where, how, within) \
+ CASE_STATEMENT(where, how, within, NEW_SPACE) \
+ CASE_BODY(where, how, within, NEW_SPACE, kUnknownOffsetFromStart) \
+ CASE_STATEMENT(where, how, within, OLD_DATA_SPACE) \
+ CASE_STATEMENT(where, how, within, OLD_POINTER_SPACE) \
+ CASE_STATEMENT(where, how, within, CODE_SPACE) \
+ CASE_STATEMENT(where, how, within, CELL_SPACE) \
+ CASE_STATEMENT(where, how, within, MAP_SPACE) \
+ CASE_STATEMENT(where, how, within, kLargeData) \
+ CASE_STATEMENT(where, how, within, kLargeCode) \
+ CASE_STATEMENT(where, how, within, kLargeFixedArray) \
+ CASE_BODY(where, how, within, kAnyOldSpace, kUnknownOffsetFromStart)
+
+#define EMIT_COMMON_REFERENCE_PATTERNS(pseudo_space_number, \
+ space_number, \
+ offset_from_start) \
+ CASE_STATEMENT(kFromStart, kPlain, kStartOfObject, pseudo_space_number) \
+ CASE_BODY(kFromStart, kPlain, kStartOfObject, space_number, offset_from_start)
+
+ // We generate 15 cases and bodies that process special tags that combine
+ // the raw data tag and the length into one byte.
#define RAW_CASE(index, size) \
- case RAW_DATA_SERIALIZATION + index: { \
+ case kRawData + index: { \
byte* raw_data_out = reinterpret_cast<byte*>(current); \
source_->CopyRaw(raw_data_out, size); \
current = reinterpret_cast<Object**>(raw_data_out + size); \
@@ -688,144 +825,77 @@
}
COMMON_RAW_LENGTHS(RAW_CASE)
#undef RAW_CASE
- case RAW_DATA_SERIALIZATION: {
+
+ // Deserialize a chunk of raw data that doesn't have one of the popular
+ // lengths.
+ case kRawData: {
int size = source_->GetInt();
byte* raw_data_out = reinterpret_cast<byte*>(current);
source_->CopyRaw(raw_data_out, size);
current = reinterpret_cast<Object**>(raw_data_out + size);
break;
}
- case OBJECT_SERIALIZATION + NEW_SPACE: {
- ReadObject(NEW_SPACE, Heap::new_space(), current);
- if (space != NEW_SPACE) {
- Heap::RecordWrite(address, static_cast<int>(
- reinterpret_cast<Address>(current) - address));
- }
- current++;
- break;
- }
- case OBJECT_SERIALIZATION + OLD_DATA_SPACE:
- ReadObject(OLD_DATA_SPACE, Heap::old_data_space(), current++);
- break;
- case OBJECT_SERIALIZATION + OLD_POINTER_SPACE:
- ReadObject(OLD_POINTER_SPACE, Heap::old_pointer_space(), current++);
- break;
- case OBJECT_SERIALIZATION + MAP_SPACE:
- ReadObject(MAP_SPACE, Heap::map_space(), current++);
- break;
- case OBJECT_SERIALIZATION + CODE_SPACE:
- ReadObject(CODE_SPACE, Heap::code_space(), current++);
- break;
- case OBJECT_SERIALIZATION + CELL_SPACE:
- ReadObject(CELL_SPACE, Heap::cell_space(), current++);
- break;
- case OBJECT_SERIALIZATION + kLargeData:
- ReadObject(kLargeData, Heap::lo_space(), current++);
- break;
- case OBJECT_SERIALIZATION + kLargeCode:
- ReadObject(kLargeCode, Heap::lo_space(), current++);
- break;
- case OBJECT_SERIALIZATION + kLargeFixedArray:
- ReadObject(kLargeFixedArray, Heap::lo_space(), current++);
- break;
- case CODE_OBJECT_SERIALIZATION + kLargeCode: {
- Object* new_code_object = NULL;
- ReadObject(kLargeCode, Heap::lo_space(), &new_code_object);
- Code* code_object = reinterpret_cast<Code*>(new_code_object);
- // Setting a branch/call to another code object from code.
- Address location_of_branch_data = reinterpret_cast<Address>(current);
- Assembler::set_target_at(location_of_branch_data,
- code_object->instruction_start());
- location_of_branch_data += Assembler::kCallTargetSize;
- current = reinterpret_cast<Object**>(location_of_branch_data);
- break;
- }
- case CODE_OBJECT_SERIALIZATION + CODE_SPACE: {
- Object* new_code_object = NULL;
- ReadObject(CODE_SPACE, Heap::code_space(), &new_code_object);
- Code* code_object = reinterpret_cast<Code*>(new_code_object);
- // Setting a branch/call to another code object from code.
- Address location_of_branch_data = reinterpret_cast<Address>(current);
- Assembler::set_target_at(location_of_branch_data,
- code_object->instruction_start());
- location_of_branch_data += Assembler::kCallTargetSize;
- current = reinterpret_cast<Object**>(location_of_branch_data);
- break;
- }
- ONE_CASE_PER_SPACE(BACKREF_SERIALIZATION) {
- // Write a backreference to an object we unpacked earlier.
- int backref_space = (data & kSpaceMask);
- if (backref_space == NEW_SPACE && space != NEW_SPACE) {
- Heap::RecordWrite(address, static_cast<int>(
- reinterpret_cast<Address>(current) - address));
- }
- *current++ = GetAddressFromEnd(backref_space);
- break;
- }
- ONE_CASE_PER_SPACE(REFERENCE_SERIALIZATION) {
- // Write a reference to an object we unpacked earlier.
- int reference_space = (data & kSpaceMask);
- if (reference_space == NEW_SPACE && space != NEW_SPACE) {
- Heap::RecordWrite(address, static_cast<int>(
- reinterpret_cast<Address>(current) - address));
- }
- *current++ = GetAddressFromStart(reference_space);
- break;
- }
-#define COMMON_REFS_CASE(index, reference_space, address) \
- case REFERENCE_SERIALIZATION + index: { \
- ASSERT(SpaceIsPaged(reference_space)); \
- Address object_address = \
- pages_[reference_space][0] + (address << kObjectAlignmentBits); \
- *current++ = HeapObject::FromAddress(object_address); \
- break; \
- }
- COMMON_REFERENCE_PATTERNS(COMMON_REFS_CASE)
-#undef COMMON_REFS_CASE
- ONE_CASE_PER_SPACE(CODE_BACKREF_SERIALIZATION) {
- int backref_space = (data & kSpaceMask);
- // Can't use Code::cast because heap is not set up yet and assertions
- // will fail.
- Code* code_object =
- reinterpret_cast<Code*>(GetAddressFromEnd(backref_space));
- // Setting a branch/call to previously decoded code object from code.
- Address location_of_branch_data = reinterpret_cast<Address>(current);
- Assembler::set_target_at(location_of_branch_data,
- code_object->instruction_start());
- location_of_branch_data += Assembler::kCallTargetSize;
- current = reinterpret_cast<Object**>(location_of_branch_data);
- break;
- }
- ONE_CASE_PER_SPACE(CODE_REFERENCE_SERIALIZATION) {
- int backref_space = (data & kSpaceMask);
- // Can't use Code::cast because heap is not set up yet and assertions
- // will fail.
- Code* code_object =
- reinterpret_cast<Code*>(GetAddressFromStart(backref_space));
- // Setting a branch/call to previously decoded code object from code.
- Address location_of_branch_data = reinterpret_cast<Address>(current);
- Assembler::set_target_at(location_of_branch_data,
- code_object->instruction_start());
- location_of_branch_data += Assembler::kCallTargetSize;
- current = reinterpret_cast<Object**>(location_of_branch_data);
- break;
- }
- case EXTERNAL_REFERENCE_SERIALIZATION: {
- int reference_id = source_->GetInt();
- Address address = external_reference_decoder_->Decode(reference_id);
- *current++ = reinterpret_cast<Object*>(address);
- break;
- }
- case EXTERNAL_BRANCH_TARGET_SERIALIZATION: {
- int reference_id = source_->GetInt();
- Address address = external_reference_decoder_->Decode(reference_id);
- Address location_of_branch_data = reinterpret_cast<Address>(current);
- Assembler::set_external_target_at(location_of_branch_data, address);
- location_of_branch_data += Assembler::kExternalTargetSize;
- current = reinterpret_cast<Object**>(location_of_branch_data);
- break;
- }
- case START_NEW_PAGE_SERIALIZATION: {
+
+ // Deserialize a new object and write a pointer to it to the current
+ // object.
+ ONE_PER_SPACE(kNewObject, kPlain, kStartOfObject)
+ // Deserialize a new code object and write a pointer to its first
+ // instruction to the current code object.
+ ONE_PER_SPACE(kNewObject, kFromCode, kFirstInstruction)
+ // Find a recently deserialized object using its offset from the current
+ // allocation point and write a pointer to it to the current object.
+ ALL_SPACES(kBackref, kPlain, kStartOfObject)
+ // Find a recently deserialized code object using its offset from the
+ // current allocation point and write a pointer to its first instruction
+ // to the current code object.
+ ALL_SPACES(kBackref, kFromCode, kFirstInstruction)
+ // Find an already deserialized object using its offset from the start
+ // and write a pointer to it to the current object.
+ ALL_SPACES(kFromStart, kPlain, kStartOfObject)
+ // Find an already deserialized code object using its offset from the
+ // start and write a pointer to its first instruction to the current code
+ // object.
+ ALL_SPACES(kFromStart, kFromCode, kFirstInstruction)
+ // Find an already deserialized object at one of the predetermined popular
+ // offsets from the start and write a pointer to it in the current object.
+ COMMON_REFERENCE_PATTERNS(EMIT_COMMON_REFERENCE_PATTERNS)
+ // Find an object in the roots array and write a pointer to it to the
+ // current object.
+ CASE_STATEMENT(kRootArray, kPlain, kStartOfObject, 0)
+ CASE_BODY(kRootArray, kPlain, kStartOfObject, 0, kUnknownOffsetFromStart)
+ // Find an object in the partial snapshots cache and write a pointer to it
+ // to the current object.
+ CASE_STATEMENT(kPartialSnapshotCache, kPlain, kStartOfObject, 0)
+ CASE_BODY(kPartialSnapshotCache,
+ kPlain,
+ kStartOfObject,
+ 0,
+ kUnknownOffsetFromStart)
+ // Find an external reference and write a pointer to it to the current
+ // object.
+ CASE_STATEMENT(kExternalReference, kPlain, kStartOfObject, 0)
+ CASE_BODY(kExternalReference,
+ kPlain,
+ kStartOfObject,
+ 0,
+ kUnknownOffsetFromStart)
+ // Find an external reference and write a pointer to it in the current
+ // code object.
+ CASE_STATEMENT(kExternalReference, kFromCode, kStartOfObject, 0)
+ CASE_BODY(kExternalReference,
+ kFromCode,
+ kStartOfObject,
+ 0,
+ kUnknownOffsetFromStart)
+
+#undef CASE_STATEMENT
+#undef CASE_BODY
+#undef ONE_PER_SPACE
+#undef ALL_SPACES
+#undef EMIT_COMMON_REFERENCE_PATTERNS
+#undef ASSIGN_DEST_SPACE
+
+ case kNewPage: {
int space = source_->Get();
pages_[space].Add(last_object_address_);
if (space == CODE_SPACE) {
@@ -833,7 +903,8 @@
}
break;
}
- case NATIVES_STRING_RESOURCE: {
+
+ case kNativesStringResource: {
int index = source_->Get();
Vector<const char> source_vector = Natives::GetScriptSource(index);
NativesExternalStringResource* resource =
@@ -841,21 +912,13 @@
*current++ = reinterpret_cast<Object*>(resource);
break;
}
- case ROOT_SERIALIZATION: {
- int root_id = source_->GetInt();
- *current++ = Heap::roots_address()[root_id];
- break;
- }
- case PARTIAL_SNAPSHOT_CACHE_ENTRY: {
- int cache_index = source_->GetInt();
- *current++ = partial_snapshot_cache_[cache_index];
- break;
- }
- case SYNCHRONIZE: {
+
+ case kSynchronize: {
// If we get here then that indicates that you have a mismatch between
// the number of GC roots when serializing and deserializing.
UNREACHABLE();
}
+
default:
UNREACHABLE();
}
@@ -880,7 +943,7 @@
int data = source_->Get();
// If this assert fails then that indicates that you have a mismatch between
// the number of GC roots when serializing and deserializing.
- ASSERT_EQ(SYNCHRONIZE, data);
+ ASSERT_EQ(kSynchronize, data);
do {
int character = source_->Get();
if (character == 0) break;
@@ -895,7 +958,7 @@
void Serializer::Synchronize(const char* tag) {
- sink_->Put(SYNCHRONIZE, tag);
+ sink_->Put(kSynchronize, tag);
int character;
do {
character = *tag++;
@@ -957,13 +1020,13 @@
void Serializer::VisitPointers(Object** start, Object** end) {
for (Object** current = start; current < end; current++) {
if ((*current)->IsSmi()) {
- sink_->Put(RAW_DATA_SERIALIZATION, "RawData");
+ sink_->Put(kRawData, "RawData");
sink_->PutInt(kPointerSize, "length");
for (int i = 0; i < kPointerSize; i++) {
sink_->Put(reinterpret_cast<byte*>(current)[i], "Byte");
}
} else {
- SerializeObject(*current, TAGGED_REPRESENTATION);
+ SerializeObject(*current, kPlain, kStartOfObject);
}
}
}
@@ -1033,7 +1096,8 @@
void Serializer::SerializeReferenceToPreviousObject(
int space,
int address,
- ReferenceRepresentation reference_representation) {
+ HowToCode how_to_code,
+ WhereToPoint where_to_point) {
int offset = CurrentAllocationAddress(space) - address;
bool from_start = true;
if (SpaceIsPaged(space)) {
@@ -1054,43 +1118,30 @@
// If we are actually dealing with real offsets (and not a numbering of
// all objects) then we should shift out the bits that are always 0.
if (!SpaceIsLarge(space)) address >>= kObjectAlignmentBits;
- // On some architectures references between code objects are encoded
- // specially (as relative offsets). Such references have their own
- // special tags to simplify the deserializer.
- if (reference_representation == CODE_TARGET_REPRESENTATION) {
- if (from_start) {
- sink_->Put(CODE_REFERENCE_SERIALIZATION + space, "RefCodeSer");
+ if (from_start) {
+#define COMMON_REFS_CASE(pseudo_space, actual_space, offset) \
+ if (space == actual_space && address == offset && \
+ how_to_code == kPlain && where_to_point == kStartOfObject) { \
+ sink_->Put(kFromStart + how_to_code + where_to_point + \
+ pseudo_space, "RefSer"); \
+ } else /* NOLINT */
+ COMMON_REFERENCE_PATTERNS(COMMON_REFS_CASE)
+#undef COMMON_REFS_CASE
+ { /* NOLINT */
+ sink_->Put(kFromStart + how_to_code + where_to_point + space, "RefSer");
sink_->PutInt(address, "address");
- } else {
- sink_->Put(CODE_BACKREF_SERIALIZATION + space, "BackRefCodeSer");
- sink_->PutInt(address, "address");
}
} else {
- // Regular absolute references.
- CHECK_EQ(TAGGED_REPRESENTATION, reference_representation);
- if (from_start) {
- // There are some common offsets that have their own specialized encoding.
-#define COMMON_REFS_CASE(tag, common_space, common_offset) \
- if (space == common_space && address == common_offset) { \
- sink_->PutSection(tag + REFERENCE_SERIALIZATION, "RefSer"); \
- } else /* NOLINT */
- COMMON_REFERENCE_PATTERNS(COMMON_REFS_CASE)
-#undef COMMON_REFS_CASE
- { /* NOLINT */
- sink_->Put(REFERENCE_SERIALIZATION + space, "RefSer");
- sink_->PutInt(address, "address");
- }
- } else {
- sink_->Put(BACKREF_SERIALIZATION + space, "BackRefSer");
- sink_->PutInt(address, "address");
- }
+ sink_->Put(kBackref + how_to_code + where_to_point + space, "BackRefSer");
+ sink_->PutInt(address, "address");
}
}
void StartupSerializer::SerializeObject(
Object* o,
- ReferenceRepresentation reference_representation) {
+ HowToCode how_to_code,
+ WhereToPoint where_to_point) {
CHECK(o->IsHeapObject());
HeapObject* heap_object = HeapObject::cast(o);
@@ -1099,13 +1150,15 @@
int address = address_mapper_.MappedTo(heap_object);
SerializeReferenceToPreviousObject(space,
address,
- reference_representation);
+ how_to_code,
+ where_to_point);
} else {
// Object has not yet been serialized. Serialize it here.
ObjectSerializer object_serializer(this,
heap_object,
sink_,
- reference_representation);
+ how_to_code,
+ where_to_point);
object_serializer.Serialize();
}
}
@@ -1115,7 +1168,7 @@
for (int i = partial_snapshot_cache_length_;
i < kPartialSnapshotCacheCapacity;
i++) {
- sink_->Put(ROOT_SERIALIZATION, "RootSerialization");
+ sink_->Put(kRootArray + kPlain + kStartOfObject, "RootSerialization");
sink_->PutInt(Heap::kUndefinedValueRootIndex, "root_index");
}
Heap::IterateWeakRoots(this, VISIT_ALL);
@@ -1124,20 +1177,22 @@
void PartialSerializer::SerializeObject(
Object* o,
- ReferenceRepresentation reference_representation) {
+ HowToCode how_to_code,
+ WhereToPoint where_to_point) {
CHECK(o->IsHeapObject());
HeapObject* heap_object = HeapObject::cast(o);
int root_index;
if ((root_index = RootIndex(heap_object)) != kInvalidRootIndex) {
- sink_->Put(ROOT_SERIALIZATION, "RootSerialization");
+ sink_->Put(kRootArray + how_to_code + where_to_point, "RootSerialization");
sink_->PutInt(root_index, "root_index");
return;
}
if (ShouldBeInThePartialSnapshotCache(heap_object)) {
int cache_index = PartialSnapshotCacheIndex(heap_object);
- sink_->Put(PARTIAL_SNAPSHOT_CACHE_ENTRY, "PartialSnapshotCache");
+ sink_->Put(kPartialSnapshotCache + how_to_code + where_to_point,
+ "PartialSnapshotCache");
sink_->PutInt(cache_index, "partial_snapshot_cache_index");
return;
}
@@ -1155,13 +1210,15 @@
int address = address_mapper_.MappedTo(heap_object);
SerializeReferenceToPreviousObject(space,
address,
- reference_representation);
+ how_to_code,
+ where_to_point);
} else {
// Object has not yet been serialized. Serialize it here.
ObjectSerializer serializer(this,
heap_object,
sink_,
- reference_representation);
+ how_to_code,
+ where_to_point);
serializer.Serialize();
}
}
@@ -1171,12 +1228,8 @@
int space = Serializer::SpaceOfObject(object_);
int size = object_->Size();
- if (reference_representation_ == TAGGED_REPRESENTATION) {
- sink_->Put(OBJECT_SERIALIZATION + space, "ObjectSerialization");
- } else {
- CHECK_EQ(CODE_TARGET_REPRESENTATION, reference_representation_);
- sink_->Put(CODE_OBJECT_SERIALIZATION + space, "ObjectSerialization");
- }
+ sink_->Put(kNewObject + reference_representation_ + space,
+ "ObjectSerialization");
sink_->PutInt(size >> kObjectAlignmentBits, "Size in words");
LOG(SnapshotPositionEvent(object_->address(), sink_->Position()));
@@ -1186,12 +1239,12 @@
int offset = serializer_->Allocate(space, size, &start_new_page);
serializer_->address_mapper()->AddMapping(object_, offset);
if (start_new_page) {
- sink_->Put(START_NEW_PAGE_SERIALIZATION, "NewPage");
+ sink_->Put(kNewPage, "NewPage");
sink_->PutSection(space, "NewPageSpace");
}
// Serialize the map (first word of the object).
- serializer_->SerializeObject(object_->map(), TAGGED_REPRESENTATION);
+ serializer_->SerializeObject(object_->map(), kPlain, kStartOfObject);
// Serialize the rest of the object.
CHECK_EQ(0, bytes_processed_so_far_);
@@ -1209,7 +1262,7 @@
if (current < end) OutputRawData(reinterpret_cast<Address>(current));
while (current < end && !(*current)->IsSmi()) {
- serializer_->SerializeObject(*current, TAGGED_REPRESENTATION);
+ serializer_->SerializeObject(*current, kPlain, kStartOfObject);
bytes_processed_so_far_ += kPointerSize;
current++;
}
@@ -1223,7 +1276,7 @@
OutputRawData(references_start);
for (Address* current = start; current < end; current++) {
- sink_->Put(EXTERNAL_REFERENCE_SERIALIZATION, "ExternalReference");
+ sink_->Put(kExternalReference + kPlain + kStartOfObject, "ExternalRef");
int reference_id = serializer_->EncodeExternalReference(*current);
sink_->PutInt(reference_id, "reference id");
}
@@ -1237,7 +1290,14 @@
Address target = rinfo->target_address();
uint32_t encoding = serializer_->EncodeExternalReference(target);
CHECK(target == NULL ? encoding == 0 : encoding != 0);
- sink_->Put(EXTERNAL_BRANCH_TARGET_SERIALIZATION, "ExternalReference");
+ int representation;
+ // Can't use a ternary operator because of gcc.
+ if (rinfo->IsCodedSpecially()) {
+ representation = kStartOfObject + kFromCode;
+ } else {
+ representation = kStartOfObject + kPlain;
+ }
+ sink_->Put(kExternalReference + representation, "ExternalReference");
sink_->PutInt(encoding, "reference id");
bytes_processed_so_far_ += Assembler::kExternalTargetSize;
}
@@ -1248,7 +1308,7 @@
Address target_start = rinfo->target_address_address();
OutputRawData(target_start);
Code* target = Code::GetCodeFromTargetAddress(rinfo->target_address());
- serializer_->SerializeObject(target, CODE_TARGET_REPRESENTATION);
+ serializer_->SerializeObject(target, kFromCode, kFirstInstruction);
bytes_processed_so_far_ += Assembler::kCallTargetSize;
}
@@ -1264,7 +1324,7 @@
typedef v8::String::ExternalAsciiStringResource Resource;
Resource* resource = string->resource();
if (resource == *resource_pointer) {
- sink_->Put(NATIVES_STRING_RESOURCE, "NativesStringResource");
+ sink_->Put(kNativesStringResource, "NativesStringResource");
sink_->PutSection(i, "NativesStringResourceEnd");
bytes_processed_so_far_ += sizeof(resource);
return;
@@ -1288,12 +1348,12 @@
Address base = object_start + bytes_processed_so_far_;
#define RAW_CASE(index, length) \
if (skipped == length) { \
- sink_->PutSection(RAW_DATA_SERIALIZATION + index, "RawDataFixed"); \
+ sink_->PutSection(kRawData + index, "RawDataFixed"); \
} else /* NOLINT */
COMMON_RAW_LENGTHS(RAW_CASE)
#undef RAW_CASE
{ /* NOLINT */
- sink_->Put(RAW_DATA_SERIALIZATION, "RawData");
+ sink_->Put(kRawData, "RawData");
sink_->PutInt(skipped, "length");
}
for (int i = 0; i < skipped; i++) {
« no previous file with comments | « src/serialize.h ('k') | src/x64/assembler-x64.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698