Move a bunch of GC related files to heap/ subdirectory

src/heap/incremental-marking.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_INCREMENTAL_MARKING_H_
-#define V8_INCREMENTAL_MARKING_H_
+#ifndef V8_HEAP_INCREMENTAL_MARKING_H_
+#define V8_HEAP_INCREMENTAL_MARKING_H_
 
 
 #include "src/execution.h"
-#include "src/mark-compact.h"
+#include "src/heap/mark-compact.h"
 #include "src/objects.h"
 
 namespace v8 {
 namespace internal {
 
 
 class IncrementalMarking {
  public:
-  enum State {
-    STOPPED,
-    SWEEPING,
-    MARKING,
-    COMPLETE
-  };
+  enum State { STOPPED, SWEEPING, MARKING, COMPLETE };
 
-  enum CompletionAction {
-    GC_VIA_STACK_GUARD,
-    NO_GC_VIA_STACK_GUARD
-  };
+  enum CompletionAction { GC_VIA_STACK_GUARD, NO_GC_VIA_STACK_GUARD };
 
   explicit IncrementalMarking(Heap* heap);
 
   static void Initialize();
 
   void TearDown();
 
   State state() {
     DCHECK(state_ == STOPPED || FLAG_incremental_marking);
     return state_;
@@ skipping 55 matching lines @@
 
   inline void RestartIfNotMarking() {
     if (state_ == COMPLETE) {
       state_ = MARKING;
       if (FLAG_trace_incremental_marking) {
         PrintF("[IncrementalMarking] Restarting (new grey objects)\n");
       }
     }
   }
 
-  static void RecordWriteFromCode(HeapObject* obj,
-                                  Object** slot,
+  static void RecordWriteFromCode(HeapObject* obj, Object** slot,
                                   Isolate* isolate);
 
   // Record a slot for compaction.  Returns false for objects that are
   // guaranteed to be rescanned or not guaranteed to survive.
   //
   // No slots in white objects should be recorded, as some slots are typed and
   // cannot be interpreted correctly if the underlying object does not survive
   // the incremental cycle (stays white).
   INLINE(bool BaseRecordWrite(HeapObject* obj, Object** slot, Object* value));
   INLINE(void RecordWrite(HeapObject* obj, Object** slot, Object* value));
-  INLINE(void RecordWriteIntoCode(HeapObject* obj,
-                                  RelocInfo* rinfo,
+  INLINE(void RecordWriteIntoCode(HeapObject* obj, RelocInfo* rinfo,
                                   Object* value));
-  INLINE(void RecordWriteOfCodeEntry(JSFunction* host,
-                                     Object** slot,
+  INLINE(void RecordWriteOfCodeEntry(JSFunction* host, Object** slot,
                                      Code* value));
 
 
   void RecordWriteSlow(HeapObject* obj, Object** slot, Object* value);
-  void RecordWriteIntoCodeSlow(HeapObject* obj,
-                               RelocInfo* rinfo,
+  void RecordWriteIntoCodeSlow(HeapObject* obj, RelocInfo* rinfo,
                                Object* value);
   void RecordWriteOfCodeEntrySlow(JSFunction* host, Object** slot, Code* value);
   void RecordCodeTargetPatch(Code* host, Address pc, HeapObject* value);
   void RecordCodeTargetPatch(Address pc, HeapObject* value);
 
   inline void RecordWrites(HeapObject* obj);
 
   inline void BlackToGreyAndUnshift(HeapObject* obj, MarkBit mark_bit);
 
   inline void WhiteToGreyAndPush(HeapObject* obj, MarkBit mark_bit);
 
   inline void SetOldSpacePageFlags(MemoryChunk* chunk) {
     SetOldSpacePageFlags(chunk, IsMarking(), IsCompacting());
   }
 
   inline void SetNewSpacePageFlags(NewSpacePage* chunk) {
     SetNewSpacePageFlags(chunk, IsMarking());
   }
 
   MarkingDeque* marking_deque() { return &marking_deque_; }
 
   bool IsCompacting() { return IsMarking() && is_compacting_; }
 
   void ActivateGeneratedStub(Code* stub);
 
   void NotifyOfHighPromotionRate() {
     if (IsMarking()) {
       if (marking_speed_ < kFastMarking) {
         if (FLAG_trace_gc) {
-          PrintPID("Increasing marking speed to %d "
-                   "due to high promotion rate\n",
-                   static_cast<int>(kFastMarking));
+          PrintPID(
+              "Increasing marking speed to %d "
+              "due to high promotion rate\n",
+              static_cast<int>(kFastMarking));
         }
         marking_speed_ = kFastMarking;
       }
     }
   }
 
-  void EnterNoMarkingScope() {
-    no_marking_scope_depth_++;
-  }
+  void EnterNoMarkingScope() { no_marking_scope_depth_++; }
 
-  void LeaveNoMarkingScope() {
-    no_marking_scope_depth_--;
-  }
+  void LeaveNoMarkingScope() { no_marking_scope_depth_--; }
 
   void UncommitMarkingDeque();
 
   void NotifyIncompleteScanOfObject(int unscanned_bytes) {
     unscanned_bytes_of_large_object_ = unscanned_bytes;
   }
 
  private:
   int64_t SpaceLeftInOldSpace();
 
   void ResetStepCounters();
 
   void StartMarking(CompactionFlag flag);
 
   void ActivateIncrementalWriteBarrier(PagedSpace* space);
   static void ActivateIncrementalWriteBarrier(NewSpace* space);
   void ActivateIncrementalWriteBarrier();
 
   static void DeactivateIncrementalWriteBarrierForSpace(PagedSpace* space);
   static void DeactivateIncrementalWriteBarrierForSpace(NewSpace* space);
   void DeactivateIncrementalWriteBarrier();
 
-  static void SetOldSpacePageFlags(MemoryChunk* chunk,
-                                   bool is_marking,
+  static void SetOldSpacePageFlags(MemoryChunk* chunk, bool is_marking,
                                    bool is_compacting);
 
   static void SetNewSpacePageFlags(NewSpacePage* chunk, bool is_marking);
 
   void EnsureMarkingDequeIsCommitted();
 
   INLINE(void ProcessMarkingDeque());
 
   INLINE(intptr_t ProcessMarkingDeque(intptr_t bytes_to_process));
 
@@ skipping 17 matching lines @@
   intptr_t bytes_scanned_;
   intptr_t allocated_;
   intptr_t write_barriers_invoked_since_last_step_;
 
   int no_marking_scope_depth_;
 
   int unscanned_bytes_of_large_object_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(IncrementalMarking);
 };
+}
+}  // namespace v8::internal
 
-} }  // namespace v8::internal
-
-#endif  // V8_INCREMENTAL_MARKING_H_
+#endif  // V8_HEAP_INCREMENTAL_MARKING_H_