[heap] Enforce explicit MarkingState

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_HEAP_SPACES_INL_H_
 #define V8_HEAP_SPACES_INL_H_
 
 #include "src/heap/incremental-marking.h"
 #include "src/heap/spaces.h"
 #include "src/isolate.h"
@@ skipping 164 matching lines @@
   bool in_to_space = (owner->id() != kFromSpace);
   chunk->SetFlag(in_to_space ? MemoryChunk::IN_TO_SPACE
                              : MemoryChunk::IN_FROM_SPACE);
   DCHECK(!chunk->IsFlagSet(in_to_space ? MemoryChunk::IN_FROM_SPACE
                                        : MemoryChunk::IN_TO_SPACE));
   Page* page = static_cast<Page*>(chunk);
   heap->incremental_marking()->SetNewSpacePageFlags(page);
   page->AllocateLocalTracker();
   if (FLAG_minor_mc) {
     page->AllocateYoungGenerationBitmap();
-    page->ClearLiveness<MarkingMode::YOUNG_GENERATION>();
+    MarkingState::External(page).ClearLiveness();
   }
   return page;
 }
 
 // --------------------------------------------------------------------------
 // PagedSpace
 
 template <Page::InitializationMode mode>
 Page* Page::Initialize(Heap* heap, MemoryChunk* chunk, Executability executable,
                        PagedSpace* owner) {
@@ skipping 27 matching lines @@
   new_page->InsertAfter(old_space->anchor()->prev_page());
   return new_page;
 }
 
 void Page::InitializeFreeListCategories() {
   for (int i = kFirstCategory; i < kNumberOfCategories; i++) {
     categories_[i].Initialize(static_cast<FreeListCategoryType>(i));
   }
 }
 
-template <MarkingMode mode>
-void MemoryChunk::IncrementLiveBytes(HeapObject* object, int by) {
-  MemoryChunk::FromAddress(object->address())->IncrementLiveBytes<mode>(by);
-}
-
-template <MarkingMode mode>
-void MemoryChunk::TraceLiveBytes(intptr_t old_value, intptr_t new_value) {
-  if (!FLAG_trace_live_bytes) return;
-  PrintIsolate(heap()->isolate(),
-               "live-bytes[%p:%s]: %" V8PRIdPTR "-> %" V8PRIdPTR "\n",
-               static_cast<void*>(this),
-               mode == MarkingMode::FULL ? "internal" : "external", old_value,
-               new_value);
-}
-
-template <MarkingMode mode>
-void MemoryChunk::ResetLiveBytes() {
-  switch (mode) {
-    case MarkingMode::FULL:
-      TraceLiveBytes(live_byte_count_, 0);
-      live_byte_count_ = 0;
-      break;
-    case MarkingMode::YOUNG_GENERATION:
-      TraceLiveBytes(young_generation_live_byte_count_, 0);
-      young_generation_live_byte_count_ = 0;
-      break;
-  }
-}
-
-template <MarkingMode mode>
-void MemoryChunk::IncrementLiveBytes(int by) {
-  switch (mode) {
-    case MarkingMode::FULL:
-      TraceLiveBytes(live_byte_count_, live_byte_count_ + by);
-      live_byte_count_ += by;
-      DCHECK_GE(live_byte_count_, 0);
-      DCHECK_LE(static_cast<size_t>(live_byte_count_), size_);
-      break;
-    case MarkingMode::YOUNG_GENERATION:
-      TraceLiveBytes(young_generation_live_byte_count_,
-                     young_generation_live_byte_count_ + by);
-      young_generation_live_byte_count_ += by;
-      DCHECK_GE(young_generation_live_byte_count_, 0);
-      DCHECK_LE(static_cast<size_t>(young_generation_live_byte_count_), size_);
-      break;
-  }
-}
-
 bool PagedSpace::Contains(Address addr) {
   return MemoryChunk::FromAnyPointerAddress(heap(), addr)->owner() == this;
 }
 
 bool PagedSpace::Contains(Object* o) {
   if (!o->IsHeapObject()) return false;
   Page* p = Page::FromAddress(HeapObject::cast(o)->address());
   if (!Page::IsValid(p)) return false;
   return p->owner() == this;
 }
@@ skipping 378 matching lines @@
     other->allocation_info_.Reset(nullptr, nullptr);
     return true;
   }
   return false;
 }
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_HEAP_SPACES_INL_H_