Move a bunch of GC related files to heap/ subdirectory

src/heap/mark-compact.h

 // 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.
 
-#ifndef V8_MARK_COMPACT_H_
-#define V8_MARK_COMPACT_H_
+#ifndef V8_HEAP_MARK_COMPACT_H_
+#define V8_HEAP_MARK_COMPACT_H_
 
 #include "src/compiler-intrinsics.h"
-#include "src/spaces.h"
+#include "src/heap/spaces.h"
 
 namespace v8 {
 namespace internal {
 
 // Callback function, returns whether an object is alive. The heap size
 // of the object is returned in size. It optionally updates the offset
 // to the first live object in the page (only used for old and map objects).
 typedef bool (*IsAliveFunction)(HeapObject* obj, int* size, int* offset);
 
 // Forward declarations.
 class CodeFlusher;
 class MarkCompactCollector;
 class MarkingVisitor;
 class RootMarkingVisitor;
 
 
 class Marking {
  public:
-  explicit Marking(Heap* heap)
-      : heap_(heap) {
-  }
+  explicit Marking(Heap* heap) : heap_(heap) {}
 
   INLINE(static MarkBit MarkBitFrom(Address addr));
 
   INLINE(static MarkBit MarkBitFrom(HeapObject* obj)) {
     return MarkBitFrom(reinterpret_cast<Address>(obj));
   }
 
   // Impossible markbits: 01
   static const char* kImpossibleBitPattern;
   INLINE(static bool IsImpossible(MarkBit mark_bit)) {
     return !mark_bit.Get() && mark_bit.Next().Get();
   }
 
   // Black markbits: 10 - this is required by the sweeper.
   static const char* kBlackBitPattern;
   INLINE(static bool IsBlack(MarkBit mark_bit)) {
     return mark_bit.Get() && !mark_bit.Next().Get();
   }
 
   // White markbits: 00 - this is required by the mark bit clearer.
   static const char* kWhiteBitPattern;
-  INLINE(static bool IsWhite(MarkBit mark_bit)) {
-    return !mark_bit.Get();
-  }
+  INLINE(static bool IsWhite(MarkBit mark_bit)) { return !mark_bit.Get(); }
 
   // Grey markbits: 11
   static const char* kGreyBitPattern;
   INLINE(static bool IsGrey(MarkBit mark_bit)) {
     return mark_bit.Get() && mark_bit.Next().Get();
   }
 
   INLINE(static void MarkBlack(MarkBit mark_bit)) {
     mark_bit.Set();
     mark_bit.Next().Clear();
   }
 
-  INLINE(static void BlackToGrey(MarkBit markbit)) {
-    markbit.Next().Set();
-  }
+  INLINE(static void BlackToGrey(MarkBit markbit)) { markbit.Next().Set(); }
 
   INLINE(static void WhiteToGrey(MarkBit markbit)) {
     markbit.Set();
     markbit.Next().Set();
   }
 
-  INLINE(static void GreyToBlack(MarkBit markbit)) {
-    markbit.Next().Clear();
-  }
+  INLINE(static void GreyToBlack(MarkBit markbit)) { markbit.Next().Clear(); }
 
   INLINE(static void BlackToGrey(HeapObject* obj)) {
     BlackToGrey(MarkBitFrom(obj));
   }
 
   INLINE(static void AnyToGrey(MarkBit markbit)) {
     markbit.Set();
     markbit.Next().Set();
   }
 
   void TransferMark(Address old_start, Address new_start);
 
 #ifdef DEBUG
   enum ObjectColor {
     BLACK_OBJECT,
     WHITE_OBJECT,
     GREY_OBJECT,
     IMPOSSIBLE_COLOR
   };
 
   static const char* ColorName(ObjectColor color) {
     switch (color) {
-      case BLACK_OBJECT: return "black";
-      case WHITE_OBJECT: return "white";
-      case GREY_OBJECT: return "grey";
-      case IMPOSSIBLE_COLOR: return "impossible";
+      case BLACK_OBJECT:
+        return "black";
+      case WHITE_OBJECT:
+        return "white";
+      case GREY_OBJECT:
+        return "grey";
+      case IMPOSSIBLE_COLOR:
+        return "impossible";
     }
     return "error";
   }
 
   static ObjectColor Color(HeapObject* obj) {
     return Color(Marking::MarkBitFrom(obj));
   }
 
   static ObjectColor Color(MarkBit mark_bit) {
     if (IsBlack(mark_bit)) return BLACK_OBJECT;
     if (IsWhite(mark_bit)) return WHITE_OBJECT;
     if (IsGrey(mark_bit)) return GREY_OBJECT;
     UNREACHABLE();
     return IMPOSSIBLE_COLOR;
   }
 #endif
 
   // Returns true if the transferred color is black.
-  INLINE(static bool TransferColor(HeapObject* from,
-                                   HeapObject* to)) {
+  INLINE(static bool TransferColor(HeapObject* from, HeapObject* to)) {
     MarkBit from_mark_bit = MarkBitFrom(from);
     MarkBit to_mark_bit = MarkBitFrom(to);
     bool is_black = false;
     if (from_mark_bit.Get()) {
       to_mark_bit.Set();
       is_black = true;  // Looks black so far.
     }
     if (from_mark_bit.Next().Get()) {
       to_mark_bit.Next().Set();
       is_black = false;  // Was actually gray.
     }
     return is_black;
   }
 
  private:
   Heap* heap_;
 };
 
 // ----------------------------------------------------------------------------
 // Marking deque for tracing live objects.
 class MarkingDeque {
  public:
   MarkingDeque()
-      : array_(NULL), top_(0), bottom_(0), mask_(0), overflowed_(false) { }
+      : array_(NULL), top_(0), bottom_(0), mask_(0), overflowed_(false) {}
 
   void Initialize(Address low, Address high) {
     HeapObject** obj_low = reinterpret_cast<HeapObject**>(low);
     HeapObject** obj_high = reinterpret_cast<HeapObject**>(high);
     array_ = obj_low;
     mask_ = RoundDownToPowerOf2(static_cast<int>(obj_high - obj_low)) - 1;
     top_ = bottom_ = 0;
     overflowed_ = false;
   }
 
@@ skipping 95 matching lines @@
  public:
   typedef Object** ObjectSlot;
 
   explicit SlotsBuffer(SlotsBuffer* next_buffer)
       : idx_(0), chain_length_(1), next_(next_buffer) {
     if (next_ != NULL) {
       chain_length_ = next_->chain_length_ + 1;
     }
   }
 
-  ~SlotsBuffer() {
-  }
+  ~SlotsBuffer() {}
 
   void Add(ObjectSlot slot) {
     DCHECK(0 <= idx_ && idx_ < kNumberOfElements);
     slots_[idx_++] = slot;
   }
 
   enum SlotType {
     EMBEDDED_OBJECT_SLOT,
     RELOCATED_CODE_OBJECT,
     CODE_TARGET_SLOT,
@@ skipping 28 matching lines @@
   void UpdateSlotsWithFilter(Heap* heap);
 
   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;
-  }
+  inline bool IsFull() { return idx_ == kNumberOfElements; }
 
-  inline bool HasSpaceForTypedSlot() {
-    return idx_ < kNumberOfElements - 1;
-  }
+  inline bool HasSpaceForTypedSlot() { return idx_ < kNumberOfElements - 1; }
 
-  static void UpdateSlotsRecordedIn(Heap* heap,
-                                    SlotsBuffer* buffer,
+  static void UpdateSlotsRecordedIn(Heap* heap, SlotsBuffer* buffer,
                                     bool code_slots_filtering_required) {
     while (buffer != NULL) {
       if (code_slots_filtering_required) {
         buffer->UpdateSlotsWithFilter(heap);
       } else {
         buffer->UpdateSlots(heap);
       }
       buffer = buffer->next();
     }
   }
 
-  enum AdditionMode {
-    FAIL_ON_OVERFLOW,
-    IGNORE_OVERFLOW
-  };
+  enum AdditionMode { FAIL_ON_OVERFLOW, IGNORE_OVERFLOW };
 
   static bool ChainLengthThresholdReached(SlotsBuffer* buffer) {
     return buffer != NULL && buffer->chain_length_ >= kChainLengthThreshold;
   }
 
   INLINE(static bool AddTo(SlotsBufferAllocator* allocator,
-                           SlotsBuffer** buffer_address,
-                           ObjectSlot slot,
+                           SlotsBuffer** buffer_address, ObjectSlot slot,
                            AdditionMode mode)) {
     SlotsBuffer* buffer = *buffer_address;
     if (buffer == NULL || buffer->IsFull()) {
       if (mode == FAIL_ON_OVERFLOW && ChainLengthThresholdReached(buffer)) {
         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,
+                    SlotsBuffer** buffer_address, SlotType type, Address addr,
                     AdditionMode mode);
 
   static const int kNumberOfElements = 1021;
 
  private:
   static const int kChainLengthThreshold = 15;
 
   intptr_t idx_;
   intptr_t chain_length_;
   SlotsBuffer* next_;
@@ skipping 148 matching lines @@
 
   void AddEvacuationCandidate(Page* p);
 
   // Prepares for GC by resetting relocation info in old and map spaces and
   // choosing spaces to compact.
   void Prepare();
 
   // Performs a global garbage collection.
   void CollectGarbage();
 
-  enum CompactionMode {
-    INCREMENTAL_COMPACTION,
-    NON_INCREMENTAL_COMPACTION
-  };
+  enum CompactionMode { INCREMENTAL_COMPACTION, NON_INCREMENTAL_COMPACTION };
 
   bool StartCompaction(CompactionMode mode);
 
   void AbortCompaction();
 
 #ifdef DEBUG
   // Checks whether performing mark-compact collection.
   bool in_use() { return state_ > PREPARE_GC; }
   bool are_map_pointers_encoded() { return state_ == UPDATE_POINTERS; }
 #endif
@@ skipping 16 matching lines @@
   void EnableCodeFlushing(bool enable);
 
   enum SweeperType {
     PARALLEL_CONSERVATIVE,
     CONCURRENT_CONSERVATIVE,
     PARALLEL_PRECISE,
     CONCURRENT_PRECISE,
     PRECISE
   };
 
-  enum SweepingParallelism {
-    SWEEP_ON_MAIN_THREAD,
-    SWEEP_IN_PARALLEL
-  };
+  enum SweepingParallelism { SWEEP_ON_MAIN_THREAD, SWEEP_IN_PARALLEL };
 
 #ifdef VERIFY_HEAP
   void VerifyMarkbitsAreClean();
   static void VerifyMarkbitsAreClean(PagedSpace* space);
   static void VerifyMarkbitsAreClean(NewSpace* space);
   void VerifyWeakEmbeddedObjectsInCode();
   void VerifyOmittedMapChecks();
 #endif
 
   // Sweep a single page from the given space conservatively.
   // Returns the size of the biggest continuous freed memory chunk in bytes.
-  template<SweepingParallelism type>
-  static int SweepConservatively(PagedSpace* space,
-                                      FreeList* free_list,
-                                      Page* p);
+  template <SweepingParallelism type>
+  static int SweepConservatively(PagedSpace* space, FreeList* free_list,
+                                 Page* p);
 
   INLINE(static bool ShouldSkipEvacuationSlotRecording(Object** anchor)) {
-    return Page::FromAddress(reinterpret_cast<Address>(anchor))->
-        ShouldSkipEvacuationSlotRecording();
+    return Page::FromAddress(reinterpret_cast<Address>(anchor))
+        ->ShouldSkipEvacuationSlotRecording();
   }
 
   INLINE(static bool ShouldSkipEvacuationSlotRecording(Object* host)) {
-    return Page::FromAddress(reinterpret_cast<Address>(host))->
-        ShouldSkipEvacuationSlotRecording();
+    return Page::FromAddress(reinterpret_cast<Address>(host))
+        ->ShouldSkipEvacuationSlotRecording();
   }
 
   INLINE(static bool IsOnEvacuationCandidate(Object* obj)) {
-    return Page::FromAddress(reinterpret_cast<Address>(obj))->
-        IsEvacuationCandidate();
+    return Page::FromAddress(reinterpret_cast<Address>(obj))
+        ->IsEvacuationCandidate();
   }
 
   INLINE(void EvictEvacuationCandidate(Page* page)) {
     if (FLAG_trace_fragmentation) {
       PrintF("Page %p is too popular. Disabling evacuation.\n",
              reinterpret_cast<void*>(page));
     }
 
     // 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, Object* target);
   void RecordCodeEntrySlot(Address slot, Code* target);
   void RecordCodeTargetPatch(Address pc, Code* target);
 
-  INLINE(void RecordSlot(Object** anchor_slot,
-                         Object** slot,
-                         Object* object,
-                         SlotsBuffer::AdditionMode mode =
-                             SlotsBuffer::FAIL_ON_OVERFLOW));
+  INLINE(void RecordSlot(
+      Object** anchor_slot, Object** slot, Object* object,
+      SlotsBuffer::AdditionMode mode = SlotsBuffer::FAIL_ON_OVERFLOW));
 
-  void MigrateObject(HeapObject* dst,
-                     HeapObject* src,
-                     int size,
+  void MigrateObject(HeapObject* dst, HeapObject* src, int size,
                      AllocationSpace to_old_space);
 
   bool TryPromoteObject(HeapObject* object, int object_size);
 
   void InvalidateCode(Code* code);
 
   void ClearMarkbits();
 
   bool abort_incremental_marking() const { return abort_incremental_marking_; }
 
@@ skipping 23 matching lines @@
 
   bool AreSweeperThreadsActivated();
 
   // Checks if sweeping is in progress right now on any space.
   bool sweeping_in_progress() { return sweeping_in_progress_; }
 
   void set_sequential_sweeping(bool sequential_sweeping) {
     sequential_sweeping_ = sequential_sweeping;
   }
 
-  bool sequential_sweeping() const {
-    return sequential_sweeping_;
-  }
+  bool sequential_sweeping() const { return sequential_sweeping_; }
 
   // Mark the global table which maps weak objects to dependent code without
   // marking its contents.
   void MarkWeakObjectToCodeTable();
 
   // Special case for processing weak references in a full collection. We need
   // to artificially keep AllocationSites alive for a time.
   void MarkAllocationSite(AllocationSite* site);
 
  private:
@@ skipping 168 matching lines @@
   //          their space's free list. Active eden semispace is compacted by
   //          evacuation.
   //
 
   // If we are not compacting the heap, we simply sweep the spaces except
   // for the large object space, clearing mark bits and adding unmarked
   // regions to each space's free list.
   void SweepSpaces();
 
   int DiscoverAndEvacuateBlackObjectsOnPage(NewSpace* new_space,
-                                           NewSpacePage* p);
+                                            NewSpacePage* p);
 
   void EvacuateNewSpace();
 
   void EvacuateLiveObjectsFromPage(Page* p);
 
   void EvacuatePages();
 
   void EvacuateNewSpaceAndCandidates();
 
   void ReleaseEvacuationCandidates();
@@ skipping 31 matching lines @@
 
   SmartPointer<FreeList> free_list_old_data_space_;
   SmartPointer<FreeList> free_list_old_pointer_space_;
 
   friend class Heap;
 };
 
 
 class MarkBitCellIterator BASE_EMBEDDED {
  public:
-  explicit MarkBitCellIterator(MemoryChunk* chunk)
-      : chunk_(chunk) {
-    last_cell_index_ = Bitmap::IndexToCell(
-        Bitmap::CellAlignIndex(
-            chunk_->AddressToMarkbitIndex(chunk_->area_end())));
+  explicit MarkBitCellIterator(MemoryChunk* chunk) : chunk_(chunk) {
+    last_cell_index_ = Bitmap::IndexToCell(Bitmap::CellAlignIndex(
+        chunk_->AddressToMarkbitIndex(chunk_->area_end())));
     cell_base_ = chunk_->area_start();
     cell_index_ = Bitmap::IndexToCell(
-        Bitmap::CellAlignIndex(
-            chunk_->AddressToMarkbitIndex(cell_base_)));
+        Bitmap::CellAlignIndex(chunk_->AddressToMarkbitIndex(cell_base_)));
     cells_ = chunk_->markbits()->cells();
   }
 
   inline bool Done() { return cell_index_ == last_cell_index_; }
 
   inline bool HasNext() { return cell_index_ < last_cell_index_ - 1; }
 
   inline MarkBit::CellType* CurrentCell() {
     DCHECK(cell_index_ == Bitmap::IndexToCell(Bitmap::CellAlignIndex(
-        chunk_->AddressToMarkbitIndex(cell_base_))));
+                              chunk_->AddressToMarkbitIndex(cell_base_))));
     return &cells_[cell_index_];
   }
 
   inline Address CurrentCellBase() {
     DCHECK(cell_index_ == Bitmap::IndexToCell(Bitmap::CellAlignIndex(
-        chunk_->AddressToMarkbitIndex(cell_base_))));
+                              chunk_->AddressToMarkbitIndex(cell_base_))));
     return cell_base_;
   }
 
   inline void Advance() {
     cell_index_++;
     cell_base_ += 32 * kPointerSize;
   }
 
  private:
   MemoryChunk* chunk_;
   MarkBit::CellType* cells_;
   unsigned int last_cell_index_;
   unsigned int cell_index_;
   Address cell_base_;
 };
 
 
 class SequentialSweepingScope BASE_EMBEDDED {
  public:
-  explicit SequentialSweepingScope(MarkCompactCollector *collector) :
-    collector_(collector) {
+  explicit SequentialSweepingScope(MarkCompactCollector* collector)
+      : collector_(collector) {
     collector_->set_sequential_sweeping(true);
   }
 
-  ~SequentialSweepingScope() {
-    collector_->set_sequential_sweeping(false);
-  }
+  ~SequentialSweepingScope() { collector_->set_sequential_sweeping(false); }
 
  private:
   MarkCompactCollector* collector_;
 };
 
 
 const char* AllocationSpaceName(AllocationSpace space);
+}
+}  // namespace v8::internal
 
-} }  // namespace v8::internal
-
-#endif  // V8_MARK_COMPACT_H_
+#endif  // V8_HEAP_MARK_COMPACT_H_