Move a bunch of GC related files to heap/ subdirectory

src/heap/spaces.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_H_
-#define V8_SPACES_H_
+#ifndef V8_HEAP_SPACES_H_
+#define V8_HEAP_SPACES_H_
 
 #include "src/allocation.h"
 #include "src/base/atomicops.h"
 #include "src/base/platform/mutex.h"
 #include "src/hashmap.h"
 #include "src/list.h"
 #include "src/log.h"
 #include "src/utils.h"
 
 namespace v8 {
@@ skipping 50 matching lines @@
 // is to enable linear allocation without having to constantly update the byte
 // array every time the top field is updated and a new object is created.  The
 // special garbage section is not in the chain of garbage sections.
 //
 // Since the top and limit fields are in the space, not the page, only one page
 // has a special garbage section, and if the top and limit are equal then there
 // is no special garbage section.
 
 // Some assertion macros used in the debugging mode.
 
-#define DCHECK_PAGE_ALIGNED(address)                                           \
+#define DCHECK_PAGE_ALIGNED(address) \
   DCHECK((OffsetFrom(address) & Page::kPageAlignmentMask) == 0)
 
-#define DCHECK_OBJECT_ALIGNED(address)                                         \
+#define DCHECK_OBJECT_ALIGNED(address) \
   DCHECK((OffsetFrom(address) & kObjectAlignmentMask) == 0)
 
-#define DCHECK_OBJECT_SIZE(size)                                               \
+#define DCHECK_OBJECT_SIZE(size) \
   DCHECK((0 < size) && (size <= Page::kMaxRegularHeapObjectSize))
 
-#define DCHECK_PAGE_OFFSET(offset)                                             \
-  DCHECK((Page::kObjectStartOffset <= offset)                                  \
-      && (offset <= Page::kPageSize))
+#define DCHECK_PAGE_OFFSET(offset) \
+  DCHECK((Page::kObjectStartOffset <= offset) && (offset <= Page::kPageSize))
 
-#define DCHECK_MAP_PAGE_INDEX(index)                                           \
+#define DCHECK_MAP_PAGE_INDEX(index) \
   DCHECK((0 <= index) && (index <= MapSpace::kMaxMapPageIndex))
 
 
 class PagedSpace;
 class MemoryAllocator;
 class AllocationInfo;
 class Space;
 class FreeList;
 class MemoryChunk;
 
 class MarkBit {
  public:
   typedef uint32_t CellType;
 
   inline MarkBit(CellType* cell, CellType mask, bool data_only)
-      : cell_(cell), mask_(mask), data_only_(data_only) { }
+      : cell_(cell), mask_(mask), data_only_(data_only) {}
 
   inline CellType* cell() { return cell_; }
   inline CellType mask() { return mask_; }
 
 #ifdef DEBUG
   bool operator==(const MarkBit& other) {
     return cell_ == other.cell_ && mask_ == other.mask_;
   }
 #endif
 
@@ skipping 25 matching lines @@
 
 // Bitmap is a sequence of cells each containing fixed number of bits.
 class Bitmap {
  public:
   static const uint32_t kBitsPerCell = 32;
   static const uint32_t kBitsPerCellLog2 = 5;
   static const uint32_t kBitIndexMask = kBitsPerCell - 1;
   static const uint32_t kBytesPerCell = kBitsPerCell / kBitsPerByte;
   static const uint32_t kBytesPerCellLog2 = kBitsPerCellLog2 - kBitsPerByteLog2;
 
-  static const size_t kLength =
-    (1 << kPageSizeBits) >> (kPointerSizeLog2);
+  static const size_t kLength = (1 << kPageSizeBits) >> (kPointerSizeLog2);
 
   static const size_t kSize =
-    (1 << kPageSizeBits) >> (kPointerSizeLog2 + kBitsPerByteLog2);
+      (1 << kPageSizeBits) >> (kPointerSizeLog2 + kBitsPerByteLog2);
 
 
   static int CellsForLength(int length) {
     return (length + kBitsPerCell - 1) >> kBitsPerCellLog2;
   }
 
-  int CellsCount() {
-    return CellsForLength(kLength);
-  }
+  int CellsCount() { return CellsForLength(kLength); }
 
   static int SizeFor(int cells_count) {
     return sizeof(MarkBit::CellType) * cells_count;
   }
 
   INLINE(static uint32_t IndexToCell(uint32_t index)) {
     return index >> kBitsPerCellLog2;
   }
 
   INLINE(static uint32_t CellToIndex(uint32_t index)) {
     return index << kBitsPerCellLog2;
   }
 
   INLINE(static uint32_t CellAlignIndex(uint32_t index)) {
     return (index + kBitIndexMask) & ~kBitIndexMask;
   }
 
   INLINE(MarkBit::CellType* cells()) {
     return reinterpret_cast<MarkBit::CellType*>(this);
   }
 
-  INLINE(Address address()) {
-    return reinterpret_cast<Address>(this);
-  }
+  INLINE(Address address()) { return reinterpret_cast<Address>(this); }
 
   INLINE(static Bitmap* FromAddress(Address addr)) {
     return reinterpret_cast<Bitmap*>(addr);
   }
 
   inline MarkBit MarkBitFromIndex(uint32_t index, bool data_only = false) {
     MarkBit::CellType mask = 1 << (index & kBitIndexMask);
     MarkBit::CellType* cell = this->cells() + (index >> kBitsPerCellLog2);
     return MarkBit(cell, mask, data_only);
   }
 
   static inline void Clear(MemoryChunk* chunk);
 
   static void PrintWord(uint32_t word, uint32_t himask = 0) {
     for (uint32_t mask = 1; mask != 0; mask <<= 1) {
       if ((mask & himask) != 0) PrintF("[");
       PrintF((mask & word) ? "1" : "0");
       if ((mask & himask) != 0) PrintF("]");
     }
   }
 
   class CellPrinter {
    public:
-    CellPrinter() : seq_start(0), seq_type(0), seq_length(0) { }
+    CellPrinter() : seq_start(0), seq_type(0), seq_length(0) {}
 
     void Print(uint32_t pos, uint32_t cell) {
       if (cell == seq_type) {
         seq_length++;
         return;
       }
 
       Flush();
 
       if (IsSeq(cell)) {
         seq_start = pos;
         seq_length = 0;
         seq_type = cell;
         return;
       }
 
       PrintF("%d: ", pos);
       PrintWord(cell);
       PrintF("\n");
     }
 
     void Flush() {
       if (seq_length > 0) {
-        PrintF("%d: %dx%d\n",
-               seq_start,
-               seq_type == 0 ? 0 : 1,
+        PrintF("%d: %dx%d\n", seq_start, seq_type == 0 ? 0 : 1,
                seq_length * kBitsPerCell);
         seq_length = 0;
       }
     }
 
     static bool IsSeq(uint32_t cell) { return cell == 0 || cell == 0xFFFFFFFF; }
 
    private:
     uint32_t seq_start;
     uint32_t seq_type;
@@ skipping 27 matching lines @@
 // It is divided into the header and the body. Chunk start is always
 // 1MB aligned. Start of the body is aligned so it can accommodate
 // any heap object.
 class MemoryChunk {
  public:
   // Only works if the pointer is in the first kPageSize of the MemoryChunk.
   static MemoryChunk* FromAddress(Address a) {
     return reinterpret_cast<MemoryChunk*>(OffsetFrom(a) & ~kAlignmentMask);
   }
   static const MemoryChunk* FromAddress(const byte* a) {
-    return reinterpret_cast<const MemoryChunk*>(
-        OffsetFrom(a) & ~kAlignmentMask);
+    return reinterpret_cast<const MemoryChunk*>(OffsetFrom(a) &
+                                                ~kAlignmentMask);
   }
 
   // Only works for addresses in pointer spaces, not data or code spaces.
   static inline MemoryChunk* FromAnyPointerAddress(Heap* heap, Address addr);
 
   Address address() { return reinterpret_cast<Address>(this); }
 
   bool is_valid() { return address() != NULL; }
 
   MemoryChunk* next_chunk() const {
@@ skipping 22 matching lines @@
     }
   }
 
   void set_owner(Space* space) {
     DCHECK((reinterpret_cast<intptr_t>(space) & kPageHeaderTagMask) == 0);
     owner_ = reinterpret_cast<Address>(space) + kPageHeaderTag;
     DCHECK((reinterpret_cast<intptr_t>(owner_) & kPageHeaderTagMask) ==
            kPageHeaderTag);
   }
 
-  base::VirtualMemory* reserved_memory() {
-    return &reservation_;
-  }
+  base::VirtualMemory* reserved_memory() { return &reservation_; }
 
-  void InitializeReservedMemory() {
-    reservation_.Reset();
-  }
+  void InitializeReservedMemory() { reservation_.Reset(); }
 
   void set_reserved_memory(base::VirtualMemory* reservation) {
     DCHECK_NOT_NULL(reservation);
     reservation_.TakeControl(reservation);
   }
 
   bool scan_on_scavenge() { return IsFlagSet(SCAN_ON_SCAVENGE); }
   void initialize_scan_on_scavenge(bool scan) {
     if (scan) {
       SetFlag(SCAN_ON_SCAVENGE);
@@ skipping 54 matching lines @@
     NUM_MEMORY_CHUNK_FLAGS
   };
 
 
   static const int kPointersToHereAreInterestingMask =
       1 << POINTERS_TO_HERE_ARE_INTERESTING;
 
   static const int kPointersFromHereAreInterestingMask =
       1 << POINTERS_FROM_HERE_ARE_INTERESTING;
 
-  static const int kEvacuationCandidateMask =
-      1 << EVACUATION_CANDIDATE;
+  static const int kEvacuationCandidateMask = 1 << EVACUATION_CANDIDATE;
 
   static const int kSkipEvacuationSlotsRecordingMask =
-      (1 << EVACUATION_CANDIDATE) |
-      (1 << RESCAN_ON_EVACUATION) |
-      (1 << IN_FROM_SPACE) |
-      (1 << IN_TO_SPACE);
+      (1 << EVACUATION_CANDIDATE) | (1 << RESCAN_ON_EVACUATION) |
+      (1 << IN_FROM_SPACE) | (1 << IN_TO_SPACE);
 
 
-  void SetFlag(int flag) {
-    flags_ |= static_cast<uintptr_t>(1) << flag;
-  }
+  void SetFlag(int flag) { flags_ |= static_cast<uintptr_t>(1) << flag; }
 
-  void ClearFlag(int flag) {
-    flags_ &= ~(static_cast<uintptr_t>(1) << flag);
-  }
+  void ClearFlag(int flag) { flags_ &= ~(static_cast<uintptr_t>(1) << flag); }
 
   void SetFlagTo(int flag, bool value) {
     if (value) {
       SetFlag(flag);
     } else {
       ClearFlag(flag);
     }
   }
 
   bool IsFlagSet(int flag) {
@@ skipping 27 matching lines @@
   ParallelSweepingState parallel_sweeping() {
     return static_cast<ParallelSweepingState>(
         base::Acquire_Load(&parallel_sweeping_));
   }
 
   void set_parallel_sweeping(ParallelSweepingState state) {
     base::Release_Store(&parallel_sweeping_, state);
   }
 
   bool TryParallelSweeping() {
-    return base::Acquire_CompareAndSwap(
-        &parallel_sweeping_, SWEEPING_PENDING, SWEEPING_IN_PROGRESS) ==
-            SWEEPING_PENDING;
+    return base::Acquire_CompareAndSwap(&parallel_sweeping_, SWEEPING_PENDING,
+                                        SWEEPING_IN_PROGRESS) ==
+           SWEEPING_PENDING;
   }
 
   bool SweepingCompleted() { return parallel_sweeping() <= SWEEPING_FINALIZE; }
 
   // Manage live byte count (count of bytes known to be live,
   // because they are marked black).
   void ResetLiveBytes() {
     if (FLAG_gc_verbose) {
-      PrintF("ResetLiveBytes:%p:%x->0\n",
-             static_cast<void*>(this), live_byte_count_);
+      PrintF("ResetLiveBytes:%p:%x->0\n", static_cast<void*>(this),
+             live_byte_count_);
     }
     live_byte_count_ = 0;
   }
   void IncrementLiveBytes(int by) {
     if (FLAG_gc_verbose) {
-      printf("UpdateLiveBytes:%p:%x%c=%x->%x\n",
-             static_cast<void*>(this), live_byte_count_,
-             ((by < 0) ? '-' : '+'), ((by < 0) ? -by : by),
+      printf("UpdateLiveBytes:%p:%x%c=%x->%x\n", static_cast<void*>(this),
+             live_byte_count_, ((by < 0) ? '-' : '+'), ((by < 0) ? -by : by),
              live_byte_count_ + by);
     }
     live_byte_count_ += by;
     DCHECK_LE(static_cast<unsigned>(live_byte_count_), size_);
   }
   int LiveBytes() {
     DCHECK(static_cast<unsigned>(live_byte_count_) <= size_);
     return live_byte_count_;
   }
 
@@ skipping 36 matching lines @@
   static void IncrementLiveBytesFromMutator(Address address, int by);
 
   static const intptr_t kAlignment =
       (static_cast<uintptr_t>(1) << kPageSizeBits);
 
   static const intptr_t kAlignmentMask = kAlignment - 1;
 
   static const intptr_t kSizeOffset = 0;
 
   static const intptr_t kLiveBytesOffset =
-     kSizeOffset + kPointerSize + kPointerSize + kPointerSize +
-     kPointerSize + kPointerSize +
-     kPointerSize + kPointerSize + kPointerSize + kIntSize;
+      kSizeOffset + kPointerSize + kPointerSize + kPointerSize + kPointerSize +
+      kPointerSize + kPointerSize + kPointerSize + kPointerSize + kIntSize;
 
   static const size_t kSlotsBufferOffset = kLiveBytesOffset + kIntSize;
 
   static const size_t kWriteBarrierCounterOffset =
       kSlotsBufferOffset + kPointerSize + kPointerSize;
 
-  static const size_t kHeaderSize = kWriteBarrierCounterOffset + kPointerSize +
-                                    kIntSize + kIntSize + kPointerSize +
-                                    5 * kPointerSize +
-                                    kPointerSize + kPointerSize;
+  static const size_t kHeaderSize =
+      kWriteBarrierCounterOffset + kPointerSize + kIntSize + kIntSize +
+      kPointerSize + 5 * kPointerSize + kPointerSize + kPointerSize;
 
   static const int kBodyOffset =
       CODE_POINTER_ALIGN(kHeaderSize + Bitmap::kSize);
 
   // The start offset of the object area in a page. Aligned to both maps and
   // code alignment to be suitable for both.  Also aligned to 32 words because
   // the marking bitmap is arranged in 32 bit chunks.
   static const int kObjectStartAlignment = 32 * kPointerSize;
-  static const int kObjectStartOffset = kBodyOffset - 1 +
+  static const int kObjectStartOffset =
+      kBodyOffset - 1 +
       (kObjectStartAlignment - (kBodyOffset - 1) % kObjectStartAlignment);
 
   size_t size() const { return size_; }
 
-  void set_size(size_t size) {
-    size_ = size;
-  }
+  void set_size(size_t size) { size_ = size; }
 
   void SetArea(Address area_start, Address area_end) {
     area_start_ = area_start;
     area_end_ = area_end;
   }
 
   Executability executable() {
     return IsFlagSet(IS_EXECUTABLE) ? EXECUTABLE : NOT_EXECUTABLE;
   }
 
-  bool ContainsOnlyData() {
-    return IsFlagSet(CONTAINS_ONLY_DATA);
-  }
+  bool ContainsOnlyData() { return IsFlagSet(CONTAINS_ONLY_DATA); }
 
   bool InNewSpace() {
     return (flags_ & ((1 << IN_FROM_SPACE) | (1 << IN_TO_SPACE))) != 0;
   }
 
-  bool InToSpace() {
-    return IsFlagSet(IN_TO_SPACE);
-  }
+  bool InToSpace() { return IsFlagSet(IN_TO_SPACE); }
 
-  bool InFromSpace() {
-    return IsFlagSet(IN_FROM_SPACE);
-  }
+  bool InFromSpace() { return IsFlagSet(IN_FROM_SPACE); }
 
   // ---------------------------------------------------------------------
   // Markbits support
 
   inline Bitmap* markbits() {
     return Bitmap::FromAddress(address() + kHeaderSize);
   }
 
   void PrintMarkbits() { markbits()->Print(); }
 
   inline uint32_t AddressToMarkbitIndex(Address addr) {
     return static_cast<uint32_t>(addr - this->address()) >> kPointerSizeLog2;
   }
 
   inline static uint32_t FastAddressToMarkbitIndex(Address addr) {
-    const intptr_t offset =
-        reinterpret_cast<intptr_t>(addr) & kAlignmentMask;
+    const intptr_t offset = reinterpret_cast<intptr_t>(addr) & kAlignmentMask;
 
     return static_cast<uint32_t>(offset) >> kPointerSizeLog2;
   }
 
   inline Address MarkbitIndexToAddress(uint32_t index) {
     return this->address() + (index << kPointerSizeLog2);
   }
 
   void InsertAfter(MemoryChunk* other);
   void Unlink();
 
   inline Heap* heap() const { return heap_; }
 
   static const int kFlagsOffset = kPointerSize;
 
   bool IsEvacuationCandidate() { return IsFlagSet(EVACUATION_CANDIDATE); }
 
   bool ShouldSkipEvacuationSlotRecording() {
     return (flags_ & kSkipEvacuationSlotsRecordingMask) != 0;
   }
 
-  inline SkipList* skip_list() {
-    return skip_list_;
-  }
+  inline SkipList* skip_list() { return skip_list_; }
 
-  inline void set_skip_list(SkipList* skip_list) {
-    skip_list_ = skip_list;
-  }
+  inline void set_skip_list(SkipList* skip_list) { skip_list_ = skip_list; }
 
-  inline SlotsBuffer* slots_buffer() {
-    return slots_buffer_;
-  }
+  inline SlotsBuffer* slots_buffer() { return slots_buffer_; }
 
-  inline SlotsBuffer** slots_buffer_address() {
-    return &slots_buffer_;
-  }
+  inline SlotsBuffer** slots_buffer_address() { return &slots_buffer_; }
 
   void MarkEvacuationCandidate() {
     DCHECK(slots_buffer_ == NULL);
     SetFlag(EVACUATION_CANDIDATE);
   }
 
   void ClearEvacuationCandidate() {
     DCHECK(slots_buffer_ == NULL);
     ClearFlag(EVACUATION_CANDIDATE);
   }
 
   Address area_start() { return area_start_; }
   Address area_end() { return area_end_; }
-  int area_size() {
-    return static_cast<int>(area_end() - area_start());
-  }
+  int area_size() { return static_cast<int>(area_end() - area_start()); }
   bool CommitArea(size_t requested);
 
   // Approximate amount of physical memory committed for this chunk.
-  size_t CommittedPhysicalMemory() {
-    return high_water_mark_;
-  }
+  size_t CommittedPhysicalMemory() { return high_water_mark_; }
 
   static inline void UpdateHighWaterMark(Address mark);
 
  protected:
   size_t size_;
   intptr_t flags_;
 
   // Start and end of allocatable memory on this chunk.
   Address area_start_;
   Address area_end_;
@@ skipping 22 matching lines @@
 
   base::AtomicWord parallel_sweeping_;
 
   // PagedSpace free-list statistics.
   intptr_t available_in_small_free_list_;
   intptr_t available_in_medium_free_list_;
   intptr_t available_in_large_free_list_;
   intptr_t available_in_huge_free_list_;
   intptr_t non_available_small_blocks_;
 
-  static MemoryChunk* Initialize(Heap* heap,
-                                 Address base,
-                                 size_t size,
-                                 Address area_start,
-                                 Address area_end,
-                                 Executability executable,
-                                 Space* owner);
+  static MemoryChunk* Initialize(Heap* heap, Address base, size_t size,
+                                 Address area_start, Address area_end,
+                                 Executability executable, Space* owner);
 
  private:
   // next_chunk_ holds a pointer of type MemoryChunk
   base::AtomicWord next_chunk_;
   // prev_chunk_ holds a pointer of type MemoryChunk
   base::AtomicWord prev_chunk_;
 
   friend class MemoryAllocator;
 };
 
@@ skipping 58 matching lines @@
   // are allocated in large object space and are never moved in memory. This
   // also applies to new space allocation, since objects are never migrated
   // from new space to large object space.  Takes double alignment into account.
   static const int kMaxRegularHeapObjectSize = kPageSize - kObjectStartOffset;
 
   // Page size mask.
   static const intptr_t kPageAlignmentMask = (1 << kPageSizeBits) - 1;
 
   inline void ClearGCFields();
 
-  static inline Page* Initialize(Heap* heap,
-                                 MemoryChunk* chunk,
-                                 Executability executable,
-                                 PagedSpace* owner);
+  static inline Page* Initialize(Heap* heap, MemoryChunk* chunk,
+                                 Executability executable, PagedSpace* owner);
 
   void InitializeAsAnchor(PagedSpace* owner);
 
   bool WasSweptPrecisely() { return IsFlagSet(WAS_SWEPT_PRECISELY); }
   bool WasSweptConservatively() { return IsFlagSet(WAS_SWEPT_CONSERVATIVELY); }
   bool WasSwept() { return WasSweptPrecisely() || WasSweptConservatively(); }
 
   void MarkSweptPrecisely() { SetFlag(WAS_SWEPT_PRECISELY); }
   void MarkSweptConservatively() { SetFlag(WAS_SWEPT_CONSERVATIVELY); }
 
@@ skipping 21 matching lines @@
 
   friend class MemoryAllocator;
 };
 
 
 STATIC_ASSERT(sizeof(Page) <= MemoryChunk::kHeaderSize);
 
 
 class LargePage : public MemoryChunk {
  public:
-  HeapObject* GetObject() {
-    return HeapObject::FromAddress(area_start());
-  }
+  HeapObject* GetObject() { return HeapObject::FromAddress(area_start()); }
 
   inline LargePage* next_page() const {
     return static_cast<LargePage*>(next_chunk());
   }
 
-  inline void set_next_page(LargePage* page) {
-    set_next_chunk(page);
-  }
+  inline void set_next_page(LargePage* page) { set_next_chunk(page); }
+
  private:
   static inline LargePage* Initialize(Heap* heap, MemoryChunk* chunk);
 
   friend class MemoryAllocator;
 };
 
 STATIC_ASSERT(sizeof(LargePage) <= MemoryChunk::kHeaderSize);
 
 // ----------------------------------------------------------------------------
 // Space is the abstract superclass for all allocation spaces.
@@ skipping 120 matching lines @@
   // Compares the start addresses of two free blocks.
   static int CompareFreeBlockAddress(const FreeBlock* left,
                                      const FreeBlock* right);
 
   DISALLOW_COPY_AND_ASSIGN(CodeRange);
 };
 
 
 class SkipList {
  public:
-  SkipList() {
-    Clear();
-  }
+  SkipList() { Clear(); }
 
   void Clear() {
     for (int idx = 0; idx < kSize; idx++) {
       starts_[idx] = reinterpret_cast<Address>(-1);
     }
   }
 
-  Address StartFor(Address addr) {
-    return starts_[RegionNumber(addr)];
-  }
+  Address StartFor(Address addr) { return starts_[RegionNumber(addr)]; }
 
   void AddObject(Address addr, int size) {
     int start_region = RegionNumber(addr);
     int end_region = RegionNumber(addr + size - kPointerSize);
     for (int idx = start_region; idx <= end_region; idx++) {
       if (starts_[idx] > addr) starts_[idx] = addr;
     }
   }
 
   static inline int RegionNumber(Address addr) {
@@ skipping 32 matching lines @@
 class MemoryAllocator {
  public:
   explicit MemoryAllocator(Isolate* isolate);
 
   // Initializes its internal bookkeeping structures.
   // Max capacity of the total space and executable memory limit.
   bool SetUp(intptr_t max_capacity, intptr_t capacity_executable);
 
   void TearDown();
 
-  Page* AllocatePage(
-      intptr_t size, PagedSpace* owner, Executability executable);
+  Page* AllocatePage(intptr_t size, PagedSpace* owner,
+                     Executability executable);
 
-  LargePage* AllocateLargePage(
-      intptr_t object_size, Space* owner, Executability executable);
+  LargePage* AllocateLargePage(intptr_t object_size, Space* owner,
+                               Executability executable);
 
   void Free(MemoryChunk* chunk);
 
   // Returns the maximum available bytes of heaps.
   intptr_t Available() { return capacity_ < size_ ? 0 : capacity_ - size_; }
 
   // Returns allocated spaces in bytes.
   intptr_t Size() { return size_; }
 
   // Returns the maximum available executable bytes of heaps.
   intptr_t AvailableExecutable() {
     if (capacity_executable_ < size_executable_) return 0;
     return capacity_executable_ - size_executable_;
   }
 
   // Returns allocated executable spaces in bytes.
   intptr_t SizeExecutable() { return size_executable_; }
 
   // Returns maximum available bytes that the old space can have.
   intptr_t MaxAvailable() {
     return (Available() / Page::kPageSize) * Page::kMaxRegularHeapObjectSize;
   }
 
   // Returns an indication of whether a pointer is in a space that has
   // been allocated by this MemoryAllocator.
   V8_INLINE bool IsOutsideAllocatedSpace(const void* address) const {
     return address < lowest_ever_allocated_ ||
-        address >= highest_ever_allocated_;
+           address >= highest_ever_allocated_;
   }
 
 #ifdef DEBUG
   // Reports statistic info of the space.
   void ReportStatistics();
 #endif
 
   // Returns a MemoryChunk in which the memory region from commit_area_size to
   // reserve_area_size of the chunk area is reserved but not committed, it
   // could be committed later by calling MemoryChunk::CommitArea.
   MemoryChunk* AllocateChunk(intptr_t reserve_area_size,
                              intptr_t commit_area_size,
-                             Executability executable,
-                             Space* space);
+                             Executability executable, Space* space);
 
-  Address ReserveAlignedMemory(size_t requested,
-                               size_t alignment,
+  Address ReserveAlignedMemory(size_t requested, size_t alignment,
                                base::VirtualMemory* controller);
-  Address AllocateAlignedMemory(size_t reserve_size,
-                                size_t commit_size,
-                                size_t alignment,
-                                Executability executable,
+  Address AllocateAlignedMemory(size_t reserve_size, size_t commit_size,
+                                size_t alignment, Executability executable,
                                 base::VirtualMemory* controller);
 
   bool CommitMemory(Address addr, size_t size, Executability executable);
 
   void FreeMemory(base::VirtualMemory* reservation, Executability executable);
   void FreeMemory(Address addr, size_t size, Executability executable);
 
   // Commit a contiguous block of memory from the initial chunk.  Assumes that
   // the address is not NULL, the size is greater than zero, and that the
   // block is contained in the initial chunk.  Returns true if it succeeded
   // and false otherwise.
   bool CommitBlock(Address start, size_t size, Executability executable);
 
   // Uncommit a contiguous block of memory [start..(start+size)[.
   // start is not NULL, the size is greater than zero, and the
   // block is contained in the initial chunk.  Returns true if it succeeded
   // and false otherwise.
   bool UncommitBlock(Address start, size_t size);
 
   // Zaps a contiguous block of memory [start..(start+size)[ thus
   // filling it up with a recognizable non-NULL bit pattern.
   void ZapBlock(Address start, size_t size);
 
-  void PerformAllocationCallback(ObjectSpace space,
-                                 AllocationAction action,
+  void PerformAllocationCallback(ObjectSpace space, AllocationAction action,
                                  size_t size);
 
   void AddMemoryAllocationCallback(MemoryAllocationCallback callback,
-                                          ObjectSpace space,
-                                          AllocationAction action);
+                                   ObjectSpace space, AllocationAction action);
 
-  void RemoveMemoryAllocationCallback(
-      MemoryAllocationCallback callback);
+  void RemoveMemoryAllocationCallback(MemoryAllocationCallback callback);
 
-  bool MemoryAllocationCallbackRegistered(
-      MemoryAllocationCallback callback);
+  bool MemoryAllocationCallbackRegistered(MemoryAllocationCallback callback);
 
   static int CodePageGuardStartOffset();
 
   static int CodePageGuardSize();
 
   static int CodePageAreaStartOffset();
 
   static int CodePageAreaEndOffset();
 
   static int CodePageAreaSize() {
     return CodePageAreaEndOffset() - CodePageAreaStartOffset();
   }
 
   MUST_USE_RESULT bool CommitExecutableMemory(base::VirtualMemory* vm,
-                                              Address start,
-                                              size_t commit_size,
+                                              Address start, size_t commit_size,
                                               size_t reserved_size);
 
  private:
   Isolate* isolate_;
 
   // Maximum space size in bytes.
   size_t capacity_;
   // Maximum subset of capacity_ that can be executable
   size_t capacity_executable_;
 
   // Allocated space size in bytes.
   size_t size_;
   // Allocated executable space size in bytes.
   size_t size_executable_;
 
   // We keep the lowest and highest addresses allocated as a quick way
   // of determining that pointers are outside the heap. The estimate is
   // conservative, i.e. not all addrsses in 'allocated' space are allocated
   // to our heap. The range is [lowest, highest[, inclusive on the low end
   // and exclusive on the high end.
   void* lowest_ever_allocated_;
   void* highest_ever_allocated_;
 
   struct MemoryAllocationCallbackRegistration {
     MemoryAllocationCallbackRegistration(MemoryAllocationCallback callback,
                                          ObjectSpace space,
                                          AllocationAction action)
-        : callback(callback), space(space), action(action) {
-    }
+        : callback(callback), space(space), action(action) {}
     MemoryAllocationCallback callback;
     ObjectSpace space;
     AllocationAction action;
   };
 
   // A List of callback that are triggered when memory is allocated or free'd
-  List<MemoryAllocationCallbackRegistration>
-      memory_allocation_callbacks_;
+  List<MemoryAllocationCallbackRegistration> memory_allocation_callbacks_;
 
   // Initializes pages in a chunk. Returns the first page address.
   // This function and GetChunkId() are provided for the mark-compact
   // collector to rebuild page headers in the from space, which is
   // used as a marking stack and its page headers are destroyed.
   Page* InitializePagesInChunk(int chunk_id, int pages_in_chunk,
                                PagedSpace* owner);
 
   void UpdateAllocatedSpaceLimits(void* low, void* high) {
     lowest_ever_allocated_ = Min(lowest_ever_allocated_, low);
     highest_ever_allocated_ = Max(highest_ever_allocated_, high);
   }
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(MemoryAllocator);
 };
 
 
 // -----------------------------------------------------------------------------
 // Interface for heap object iterator to be implemented by all object space
 // object iterators.
 //
 // NOTE: The space specific object iterators also implements the own next()
 //       method which is used to avoid using virtual functions
 //       iterating a specific space.
 
 class ObjectIterator : public Malloced {
  public:
-  virtual ~ObjectIterator() { }
+  virtual ~ObjectIterator() {}
 
   virtual HeapObject* next_object() = 0;
 };
 
 
 // -----------------------------------------------------------------------------
 // Heap object iterator in new/old/map spaces.
 //
 // A HeapObjectIterator iterates objects from the bottom of the given space
 // to its top or from the bottom of the given page to its top.
 //
 // If objects are allocated in the page during iteration the iterator may
 // or may not iterate over those objects.  The caller must create a new
 // iterator in order to be sure to visit these new objects.
-class HeapObjectIterator: public ObjectIterator {
+class HeapObjectIterator : public ObjectIterator {
  public:
   // Creates a new object iterator in a given space.
   // If the size function is not given, the iterator calls the default
   // Object::Size().
   explicit HeapObjectIterator(PagedSpace* space);
   HeapObjectIterator(PagedSpace* space, HeapObjectCallback size_func);
   HeapObjectIterator(Page* page, HeapObjectCallback size_func);
 
   // Advance to the next object, skipping free spaces and other fillers and
   // skipping the special garbage section of which there is one per space.
   // Returns NULL when the iteration has ended.
   inline HeapObject* Next() {
     do {
       HeapObject* next_obj = FromCurrentPage();
       if (next_obj != NULL) return next_obj;
     } while (AdvanceToNextPage());
     return NULL;
   }
 
-  virtual HeapObject* next_object() {
-    return Next();
-  }
+  virtual HeapObject* next_object() { return Next(); }
 
  private:
   enum PageMode { kOnePageOnly, kAllPagesInSpace };
 
-  Address cur_addr_;  // Current iteration point.
-  Address cur_end_;   // End iteration point.
+  Address cur_addr_;              // Current iteration point.
+  Address cur_end_;               // End iteration point.
   HeapObjectCallback size_func_;  // Size function or NULL.
   PagedSpace* space_;
   PageMode page_mode_;
 
   // Fast (inlined) path of next().
   inline HeapObject* FromCurrentPage();
 
   // Slow path of next(), goes into the next page.  Returns false if the
   // iteration has ended.
   bool AdvanceToNextPage();
 
   // Initializes fields.
-  inline void Initialize(PagedSpace* owner,
-                         Address start,
-                         Address end,
-                         PageMode mode,
-                         HeapObjectCallback size_func);
+  inline void Initialize(PagedSpace* owner, Address start, Address end,
+                         PageMode mode, HeapObjectCallback size_func);
 };
 
 
 // -----------------------------------------------------------------------------
 // A PageIterator iterates the pages in a paged space.
 
 class PageIterator BASE_EMBEDDED {
  public:
   explicit inline PageIterator(PagedSpace* space);
 
@@ skipping 10 matching lines @@
 
 
 // -----------------------------------------------------------------------------
 // A space has a circular list of pages. The next page can be accessed via
 // Page::next_page() call.
 
 // An abstraction of allocation and relocation pointers in a page-structured
 // space.
 class AllocationInfo {
  public:
-  AllocationInfo() : top_(NULL), limit_(NULL) {
-  }
+  AllocationInfo() : top_(NULL), limit_(NULL) {}
 
   INLINE(void set_top(Address top)) {
     SLOW_DCHECK(top == NULL ||
-        (reinterpret_cast<intptr_t>(top) & HeapObjectTagMask()) == 0);
+                (reinterpret_cast<intptr_t>(top) & HeapObjectTagMask()) == 0);
     top_ = top;
   }
 
   INLINE(Address top()) const {
     SLOW_DCHECK(top_ == NULL ||
-        (reinterpret_cast<intptr_t>(top_) & HeapObjectTagMask()) == 0);
+                (reinterpret_cast<intptr_t>(top_) & HeapObjectTagMask()) == 0);
     return top_;
   }
 
-  Address* top_address() {
-    return &top_;
-  }
+  Address* top_address() { return &top_; }
 
   INLINE(void set_limit(Address limit)) {
     SLOW_DCHECK(limit == NULL ||
-        (reinterpret_cast<intptr_t>(limit) & HeapObjectTagMask()) == 0);
+                (reinterpret_cast<intptr_t>(limit) & HeapObjectTagMask()) == 0);
     limit_ = limit;
   }
 
   INLINE(Address limit()) const {
     SLOW_DCHECK(limit_ == NULL ||
-        (reinterpret_cast<intptr_t>(limit_) & HeapObjectTagMask()) == 0);
+                (reinterpret_cast<intptr_t>(limit_) & HeapObjectTagMask()) ==
+                    0);
     return limit_;
   }
 
-  Address* limit_address() {
-    return &limit_;
-  }
+  Address* limit_address() { return &limit_; }
 
 #ifdef DEBUG
   bool VerifyPagedAllocation() {
-    return (Page::FromAllocationTop(top_) == Page::FromAllocationTop(limit_))
-        && (top_ <= limit_);
+    return (Page::FromAllocationTop(top_) == Page::FromAllocationTop(limit_)) &&
+           (top_ <= limit_);
   }
 #endif
 
  private:
   // Current allocation top.
   Address top_;
   // Current allocation limit.
   Address limit_;
 };
 
@@ skipping 89 matching lines @@
 };
 
 
 // -----------------------------------------------------------------------------
 // Free lists for old object spaces
 //
 // Free-list nodes are free blocks in the heap.  They look like heap objects
 // (free-list node pointers have the heap object tag, and they have a map like
 // a heap object).  They have a size and a next pointer.  The next pointer is
 // the raw address of the next free list node (or NULL).
-class FreeListNode: public HeapObject {
+class FreeListNode : public HeapObject {
  public:
   // Obtain a free-list node from a raw address.  This is not a cast because
   // it does not check nor require that the first word at the address is a map
   // pointer.
   static FreeListNode* FromAddress(Address address) {
     return reinterpret_cast<FreeListNode*>(HeapObject::FromAddress(address));
   }
 
   static inline bool IsFreeListNode(HeapObject* object);
 
@@ skipping 18 matching lines @@
   static const int kNextOffset = POINTER_SIZE_ALIGN(FreeSpace::kHeaderSize);
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(FreeListNode);
 };
 
 
 // The free list category holds a pointer to the top element and a pointer to
 // the end element of the linked list of free memory blocks.
 class FreeListCategory {
  public:
-  FreeListCategory() :
-      top_(0),
-      end_(NULL),
-      available_(0) {}
+  FreeListCategory() : top_(0), end_(NULL), available_(0) {}
 
   intptr_t Concatenate(FreeListCategory* category);
 
   void Reset();
 
   void Free(FreeListNode* node, int size_in_bytes);
 
-  FreeListNode* PickNodeFromList(int *node_size);
-  FreeListNode* PickNodeFromList(int size_in_bytes, int *node_size);
+  FreeListNode* PickNodeFromList(int* node_size);
+  FreeListNode* PickNodeFromList(int size_in_bytes, int* node_size);
 
   intptr_t EvictFreeListItemsInList(Page* p);
   bool ContainsPageFreeListItemsInList(Page* p);
 
   void RepairFreeList(Heap* heap);
 
   FreeListNode* top() const {
     return reinterpret_cast<FreeListNode*>(base::NoBarrier_Load(&top_));
   }
 
   void set_top(FreeListNode* top) {
     base::NoBarrier_Store(&top_, reinterpret_cast<base::AtomicWord>(top));
   }
 
   FreeListNode** GetEndAddress() { return &end_; }
   FreeListNode* end() const { return end_; }
   void set_end(FreeListNode* end) { end_ = end; }
 
   int* GetAvailableAddress() { return &available_; }
   int available() const { return available_; }
   void set_available(int available) { available_ = available; }
 
   base::Mutex* mutex() { return &mutex_; }
 
-  bool IsEmpty() {
-    return top() == 0;
-  }
+  bool IsEmpty() { return top() == 0; }
 
 #ifdef DEBUG
   intptr_t SumFreeList();
   int FreeListLength();
 #endif
 
  private:
   // top_ points to the top FreeListNode* in the free list category.
   base::AtomicWord top_;
   FreeListNode* end_;
@@ skipping 115 matching lines @@
   FreeListCategory large_list_;
   FreeListCategory huge_list_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(FreeList);
 };
 
 
 class AllocationResult {
  public:
   // Implicit constructor from Object*.
-  AllocationResult(Object* object) : object_(object),  // NOLINT
-                                     retry_space_(INVALID_SPACE) { }
+  explicit AllocationResult(Object* object)
+      : object_(object),  // NOLINT
+        retry_space_(INVALID_SPACE) {}
 
-  AllocationResult() : object_(NULL),
-                       retry_space_(INVALID_SPACE) { }
+  AllocationResult() : object_(NULL), retry_space_(INVALID_SPACE) {}
 
   static inline AllocationResult Retry(AllocationSpace space = NEW_SPACE) {
     return AllocationResult(space);
   }
 
   inline bool IsRetry() { return retry_space_ != INVALID_SPACE; }
 
   template <typename T>
   bool To(T** obj) {
     if (IsRetry()) return false;
     *obj = T::cast(object_);
     return true;
   }
 
   Object* ToObjectChecked() {
     CHECK(!IsRetry());
     return object_;
   }
 
   AllocationSpace RetrySpace() {
     DCHECK(IsRetry());
     return retry_space_;
   }
 
  private:
-  explicit AllocationResult(AllocationSpace space) : object_(NULL),
-                                                     retry_space_(space) { }
+  explicit AllocationResult(AllocationSpace space)
+      : object_(NULL), retry_space_(space) {}
 
   Object* object_;
   AllocationSpace retry_space_;
 };
 
 
 class PagedSpace : public Space {
  public:
   // Creates a space with a maximum capacity, and an id.
-  PagedSpace(Heap* heap,
-             intptr_t max_capacity,
-             AllocationSpace id,
+  PagedSpace(Heap* heap, intptr_t max_capacity, AllocationSpace id,
              Executability executable);
 
   virtual ~PagedSpace() {}
 
   // Set up the space using the given address range of virtual memory (from
   // the memory allocator's initial chunk) if possible.  If the block of
   // addresses is not big enough to contain a single page-aligned page, a
   // fresh chunk will be allocated.
   bool SetUp();
 
@@ skipping 83 matching lines @@
   // Wasted bytes in this space.  These are just the bytes that were thrown away
   // due to being too small to use for allocation.  They do not include the
   // free bytes that were not found at all due to lazy sweeping.
   virtual intptr_t Waste() { return accounting_stats_.Waste(); }
 
   // Returns the allocation pointer in this space.
   Address top() { return allocation_info_.top(); }
   Address limit() { return allocation_info_.limit(); }
 
   // The allocation top address.
-  Address* allocation_top_address() {
-    return allocation_info_.top_address();
-  }
+  Address* allocation_top_address() { return allocation_info_.top_address(); }
 
   // The allocation limit address.
   Address* allocation_limit_address() {
     return allocation_info_.limit_address();
   }
 
   // Allocate the requested number of bytes in the space if possible, return a
   // failure object if not.
   MUST_USE_RESULT inline AllocationResult AllocateRaw(int size_in_bytes);
 
   // Give a block of memory to the space's free list.  It might be added to
   // the free list or accounted as waste.
   // If add_to_freelist is false then just accounting stats are updated and
   // no attempt to add area to free list is made.
   int Free(Address start, int size_in_bytes) {
     int wasted = free_list_.Free(start, size_in_bytes);
     accounting_stats_.DeallocateBytes(size_in_bytes);
     accounting_stats_.WasteBytes(wasted);
     return size_in_bytes - wasted;
   }
 
-  void ResetFreeList() {
-    free_list_.Reset();
-  }
+  void ResetFreeList() { free_list_.Reset(); }
 
   // Set space allocation info.
   void SetTopAndLimit(Address top, Address limit) {
     DCHECK(top == limit ||
            Page::FromAddress(top) == Page::FromAddress(limit - 1));
     MemoryChunk::UpdateHighWaterMark(allocation_info_.top());
     allocation_info_.set_top(top);
     allocation_info_.set_limit(limit);
   }
 
   // Empty space allocation info, returning unused area to free list.
   void EmptyAllocationInfo() {
     // Mark the old linear allocation area with a free space map so it can be
     // skipped when scanning the heap.
     int old_linear_size = static_cast<int>(limit() - top());
     Free(top(), old_linear_size);
     SetTopAndLimit(NULL, NULL);
   }
 
-  void Allocate(int bytes) {
-    accounting_stats_.AllocateBytes(bytes);
-  }
+  void Allocate(int bytes) { accounting_stats_.AllocateBytes(bytes); }
 
   void IncreaseCapacity(int size);
 
   // Releases an unused page and shrinks the space.
   void ReleasePage(Page* page);
 
   // The dummy page that anchors the linked list of pages.
   Page* anchor() { return &anchor_; }
 
 #ifdef VERIFY_HEAP
@@ skipping 18 matching lines @@
   static void ResetCodeStatistics(Isolate* isolate);
 #endif
 
   bool swept_precisely() { return swept_precisely_; }
   void set_swept_precisely(bool b) { swept_precisely_ = b; }
 
   // Evacuation candidates are swept by evacuator.  Needs to return a valid
   // result before _and_ after evacuation has finished.
   static bool ShouldBeSweptBySweeperThreads(Page* p) {
     return !p->IsEvacuationCandidate() &&
-           !p->IsFlagSet(Page::RESCAN_ON_EVACUATION) &&
-           !p->WasSweptPrecisely();
+           !p->IsFlagSet(Page::RESCAN_ON_EVACUATION) && !p->WasSweptPrecisely();
   }
 
-  void IncrementUnsweptFreeBytes(intptr_t by) {
-    unswept_free_bytes_ += by;
-  }
+  void IncrementUnsweptFreeBytes(intptr_t by) { unswept_free_bytes_ += by; }
 
   void IncreaseUnsweptFreeBytes(Page* p) {
     DCHECK(ShouldBeSweptBySweeperThreads(p));
     unswept_free_bytes_ += (p->area_size() - p->LiveBytes());
   }
 
-  void DecrementUnsweptFreeBytes(intptr_t by) {
-    unswept_free_bytes_ -= by;
-  }
+  void DecrementUnsweptFreeBytes(intptr_t by) { unswept_free_bytes_ -= by; }
 
   void DecreaseUnsweptFreeBytes(Page* p) {
     DCHECK(ShouldBeSweptBySweeperThreads(p));
     unswept_free_bytes_ -= (p->area_size() - p->LiveBytes());
   }
 
-  void ResetUnsweptFreeBytes() {
-    unswept_free_bytes_ = 0;
-  }
+  void ResetUnsweptFreeBytes() { unswept_free_bytes_ = 0; }
 
   // This function tries to steal size_in_bytes memory from the sweeper threads
   // free-lists. If it does not succeed stealing enough memory, it will wait
   // for the sweeper threads to finish sweeping.
   // It returns true when sweeping is completed and false otherwise.
   bool EnsureSweeperProgress(intptr_t size_in_bytes);
 
-  void set_end_of_unswept_pages(Page* page) {
-    end_of_unswept_pages_ = page;
-  }
+  void set_end_of_unswept_pages(Page* page) { end_of_unswept_pages_ = page; }
 
-  Page* end_of_unswept_pages() {
-    return end_of_unswept_pages_;
-  }
+  Page* end_of_unswept_pages() { return end_of_unswept_pages_; }
 
   Page* FirstPage() { return anchor_.next_page(); }
   Page* LastPage() { return anchor_.prev_page(); }
 
   void EvictEvacuationCandidatesFromFreeLists();
 
   bool CanExpand();
 
   // Returns the number of total pages in this space.
   int CountTotalPages();
 
   // Return size of allocatable area on a page in this space.
-  inline int AreaSize() {
-    return area_size_;
-  }
+  inline int AreaSize() { return area_size_; }
 
   void CreateEmergencyMemory();
   void FreeEmergencyMemory();
   void UseEmergencyMemory();
 
   bool HasEmergencyMemory() { return emergency_memory_ != NULL; }
 
  protected:
   FreeList* free_list() { return &free_list_; }
 
@@ skipping 74 matching lines @@
   }
 
  private:
   int number_;
   int bytes_;
 };
 
 
 // HistogramInfo class for recording a single "bar" of a histogram.  This
 // class is used for collecting statistics to print to the log file.
-class HistogramInfo: public NumberAndSizeInfo {
+class HistogramInfo : public NumberAndSizeInfo {
  public:
   HistogramInfo() : NumberAndSizeInfo() {}
 
   const char* name() { return name_; }
   void set_name(const char* name) { name_ = name; }
 
  private:
   const char* name_;
 };
 
 
-enum SemiSpaceId {
-  kFromSpace = 0,
-  kToSpace = 1
-};
+enum SemiSpaceId { kFromSpace = 0, kToSpace = 1 };
 
 
 class SemiSpace;
 
 
 class NewSpacePage : public MemoryChunk {
  public:
   // GC related flags copied from from-space to to-space when
   // flipping semispaces.
   static const intptr_t kCopyOnFlipFlagsMask =
-    (1 << MemoryChunk::POINTERS_TO_HERE_ARE_INTERESTING) |
-    (1 << MemoryChunk::POINTERS_FROM_HERE_ARE_INTERESTING) |
-    (1 << MemoryChunk::SCAN_ON_SCAVENGE);
+      (1 << MemoryChunk::POINTERS_TO_HERE_ARE_INTERESTING) |
+      (1 << MemoryChunk::POINTERS_FROM_HERE_ARE_INTERESTING) |
+      (1 << MemoryChunk::SCAN_ON_SCAVENGE);
 
   static const int kAreaSize = Page::kMaxRegularHeapObjectSize;
 
   inline NewSpacePage* next_page() const {
     return static_cast<NewSpacePage*>(next_chunk());
   }
 
-  inline void set_next_page(NewSpacePage* page) {
-    set_next_chunk(page);
-  }
+  inline void set_next_page(NewSpacePage* page) { set_next_chunk(page); }
 
   inline NewSpacePage* prev_page() const {
     return static_cast<NewSpacePage*>(prev_chunk());
   }
 
-  inline void set_prev_page(NewSpacePage* page) {
-    set_prev_chunk(page);
-  }
+  inline void set_prev_page(NewSpacePage* page) { set_prev_chunk(page); }
 
-  SemiSpace* semi_space() {
-    return reinterpret_cast<SemiSpace*>(owner());
-  }
+  SemiSpace* semi_space() { return reinterpret_cast<SemiSpace*>(owner()); }
 
   bool is_anchor() { return !this->InNewSpace(); }
 
   static bool IsAtStart(Address addr) {
-    return (reinterpret_cast<intptr_t>(addr) & Page::kPageAlignmentMask)
-        == kObjectStartOffset;
+    return (reinterpret_cast<intptr_t>(addr) & Page::kPageAlignmentMask) ==
+           kObjectStartOffset;
   }
 
   static bool IsAtEnd(Address addr) {
     return (reinterpret_cast<intptr_t>(addr) & Page::kPageAlignmentMask) == 0;
   }
 
-  Address address() {
-    return reinterpret_cast<Address>(this);
-  }
+  Address address() { return reinterpret_cast<Address>(this); }
 
   // Finds the NewSpacePage containg the given address.
   static inline NewSpacePage* FromAddress(Address address_in_page) {
     Address page_start =
         reinterpret_cast<Address>(reinterpret_cast<uintptr_t>(address_in_page) &
                                   ~Page::kPageAlignmentMask);
     NewSpacePage* page = reinterpret_cast<NewSpacePage*>(page_start);
     return page;
   }
 
   // Find the page for a limit address. A limit address is either an address
   // inside a page, or the address right after the last byte of a page.
   static inline NewSpacePage* FromLimit(Address address_limit) {
     return NewSpacePage::FromAddress(address_limit - 1);
   }
 
   // Checks if address1 and address2 are on the same new space page.
   static inline bool OnSamePage(Address address1, Address address2) {
     return NewSpacePage::FromAddress(address1) ==
            NewSpacePage::FromAddress(address2);
   }
 
  private:
   // Create a NewSpacePage object that is only used as anchor
   // for the doubly-linked list of real pages.
-  explicit NewSpacePage(SemiSpace* owner) {
-    InitializeAsAnchor(owner);
-  }
+  explicit NewSpacePage(SemiSpace* owner) { InitializeAsAnchor(owner); }
 
-  static NewSpacePage* Initialize(Heap* heap,
-                                  Address start,
+  static NewSpacePage* Initialize(Heap* heap, Address start,
                                   SemiSpace* semi_space);
 
   // Intialize a fake NewSpacePage used as sentinel at the ends
   // of a doubly-linked list of real NewSpacePages.
   // Only uses the prev/next links, and sets flags to not be in new-space.
   void InitializeAsAnchor(SemiSpace* owner);
 
   friend class SemiSpace;
   friend class SemiSpaceIterator;
 };
 
 
 // -----------------------------------------------------------------------------
 // SemiSpace in young generation
 //
 // A semispace is a contiguous chunk of memory holding page-like memory
 // chunks. The mark-compact collector  uses the memory of the first page in
 // the from space as a marking stack when tracing live objects.
 
 class SemiSpace : public Space {
  public:
   // Constructor.
   SemiSpace(Heap* heap, SemiSpaceId semispace)
-    : Space(heap, NEW_SPACE, NOT_EXECUTABLE),
-      start_(NULL),
-      age_mark_(NULL),
-      id_(semispace),
-      anchor_(this),
-      current_page_(NULL) { }
+      : Space(heap, NEW_SPACE, NOT_EXECUTABLE),
+        start_(NULL),
+        age_mark_(NULL),
+        id_(semispace),
+        anchor_(this),
+        current_page_(NULL) {}
 
   // Sets up the semispace using the given chunk.
   void SetUp(Address start, int initial_capacity, int maximum_capacity);
 
   // Tear down the space.  Heap memory was not allocated by the space, so it
   // is not deallocated here.
   void TearDown();
 
   // True if the space has been set up but not torn down.
   bool HasBeenSetUp() { return start_ != NULL; }
 
   // Grow the semispace to the new capacity.  The new capacity
   // requested must be larger than the current capacity and less than
   // the maximum capacity.
   bool GrowTo(int new_capacity);
 
   // Shrinks the semispace to the new capacity.  The new capacity
   // requested must be more than the amount of used memory in the
   // semispace and less than the current capacity.
   bool ShrinkTo(int new_capacity);
 
   // Returns the start address of the first page of the space.
   Address space_start() {
     DCHECK(anchor_.next_page() != &anchor_);
     return anchor_.next_page()->area_start();
   }
 
   // Returns the start address of the current page of the space.
-  Address page_low() {
-    return current_page_->area_start();
-  }
+  Address page_low() { return current_page_->area_start(); }
 
   // Returns one past the end address of the space.
-  Address space_end() {
-    return anchor_.prev_page()->area_end();
-  }
+  Address space_end() { return anchor_.prev_page()->area_end(); }
 
   // Returns one past the end address of the current page of the space.
-  Address page_high() {
-    return current_page_->area_end();
-  }
+  Address page_high() { return current_page_->area_end(); }
 
   bool AdvancePage() {
     NewSpacePage* next_page = current_page_->next_page();
     if (next_page == anchor()) return false;
     current_page_ = next_page;
     return true;
   }
 
   // Resets the space to using the first page.
   void Reset();
 
   // Age mark accessors.
   Address age_mark() { return age_mark_; }
   void set_age_mark(Address mark);
 
   // True if the address is in the address range of this semispace (not
   // necessarily below the allocation pointer).
   bool Contains(Address a) {
-    return (reinterpret_cast<uintptr_t>(a) & address_mask_)
-           == reinterpret_cast<uintptr_t>(start_);
+    return (reinterpret_cast<uintptr_t>(a) & address_mask_) ==
+           reinterpret_cast<uintptr_t>(start_);
   }
 
   // True if the object is a heap object in the address range of this
   // semispace (not necessarily below the allocation pointer).
   bool Contains(Object* o) {
     return (reinterpret_cast<uintptr_t>(o) & object_mask_) == object_expected_;
   }
 
   // If we don't have these here then SemiSpace will be abstract.  However
   // they should never be called.
@@ skipping 71 matching lines @@
   uintptr_t object_expected_;
 
   bool committed_;
   SemiSpaceId id_;
 
   NewSpacePage anchor_;
   NewSpacePage* current_page_;
 
   friend class SemiSpaceIterator;
   friend class NewSpacePageIterator;
+
  public:
   TRACK_MEMORY("SemiSpace")
 };
 
 
 // A SemiSpaceIterator is an ObjectIterator that iterates over the active
 // semispace of the heap's new space.  It iterates over the objects in the
 // semispace from a given start address (defaulting to the bottom of the
 // semispace) to the top of the semispace.  New objects allocated after the
 // iterator is created are not iterated.
@@ skipping 27 matching lines @@
     int size = (size_func_ == NULL) ? object->Size() : size_func_(object);
 
     current_ += size;
     return object;
   }
 
   // Implementation of the ObjectIterator functions.
   virtual HeapObject* next_object() { return Next(); }
 
  private:
-  void Initialize(Address start,
-                  Address end,
-                  HeapObjectCallback size_func);
+  void Initialize(Address start, Address end, HeapObjectCallback size_func);
 
   // The current iteration point.
   Address current_;
   // The end of iteration.
   Address limit_;
   // The callback function.
   HeapObjectCallback size_func_;
 };
 
 
@@ skipping 28 matching lines @@
 // -----------------------------------------------------------------------------
 // The young generation space.
 //
 // The new space consists of a contiguous pair of semispaces.  It simply
 // forwards most functions to the appropriate semispace.
 
 class NewSpace : public Space {
  public:
   // Constructor.
   explicit NewSpace(Heap* heap)
-    : Space(heap, NEW_SPACE, NOT_EXECUTABLE),
-      to_space_(heap, kToSpace),
-      from_space_(heap, kFromSpace),
-      reservation_(),
-      inline_allocation_limit_step_(0) {}
+      : Space(heap, NEW_SPACE, NOT_EXECUTABLE),
+        to_space_(heap, kToSpace),
+        from_space_(heap, kFromSpace),
+        reservation_(),
+        inline_allocation_limit_step_(0) {}
 
   // Sets up the new space using the given chunk.
   bool SetUp(int reserved_semispace_size_, int max_semi_space_size);
 
   // Tears down the space.  Heap memory was not allocated by the space, so it
   // is not deallocated here.
   void TearDown();
 
   // True if the space has been set up but not torn down.
   bool HasBeenSetUp() {
     return to_space_.HasBeenSetUp() && from_space_.HasBeenSetUp();
   }
 
   // Flip the pair of spaces.
   void Flip();
 
   // Grow the capacity of the semispaces.  Assumes that they are not at
   // their maximum capacity.
   void Grow();
 
   // Shrink the capacity of the semispaces.
   void Shrink();
 
   // True if the address or object lies in the address range of either
   // semispace (not necessarily below the allocation pointer).
   bool Contains(Address a) {
-    return (reinterpret_cast<uintptr_t>(a) & address_mask_)
-        == reinterpret_cast<uintptr_t>(start_);
+    return (reinterpret_cast<uintptr_t>(a) & address_mask_) ==
+           reinterpret_cast<uintptr_t>(start_);
   }
 
   bool Contains(Object* o) {
     Address a = reinterpret_cast<Address>(o);
     return (reinterpret_cast<uintptr_t>(a) & object_mask_) == object_expected_;
   }
 
   // Return the allocated bytes in the active semispace.
   virtual intptr_t Size() {
     return pages_used_ * NewSpacePage::kAreaSize +
-        static_cast<int>(top() - to_space_.page_low());
+           static_cast<int>(top() - to_space_.page_low());
   }
 
   // The same, but returning an int.  We have to have the one that returns
   // intptr_t because it is inherited, but if we know we are dealing with the
   // new space, which can't get as big as the other spaces then this is useful:
   int SizeAsInt() { return static_cast<int>(Size()); }
 
   // Return the current capacity of a semispace.
   intptr_t EffectiveCapacity() {
     SLOW_DCHECK(to_space_.Capacity() == from_space_.Capacity());
     return (to_space_.Capacity() / Page::kPageSize) * NewSpacePage::kAreaSize;
   }
 
   // Return the current capacity of a semispace.
   intptr_t Capacity() {
     DCHECK(to_space_.Capacity() == from_space_.Capacity());
     return to_space_.Capacity();
   }
 
   // Return the total amount of memory committed for new space.
   intptr_t CommittedMemory() {
     if (from_space_.is_committed()) return 2 * Capacity();
     return Capacity();
   }
 
   // Return the total amount of memory committed for new space.
   intptr_t MaximumCommittedMemory() {
     return to_space_.MaximumCommittedMemory() +
-        from_space_.MaximumCommittedMemory();
+           from_space_.MaximumCommittedMemory();
   }
 
   // Approximate amount of physical memory committed for this space.
   size_t CommittedPhysicalMemory();
 
   // Return the available bytes without growing.
-  intptr_t Available() {
-    return Capacity() - Size();
-  }
+  intptr_t Available() { return Capacity() - Size(); }
 
   // Return the maximum capacity of a semispace.
   int MaximumCapacity() {
     DCHECK(to_space_.MaximumCapacity() == from_space_.MaximumCapacity());
     return to_space_.MaximumCapacity();
   }
 
-  bool IsAtMaximumCapacity() {
-    return Capacity() == MaximumCapacity();
-  }
+  bool IsAtMaximumCapacity() { return Capacity() == MaximumCapacity(); }
 
   // Returns the initial capacity of a semispace.
   int InitialCapacity() {
     DCHECK(to_space_.InitialCapacity() == from_space_.InitialCapacity());
     return to_space_.InitialCapacity();
   }
 
   // Return the address of the allocation pointer in the active semispace.
   Address top() {
     DCHECK(to_space_.current_page()->ContainsLimit(allocation_info_.top()));
@@ skipping 29 matching lines @@
     DCHECK(IsAligned(OffsetFrom(addr), kPointerSize) ||
            IsAligned(OffsetFrom(addr) - 1, kPointerSize));
     return static_cast<uint32_t>(addr - start_) >> kPointerSizeLog2;
   }
 
   INLINE(Address MarkbitIndexToAddress(uint32_t index)) {
     return reinterpret_cast<Address>(index << kPointerSizeLog2);
   }
 
   // The allocation top and limit address.
-  Address* allocation_top_address() {
-    return allocation_info_.top_address();
-  }
+  Address* allocation_top_address() { return allocation_info_.top_address(); }
 
   // The allocation limit address.
   Address* allocation_limit_address() {
     return allocation_info_.limit_address();
   }
 
   MUST_USE_RESULT INLINE(AllocationResult AllocateRaw(int size_in_bytes));
 
   // Reset the allocation pointer to the beginning of the active semispace.
   void ResetAllocationInfo();
@@ skipping 119 matching lines @@
 };
 
 
 // -----------------------------------------------------------------------------
 // Old object space (excluding map objects)
 
 class OldSpace : public PagedSpace {
  public:
   // Creates an old space object with a given maximum capacity.
   // The constructor does not allocate pages from OS.
-  OldSpace(Heap* heap,
-           intptr_t max_capacity,
-           AllocationSpace id,
+  OldSpace(Heap* heap, intptr_t max_capacity, AllocationSpace id,
            Executability executable)
-      : PagedSpace(heap, max_capacity, id, executable) {
-  }
+      : PagedSpace(heap, max_capacity, id, executable) {}
 
  public:
   TRACK_MEMORY("OldSpace")
 };
 
 
 // For contiguous spaces, top should be in the space (or at the end) and limit
 // should be the end of the space.
 #define DCHECK_SEMISPACE_ALLOCATION_INFO(info, space) \
-  SLOW_DCHECK((space).page_low() <= (info).top() \
-              && (info).top() <= (space).page_high() \
-              && (info).limit() <= (space).page_high())
+  SLOW_DCHECK((space).page_low() <= (info).top() &&   \
+              (info).top() <= (space).page_high() &&  \
+              (info).limit() <= (space).page_high())
 
 
 // -----------------------------------------------------------------------------
 // Old space for all map objects
 
 class MapSpace : public PagedSpace {
  public:
   // Creates a map space object with a maximum capacity.
   MapSpace(Heap* heap, intptr_t max_capacity, AllocationSpace id)
       : PagedSpace(heap, max_capacity, id, NOT_EXECUTABLE),
-        max_map_space_pages_(kMaxMapPageIndex - 1) {
-  }
+        max_map_space_pages_(kMaxMapPageIndex - 1) {}
 
   // Given an index, returns the page address.
   // TODO(1600): this limit is artifical just to keep code compilable
   static const int kMaxMapPageIndex = 1 << 16;
 
   virtual int RoundSizeDownToObjectAlignment(int size) {
     if (IsPowerOf2(Map::kSize)) {
       return RoundDown(size, Map::kSize);
     } else {
       return (size / Map::kSize) * Map::kSize;
@@ skipping 18 matching lines @@
 };
 
 
 // -----------------------------------------------------------------------------
 // Old space for simple property cell objects
 
 class CellSpace : public PagedSpace {
  public:
   // Creates a property cell space object with a maximum capacity.
   CellSpace(Heap* heap, intptr_t max_capacity, AllocationSpace id)
-      : PagedSpace(heap, max_capacity, id, NOT_EXECUTABLE) {
-  }
+      : PagedSpace(heap, max_capacity, id, NOT_EXECUTABLE) {}
 
   virtual int RoundSizeDownToObjectAlignment(int size) {
     if (IsPowerOf2(Cell::kSize)) {
       return RoundDown(size, Cell::kSize);
     } else {
       return (size / Cell::kSize) * Cell::kSize;
     }
   }
 
  protected:
   virtual void VerifyObject(HeapObject* obj);
 
  public:
   TRACK_MEMORY("CellSpace")
 };
 
 
 // -----------------------------------------------------------------------------
 // Old space for all global object property cell objects
 
 class PropertyCellSpace : public PagedSpace {
  public:
   // Creates a property cell space object with a maximum capacity.
-  PropertyCellSpace(Heap* heap, intptr_t max_capacity,
-                    AllocationSpace id)
-      : PagedSpace(heap, max_capacity, id, NOT_EXECUTABLE) {
-  }
+  PropertyCellSpace(Heap* heap, intptr_t max_capacity, AllocationSpace id)
+      : PagedSpace(heap, max_capacity, id, NOT_EXECUTABLE) {}
 
   virtual int RoundSizeDownToObjectAlignment(int size) {
     if (IsPowerOf2(PropertyCell::kSize)) {
       return RoundDown(size, PropertyCell::kSize);
     } else {
       return (size / PropertyCell::kSize) * PropertyCell::kSize;
     }
   }
 
  protected:
@@ skipping 22 matching lines @@
   // Releases internal resources, frees objects in this space.
   void TearDown();
 
   static intptr_t ObjectSizeFor(intptr_t chunk_size) {
     if (chunk_size <= (Page::kPageSize + Page::kObjectStartOffset)) return 0;
     return chunk_size - Page::kPageSize - Page::kObjectStartOffset;
   }
 
   // Shared implementation of AllocateRaw, AllocateRawCode and
   // AllocateRawFixedArray.
-  MUST_USE_RESULT AllocationResult AllocateRaw(int object_size,
-                                               Executability executable);
+  MUST_USE_RESULT AllocationResult
+      AllocateRaw(int object_size, Executability executable);
 
   // Available bytes for objects in this space.
   inline intptr_t Available();
 
-  virtual intptr_t Size() {
-    return size_;
-  }
+  virtual intptr_t Size() { return size_; }
 
-  virtual intptr_t SizeOfObjects() {
-    return objects_size_;
-  }
+  virtual intptr_t SizeOfObjects() { return objects_size_; }
 
-  intptr_t MaximumCommittedMemory() {
-    return maximum_committed_;
-  }
+  intptr_t MaximumCommittedMemory() { return maximum_committed_; }
 
-  intptr_t CommittedMemory() {
-    return Size();
-  }
+  intptr_t CommittedMemory() { return Size(); }
 
   // Approximate amount of physical memory committed for this space.
   size_t CommittedPhysicalMemory();
 
-  int PageCount() {
-    return page_count_;
-  }
+  int PageCount() { return page_count_; }
 
   // Finds an object for a given address, returns a Smi if it is not found.
   // The function iterates through all objects in this space, may be slow.
   Object* FindObject(Address a);
 
   // Finds a large object page containing the given address, returns NULL
   // if such a page doesn't exist.
   LargePage* FindPage(Address a);
 
   // Frees unmarked objects.
@@ skipping 18 matching lines @@
 #endif
   // Checks whether an address is in the object area in this space.  It
   // iterates all objects in the space. May be slow.
   bool SlowContains(Address addr) { return FindObject(addr)->IsHeapObject(); }
 
  private:
   intptr_t max_capacity_;
   intptr_t maximum_committed_;
   // The head of the linked list of large object chunks.
   LargePage* first_page_;
-  intptr_t size_;  // allocated bytes
-  int page_count_;  // number of chunks
+  intptr_t size_;          // allocated bytes
+  int page_count_;         // number of chunks
   intptr_t objects_size_;  // size of objects
   // Map MemoryChunk::kAlignment-aligned chunks to large pages covering them
   HashMap chunk_map_;
 
   friend class LargeObjectIterator;
 
  public:
   TRACK_MEMORY("LargeObjectSpace")
 };
 
 
-class LargeObjectIterator: public ObjectIterator {
+class LargeObjectIterator : public ObjectIterator {
  public:
   explicit LargeObjectIterator(LargeObjectSpace* space);
   LargeObjectIterator(LargeObjectSpace* space, HeapObjectCallback size_func);
 
   HeapObject* Next();
 
   // implementation of ObjectIterator.
   virtual HeapObject* next_object() { return Next(); }
 
  private:
@@ skipping 43 matching lines @@
         return NULL;
       default:
         break;
     }
     UNREACHABLE();
     return NULL;
   }
 
 
  private:
-  enum State {
-    kOldPointerState,
-    kMapState,
-    kLargeObjectState,
-    kFinishedState
-  };
+  enum State { kOldPointerState, kMapState, kLargeObjectState, kFinishedState };
   State state_;
   PageIterator old_pointer_iterator_;
   PageIterator map_iterator_;
   LargeObjectIterator lo_iterator_;
 };
 
 
 #ifdef DEBUG
 struct CommentStatistic {
   const char* comment;
   int size;
   int count;
   void Clear() {
     comment = NULL;
     size = 0;
     count = 0;
   }
   // Must be small, since an iteration is used for lookup.
   static const int kMaxComments = 64;
 };
 #endif
+}
+}  // namespace v8::internal
 
-
-} }  // namespace v8::internal
-
-#endif  // V8_SPACES_H_
+#endif  // V8_HEAP_SPACES_H_