Support compaction for code space pages.

src/mark-compact.h

 // Copyright 2011 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 277 matching lines @@
   }
 
   ~SlotsBuffer() {
   }
 
   void Add(ObjectSlot slot) {
     ASSERT(0 <= idx_ && idx_ < kNumberOfElements);
     slots_[idx_++] = slot;
   }
 
-  void UpdateSlots();
+  enum SlotType {
+    NONE,
+    RELOCATED_CODE_OBJECT,
+    CODE_TARGET_SLOT,
+    CODE_ENTRY_SLOT,
+    DEBUG_TARGET_SLOT,
+    JS_RETURN_SLOT,
+    NUMBER_OF_SLOT_TYPES
+  };
+
+  SlotType UpdateSlots(Heap* heap, SlotType pending);
 
   SlotsBuffer* next() { return next_; }
 
   static int SizeOfChain(SlotsBuffer* buffer) {
     if (buffer == NULL) return 0;
     return static_cast<int>(buffer->idx_ +
                             (buffer->chain_length_ - 1) * kNumberOfElements);
   }
 
   inline bool IsFull() {
     return idx_ == kNumberOfElements;
   }
 
-  static void UpdateSlotsRecordedIn(SlotsBuffer* buffer) {
+  static void UpdateSlotsRecordedIn(Heap* heap, SlotsBuffer* buffer) {
+    SlotType pending = NONE;
     while (buffer != NULL) {
-      buffer->UpdateSlots();
+      pending = buffer->UpdateSlots(heap, pending);
       buffer = buffer->next();
     }
   }
 
   enum AdditionMode {
     FAIL_ON_OVERFLOW,
     IGNORE_OVERFLOW
   };
 
   static bool AddTo(SlotsBufferAllocator* allocator,
                     SlotsBuffer** buffer_address,
                     ObjectSlot slot,
                     AdditionMode mode) {
     SlotsBuffer* buffer = *buffer_address;
     if (buffer == NULL || buffer->IsFull()) {
       if (mode == FAIL_ON_OVERFLOW &&
           buffer != NULL &&
           buffer->chain_length_ >= kChainLengthThreshold) {
         allocator->DeallocateChain(buffer_address);
         return false;
       }
       buffer = allocator->AllocateBuffer(buffer);
       *buffer_address = buffer;
     }
     buffer->Add(slot);
     return true;
   }
 
+  static bool IsTypedSlot(ObjectSlot slot);
+
+  static bool AddTo(SlotsBufferAllocator* allocator,
+                    SlotsBuffer** buffer_address,
+                    SlotType type,
+                    Address addr,
+                    AdditionMode mode);
+
   static const int kNumberOfElements = 1021;
 
  private:
   static const int kChainLengthThreshold = 6;
 
   intptr_t idx_;
   intptr_t chain_length_;
   SlotsBuffer* next_;
   ObjectSlot slots_[kNumberOfElements];
 };
@@ skipping 95 matching lines @@
 
   // Sweep a single page from the given space conservatively.
   // Return a number of reclaimed bytes.
   static intptr_t SweepConservatively(PagedSpace* space, Page* p);
 
   INLINE(static bool ShouldSkipEvacuationSlotRecording(Object** anchor)) {
     return Page::FromAddress(reinterpret_cast<Address>(anchor))->
         ShouldSkipEvacuationSlotRecording();
   }
 
+  INLINE(static bool ShouldSkipEvacuationSlotRecording(Object* host)) {
+    return Page::FromAddress(reinterpret_cast<Address>(host))->
+        ShouldSkipEvacuationSlotRecording();
+  }
+
   INLINE(static bool IsOnEvacuationCandidate(Object* obj)) {
     return Page::FromAddress(reinterpret_cast<Address>(obj))->
         IsEvacuationCandidate();
   }
 
-  INLINE(void RecordSlot(Object** anchor_slot, Object** slot, Object* object)) {
-    Page* object_page = Page::FromAddress(reinterpret_cast<Address>(object));
-    if (object_page->IsEvacuationCandidate() &&
-        !ShouldSkipEvacuationSlotRecording(anchor_slot)) {
-      if (!SlotsBuffer::AddTo(&slots_buffer_allocator_,
-                              object_page->slots_buffer_address(),
-                              slot,
-                              SlotsBuffer::FAIL_ON_OVERFLOW)) {
-        if (FLAG_trace_fragmentation) {
-          PrintF("Page %p is too popular. Disabling evacuation.\n",
-                 reinterpret_cast<void*>(object_page));
-        }
-        // TODO(gc) If all evacuation candidates are too popular we
-        // should stop slots recording entirely.
-        object_page->ClearEvacuationCandidate();
+  void EvictEvacuationCandidate(Page* page) {
+    if (FLAG_trace_fragmentation) {
+      PrintF("Page %p is too popular. Disabling evacuation.\n",
+             reinterpret_cast<void*>(page));
+    }
 
-        // We were not collecting slots on this page that point
-        // to other evacuation candidates thus we have to
-        // rescan the page after evacuation to discover and update all
-        // pointers to evacuated objects.
-        if (object_page->owner()->identity() == OLD_DATA_SPACE) {
-          evacuation_candidates_.RemoveElement(object_page);
-        } else {
-          object_page->SetFlag(Page::RESCAN_ON_EVACUATION);
-        }
-      }
+    // TODO(gc) If all evacuation candidates are too popular we
+    // should stop slots recording entirely.
+    page->ClearEvacuationCandidate();
+
+    // We were not collecting slots on this page that point
+    // to other evacuation candidates thus we have to
+    // rescan the page after evacuation to discover and update all
+    // pointers to evacuated objects.
+    if (page->owner()->identity() == OLD_DATA_SPACE) {
+      evacuation_candidates_.RemoveElement(page);
+    } else {
+      page->SetFlag(Page::RESCAN_ON_EVACUATION);
     }
   }
 
+  void RecordRelocSlot(RelocInfo* rinfo, Code* target);
+  void RecordCodeEntrySlot(Address slot, Code* target);
+
+  INLINE(void RecordSlot(Object** anchor_slot, Object** slot, Object* object));
+
   void MigrateObject(Address dst,
                      Address src,
                      int size,
                      AllocationSpace to_old_space);
 
   bool TryPromoteObject(HeapObject* object, int object_size);
 
   inline Object* encountered_weak_maps() { return encountered_weak_maps_; }
   inline void set_encountered_weak_maps(Object* weak_map) {
     encountered_weak_maps_ = weak_map;
@@ skipping 216 matching lines @@
 
   List<Page*> evacuation_candidates_;
 
   friend class Heap;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_MARK_COMPACT_H_