Serializer: serialize internal references via object visitor.

src/serialize.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/v8.h"
 
 #include "src/accessors.h"
 #include "src/api.h"
 #include "src/base/platform/platform.h"
 #include "src/bootstrapper.h"
@@ skipping 774 matching lines @@
 
   Object* write_back_obj = obj;
   UnalignedCopy(write_back, &write_back_obj);
 #ifdef DEBUG
   if (obj->IsCode()) {
     DCHECK(space_number == CODE_SPACE || space_number == LO_SPACE);
   } else {
     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);
-    }
-  }
 }
 
 
 // We know the space requirements before deserialization and can
 // pre-allocate that reserved space. During deserialization, all we need
 // to do is to bump up the pointer for each space in the reserved
 // space. This is also used for fixing back references.
 // We may have to split up the pre-allocation into several chunks
 // because it would not fit onto a single page. We do not have to keep
 // track of when to move to the next chunk. An opcode will signal this.
@@ skipping 358 matching lines @@
 #undef CASE_BODY
 #undef ALL_SPACES
 
       case kSkip: {
         int size = source_.GetInt();
         current = reinterpret_cast<Object**>(
             reinterpret_cast<intptr_t>(current) + size);
         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();
         Vector<const char> source_vector = Natives::GetScriptSource(index);
         NativesExternalStringResource* resource =
             new NativesExternalStringResource(source_vector.start(),
                                               source_vector.length());
         Object* resource_obj = reinterpret_cast<Object*>(resource);
         UnalignedCopy(current++, &resource_obj);
         break;
@@ skipping 667 matching lines @@
                            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_external_reference();
   sink_->PutInt(serializer_->EncodeExternalReference(target), "reference id");
   bytes_processed_so_far_ += rinfo->target_address_size();
 }
 
 
+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);
   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();
 }
@@ skipping 55 matching lines @@
 }
 
 
 Address Serializer::ObjectSerializer::PrepareCode() {
   // To make snapshots reproducible, we make a copy of the code object
   // and wipe all pointers in the copy, which we then serialize.
   Code* original = Code::cast(object_);
   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) |
                   RelocInfo::ModeMask(RelocInfo::RUNTIME_ENTRY) |
                   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();
-    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();
     }
   }
   // 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();
   return code->address();
 }
 
 
@@ skipping 582 matching lines @@
   DisallowHeapAllocation no_gc;
   SerializedCodeData* scd = new SerializedCodeData(cached_data);
   SanityCheckResult r = scd->SanityCheck(isolate, source);
   if (r == CHECK_SUCCESS) return scd;
   cached_data->Reject();
   source->GetIsolate()->counters()->code_cache_reject_reason()->AddSample(r);
   delete scd;
   return NULL;
 }
 } }  // namespace v8::internal