[heap] Enforce explicit MarkingState

src/heap/mark-compact.cc

 // 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.
 
 #include "src/heap/mark-compact.h"
 
 #include "src/base/atomicops.h"
 #include "src/base/bits.h"
 #include "src/base/sys-info.h"
 #include "src/code-stubs.h"
@@ skipping 86 matching lines @@
     // One word fillers at the end of a black area can be grey.
     if (ObjectMarking::IsBlackOrGrey(object, state) &&
         object->map() != heap_->one_pointer_filler_map()) {
       CHECK(ObjectMarking::IsBlack(object, state));
       CHECK(current >= next_object_must_be_here_or_later);
       object->Iterate(this);
       next_object_must_be_here_or_later = current + object->Size();
       // The object is either part of a black area of black allocation or a
       // regular black object
       CHECK(
-          state.bitmap->AllBitsSetInRange(
+          state.bitmap()->AllBitsSetInRange(
               page.AddressToMarkbitIndex(current),
               page.AddressToMarkbitIndex(next_object_must_be_here_or_later)) ||
-          state.bitmap->AllBitsClearInRange(
+          state.bitmap()->AllBitsClearInRange(
               page.AddressToMarkbitIndex(current + kPointerSize * 2),
               page.AddressToMarkbitIndex(next_object_must_be_here_or_later)));
       current = next_object_must_be_here_or_later;
     } else {
       current += kPointerSize;
     }
   }
 }
 
 void MarkingVerifier::VerifyMarking(NewSpace* space) {
@@ skipping 31 matching lines @@
     LargeObjectIterator it(heap_->lo_space());
     for (HeapObject* obj = it.Next(); obj != NULL; obj = it.Next()) {
       if (ObjectMarking::IsBlackOrGrey(obj, marking_state(obj))) {
         obj->Iterate(this);
       }
     }
   }
 
  protected:
   MarkingState marking_state(MemoryChunk* chunk) override {
-    return MarkingState::FromPageInternal(chunk);
+    return MarkingState::Internal(chunk);
   }
 
   MarkingState marking_state(HeapObject* object) {
-    return marking_state(Page::FromAddress(object->address()));
+    return MarkingState::Internal(object);
   }
 
   void VisitPointers(Object** start, Object** end) override {
     for (Object** current = start; current < end; current++) {
       if ((*current)->IsHeapObject()) {
         HeapObject* object = HeapObject::cast(*current);
         CHECK(ObjectMarking::IsBlackOrGrey(object, marking_state(object)));
       }
     }
   }
@@ skipping 13 matching lines @@
       ObjectVisitor::VisitCell(rinfo);
     }
   }
 };
 
 class YoungGenerationMarkingVerifier : public MarkingVerifier {
  public:
   explicit YoungGenerationMarkingVerifier(Heap* heap) : MarkingVerifier(heap) {}
 
   MarkingState marking_state(MemoryChunk* chunk) override {
-    return MarkingState::FromPageExternal(chunk);
+    return MarkingState::External(chunk);
   }
 
   MarkingState marking_state(HeapObject* object) {
-    return marking_state(Page::FromAddress(object->address()));
+    return MarkingState::External(object);
   }
 
   void Run() override {
     VerifyRoots(VISIT_ALL_IN_SCAVENGE);
     VerifyMarking(heap_->new_space());
   }
 
   void VisitPointers(Object** start, Object** end) override {
     for (Object** current = start; current < end; current++) {
       if ((*current)->IsHeapObject()) {
@@ skipping 157 matching lines @@
   StartSweepSpaces();
 
   EvacuateNewSpaceAndCandidates();
 
   Finish();
 }
 
 #ifdef VERIFY_HEAP
 void MarkCompactCollector::VerifyMarkbitsAreClean(PagedSpace* space) {
   for (Page* p : *space) {
-    CHECK(p->markbits()->IsClean());
-    CHECK_EQ(0, p->LiveBytes());
+    const MarkingState state = MarkingState::Internal(p);
+    CHECK(state.bitmap()->IsClean());
+    CHECK_EQ(0, state.live_bytes());
   }
 }
 
 
 void MarkCompactCollector::VerifyMarkbitsAreClean(NewSpace* space) {
   for (Page* p : PageRange(space->bottom(), space->top())) {
-    CHECK(p->markbits()->IsClean());
-    CHECK_EQ(0, p->LiveBytes());
+    const MarkingState state = MarkingState::Internal(p);
+    CHECK(state.bitmap()->IsClean());
+    CHECK_EQ(0, state.live_bytes());
   }
 }
 
 
 void MarkCompactCollector::VerifyMarkbitsAreClean() {
   VerifyMarkbitsAreClean(heap_->old_space());
   VerifyMarkbitsAreClean(heap_->code_space());
   VerifyMarkbitsAreClean(heap_->map_space());
   VerifyMarkbitsAreClean(heap_->new_space());
 
   LargeObjectIterator it(heap_->lo_space());
   for (HeapObject* obj = it.Next(); obj != NULL; obj = it.Next()) {
-    CHECK(ObjectMarking::IsWhite(obj));
-    CHECK_EQ(0, Page::FromAddress(obj->address())->LiveBytes());
+    CHECK(ObjectMarking::IsWhite(obj, MarkingState::Internal(obj)));
+    CHECK_EQ(0, MarkingState::Internal(obj).live_bytes());
   }
 }
 
 void MarkCompactCollector::VerifyWeakEmbeddedObjectsInCode() {
   HeapObjectIterator code_iterator(heap()->code_space());
   for (HeapObject* obj = code_iterator.Next(); obj != NULL;
        obj = code_iterator.Next()) {
     Code* code = Code::cast(obj);
     if (!code->is_optimized_code()) continue;
     if (WillBeDeoptimized(code)) continue;
     code->VerifyEmbeddedObjectsDependency();
   }
 }
 
 
 void MarkCompactCollector::VerifyOmittedMapChecks() {
   HeapObjectIterator iterator(heap()->map_space());
   for (HeapObject* obj = iterator.Next(); obj != NULL; obj = iterator.Next()) {
     Map* map = Map::cast(obj);
     map->VerifyOmittedMapChecks();
   }
 }
 #endif  // VERIFY_HEAP
 
 
 static void ClearMarkbitsInPagedSpace(PagedSpace* space) {
   for (Page* p : *space) {
-    p->ClearLiveness();
+    MarkingState::Internal(p).ClearLiveness();
   }
 }
 
 
 static void ClearMarkbitsInNewSpace(NewSpace* space) {
-  for (Page* page : *space) {
-    page->ClearLiveness();
+  for (Page* p : *space) {
+    MarkingState::Internal(p).ClearLiveness();
   }
 }
 
 
 void MarkCompactCollector::ClearMarkbits() {
   ClearMarkbitsInPagedSpace(heap_->code_space());
   ClearMarkbitsInPagedSpace(heap_->map_space());
   ClearMarkbitsInPagedSpace(heap_->old_space());
   ClearMarkbitsInNewSpace(heap_->new_space());
   heap_->lo_space()->ClearMarkingStateOfLiveObjects();
@@ skipping 33 matching lines @@
   base::AtomicNumber<intptr_t>* num_sweeping_tasks_;
   AllocationSpace space_to_start_;
 
   DISALLOW_COPY_AND_ASSIGN(SweeperTask);
 };
 
 void MarkCompactCollector::Sweeper::StartSweeping() {
   sweeping_in_progress_ = true;
   ForAllSweepingSpaces([this](AllocationSpace space) {
     std::sort(sweeping_list_[space].begin(), sweeping_list_[space].end(),
-              [](Page* a, Page* b) { return a->LiveBytes() < b->LiveBytes(); });
+              [](Page* a, Page* b) {
+                return MarkingState::Internal(a).live_bytes() <
+                       MarkingState::Internal(b).live_bytes();
+              });
   });
 }
 
 void MarkCompactCollector::Sweeper::StartSweeperTasks() {
   if (FLAG_concurrent_sweeping && sweeping_in_progress_) {
     ForAllSweepingSpaces([this](AllocationSpace space) {
       if (space == NEW_SPACE) return;
       num_sweeping_tasks_.Increment(1);
       semaphore_counter_++;
       V8::GetCurrentPlatform()->CallOnBackgroundThread(
@@ skipping 433 matching lines @@
 
   JSFunction* candidate = jsfunction_candidates_head_;
   JSFunction* next_candidate;
   while (candidate != NULL) {
     next_candidate = GetNextCandidate(candidate);
     ClearNextCandidate(candidate, undefined);
 
     SharedFunctionInfo* shared = candidate->shared();
 
     Code* code = shared->code();
-    if (ObjectMarking::IsWhite(code)) {
+    if (ObjectMarking::IsWhite(code, MarkingState::Internal(code))) {
       if (FLAG_trace_code_flushing && shared->is_compiled()) {
         PrintF("[code-flushing clears: ");
         shared->ShortPrint();
         PrintF(" - age: %d]\n", code->GetAge());
       }
       // Always flush the optimized code map if there is one.
       if (!shared->OptimizedCodeMapIsCleared()) {
         shared->ClearOptimizedCodeMap();
       }
       if (shared->HasBytecodeArray()) {
         shared->set_code(interpreter_entry_trampoline);
         candidate->set_code(interpreter_entry_trampoline);
       } else {
         shared->set_code(lazy_compile);
         candidate->set_code(lazy_compile);
       }
     } else {
-      DCHECK(ObjectMarking::IsBlack(code));
+      DCHECK(ObjectMarking::IsBlack(code, MarkingState::Internal(code)));
       candidate->set_code(code);
     }
 
     // We are in the middle of a GC cycle so the write barrier in the code
     // setter did not record the slot update and we have to do that manually.
     Address slot = candidate->address() + JSFunction::kCodeEntryOffset;
     Code* target = Code::cast(Code::GetObjectFromEntryAddress(slot));
     isolate_->heap()->mark_compact_collector()->RecordCodeEntrySlot(
         candidate, slot, target);
 
@@ skipping 13 matching lines @@
   Code* lazy_compile = isolate_->builtins()->builtin(Builtins::kCompileLazy);
   Code* interpreter_entry_trampoline =
       isolate_->builtins()->builtin(Builtins::kInterpreterEntryTrampoline);
   SharedFunctionInfo* candidate = shared_function_info_candidates_head_;
   SharedFunctionInfo* next_candidate;
   while (candidate != NULL) {
     next_candidate = GetNextCandidate(candidate);
     ClearNextCandidate(candidate);
 
     Code* code = candidate->code();
-    if (ObjectMarking::IsWhite(code)) {
+    if (ObjectMarking::IsWhite(code, MarkingState::Internal(code))) {
       if (FLAG_trace_code_flushing && candidate->is_compiled()) {
         PrintF("[code-flushing clears: ");
         candidate->ShortPrint();
         PrintF(" - age: %d]\n", code->GetAge());
       }
       // Always flush the optimized code map if there is one.
       if (!candidate->OptimizedCodeMapIsCleared()) {
         candidate->ClearOptimizedCodeMap();
       }
       if (candidate->HasBytecodeArray()) {
@@ skipping 114 matching lines @@
       if (MarkRecursively(heap, target_object)) return;
       heap->minor_mark_compact_collector()->MarkObject(target_object);
     }
   }
 
  protected:
   inline static bool MarkRecursively(Heap* heap, HeapObject* object) {
     StackLimitCheck check(heap->isolate());
     if (check.HasOverflowed()) return false;
 
-    const MarkingState state =
-        MinorMarkCompactCollector::StateForObject(object);
-    if (ObjectMarking::IsBlackOrGrey<MarkBit::NON_ATOMIC>(object, state))
+    if (ObjectMarking::IsBlackOrGrey<MarkBit::NON_ATOMIC>(
+            object, MarkingState::External(object)))
       return true;
-    ObjectMarking::WhiteToBlack<MarkBit::NON_ATOMIC>(object, state);
+    ObjectMarking::WhiteToBlack<MarkBit::NON_ATOMIC>(
+        object, MarkingState::External(object));
     IterateBody(object->map(), object);
     return true;
   }
 };
 
 class MarkCompactMarkingVisitor
     : public StaticMarkingVisitor<MarkCompactMarkingVisitor> {
  public:
   static void Initialize();
 
@@ skipping 16 matching lines @@
   }
 
   // Marks the object black and pushes it on the marking stack.
   INLINE(static void MarkObject(Heap* heap, HeapObject* object)) {
     heap->mark_compact_collector()->MarkObject(object);
   }
 
   // Marks the object black without pushing it on the marking stack.
   // Returns true if object needed marking and false otherwise.
   INLINE(static bool MarkObjectWithoutPush(Heap* heap, HeapObject* object)) {
-    if (ObjectMarking::IsWhite(object)) {
-      ObjectMarking::WhiteToBlack(object);
+    if (ObjectMarking::IsWhite(object, MarkingState::Internal(object))) {
+      ObjectMarking::WhiteToBlack(object, MarkingState::Internal(object));
       return true;
     }
     return false;
   }
 
   // Mark object pointed to by p.
   INLINE(static void MarkObjectByPointer(MarkCompactCollector* collector,
                                          HeapObject* object, Object** p)) {
     if (!(*p)->IsHeapObject()) return;
     HeapObject* target_object = HeapObject::cast(*p);
     collector->RecordSlot(object, p, target_object);
     collector->MarkObject(target_object);
   }
 
 
   // Visit an unmarked object.
   INLINE(static void VisitUnmarkedObject(MarkCompactCollector* collector,
                                          HeapObject* obj)) {
 #ifdef DEBUG
     DCHECK(collector->heap()->Contains(obj));
-    DCHECK(ObjectMarking::IsWhite(obj));
+    DCHECK(ObjectMarking::IsWhite(obj, MarkingState::Internal(obj)));
 #endif
     Map* map = obj->map();
     Heap* heap = obj->GetHeap();
-    ObjectMarking::WhiteToBlack(obj);
+    ObjectMarking::WhiteToBlack(obj, MarkingState::Internal(obj));
     // Mark the map pointer and the body.
     heap->mark_compact_collector()->MarkObject(map);
     IterateBody(map, obj);
   }
 
   // Visit all unmarked objects pointed to by [start, end).
   // Returns false if the operation fails (lack of stack space).
   INLINE(static bool VisitUnmarkedObjects(Heap* heap, HeapObject* object,
                                           Object** start, Object** end)) {
     // Return false is we are close to the stack limit.
     StackLimitCheck check(heap->isolate());
     if (check.HasOverflowed()) return false;
 
     MarkCompactCollector* collector = heap->mark_compact_collector();
     // Visit the unmarked objects.
     for (Object** p = start; p < end; p++) {
       Object* o = *p;
       if (!o->IsHeapObject()) continue;
       collector->RecordSlot(object, p, o);
       HeapObject* obj = HeapObject::cast(o);
-      if (ObjectMarking::IsBlackOrGrey(obj)) continue;
+      if (ObjectMarking::IsBlackOrGrey(obj, MarkingState::Internal(obj)))
+        continue;
       VisitUnmarkedObject(collector, obj);
     }
     return true;
   }
 
  private:
   // Code flushing support.
 
   static const int kRegExpCodeThreshold = 5;
 
@@ skipping 12 matching lines @@
     if (!code->IsSmi() &&
         HeapObject::cast(code)->map()->instance_type() == CODE_TYPE) {
       // Save a copy that can be reinstated if we need the code again.
       re->SetDataAt(JSRegExp::saved_code_index(is_one_byte), code);
 
       // Saving a copy might create a pointer into compaction candidate
       // that was not observed by marker.  This might happen if JSRegExp data
       // was marked through the compilation cache before marker reached JSRegExp
       // object.
       FixedArray* data = FixedArray::cast(re->data());
-      if (ObjectMarking::IsBlackOrGrey(data)) {
+      if (ObjectMarking::IsBlackOrGrey(data, MarkingState::Internal(data))) {
         Object** slot =
             data->data_start() + JSRegExp::saved_code_index(is_one_byte);
         heap->mark_compact_collector()->RecordSlot(data, slot, code);
       }
 
       // Set a number in the 0-255 range to guarantee no smi overflow.
       re->SetDataAt(JSRegExp::code_index(is_one_byte),
                     Smi::FromInt(heap->ms_count() & 0xff));
     } else if (code->IsSmi()) {
       int value = Smi::cast(code)->value();
@@ skipping 137 matching lines @@
 
  private:
   void MarkObjectByPointer(Object** p) {
     if (!(*p)->IsHeapObject()) return;
 
     HeapObject* object = HeapObject::cast(*p);
 
     if (!collector_->heap()->InNewSpace(object)) return;
 
     if (ObjectMarking::IsBlackOrGrey<MarkBit::NON_ATOMIC>(
-            object, StateForObject(object)))
+            object, MarkingState::External(object)))
       return;
 
     Map* map = object->map();
-    ObjectMarking::WhiteToBlack<MarkBit::NON_ATOMIC>(object,
-                                                     StateForObject(object));
+    ObjectMarking::WhiteToBlack<MarkBit::NON_ATOMIC>(
+        object, MarkingState::External(object));
     StaticYoungGenerationMarkingVisitor::IterateBody(map, object);
 
     collector_->EmptyMarkingDeque();
   }
 
   MinorMarkCompactCollector* collector_;
 };
 
 // Visitor class for marking heap roots.
 class MarkCompactCollector::RootMarkingVisitor : public ObjectVisitor {
@@ skipping 10 matching lines @@
   // Skip the weak next code link in a code object, which is visited in
   // ProcessTopOptimizedFrame.
   void VisitNextCodeLink(Object** p) override {}
 
  private:
   void MarkObjectByPointer(Object** p) {
     if (!(*p)->IsHeapObject()) return;
 
     HeapObject* object = HeapObject::cast(*p);
 
-    if (ObjectMarking::IsBlackOrGrey<MarkBit::NON_ATOMIC>(object)) return;
+    if (ObjectMarking::IsBlackOrGrey<MarkBit::NON_ATOMIC>(
+            object, MarkingState::Internal(object)))
+      return;
 
     Map* map = object->map();
     // Mark the object.
-    ObjectMarking::WhiteToBlack<MarkBit::NON_ATOMIC>(object);
+    ObjectMarking::WhiteToBlack<MarkBit::NON_ATOMIC>(
+        object, MarkingState::Internal(object));
 
     // Mark the map pointer and body, and push them on the marking stack.
     collector_->MarkObject(map);
     MarkCompactMarkingVisitor::IterateBody(map, object);
 
     // Mark all the objects reachable from the map and body.  May leave
     // overflowed objects in the heap.
     collector_->EmptyMarkingDeque();
   }
 
   MarkCompactCollector* collector_;
 };
 
 
 // Helper class for pruning the string table.
 template <bool finalize_external_strings, bool record_slots>
 class StringTableCleaner : public ObjectVisitor {
  public:
   StringTableCleaner(Heap* heap, HeapObject* table)
       : heap_(heap), pointers_removed_(0), table_(table) {
     DCHECK(!record_slots || table != nullptr);
   }
 
   void VisitPointers(Object** start, Object** end) override {
     // Visit all HeapObject pointers in [start, end).
     MarkCompactCollector* collector = heap_->mark_compact_collector();
     for (Object** p = start; p < end; p++) {
       Object* o = *p;
       if (o->IsHeapObject()) {
-        if (ObjectMarking::IsWhite(HeapObject::cast(o))) {
+        HeapObject* heap_object = HeapObject::cast(o);
+        if (ObjectMarking::IsWhite(heap_object,
+                                   MarkingState::Internal(heap_object))) {
           if (finalize_external_strings) {
             if (o->IsExternalString()) {
               heap_->FinalizeExternalString(String::cast(*p));
             } else {
               // The original external string may have been internalized.
               DCHECK(o->IsThinString());
             }
           } else {
             pointers_removed_++;
           }
@@ skipping 20 matching lines @@
 };
 
 typedef StringTableCleaner<false, true> InternalizedStringTableCleaner;
 typedef StringTableCleaner<true, false> ExternalStringTableCleaner;
 
 // Implementation of WeakObjectRetainer for mark compact GCs. All marked objects
 // are retained.
 class MarkCompactWeakObjectRetainer : public WeakObjectRetainer {
  public:
   virtual Object* RetainAs(Object* object) {
-    DCHECK(!ObjectMarking::IsGrey(HeapObject::cast(object)));
-    if (ObjectMarking::IsBlack(HeapObject::cast(object))) {
+    HeapObject* heap_object = HeapObject::cast(object);
+    DCHECK(!ObjectMarking::IsGrey(heap_object,
+                                  MarkingState::Internal(heap_object)));
+    if (ObjectMarking::IsBlack(heap_object,
+                               MarkingState::Internal(heap_object))) {
       return object;
     } else if (object->IsAllocationSite() &&
                !(AllocationSite::cast(object)->IsZombie())) {
       // "dead" AllocationSites need to live long enough for a traversal of new
       // space. These sites get a one-time reprieve.
       AllocationSite* site = AllocationSite::cast(object);
       site->MarkZombie();
-      ObjectMarking::WhiteToBlack(site);
+      ObjectMarking::WhiteToBlack(site, MarkingState::Internal(site));
       return object;
     } else {
       return NULL;
     }
   }
 };
 
 
 // Fill the marking stack with overflowed objects returned by the given
 // iterator.  Stop when the marking stack is filled or the end of the space
 // is reached, whichever comes first.
 template <class T>
 void MarkCompactCollector::DiscoverGreyObjectsWithIterator(T* it) {
   // The caller should ensure that the marking stack is initially not full,
   // so that we don't waste effort pointlessly scanning for objects.
   DCHECK(!marking_deque()->IsFull());
 
   Map* filler_map = heap()->one_pointer_filler_map();
   for (HeapObject* object = it->Next(); object != NULL; object = it->Next()) {
-    if ((object->map() != filler_map) && ObjectMarking::IsGrey(object)) {
-      ObjectMarking::GreyToBlack(object);
+    if ((object->map() != filler_map) &&
+        ObjectMarking::IsGrey(object, MarkingState::Internal(object))) {
+      ObjectMarking::GreyToBlack(object, MarkingState::Internal(object));
       PushBlack(object);
       if (marking_deque()->IsFull()) return;
     }
   }
 }
 
 void MarkCompactCollector::DiscoverGreyObjectsOnPage(MemoryChunk* p) {
   DCHECK(!marking_deque()->IsFull());
-  LiveObjectIterator<kGreyObjects> it(p, MarkingState::FromPageInternal(p));
+  LiveObjectIterator<kGreyObjects> it(p, MarkingState::Internal(p));
   HeapObject* object = NULL;
   while ((object = it.Next()) != NULL) {
-    DCHECK(ObjectMarking::IsGrey(object));
-    ObjectMarking::GreyToBlack(object);
+    DCHECK(ObjectMarking::IsGrey(object, MarkingState::Internal(object)));
+    ObjectMarking::GreyToBlack(object, MarkingState::Internal(object));
     PushBlack(object);
     if (marking_deque()->IsFull()) return;
   }
 }
 
 class RecordMigratedSlotVisitor final : public ObjectVisitor {
  public:
   explicit RecordMigratedSlotVisitor(MarkCompactCollector* collector)
       : collector_(collector) {}
 
@@ skipping 432 matching lines @@
   for (Page* page : PageRange(space->bottom(), space->top())) {
     DiscoverGreyObjectsOnPage(page);
     if (marking_deque()->IsFull()) return;
   }
 }
 
 
 bool MarkCompactCollector::IsUnmarkedHeapObject(Object** p) {
   Object* o = *p;
   if (!o->IsHeapObject()) return false;
-  return ObjectMarking::IsWhite(HeapObject::cast(o));
+  return ObjectMarking::IsWhite(HeapObject::cast(o),
+                                MarkingState::Internal(HeapObject::cast(o)));
 }
 
 void MarkCompactCollector::MarkStringTable(RootMarkingVisitor* visitor) {
   StringTable* string_table = heap()->string_table();
   // Mark the string table itself.
-  if (ObjectMarking::IsWhite(string_table)) {
+  if (ObjectMarking::IsWhite(string_table,
+                             MarkingState::Internal(string_table))) {
     // String table could have already been marked by visiting the handles list.
-    ObjectMarking::WhiteToBlack(string_table);
+    ObjectMarking::WhiteToBlack(string_table,
+                                MarkingState::Internal(string_table));
   }
   // Explicitly mark the prefix.
   string_table->IteratePrefix(visitor);
   ProcessMarkingDeque();
 }
 
 void MarkCompactCollector::MarkRoots(RootMarkingVisitor* visitor) {
   // Mark the heap roots including global variables, stack variables,
   // etc., and all objects reachable from them.
   heap()->IterateStrongRoots(visitor, VISIT_ONLY_STRONG);
@@ skipping 12 matching lines @@
 // Before: the marking stack contains zero or more heap object pointers.
 // After: the marking stack is empty, and all objects reachable from the
 // marking stack have been marked, or are overflowed in the heap.
 void MarkCompactCollector::EmptyMarkingDeque() {
   while (!marking_deque()->IsEmpty()) {
     HeapObject* object = marking_deque()->Pop();
 
     DCHECK(!object->IsFiller());
     DCHECK(object->IsHeapObject());
     DCHECK(heap()->Contains(object));
-    DCHECK(!(ObjectMarking::IsWhite<MarkBit::NON_ATOMIC>(object)));
+    DCHECK(!(ObjectMarking::IsWhite<MarkBit::NON_ATOMIC>(
+        object, MarkingState::Internal(object))));
 
     Map* map = object->map();
     MarkObject(map);
     MarkCompactMarkingVisitor::IterateBody(map, object);
   }
 }
 
 
 // Sweep the heap for overflowed objects, clear their overflow bits, and
 // push them on the marking stack.  Stop early if the marking stack fills
@@ skipping 170 matching lines @@
   ObjectStatsVisitor(Heap* heap, ObjectStats* live_stats,
                      ObjectStats* dead_stats)
       : live_collector_(heap, live_stats), dead_collector_(heap, dead_stats) {
     DCHECK_NOT_NULL(live_stats);
     DCHECK_NOT_NULL(dead_stats);
     // Global objects are roots and thus recorded as live.
     live_collector_.CollectGlobalStatistics();
   }
 
   bool Visit(HeapObject* obj) override {
-    if (ObjectMarking::IsBlack(obj)) {
+    if (ObjectMarking::IsBlack(obj, MarkingState::Internal(obj))) {
       live_collector_.CollectStatistics(obj);
     } else {
-      DCHECK(!ObjectMarking::IsGrey(obj));
+      DCHECK(!ObjectMarking::IsGrey(obj, MarkingState::Internal(obj)));
       dead_collector_.CollectStatistics(obj);
     }
     return true;
   }
 
  private:
   ObjectStatsCollector live_collector_;
   ObjectStatsCollector dead_collector_;
 };
 
@@ skipping 35 matching lines @@
 }
 
 SlotCallbackResult MinorMarkCompactCollector::CheckAndMarkObject(
     Heap* heap, Address slot_address) {
   Object* object = *reinterpret_cast<Object**>(slot_address);
   if (heap->InNewSpace(object)) {
     // Marking happens before flipping the young generation, so the object
     // has to be in ToSpace.
     DCHECK(heap->InToSpace(object));
     HeapObject* heap_object = reinterpret_cast<HeapObject*>(object);
-    const MarkingState state =
-        MinorMarkCompactCollector::StateForObject(heap_object);
+    const MarkingState state = MarkingState::External(heap_object);
     if (ObjectMarking::IsBlackOrGrey<MarkBit::NON_ATOMIC>(heap_object, state)) {
       return KEEP_SLOT;
     }
     ObjectMarking::WhiteToBlack<MarkBit::NON_ATOMIC>(heap_object, state);
     StaticYoungGenerationMarkingVisitor::IterateBody(heap_object->map(),
                                                      heap_object);
     return KEEP_SLOT;
   }
   return REMOVE_SLOT;
 }
 
 static bool IsUnmarkedObject(Heap* heap, Object** p) {
   DCHECK_IMPLIES(heap->InNewSpace(*p), heap->InToSpace(*p));
-  return heap->InNewSpace(*p) && !ObjectMarking::IsBlack(HeapObject::cast(*p));
+  return heap->InNewSpace(*p) &&
+         !ObjectMarking::IsBlack(HeapObject::cast(*p),
+                                 MarkingState::Internal(HeapObject::cast(*p)));
 }
 
 void MinorMarkCompactCollector::MarkLiveObjects() {
   TRACE_GC(heap()->tracer(), GCTracer::Scope::MINOR_MC_MARK);
 
   PostponeInterruptsScope postpone(isolate());
 
   StaticYoungGenerationMarkingVisitor::Initialize(heap());
   RootMarkingVisitor root_visitor(this);
 
@@ skipping 53 matching lines @@
 
 void MinorMarkCompactCollector::EmptyMarkingDeque() {
   while (!marking_deque()->IsEmpty()) {
     HeapObject* object = marking_deque()->Pop();
 
     DCHECK(!object->IsFiller());
     DCHECK(object->IsHeapObject());
     DCHECK(heap()->Contains(object));
 
     DCHECK(!(ObjectMarking::IsWhite<MarkBit::NON_ATOMIC>(
-        object, StateForObject(object))));
+        object, MarkingState::External(object))));
 
     Map* map = object->map();
     DCHECK((ObjectMarking::IsBlack<MarkBit::NON_ATOMIC>(
-        object, StateForObject(object))));
+        object, MarkingState::External(object))));
     StaticYoungGenerationMarkingVisitor::IterateBody(map, object);
   }
 }
 
 void MinorMarkCompactCollector::CollectGarbage() {
   MarkLiveObjects();
 
 #ifdef VERIFY_HEAP
   if (FLAG_verify_heap) {
     YoungGenerationMarkingVerifier verifier(heap());
@@ skipping 203 matching lines @@
 }
 
 
 void MarkCompactCollector::ClearSimpleMapTransitions(
     Object* non_live_map_list) {
   Object* the_hole_value = heap()->the_hole_value();
   Object* weak_cell_obj = non_live_map_list;
   while (weak_cell_obj != Smi::kZero) {
     WeakCell* weak_cell = WeakCell::cast(weak_cell_obj);
     Map* map = Map::cast(weak_cell->value());
-    DCHECK(ObjectMarking::IsWhite(map));
+    DCHECK(ObjectMarking::IsWhite(map, MarkingState::Internal(map)));
     Object* potential_parent = map->constructor_or_backpointer();
     if (potential_parent->IsMap()) {
       Map* parent = Map::cast(potential_parent);
-      if (ObjectMarking::IsBlackOrGrey(parent) &&
+      if (ObjectMarking::IsBlackOrGrey(parent,
+                                       MarkingState::Internal(parent)) &&
           parent->raw_transitions() == weak_cell) {
         ClearSimpleMapTransition(parent, map);
       }
     }
     weak_cell->clear();
     weak_cell_obj = weak_cell->next();
     weak_cell->clear_next(the_hole_value);
   }
 }
 
@@ skipping 18 matching lines @@
 void MarkCompactCollector::ClearFullMapTransitions() {
   HeapObject* undefined = heap()->undefined_value();
   Object* obj = heap()->encountered_transition_arrays();
   while (obj != Smi::kZero) {
     TransitionArray* array = TransitionArray::cast(obj);
     int num_transitions = array->number_of_entries();
     DCHECK_EQ(TransitionArray::NumberOfTransitions(array), num_transitions);
     if (num_transitions > 0) {
       Map* map = array->GetTarget(0);
       Map* parent = Map::cast(map->constructor_or_backpointer());
-      bool parent_is_alive = ObjectMarking::IsBlackOrGrey(parent);
+      bool parent_is_alive =
+          ObjectMarking::IsBlackOrGrey(parent, MarkingState::Internal(parent));
       DescriptorArray* descriptors =
           parent_is_alive ? parent->instance_descriptors() : nullptr;
       bool descriptors_owner_died =
           CompactTransitionArray(parent, array, descriptors);
       if (descriptors_owner_died) {
         TrimDescriptorArray(parent, descriptors);
       }
     }
     obj = array->next_link();
     array->set_next_link(undefined, SKIP_WRITE_BARRIER);
   }
   heap()->set_encountered_transition_arrays(Smi::kZero);
 }
 
 
 bool MarkCompactCollector::CompactTransitionArray(
     Map* map, TransitionArray* transitions, DescriptorArray* descriptors) {
   int num_transitions = transitions->number_of_entries();
   bool descriptors_owner_died = false;
   int transition_index = 0;
   // Compact all live transitions to the left.
   for (int i = 0; i < num_transitions; ++i) {
     Map* target = transitions->GetTarget(i);
     DCHECK_EQ(target->constructor_or_backpointer(), map);
-    if (ObjectMarking::IsWhite(target)) {
+    if (ObjectMarking::IsWhite(target, MarkingState::Internal(target))) {
       if (descriptors != nullptr &&
           target->instance_descriptors() == descriptors) {
         descriptors_owner_died = true;
       }
     } else {
       if (i != transition_index) {
         Name* key = transitions->GetKey(i);
         transitions->SetKey(transition_index, key);
         Object** key_slot = transitions->GetKeySlot(transition_index);
         RecordSlot(transitions, key_slot, key);
@@ skipping 71 matching lines @@
   FixedArray* enum_indices_cache = descriptors->GetEnumIndicesCache();
   heap_->RightTrimFixedArray(enum_indices_cache, to_trim);
 }
 
 
 void MarkCompactCollector::ProcessWeakCollections() {
   Object* weak_collection_obj = heap()->encountered_weak_collections();
   while (weak_collection_obj != Smi::kZero) {
     JSWeakCollection* weak_collection =
         reinterpret_cast<JSWeakCollection*>(weak_collection_obj);
-    DCHECK(ObjectMarking::IsBlackOrGrey(weak_collection));
+    DCHECK(ObjectMarking::IsBlackOrGrey(
+        weak_collection, MarkingState::Internal(weak_collection)));
     if (weak_collection->table()->IsHashTable()) {
       ObjectHashTable* table = ObjectHashTable::cast(weak_collection->table());
       for (int i = 0; i < table->Capacity(); i++) {
-        if (ObjectMarking::IsBlackOrGrey(HeapObject::cast(table->KeyAt(i)))) {
+        HeapObject* heap_object = HeapObject::cast(table->KeyAt(i));
+        if (ObjectMarking::IsBlackOrGrey(heap_object,
+                                         MarkingState::Internal(heap_object))) {
           Object** key_slot =
               table->RawFieldOfElementAt(ObjectHashTable::EntryToIndex(i));
           RecordSlot(table, key_slot, *key_slot);
           Object** value_slot =
               table->RawFieldOfElementAt(ObjectHashTable::EntryToValueIndex(i));
           MarkCompactMarkingVisitor::MarkObjectByPointer(this, table,
                                                          value_slot);
         }
       }
     }
     weak_collection_obj = weak_collection->next();
   }
 }
 
 
 void MarkCompactCollector::ClearWeakCollections() {
   TRACE_GC(heap()->tracer(), GCTracer::Scope::MC_CLEAR_WEAK_COLLECTIONS);
   Object* weak_collection_obj = heap()->encountered_weak_collections();
   while (weak_collection_obj != Smi::kZero) {
     JSWeakCollection* weak_collection =
         reinterpret_cast<JSWeakCollection*>(weak_collection_obj);
-    DCHECK(ObjectMarking::IsBlackOrGrey(weak_collection));
+    DCHECK(ObjectMarking::IsBlackOrGrey(
+        weak_collection, MarkingState::Internal(weak_collection)));
     if (weak_collection->table()->IsHashTable()) {
       ObjectHashTable* table = ObjectHashTable::cast(weak_collection->table());
       for (int i = 0; i < table->Capacity(); i++) {
         HeapObject* key = HeapObject::cast(table->KeyAt(i));
-        if (!ObjectMarking::IsBlackOrGrey(key)) {
+        if (!ObjectMarking::IsBlackOrGrey(key, MarkingState::Internal(key))) {
           table->RemoveEntry(i);
         }
       }
     }
     weak_collection_obj = weak_collection->next();
     weak_collection->set_next(heap()->undefined_value());
   }
   heap()->set_encountered_weak_collections(Smi::kZero);
 }
 
@@ skipping 20 matching lines @@
       DependentCode::cast(heap->empty_fixed_array());
   Object* non_live_map_head = Smi::kZero;
   while (weak_cell_obj != Smi::kZero) {
     WeakCell* weak_cell = reinterpret_cast<WeakCell*>(weak_cell_obj);
     Object* next_weak_cell = weak_cell->next();
     bool clear_value = true;
     bool clear_next = true;
     // We do not insert cleared weak cells into the list, so the value
     // cannot be a Smi here.
     HeapObject* value = HeapObject::cast(weak_cell->value());
-    if (!ObjectMarking::IsBlackOrGrey(value)) {
+    if (!ObjectMarking::IsBlackOrGrey(value, MarkingState::Internal(value))) {
       // Cells for new-space objects embedded in optimized code are wrapped in
       // WeakCell and put into Heap::weak_object_to_code_table.
       // Such cells do not have any strong references but we want to keep them
       // alive as long as the cell value is alive.
       // TODO(ulan): remove this once we remove Heap::weak_object_to_code_table.
       if (value->IsCell()) {
         Object* cell_value = Cell::cast(value)->value();
         if (cell_value->IsHeapObject() &&
-            ObjectMarking::IsBlackOrGrey(HeapObject::cast(cell_value))) {
+            ObjectMarking::IsBlackOrGrey(
+                HeapObject::cast(cell_value),
+                MarkingState::Internal(HeapObject::cast(cell_value)))) {
           // Resurrect the cell.
-          ObjectMarking::WhiteToBlack(value);
+          ObjectMarking::WhiteToBlack(value, MarkingState::Internal(value));
           Object** slot = HeapObject::RawField(value, Cell::kValueOffset);
           RecordSlot(value, slot, *slot);
           slot = HeapObject::RawField(weak_cell, WeakCell::kValueOffset);
           RecordSlot(weak_cell, slot, *slot);
           clear_value = false;
         }
       }
       if (value->IsMap()) {
         // The map is non-live.
         Map* map = Map::cast(value);
@@ skipping 273 matching lines @@
  public:
   FullEvacuator(Heap* heap, RecordMigratedSlotVisitor* record_visitor)
       : Evacuator(heap, record_visitor) {}
 
   bool EvacuatePage(Page* page, const MarkingState& state) override;
 };
 
 bool FullEvacuator::EvacuatePage(Page* page, const MarkingState& state) {
   bool success = false;
   DCHECK(page->SweepingDone());
-  intptr_t saved_live_bytes = *state.live_bytes;
+  intptr_t saved_live_bytes = state.live_bytes();
   double evacuation_time = 0.0;
   {
     AlwaysAllocateScope always_allocate(heap()->isolate());
     TimedScope timed_scope(&evacuation_time);
     LiveObjectVisitor object_visitor;
     switch (ComputeEvacuationMode(page)) {
       case kObjectsNewToOld:
         success =
             object_visitor.VisitBlackObjects(page, state, &new_space_visitor_,
                                              LiveObjectVisitor::kClearMarkbits);
         DCHECK(success);
         ArrayBufferTracker::ProcessBuffers(
             page, ArrayBufferTracker::kUpdateForwardedRemoveOthers);
         break;
       case kPageNewToOld:
         success = object_visitor.VisitBlackObjects(
             page, state, &new_to_old_page_visitor_,
             LiveObjectVisitor::kKeepMarking);
         DCHECK(success);
-        new_to_old_page_visitor_.account_moved_bytes(page->LiveBytes());
+        new_to_old_page_visitor_.account_moved_bytes(
+            MarkingState::Internal(page).live_bytes());
         // ArrayBufferTracker will be updated during sweeping.
         break;
       case kPageNewToNew:
         success = object_visitor.VisitBlackObjects(
             page, state, &new_to_new_page_visitor_,
             LiveObjectVisitor::kKeepMarking);
         DCHECK(success);
-        new_to_new_page_visitor_.account_moved_bytes(page->LiveBytes());
+        new_to_new_page_visitor_.account_moved_bytes(
+            MarkingState::Internal(page).live_bytes());
         // ArrayBufferTracker will be updated during sweeping.
         break;
       case kObjectsOldToOld:
         success =
             object_visitor.VisitBlackObjects(page, state, &old_space_visitor_,
                                              LiveObjectVisitor::kClearMarkbits);
         if (!success) {
           // Aborted compaction page. We have to record slots here, since we
           // might not have recorded them in first place.
           // Note: We mark the page as aborted here to be able to record slots
@@ skipping 63 matching lines @@
 class EvacuationJobTraits {
  public:
   typedef int* PerPageData;  // Pointer to number of aborted pages.
   typedef Evacuator* PerTaskData;
 
   static const bool NeedSequentialFinalization = true;
 
   static bool ProcessPageInParallel(Heap* heap, PerTaskData evacuator,
                                     MemoryChunk* chunk, PerPageData) {
     return evacuator->EvacuatePage(reinterpret_cast<Page*>(chunk),
-                                   MarkingState::FromPageInternal(chunk));
+                                   MarkingState::Internal(chunk));
   }
 
   static void FinalizePageSequentially(Heap* heap, MemoryChunk* chunk,
                                        bool success, PerPageData data) {
     Page* p = static_cast<Page*>(chunk);
     switch (Evacuator::ComputeEvacuationMode(p)) {
       case Evacuator::kPageNewToOld:
         break;
       case Evacuator::kPageNewToNew:
         DCHECK(success);
@@ skipping 22 matching lines @@
 };
 
 void MarkCompactCollector::EvacuatePagesInParallel() {
   PageParallelJob<EvacuationJobTraits> job(
       heap_, heap_->isolate()->cancelable_task_manager(),
       &page_parallel_job_semaphore_);
 
   int abandoned_pages = 0;
   intptr_t live_bytes = 0;
   for (Page* page : old_space_evacuation_pages_) {
-    live_bytes += page->LiveBytes();
+    live_bytes += MarkingState::Internal(page).live_bytes();
     job.AddPage(page, &abandoned_pages);
   }
 
   const bool reduce_memory = heap()->ShouldReduceMemory();
   const Address age_mark = heap()->new_space()->age_mark();
   for (Page* page : new_space_evacuation_pages_) {
-    live_bytes += page->LiveBytes();
+    intptr_t live_bytes_on_page = MarkingState::Internal(page).live_bytes();
+    live_bytes += live_bytes_on_page;
     if (!reduce_memory && !page->NeverEvacuate() &&
-        (page->LiveBytes() > Evacuator::PageEvacuationThreshold()) &&
+        (live_bytes_on_page > Evacuator::PageEvacuationThreshold()) &&
         !page->Contains(age_mark) &&
-        heap()->CanExpandOldGeneration(page->LiveBytes())) {
+        heap()->CanExpandOldGeneration(live_bytes_on_page)) {
       if (page->IsFlagSet(MemoryChunk::NEW_SPACE_BELOW_AGE_MARK)) {
         EvacuateNewSpacePageVisitor<NEW_TO_OLD>::Move(page);
       } else {
         EvacuateNewSpacePageVisitor<NEW_TO_NEW>::Move(page);
       }
     }
 
     job.AddPage(page, &abandoned_pages);
   }
   DCHECK_GE(job.NumberOfPages(), 1);
@@ skipping 95 matching lines @@
       space->identity() == CODE_SPACE && p->skip_list() != nullptr;
   SkipList* skip_list = p->skip_list();
   if (rebuild_skip_list) {
     skip_list->Clear();
   }
 
   intptr_t freed_bytes = 0;
   intptr_t max_freed_bytes = 0;
   int curr_region = -1;
 
-  LiveObjectIterator<kBlackObjects> it(p, MarkingState::FromPageInternal(p));
+  LiveObjectIterator<kBlackObjects> it(p, MarkingState::Internal(p));
   HeapObject* object = NULL;
 
   while ((object = it.Next()) != NULL) {
-    DCHECK(ObjectMarking::IsBlack(object));
+    DCHECK(ObjectMarking::IsBlack(object, MarkingState::Internal(object)));
     Address free_end = object->address();
     if (free_end != free_start) {
       CHECK_GT(free_end, free_start);
       size_t size = static_cast<size_t>(free_end - free_start);
       if (free_space_mode == ZAP_FREE_SPACE) {
         memset(free_start, 0xcc, size);
       }
       if (free_list_mode == REBUILD_FREE_LIST) {
         freed_bytes = reinterpret_cast<PagedSpace*>(space)->UnaccountedFree(
             free_start, size);
@@ skipping 50 matching lines @@
           static_cast<uint32_t>(p->area_end() - p->address())));
     }
   }
 
   // Clear invalid typed slots after collection all free ranges.
   if (slots_clearing_mode == CLEAR_TYPED_SLOTS) {
     p->typed_old_to_new_slots()->RemoveInvaldSlots(free_ranges);
   }
 
   // Clear the mark bits of that page and reset live bytes count.
-  p->ClearLiveness();
+  MarkingState::Internal(p).ClearLiveness();
 
   p->concurrent_sweeping_state().SetValue(Page::kSweepingDone);
   if (free_list_mode == IGNORE_FREE_LIST) return 0;
   return static_cast<int>(FreeList::GuaranteedAllocatable(max_freed_bytes));
 }
 
 void MarkCompactCollector::InvalidateCode(Code* code) {
   Page* page = Page::FromAddress(code->address());
   Address start = code->instruction_start();
   Address end = code->address() + code->Size();
 
   RememberedSet<OLD_TO_NEW>::RemoveRangeTyped(page, start, end);
 
   if (heap_->incremental_marking()->IsCompacting() &&
       !ShouldSkipEvacuationSlotRecording(code)) {
     DCHECK(compacting_);
 
     // If the object is white than no slots were recorded on it yet.
-    if (ObjectMarking::IsWhite(code)) return;
+    if (ObjectMarking::IsWhite(code, MarkingState::Internal(code))) return;
 
     // Ignore all slots that might have been recorded in the body of the
     // deoptimized code object. Assumption: no slots will be recorded for
     // this object after invalidating it.
     RememberedSet<OLD_TO_OLD>::RemoveRangeTyped(page, start, end);
   }
 }
 
 
 // Return true if the given code is deoptimized or will be deoptimized.
 bool MarkCompactCollector::WillBeDeoptimized(Code* code) {
   return code->is_optimized_code() && code->marked_for_deoptimization();
 }
 
 void MarkCompactCollector::RecordLiveSlotsOnPage(Page* page) {
   EvacuateRecordOnlyVisitor visitor(heap());
   LiveObjectVisitor object_visitor;
-  object_visitor.VisitBlackObjects(page, MarkingState::FromPageInternal(page),
-                                   &visitor, LiveObjectVisitor::kKeepMarking);
+  object_visitor.VisitBlackObjects(page, MarkingState::Internal(page), &visitor,
+                                   LiveObjectVisitor::kKeepMarking);
 }
 
 template <class Visitor>
 bool LiveObjectVisitor::VisitBlackObjects(MemoryChunk* chunk,
                                           const MarkingState& state,
                                           Visitor* visitor,
                                           IterationMode iteration_mode) {
   LiveObjectIterator<kBlackObjects> it(chunk, state);
   HeapObject* object = nullptr;
   while ((object = it.Next()) != nullptr) {
     DCHECK(ObjectMarking::IsBlack(object, state));
     if (!visitor->Visit(object)) {
       if (iteration_mode == kClearMarkbits) {
-        state.bitmap->ClearRange(
+        state.bitmap()->ClearRange(
             chunk->AddressToMarkbitIndex(chunk->area_start()),
             chunk->AddressToMarkbitIndex(object->address()));
         if (chunk->old_to_new_slots() != nullptr) {
           chunk->old_to_new_slots()->RemoveRange(
               0, static_cast<int>(object->address() - chunk->address()),
               SlotSet::PREFREE_EMPTY_BUCKETS);
         }
         if (chunk->typed_old_to_new_slots() != nullptr) {
           RememberedSet<OLD_TO_NEW>::RemoveRangeTyped(chunk, chunk->address(),
                                                       object->address());
@@ skipping 180 matching lines @@
       // Unfortunately, we do not know about the slot. It could be in a
       // just freed free space object.
       if (heap->InToSpace(slot->Value())) {
         return KEEP_SLOT;
       }
     } else if (heap->InToSpace(slot_reference)) {
       // Slots can point to "to" space if the page has been moved, or if the
       // slot has been recorded multiple times in the remembered set. Since
       // there is no forwarding information present we need to check the
       // markbits to determine liveness.
-      if (ObjectMarking::IsBlack(reinterpret_cast<HeapObject*>(slot_reference)))
+      HeapObject* heap_object = reinterpret_cast<HeapObject*>(slot_reference);
+      if (ObjectMarking::IsBlack(heap_object,
+                                 MarkingState::Internal(heap_object)))
         return KEEP_SLOT;
     } else {
       DCHECK(!heap->InNewSpace(slot_reference));
     }
     return REMOVE_SLOT;
   }
 };
 
 int NumberOfPointerUpdateTasks(int pages) {
   if (!FLAG_parallel_pointer_update) return 1;
@@ skipping 45 matching lines @@
       Map* map = object->map();
       int size = object->SizeFromMap(map);
       object->IterateBody(map->instance_type(), size, visitor);
       cur += size;
     }
   }
 
   static void ProcessPageInParallelVisitLive(Heap* heap, PerTaskData visitor,
                                              MemoryChunk* chunk,
                                              PerPageData limits) {
-    LiveObjectIterator<kBlackObjects> it(chunk,
-                                         MarkingState::FromPageInternal(chunk));
+    LiveObjectIterator<kBlackObjects> it(chunk, MarkingState::Internal(chunk));
     HeapObject* object = NULL;
     while ((object = it.Next()) != NULL) {
       Map* map = object->map();
       int size = object->SizeFromMap(map);
       object->IterateBody(map->instance_type(), size, visitor);
     }
   }
 };
 
 void UpdateToSpacePointersInParallel(Heap* heap, base::Semaphore* semaphore) {
@@ skipping 43 matching lines @@
     EvacuationWeakObjectRetainer evacuation_object_retainer;
     heap()->ProcessWeakListRoots(&evacuation_object_retainer);
   }
 }
 
 
 void MarkCompactCollector::ReleaseEvacuationCandidates() {
   for (Page* p : old_space_evacuation_pages_) {
     if (!p->IsEvacuationCandidate()) continue;
     PagedSpace* space = static_cast<PagedSpace*>(p->owner());
-    p->ResetLiveBytes();
+    MarkingState::Internal(p).SetLiveBytes(0);
     CHECK(p->SweepingDone());
     space->ReleasePage(p);
   }
   old_space_evacuation_pages_.Rewind(0);
   compacting_ = false;
   heap()->memory_allocator()->unmapper()->FreeQueuedChunks();
 }
 
 int MarkCompactCollector::Sweeper::ParallelSweepSpace(AllocationSpace identity,
                                                       int required_freed_bytes,
@@ skipping 50 matching lines @@
 
 void MarkCompactCollector::Sweeper::AddPage(AllocationSpace space, Page* page) {
   DCHECK(!FLAG_concurrent_sweeping || !AreSweeperTasksRunning());
   PrepareToBeSweptPage(space, page);
   sweeping_list_[space].push_back(page);
 }
 
 void MarkCompactCollector::Sweeper::PrepareToBeSweptPage(AllocationSpace space,
                                                          Page* page) {
   page->concurrent_sweeping_state().SetValue(Page::kSweepingPending);
-  DCHECK_GE(page->area_size(), static_cast<size_t>(page->LiveBytes()));
-  size_t to_sweep = page->area_size() - page->LiveBytes();
+  DCHECK_GE(page->area_size(),
+            static_cast<size_t>(MarkingState::Internal(page).live_bytes()));
+  size_t to_sweep =
+      page->area_size() - MarkingState::Internal(page).live_bytes();
   if (space != NEW_SPACE)
     heap_->paged_space(space)->accounting_stats_.ShrinkSpace(to_sweep);
 }
 
 Page* MarkCompactCollector::Sweeper::GetSweepingPageSafe(
     AllocationSpace space) {
   base::LockGuard<base::Mutex> guard(&mutex_);
   Page* page = nullptr;
   if (!sweeping_list_[space].empty()) {
     page = sweeping_list_[space].front();
@@ skipping 31 matching lines @@
       // (in the free list) dropped again. Since we only use the flag for
       // testing this is fine.
       p->concurrent_sweeping_state().SetValue(Page::kSweepingInProgress);
       Sweeper::RawSweep(p, Sweeper::IGNORE_FREE_LIST,
                         Heap::ShouldZapGarbage() ? Sweeper::ZAP_FREE_SPACE
                                                  : Sweeper::IGNORE_FREE_SPACE);
       continue;
     }
 
     // One unused page is kept, all further are released before sweeping them.
-    if (p->LiveBytes() == 0) {
+    if (MarkingState::Internal(p).live_bytes() == 0) {
       if (unused_page_present) {
         if (FLAG_gc_verbose) {
           PrintIsolate(isolate(), "sweeping: released page: %p",
                        static_cast<void*>(p));
         }
         ArrayBufferTracker::FreeAll(p);
         space->ReleasePage(p);
         continue;
       }
       unused_page_present = true;
@@ skipping 59 matching lines @@
   }
 }
 
 
 void MarkCompactCollector::RecordCodeTargetPatch(Address pc, Code* target) {
   DCHECK(heap()->gc_state() == Heap::MARK_COMPACT);
   if (is_compacting()) {
     Code* host =
         isolate()->inner_pointer_to_code_cache()->GcSafeFindCodeForInnerPointer(
             pc);
-    if (ObjectMarking::IsBlack(host)) {
+    if (ObjectMarking::IsBlack(host, MarkingState::Internal(host))) {
       RelocInfo rinfo(pc, RelocInfo::CODE_TARGET, 0, host);
       // The target is always in old space, we don't have to record the slot in
       // the old-to-new remembered set.
       DCHECK(!heap()->InNewSpace(target));
       RecordRelocSlot(host, &rinfo, target);
     }
   }
 }
 
 }  // namespace internal
 }  // namespace v8