MIPS: Fix 'MIPS: 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 1030 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 kInternalReferenceEncoded:
       case kInternalReference: {
         // Internal reference address is not encoded via skip, but by offset
         // from code entry.
         int pc_offset = source_.GetInt();
         int target_offset = source_.GetInt();
         Code* code =
             Code::cast(HeapObject::FromAddress(current_object_address));
         DCHECK(0 <= pc_offset && pc_offset <= code->instruction_size());
         DCHECK(0 <= target_offset && target_offset <= code->instruction_size());
         Address pc = code->entry() + pc_offset;
         Address target = code->entry() + target_offset;
-        Assembler::deserialization_set_target_internal_reference_at(pc, target);
+        if (data == kInternalReference) {
+          Assembler::deserialization_set_target_internal_reference_at(pc,
+                                                                      target);
+        } else {
+          Assembler::deserialization_set_target_internal_reference_encoded_at(
+              pc, target);
+        }
         break;
       }
 
       case kNop:
         break;
 
       case kNextChunk: {
         int space = source_.Get();
         DCHECK(space < kNumberOfPreallocatedSpaces);
         int chunk_index = current_chunk_[space];
@@ skipping 747 matching lines @@
   // end of the code in the constant pool, whereas internal references are
   // inline. That would cause the skip to be negative. Instead, we store the
   // offset from code entry.
   Address entry = Code::cast(object_)->entry();
   intptr_t pc_offset = rinfo->target_internal_reference_address() - entry;
   intptr_t target_offset = rinfo->target_internal_reference() - entry;
   DCHECK(0 <= pc_offset &&
          pc_offset <= Code::cast(object_)->instruction_size());
   DCHECK(0 <= target_offset &&
          target_offset <= Code::cast(object_)->instruction_size());
-  sink_->Put(kInternalReference, "InternalRef");
+  rinfo->rmode() == RelocInfo::INTERNAL_REFERENCE

[yangguo, 2015/03/19 19:16:33]

Please do not use a tertiary operator like this. I definitely prefer

sink_->Put(rinfo->rmode() == ... ? ... : ..., "InternalRef");

Or an if-else if you want to preserve the comment strings.

[balazs.kilvady, 2015/03/20 11:14:42]

Done.

+      ? sink_->Put(kInternalReference, "InternalRef")
+      : sink_->Put(kInternalReferenceEncoded, "InternalRefEnc");
   sink_->PutInt(static_cast<uintptr_t>(pc_offset), "internal ref address");
   sink_->PutInt(static_cast<uintptr_t>(target_offset), "internal ref value");
 }
 
 
 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");
@@ skipping 667 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