Serializer: serialize internal references via object visitor.

src/serialize.cc

Index: src/serialize.cc
diff --git a/src/serialize.cc b/src/serialize.cc
index 00405dda91a2999739b6fa45fcff3ce435c90e35..916c5333ad1690e84361e9a21c6618aab13c0702 100644
--- a/src/serialize.cc
+++ b/src/serialize.cc
@@ -792,21 +792,6 @@ void Deserializer::ReadObject(int space_number, Object** write_back) {
     DCHECK(space_number != CODE_SPACE);
   }
 #endif
-
-  if (obj->IsCode()) {
-    // Turn internal references encoded as offsets back to absolute addresses.
-    Code* code = Code::cast(obj);
-    Address entry = code->entry();
-    int mode_mask = RelocInfo::ModeMask(RelocInfo::INTERNAL_REFERENCE) |
-                    RelocInfo::ModeMask(RelocInfo::INTERNAL_REFERENCE_ENCODED);
-    for (RelocIterator it(code, mode_mask); !it.done(); it.next()) {
-      RelocInfo* rinfo = it.rinfo();
-      intptr_t offset =
-          reinterpret_cast<intptr_t>(rinfo->target_internal_reference());
-      DCHECK(0 <= offset && offset <= code->instruction_size());
-      rinfo->set_target_internal_reference(entry + offset);
-    }
-  }
 }
 
 
@@ -1185,6 +1170,20 @@ void Deserializer::ReadData(Object** current, Object** limit, int source_space,
         break;
       }
 
+      case kInternalReference: {
+        int skip = source_.GetInt();
+        current = reinterpret_cast<Object**>(
+            reinterpret_cast<Address>(current) + skip);
+        int offset = source_.GetInt();
+        Code* code =
+            Code::cast(HeapObject::FromAddress(current_object_address));
+        DCHECK(0 <= offset && offset <= code->instruction_size());
+        Address target = code->entry() + offset;
+        Assembler::deserialization_set_target_internal_reference_at(
+            reinterpret_cast<Address>(current), target);
+        break;
+      }
+
       case kNativesStringResource: {
         DCHECK(!isolate_->heap()->deserialization_complete());
         int index = source_.Get();
@@ -1872,6 +1871,19 @@ void Serializer::ObjectSerializer::VisitExternalReference(RelocInfo* rinfo) {
 }
 
 
+void Serializer::ObjectSerializer::VisitInternalReference(RelocInfo* rinfo) {
+  DCHECK(code_object_);

[Erik Corry, 2015/03/17 15:31:16]

I don't think you are allowed to use implicit bool conversion.

[Yang, 2015/03/18 09:37:20]

code_object_ is a bool. I renamed it to is_code_object_

+  int skip = OutputRawData(rinfo->target_address_address(),
+                           kCanReturnSkipInsteadOfSkipping);
+  sink_->Put(kInternalReference, "InternalRef");
+  sink_->PutInt(skip, "SkipB4InternalRef");
+  Address target = rinfo->target_internal_reference();
+  intptr_t offset = target - Code::cast(object_)->entry();
+  DCHECK(0 <= offset && offset <= Code::cast(object_)->instruction_size());
+  sink_->PutInt(static_cast<uintptr_t>(offset), "internal reference offset");
+}
+
+
 void Serializer::ObjectSerializer::VisitRuntimeEntry(RelocInfo* rinfo) {
   int skip = OutputRawData(rinfo->target_address_address(),
                            kCanReturnSkipInsteadOfSkipping);
@@ -1947,7 +1959,6 @@ Address Serializer::ObjectSerializer::PrepareCode() {
   Code* code = serializer_->CopyCode(original);
   // Code age headers are not serializable.
   code->MakeYoung(serializer_->isolate());
-  Address entry = original->entry();
   int mode_mask = RelocInfo::kCodeTargetMask |
                   RelocInfo::ModeMask(RelocInfo::EMBEDDED_OBJECT) |
                   RelocInfo::ModeMask(RelocInfo::EXTERNAL_REFERENCE) |
@@ -1956,15 +1967,7 @@ Address Serializer::ObjectSerializer::PrepareCode() {
                   RelocInfo::ModeMask(RelocInfo::INTERNAL_REFERENCE_ENCODED);
   for (RelocIterator it(code, mode_mask); !it.done(); it.next()) {
     RelocInfo* rinfo = it.rinfo();
-    RelocInfo::Mode rmode = rinfo->rmode();
-    if (RelocInfo::IsInternalReference(rmode) ||
-        RelocInfo::IsInternalReferenceEncoded(rmode)) {
-      // Convert internal references to relative offsets.
-      Address target = rinfo->target_internal_reference();
-      intptr_t offset = target - entry;
-      DCHECK(0 <= offset && offset <= original->instruction_size());
-      rinfo->set_target_internal_reference(reinterpret_cast<Address>(offset));
-    } else if (!(FLAG_enable_ool_constant_pool && rinfo->IsInConstantPool())) {
+    if (!(FLAG_enable_ool_constant_pool && rinfo->IsInConstantPool())) {

[Erik Corry, 2015/03/17 15:31:16]

If you don't wipe internal offsets, will snapshots still be reproducible?  This
would only be the case if they were always coded in a relative way, but in that
case you didn't need special handling in the snapshot at all.

[Yang, 2015/03/18 09:37:20]

This is necessary to make the snapshot reproducible. Internal references are
absolute addresses into the code object (currently only used for jump tables),
and therefore need to change on relocation.

       rinfo->WipeOut();
     }
   }