Move a bunch of GC related files to heap/ subdirectory

src/heap/spaces-inl.h

 // Copyright 2011 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_SPACES_INL_H_
-#define V8_SPACES_INL_H_
+#ifndef V8_HEAP_SPACES_INL_H_
+#define V8_HEAP_SPACES_INL_H_
 
+#include "src/heap/spaces.h"
 #include "src/heap-profiler.h"
 #include "src/isolate.h"
-#include "src/spaces.h"
 #include "src/v8memory.h"
 
 namespace v8 {
 namespace internal {
 
 
 // -----------------------------------------------------------------------------
 // Bitmap
 
 void Bitmap::Clear(MemoryChunk* chunk) {
   Bitmap* bitmap = chunk->markbits();
   for (int i = 0; i < bitmap->CellsCount(); i++) bitmap->cells()[i] = 0;
   chunk->ResetLiveBytes();
 }
 
 
 // -----------------------------------------------------------------------------
 // PageIterator
 
 
 PageIterator::PageIterator(PagedSpace* space)
     : space_(space),
       prev_page_(&space->anchor_),
-      next_page_(prev_page_->next_page()) { }
+      next_page_(prev_page_->next_page()) {}
 
 
-bool PageIterator::has_next() {
-  return next_page_ != &space_->anchor_;
-}
+bool PageIterator::has_next() { return next_page_ != &space_->anchor_; }
 
 
 Page* PageIterator::next() {
   DCHECK(has_next());
   prev_page_ = next_page_;
   next_page_ = next_page_->next_page();
   return prev_page_;
 }
 
 
 // -----------------------------------------------------------------------------
 // NewSpacePageIterator
 
 
 NewSpacePageIterator::NewSpacePageIterator(NewSpace* space)
     : prev_page_(NewSpacePage::FromAddress(space->ToSpaceStart())->prev_page()),
       next_page_(NewSpacePage::FromAddress(space->ToSpaceStart())),
-      last_page_(NewSpacePage::FromLimit(space->ToSpaceEnd())) { }
+      last_page_(NewSpacePage::FromLimit(space->ToSpaceEnd())) {}
 
 NewSpacePageIterator::NewSpacePageIterator(SemiSpace* space)
     : prev_page_(space->anchor()),
       next_page_(prev_page_->next_page()),
-      last_page_(prev_page_->prev_page()) { }
+      last_page_(prev_page_->prev_page()) {}
 
 NewSpacePageIterator::NewSpacePageIterator(Address start, Address limit)
     : prev_page_(NewSpacePage::FromAddress(start)->prev_page()),
       next_page_(NewSpacePage::FromAddress(start)),
       last_page_(NewSpacePage::FromLimit(limit)) {
   SemiSpace::AssertValidRange(start, limit);
 }
 
 
-bool NewSpacePageIterator::has_next() {
-  return prev_page_ != last_page_;
-}
+bool NewSpacePageIterator::has_next() { return prev_page_ != last_page_; }
 
 
 NewSpacePage* NewSpacePageIterator::next() {
   DCHECK(has_next());
   prev_page_ = next_page_;
   next_page_ = next_page_->next_page();
   return prev_page_;
 }
 
 
@@ skipping 21 matching lines @@
 // -----------------------------------------------------------------------------
 // MemoryAllocator
 
 #ifdef ENABLE_HEAP_PROTECTION
 
 void MemoryAllocator::Protect(Address start, size_t size) {
   base::OS::Protect(start, size);
 }
 
 
-void MemoryAllocator::Unprotect(Address start,
-                                size_t size,
+void MemoryAllocator::Unprotect(Address start, size_t size,
                                 Executability executable) {
   base::OS::Unprotect(start, size, executable);
 }
 
 
 void MemoryAllocator::ProtectChunkFromPage(Page* page) {
   int id = GetChunkId(page);
   base::OS::Protect(chunks_[id].address(), chunks_[id].size());
 }
 
 
 void MemoryAllocator::UnprotectChunkFromPage(Page* page) {
   int id = GetChunkId(page);
   base::OS::Unprotect(chunks_[id].address(), chunks_[id].size(),
                       chunks_[id].owner()->executable() == EXECUTABLE);
 }
 
 #endif
 
 
 // --------------------------------------------------------------------------
 // PagedSpace
-Page* Page::Initialize(Heap* heap,
-                       MemoryChunk* chunk,
-                       Executability executable,
+Page* Page::Initialize(Heap* heap, MemoryChunk* chunk, Executability executable,
                        PagedSpace* owner) {
   Page* page = reinterpret_cast<Page*>(chunk);
   DCHECK(page->area_size() <= kMaxRegularHeapObjectSize);
   DCHECK(chunk->owner() == owner);
   owner->IncreaseCapacity(page->area_size());
   owner->Free(page->area_start(), page->area_size());
 
   heap->incremental_marking()->SetOldSpacePageFlags(chunk);
 
   return page;
@@ skipping 49 matching lines @@
   if (new_mark > chunk->high_water_mark_) {
     chunk->high_water_mark_ = new_mark;
   }
 }
 
 
 PointerChunkIterator::PointerChunkIterator(Heap* heap)
     : state_(kOldPointerState),
       old_pointer_iterator_(heap->old_pointer_space()),
       map_iterator_(heap->map_space()),
-      lo_iterator_(heap->lo_space()) { }
+      lo_iterator_(heap->lo_space()) {}
 
 
 Page* Page::next_page() {
   DCHECK(next_chunk()->owner() == owner());
   return static_cast<Page*>(next_chunk());
 }
 
 
 Page* Page::prev_page() {
   DCHECK(prev_chunk()->owner() == owner());
@@ skipping 75 matching lines @@
 
 
 intptr_t LargeObjectSpace::Available() {
   return ObjectSizeFor(heap()->isolate()->memory_allocator()->Available());
 }
 
 
 bool FreeListNode::IsFreeListNode(HeapObject* object) {
   Map* map = object->map();
   Heap* heap = object->GetHeap();
-  return map == heap->raw_unchecked_free_space_map()
-      || map == heap->raw_unchecked_one_pointer_filler_map()
-      || map == heap->raw_unchecked_two_pointer_filler_map();
+  return map == heap->raw_unchecked_free_space_map() ||
+         map == heap->raw_unchecked_one_pointer_filler_map() ||
+         map == heap->raw_unchecked_two_pointer_filler_map();
 }
+}
+}  // namespace v8::internal
 
-} }  // namespace v8::internal
-
-#endif  // V8_SPACES_INL_H_
+#endif  // V8_HEAP_SPACES_INL_H_