Don't convert jump and call targets to code object pointers when (de)serializ...

src/serialize.cc

 // Copyright 2006-2008 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 917 matching lines @@
   virtual void VisitPointers(Object** start, Object** end) {
     for (Object** p = start; p < end; ++p) {
       if ((*p)->IsHeapObject()) {
         offsets_.Add(reinterpret_cast<Address>(p) - obj_address_);
         Address a = serializer_->GetSavedAddress(HeapObject::cast(*p));
         addresses_.Add(a);
       }
     }
   }
 
+  // Do not assert that code targets have been converted to object pointers.
+  virtual void BeginCodeIteration(Code* code) {
+  }
+
+  virtual void VisitCodeTarget(RelocInfo* rinfo) {
+    ASSERT(RelocInfo::IsCodeTarget(rinfo->rmode()));
+    Code* target = Code::GetCodeFromTargetAddress(rinfo->target_address());
+    Address encoded_target = serializer_->GetSavedAddress(target);
+    offsets_.Add(rinfo->target_address_address() - obj_address_);
+    addresses_.Add(encoded_target);
+  }
+
+
   virtual void VisitExternalReferences(Address* start, Address* end) {
     for (Address* p = start; p < end; ++p) {
       uint32_t code = reference_encoder_->Encode(*p);
       CHECK(*p == NULL ? code == 0 : code != 0);
       offsets_.Add(reinterpret_cast<Address>(p) - obj_address_);
       addresses_.Add(reinterpret_cast<Address>(code));
     }
   }
 
   virtual void VisitRuntimeEntry(RelocInfo* rinfo) {
@@ skipping 138 matching lines @@
       roots_++;
       // If the object was not just serialized,
       // write its encoded address instead.
       if (!serialized) PutEncodedAddress(a);
     }
   }
   root_ = root;
 }
 
 
+void Serializer::VisitCodeTarget(RelocInfo* rinfo) {
+  ASSERT(RelocInfo::IsCodeTarget(rinfo->rmode()));
+  Code* target = Code::GetCodeFromTargetAddress(rinfo->target_address());
+  bool serialized;
+  Encode(target, &serialized);
+}
+
+
 class GlobalHandlesRetriever: public ObjectVisitor {
  public:
   explicit GlobalHandlesRetriever(List<Object**>* handles)
   : global_handles_(handles) {}
 
   virtual void VisitPointers(Object** start, Object** end) {
     for (; start != end; ++start) {
       global_handles_->Add(start);
     }
   }
@@ skipping 142 matching lines @@
   InstanceType type = map->instance_type();
   int size = obj->SizeFromMap(map);
 
   // Simulate the allocation of obj to predict where it will be
   // allocated during deserialization.
   Address addr = Allocate(obj).Encode();
 
   SaveAddress(obj, addr);
 
   if (type == CODE_TYPE) {
-    Code* code = Code::cast(obj);
-    // Ensure Code objects contain Object pointers, not Addresses.
-    code->ConvertICTargetsFromAddressToObject();
-    LOG(CodeMoveEvent(code->address(), addr));
+    LOG(CodeMoveEvent(obj->address(), addr));
   }
 
   // Write out the object prologue: type, size, and simulated address of obj.
   writer_->PutC('[');
   CHECK_EQ(0, static_cast<int>(size & kObjectAlignmentMask));
   writer_->PutInt(type);
   writer_->PutInt(size >> kObjectAlignmentBits);
   PutEncodedAddress(addr);  // encodes AllocationSpace
 
   // Visit all the pointers in the object other than the map. This
@@ skipping 11 matching lines @@
   updater.Update(writer_->position() - size);
 
 #ifdef DEBUG
   if (FLAG_debug_serialization) {
     // Write out the object epilogue to catch synchronization errors.
     PutEncodedAddress(addr);
     writer_->PutC(']');
   }
 #endif
 
-  if (type == CODE_TYPE) {
-    Code* code = Code::cast(obj);
-    // Convert relocations from Object* to Address in Code objects
-    code->ConvertICTargetsFromObjectToAddress();
-  }
-
   objects_++;
   return addr;
 }
 
 
 RelativeAddress Serializer::Allocate(HeapObject* obj) {
   // Find out which AllocationSpace 'obj' is in.
   AllocationSpace s;
   bool found = false;
   for (int i = FIRST_SPACE; !found && i <= LAST_SPACE; i++) {
@@ skipping 106 matching lines @@
     } else {
       // A pointer internal to a HeapObject that we've already
       // read: resolve it to a true address (or Smi)
       *p = Resolve(reinterpret_cast<Address>(*p));
     }
   }
   root_ = root;
 }
 
 
+void Deserializer::VisitCodeTarget(RelocInfo* rinfo) {
+  ASSERT(RelocInfo::IsCodeTarget(rinfo->rmode()));
+  Address encoded_address = reinterpret_cast<Address>(rinfo->target_object());
+  Code* target_object = reinterpret_cast<Code*>(Resolve(encoded_address));
+  rinfo->set_target_address(target_object->instruction_start());
+}
+
+
 void Deserializer::VisitExternalReferences(Address* start, Address* end) {
   for (Address* p = start; p < end; ++p) {
     uint32_t code = static_cast<uint32_t>(reinterpret_cast<uintptr_t>(*p));
     *p = reference_decoder_->Decode(code);
   }
 }
 
 
 void Deserializer::VisitRuntimeEntry(RelocInfo* rinfo) {
   uint32_t* pc = reinterpret_cast<uint32_t*>(rinfo->target_address_address());
@@ skipping 175 matching lines @@
   }
 #endif
 
   // Resolve the encoded pointers we just read in.
   // Same as obj->Iterate(this), but doesn't rely on the map pointer being set.
   VisitPointer(reinterpret_cast<Object**>(obj->address()));
   obj->IterateBody(type, size, this);
 
   if (type == CODE_TYPE) {
     Code* code = Code::cast(obj);
-    // Convert relocations from Object* to Address in Code objects
-    code->ConvertICTargetsFromObjectToAddress();
     LOG(CodeMoveEvent(a, code->address()));
   }
   objects_++;
   return o;
 }
 
 
 static inline Object* ResolvePaged(int page_index,
                                    int page_offset,
                                    PagedSpace* space,
@@ skipping 62 matching lines @@
         ASSERT(index < large_objects_.length());
       }
       return large_objects_[index];  // s.page_offset() is ignored.
   }
   UNREACHABLE();
   return NULL;
 }
 
 
 } }  // namespace v8::internal