Stop "cooking" targets of jumps and calls in code objects. Do not convert ju...

src/mark-compact.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 247 matching lines @@
   void VisitPointers(Object** start, Object** end) {
     // Mark all objects pointed to in [start, end).
     const int kMinRangeForMarkingRecursion = 64;
     if (end - start >= kMinRangeForMarkingRecursion) {
       if (VisitUnmarkedObjects(start, end)) return;
       // We are close to a stack overflow, so just mark the objects.
     }
     for (Object** p = start; p < end; p++) MarkObjectByPointer(p);
   }
 
-  void BeginCodeIteration(Code* code) {
-    // When iterating over a code object during marking
-    // ic targets are derived pointers.
-    ASSERT(code->ic_flag() == Code::IC_TARGET_IS_ADDRESS);
-  }
-
-  void EndCodeIteration(Code* code) {
-    // If this is a compacting collection, set ic targets
-    // are pointing to object headers.
-    if (IsCompacting()) code->set_ic_flag(Code::IC_TARGET_IS_OBJECT);
-  }
-
   void VisitCodeTarget(RelocInfo* rinfo) {
     ASSERT(RelocInfo::IsCodeTarget(rinfo->rmode()));
     Code* code = Code::GetCodeFromTargetAddress(rinfo->target_address());
     if (FLAG_cleanup_ics_at_gc && code->is_inline_cache_stub()) {
       IC::Clear(rinfo->pc());
       // Please note targets for cleared inline cached do not have to be
       // marked since they are contained in Heap::non_monomorphic_cache().
     } else {
       MarkCompactCollector::MarkObject(code);
     }
-    if (IsCompacting()) {
-      // When compacting we convert the target to a real object pointer.
-      code = Code::GetCodeFromTargetAddress(rinfo->target_address());
-      rinfo->set_target_object(code);
-    }
   }
 
   void VisitDebugTarget(RelocInfo* rinfo) {
     ASSERT(RelocInfo::IsJSReturn(rinfo->rmode()) &&
            rinfo->IsCallInstruction());
     HeapObject* code = Code::GetCodeFromTargetAddress(rinfo->call_address());
     MarkCompactCollector::MarkObject(code);
     // When compacting we convert the call to a real object pointer.
     if (IsCompacting()) rinfo->set_call_object(code);
   }
@@ skipping 875 matching lines @@
     Address free_start = NULL;
     HeapObject* object;
 
     for (Address current = p->ObjectAreaStart();
          current < p->AllocationTop();
          current += object->Size()) {
       object = HeapObject::FromAddress(current);
       if (object->IsMarked()) {
         object->ClearMark();
         MarkCompactCollector::tracer()->decrement_marked_count();
-        if (MarkCompactCollector::IsCompacting() && object->IsCode()) {
-          // If this is compacting collection marked code objects have had
-          // their IC targets converted to objects.
-          // They need to be converted back to addresses.
-          Code::cast(object)->ConvertICTargetsFromObjectToAddress();
-        }
         if (!is_previous_alive) {  // Transition from free to live.
           dealloc(free_start, current - free_start);
           is_previous_alive = true;
         }
       } else {
         if (object->IsCode()) {
           // Notify the logger that compiled code has been collected.
           LOG(CodeDeleteEvent(Code::cast(object)->address()));
         }
         if (is_previous_alive) {  // Transition from live to free.
@@ skipping 185 matching lines @@
  public:
   void VisitPointer(Object** p) {
     UpdatePointer(p);
   }
 
   void VisitPointers(Object** start, Object** end) {
     // Mark all HeapObject pointers in [start, end)
     for (Object** p = start; p < end; p++) UpdatePointer(p);
   }
 
+  void VisitCodeTarget(RelocInfo* rinfo) {
+    ASSERT(RelocInfo::IsCodeTarget(rinfo->rmode()));
+    Object* target = Code::GetCodeFromTargetAddress(rinfo->target_address());
+    VisitPointer(&target);
+    rinfo->set_target_address(
+        reinterpret_cast<Code*>(target)->instruction_start());
+  }
+
  private:
   void UpdatePointer(Object** p) {
     if (!(*p)->IsHeapObject()) return;
 
     HeapObject* obj = HeapObject::cast(*p);
     Address old_addr = obj->address();
     Address new_addr;
     ASSERT(!Heap::InFromSpace(obj));
 
     if (Heap::new_space()->Contains(obj)) {
@@ skipping 213 matching lines @@
   USE(live_codes);
   USE(live_cells);
   USE(live_news);
   ASSERT(live_maps == live_map_objects_);
   ASSERT(live_data_olds == live_old_data_objects_);
   ASSERT(live_pointer_olds == live_old_pointer_objects_);
   ASSERT(live_codes == live_code_objects_);
   ASSERT(live_cells == live_cell_objects_);
   ASSERT(live_news == live_young_objects_);
 
-  // Notify code object in LO to convert IC target to address
-  // This must happen after lo_space_->Compact
-  LargeObjectIterator it(Heap::lo_space());
-  while (it.has_next()) { ConvertCodeICTargetToAddress(it.next()); }
-
   // Flip from and to spaces
   Heap::new_space()->Flip();
 
   // Set age_mark to bottom in to space
   Address mark = Heap::new_space()->bottom();
   Heap::new_space()->set_age_mark(mark);
 
   Heap::new_space()->MCCommitRelocationInfo();
 #ifdef DEBUG
   // It is safe to write to the remembered sets as remembered sets on a
   // page-by-page basis after committing the m-c forwarding pointer.
   Page::set_rset_state(Page::IN_USE);
 #endif
   PagedSpaces spaces;
   while (PagedSpace* space = spaces.next()) space->MCCommitRelocationInfo();
 }
 
 
-int MarkCompactCollector::ConvertCodeICTargetToAddress(HeapObject* obj) {
-  if (obj->IsCode()) {
-    Code::cast(obj)->ConvertICTargetsFromObjectToAddress();
-  }
-  return obj->Size();
-}
-
-
 int MarkCompactCollector::RelocateMapObject(HeapObject* obj) {
   // Recover map pointer.
   MapWord encoding = obj->map_word();
   Address map_addr = encoding.DecodeMapAddress(Heap::map_space());
   ASSERT(Heap::map_space()->Contains(HeapObject::FromAddress(map_addr)));
 
   // Get forwarding address before resetting map pointer
   Address new_addr = GetForwardingAddressInOldSpace(obj);
 
   // Reset map pointer.  The meta map object may not be copied yet so
@@ skipping 88 matching lines @@
   MapWord encoding = obj->map_word();
   Address map_addr = encoding.DecodeMapAddress(Heap::map_space());
   ASSERT(Heap::map_space()->Contains(HeapObject::FromAddress(map_addr)));
 
   // Get forwarding address before resetting map pointer
   Address new_addr = GetForwardingAddressInOldSpace(obj);
 
   // Reset the map pointer.
   int obj_size = RestoreMap(obj, Heap::code_space(), new_addr, map_addr);
 
-  // Convert inline cache target to address using old address.
-  if (obj->IsCode()) {
-    Code::cast(obj)->ConvertICTargetsFromObjectToAddress();
-  }
-
   Address old_addr = obj->address();
 
   if (new_addr != old_addr) {
     memmove(new_addr, old_addr, obj_size);  // Copy contents.
   }
 
   HeapObject* copied_to = HeapObject::FromAddress(new_addr);
   if (copied_to->IsCode()) {
     // May also update inline cache target.
     Code::cast(copied_to)->Relocate(new_addr - old_addr);
@@ skipping 45 matching lines @@
 
 void MarkCompactCollector::RebuildRSets() {
 #ifdef DEBUG
   ASSERT(state_ == RELOCATE_OBJECTS);
   state_ = REBUILD_RSETS;
 #endif
   Heap::RebuildRSets();
 }
 
 } }  // namespace v8::internal