Create an abstraction (MarkBit) object to hold the location of the...

src/mark-compact.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 80 matching lines @@
 }
 
 
 #ifdef DEBUG
 class VerifyMarkingVisitor: public ObjectVisitor {
  public:
   void VisitPointers(Object** start, Object** end) {
     for (Object** current = start; current < end; current++) {
       if ((*current)->IsHeapObject()) {
         HeapObject* object = HeapObject::cast(*current);
-        ASSERT(Marking::IsMarked(object));
+        ASSERT(MarkCompactCollector::IsMarked(object));
       }
     }
   }
 };
 
 
 static void VerifyMarking(Address bottom, Address top) {
   VerifyMarkingVisitor visitor;
   HeapObject* object;
   Address next_object_must_be_here_or_later = bottom;
 
   for (Address current = bottom;
        current < top;
        current += kPointerSize) {
     object = HeapObject::FromAddress(current);
-    if (Marking::IsMarked(object)) {
+    if (MarkCompactCollector::IsMarked(object)) {
       ASSERT(current >= next_object_must_be_here_or_later);
       object->Iterate(&visitor);
       next_object_must_be_here_or_later = current + object->Size();
     }
   }
 }
 
 
 static void VerifyMarking(Page* p) {
   VerifyMarking(p->ObjectAreaStart(), p->ObjectAreaEnd());
@@ skipping 103 matching lines @@
   ClearMarkbits(Heap::map_space());
   ClearMarkbits(Heap::old_pointer_space());
   ClearMarkbits(Heap::old_data_space());
   ClearMarkbits(Heap::cell_space());
 }
 
 
 void Marking::TransferMark(Address old_start, Address new_start) {
   if (old_start == new_start) return;
 
+  MarkBit new_mark_bit = Marking::MarkBitFrom(new_start);
+
   if (!IncrementalMarking::IsStopped()) {
-    if (IncrementalMarking::IsBlack(HeapObject::FromAddress(old_start))) {
-      IncrementalMarking::MarkBlack(HeapObject::FromAddress(new_start));
-      ClearMark(old_start);
-    } else if (IncrementalMarking::IsGrey(HeapObject::FromAddress(old_start))) {
-      ClearMark(old_start + kPointerSize);
-      IncrementalMarking::WhiteToGrey(HeapObject::FromAddress(new_start));
+    MarkBit old_mark_bit = Marking::MarkBitFrom(old_start);
+    if (IncrementalMarking::IsBlack(old_mark_bit)) {
+      IncrementalMarking::MarkBlack(old_mark_bit);

[Vyacheslav Egorov (Chromium), 2011/03/21 17:16:30]

new_mark_bit

[Erik Corry, 2011/03/21 20:48:53]

Good catch.

+      old_mark_bit.Clear();
+    } else if (IncrementalMarking::IsGrey(old_mark_bit)) {
+      old_mark_bit.Next().Clear();
+      IncrementalMarking::WhiteToGrey(HeapObject::FromAddress(new_start),
+                                      new_mark_bit);
       IncrementalMarking::RestartIfNotMarking();
       // TODO(gc): if we shift huge array in the loop we might end up pushing
       // to much to marking stack. maybe we should check one or two elements
       // on top of it to see whether they are equal to old_start.
     }
   } else {
-    if (Heap::InNewSpace(old_start) || !IsMarked(old_start)) {
+    ASSERT(IncrementalMarking::IsStopped());
+    if (Heap::InNewSpace(old_start)) {
       return;
+    } else {
+      MarkBit old_mark_bit = Marking::MarkBitFrom(old_start);
+      if (!old_mark_bit.Get()) {
+        return;
+      }
     }
-    SetMark(new_start);
+    new_mark_bit.Set();
   }
 }
 
 
 void MarkCompactCollector::Prepare(GCTracer* tracer) {
   FLAG_flush_code = false;
   FLAG_always_compact = false;
   FLAG_never_compact = true;
 
   // Disable collection of maps if incremental marking is enabled.
@@ skipping 27 matching lines @@
   }
 #endif
 
   PagedSpaces spaces;
   for (PagedSpace* space = spaces.next();
        space != NULL; space = spaces.next()) {
     space->PrepareForMarkCompact(compacting_collection_);
   }
 
   if (IncrementalMarking::state() == IncrementalMarking::STOPPED) {
-    Address new_space_top = Heap::new_space()->top();
     Address new_space_bottom = Heap::new_space()->bottom();
+    uintptr_t new_space_size =
+        RoundUp(Heap::new_space()->top() - new_space_bottom, 32 * kPointerSize);
 
-    Marking::ClearRange(new_space_bottom,
-                        static_cast<int>(new_space_top - new_space_bottom));
+    Marking::ClearRange(new_space_bottom, new_space_size);
 
     ClearMarkbits();
 #ifdef DEBUG
     VerifyMarkbitsAreClean();
 #endif
   }
 
 #ifdef DEBUG
   live_bytes_ = 0;
   live_young_objects_size_ = 0;
@@ skipping 104 matching lines @@
     Code* lazy_compile = Builtins::builtin(Builtins::LazyCompile);
 
     JSFunction* candidate = jsfunction_candidates_head_;
     JSFunction* next_candidate;
     while (candidate != NULL) {
       next_candidate = GetNextCandidate(candidate);
 
       SharedFunctionInfo* shared = candidate->unchecked_shared();
 
       Code* code = shared->unchecked_code();
-      if (!Marking::IsMarked(code->address())) {
+      MarkBit code_mark = Marking::MarkBitFrom(code);
+      if (!code_mark.Get()) {
         shared->set_code(lazy_compile);
         candidate->set_code(lazy_compile);
       } else {
         candidate->set_code(shared->unchecked_code());
       }
 
       candidate = next_candidate;
     }
 
     jsfunction_candidates_head_ = NULL;
   }
 
 
   static void ProcessSharedFunctionInfoCandidates() {
     Code* lazy_compile = Builtins::builtin(Builtins::LazyCompile);
 
     SharedFunctionInfo* candidate = shared_function_info_candidates_head_;
     SharedFunctionInfo* next_candidate;
     while (candidate != NULL) {
       next_candidate = GetNextCandidate(candidate);
       SetNextCandidate(candidate, NULL);
 
       Code* code = candidate->unchecked_code();
-      if (!Marking::IsMarked(code->address())) {
+      MarkBit code_mark = Marking::MarkBitFrom(code);
+      if (!code_mark.Get()) {
         candidate->set_code(lazy_compile);
       }
 
       candidate = next_candidate;
     }
 
     shared_function_info_candidates_head_ = NULL;
   }
 
 
@@ skipping 174 matching lines @@
   }
 
   static inline void VisitCodeTarget(RelocInfo* rinfo) {
     ASSERT(RelocInfo::IsCodeTarget(rinfo->rmode()));
     Code* code = Code::GetCodeFromTargetAddress(rinfo->target_address());
     if (FLAG_cleanup_ics_at_gc && code->is_inline_cache_stub()) {
       IC::Clear(rinfo->pc());
       // Please note targets for cleared inline cached do not have to be
       // marked since they are contained in Heap::non_monomorphic_cache().
     } else {
-      MarkCompactCollector::MarkObject(code);
+      MarkBit code_mark = Marking::MarkBitFrom(code);
+      MarkCompactCollector::MarkObject(code, code_mark);
     }
   }
 
   static void VisitGlobalPropertyCell(RelocInfo* rinfo) {
     ASSERT(rinfo->rmode() == RelocInfo::GLOBAL_PROPERTY_CELL);
     Object* cell = rinfo->target_cell();
     Object* old_cell = cell;
     VisitPointer(&cell);
     if (cell != old_cell) {
       rinfo->set_target_cell(reinterpret_cast<JSGlobalPropertyCell*>(cell),
                              NULL);
     }
   }
 
   static inline void VisitDebugTarget(RelocInfo* rinfo) {
     ASSERT((RelocInfo::IsJSReturn(rinfo->rmode()) &&
             rinfo->IsPatchedReturnSequence()) ||
            (RelocInfo::IsDebugBreakSlot(rinfo->rmode()) &&
             rinfo->IsPatchedDebugBreakSlotSequence()));
     HeapObject* code = Code::GetCodeFromTargetAddress(rinfo->call_address());
-    MarkCompactCollector::MarkObject(code);
+    MarkBit code_mark = Marking::MarkBitFrom(code);
+    MarkCompactCollector::MarkObject(code, code_mark);
   }
 
   // Mark object pointed to by p.
   INLINE(static void MarkObjectByPointer(Object** p)) {
     if (!(*p)->IsHeapObject()) return;
     HeapObject* object = ShortCircuitConsString(p);
-    MarkCompactCollector::MarkObject(object);
+    MarkBit mark = Marking::MarkBitFrom(object);
+    MarkCompactCollector::MarkObject(object, mark);
   }
 
   // Visit an unmarked object.
   static inline void VisitUnmarkedObject(HeapObject* obj) {
 #ifdef DEBUG
     ASSERT(Heap::Contains(obj));
-    ASSERT(!Marking::IsMarked(obj->address()));
+    ASSERT(!MarkCompactCollector::IsMarked(obj));
 #endif
     Map* map = obj->map();
-    MarkCompactCollector::SetMark(obj);
+    MarkBit mark = Marking::MarkBitFrom(obj);
+    MarkCompactCollector::SetMark(obj, mark);
     // Mark the map pointer and the body.
-    MarkCompactCollector::MarkObject(map);
+    MarkBit map_mark = Marking::MarkBitFrom(map);
+    MarkCompactCollector::MarkObject(map, map_mark);
     IterateBody(map, obj);
   }
 
   // Visit all unmarked objects pointed to by [start, end).
   // Returns false if the operation fails (lack of stack space).
   static inline bool VisitUnmarkedObjects(Object** start, Object** end) {
     // Return false is we are close to the stack limit.
     StackLimitCheck check;
     if (check.HasOverflowed()) return false;
 
     // Visit the unmarked objects.
     for (Object** p = start; p < end; p++) {
-      if (!(*p)->IsHeapObject()) continue;
-      HeapObject* obj = HeapObject::cast(*p);
-      if (Marking::IsMarked(obj)) continue;
+      Object* o = *p;
+      if (!o->IsHeapObject()) continue;
+      HeapObject* obj = HeapObject::cast(o);
+      MarkBit mark = Marking::MarkBitFrom(obj);
+      if (mark.Get()) continue;
       VisitUnmarkedObject(obj);
     }
     return true;
   }
 
   static inline void VisitExternalReference(Address* p) { }
   static inline void VisitRuntimeEntry(RelocInfo* rinfo) { }
 
  private:
   class DataObjectVisitor {
@@ skipping 40 matching lines @@
   inline static bool IsCompiled(SharedFunctionInfo* function) {
     return
         function->unchecked_code() != Builtins::builtin(Builtins::LazyCompile);
   }
 
   inline static bool IsFlushable(JSFunction* function) {
     SharedFunctionInfo* shared_info = function->unchecked_shared();
 
     // Code is either on stack, in compilation cache or referenced
     // by optimized version of function.
-    if (Marking::IsMarked(function->unchecked_code())) {
+    MarkBit code_mark = Marking::MarkBitFrom(function->unchecked_code());
+    if (code_mark.Get()) {
       shared_info->set_code_age(0);
       return false;
     }
 
     // We do not flush code for optimized functions.
     if (function->code() != shared_info->unchecked_code()) {
       return false;
     }
 
     return IsFlushable(shared_info);
   }
 
   inline static bool IsFlushable(SharedFunctionInfo* shared_info) {
     // Code is either on stack, in compilation cache or referenced
     // by optimized version of function.
-    if (Marking::IsMarked(shared_info->unchecked_code())) {
+    MarkBit code_mark = Marking::MarkBitFrom(shared_info->unchecked_code());
+    if (code_mark.Get()) {
       shared_info->set_code_age(0);
       return false;
     }
 
     // The function must be compiled and have the source code available,
     // to be able to recompile it in case we need the function again.
     if (!(shared_info->is_compiled() && HasSourceCode(shared_info))) {
       return false;
     }
 
@@ skipping 113 matching lines @@
 
   static void VisitJSFunctionAndFlushCode(Map* map, HeapObject* object) {
     JSFunction* jsfunction = reinterpret_cast<JSFunction*>(object);
     // The function must have a valid context and not be a builtin.
     bool flush_code_candidate = false;
     if (IsValidNotBuiltinContext(jsfunction->unchecked_context())) {
       flush_code_candidate = FlushCodeForFunction(jsfunction);
     }
 
     if (!flush_code_candidate) {
-      MarkCompactCollector::MarkObject(
-          jsfunction->unchecked_shared()->unchecked_code());
+      Code* code = jsfunction->unchecked_shared()->unchecked_code();
+      MarkBit code_mark = Marking::MarkBitFrom(code);
+      MarkCompactCollector::MarkObject(code, code_mark);
 
       if (jsfunction->unchecked_code()->kind() == Code::OPTIMIZED_FUNCTION) {
         // For optimized functions we should retain both non-optimized version
         // of it's code and non-optimized version of all inlined functions.
         // This is required to support bailing out from inlined code.
         DeoptimizationInputData* data =
             reinterpret_cast<DeoptimizationInputData*>(
                 jsfunction->unchecked_code()->unchecked_deoptimization_data());
 
         FixedArray* literals = data->UncheckedLiteralArray();
 
         for (int i = 0, count = data->InlinedFunctionCount()->value();
              i < count;
              i++) {
           JSFunction* inlined = reinterpret_cast<JSFunction*>(literals->get(i));
-          MarkCompactCollector::MarkObject(
-              inlined->unchecked_shared()->unchecked_code());
+          Code* inlined_code = inlined->unchecked_shared()->unchecked_code();

[Vyacheslav Egorov (Chromium), 2011/03/21 17:16:30]

I think we will need to kill all unchecked_* getters.

add TODO(gc) for that.

[Erik Corry, 2011/03/21 20:48:53]

Done.

+          MarkBit inlined_code_mark = Marking::MarkBitFrom(inlined_code);
+          MarkCompactCollector::MarkObject(inlined_code, inlined_code_mark);
         }
       }
     }
 
     VisitJSFunctionFields(map,
                           reinterpret_cast<JSFunction*>(object),
                           flush_code_candidate);
   }
 
 
@@ skipping 15 matching lines @@
                   SLOT_ADDR(object, JSFunction::kCodeEntryOffset));
 
     if (!flush_code_candidate) {
       VisitCodeEntry(object->address() + JSFunction::kCodeEntryOffset);
     } else {
       // Don't visit code object.
 
       // Visit shared function info to avoid double checking of it's
       // flushability.
       SharedFunctionInfo* shared_info = object->unchecked_shared();
-      if (!Marking::IsMarked(shared_info)) {
+      MarkBit shared_info_mark = Marking::MarkBitFrom(shared_info);
+      if (!shared_info_mark.Get()) {
         Map* shared_info_map = shared_info->map();
-        MarkCompactCollector::SetMark(shared_info);
-        MarkCompactCollector::MarkObject(shared_info_map);
+        MarkBit shared_info_map_mark = Marking::MarkBitFrom(shared_info_map);
+        MarkCompactCollector::SetMark(shared_info, shared_info_mark);
+        MarkCompactCollector::MarkObject(shared_info_map, shared_info_map_mark);
         VisitSharedFunctionInfoAndFlushCodeGeneric(shared_info_map,
                                                    shared_info,
                                                    true);
       }
     }
 
     VisitPointers(SLOT_ADDR(object,
                             JSFunction::kCodeEntryOffset + kPointerSize),
                   SLOT_ADDR(object, JSFunction::kNonWeakFieldsEndOffset));
 
@@ skipping 46 matching lines @@
   void VisitDebugTarget(RelocInfo* rinfo) {
     StaticMarkingVisitor::VisitDebugTarget(rinfo);
   }
 };
 
 
 class CodeMarkingVisitor : public ThreadVisitor {
  public:
   void VisitThread(ThreadLocalTop* top) {
     for (StackFrameIterator it(top); !it.done(); it.Advance()) {
-      MarkCompactCollector::MarkObject(it.frame()->unchecked_code());
+      Code* code = it.frame()->unchecked_code();
+      MarkBit code_bit = Marking::MarkBitFrom(code);
+      MarkCompactCollector::MarkObject(it.frame()->unchecked_code(), code_bit);
     }
   }
 };
 
 
 class SharedFunctionInfoMarkingVisitor : public ObjectVisitor {
  public:
   void VisitPointers(Object** start, Object** end) {
     for (Object** p = start; p < end; p++) VisitPointer(p);
   }
 
   void VisitPointer(Object** slot) {
     Object* obj = *slot;
     if (obj->IsSharedFunctionInfo()) {
       SharedFunctionInfo* shared = reinterpret_cast<SharedFunctionInfo*>(obj);
-      MarkCompactCollector::MarkObject(shared->unchecked_code());
-      MarkCompactCollector::MarkObject(shared);
+      MarkBit shared_mark = Marking::MarkBitFrom(shared);
+      MarkBit code_mark = Marking::MarkBitFrom(shared->unchecked_code());
+      MarkCompactCollector::MarkObject(shared->unchecked_code(), code_mark);
+      MarkCompactCollector::MarkObject(shared, shared_mark);
     }
   }
 };
 
 
 void MarkCompactCollector::PrepareForCodeFlushing() {
   if (!FLAG_flush_code) {
     StaticMarkingVisitor::EnableCodeFlushing(false);
     return;
   }
 
 #ifdef ENABLE_DEBUGGER_SUPPORT
   if (Debug::IsLoaded() || Debug::has_break_points()) {
     StaticMarkingVisitor::EnableCodeFlushing(false);
     return;
   }
 #endif
   StaticMarkingVisitor::EnableCodeFlushing(true);
 
   // Ensure that empty descriptor array is marked. Method MarkDescriptorArray
   // relies on it being marked before any other descriptor array.
-  MarkObject(Heap::raw_unchecked_empty_descriptor_array());
+  HeapObject* descriptor_array = Heap::raw_unchecked_empty_descriptor_array();
+  MarkBit descriptor_array_mark = Marking::MarkBitFrom(descriptor_array);
+  MarkObject(descriptor_array, descriptor_array_mark);
 
   // Make sure we are not referencing the code from the stack.
   for (StackFrameIterator it; !it.done(); it.Advance()) {
-    MarkObject(it.frame()->unchecked_code());
+    Code* code = it.frame()->unchecked_code();
+    MarkBit code_mark = Marking::MarkBitFrom(code);
+    MarkObject(code, code_mark);
   }
 
   // Iterate the archived stacks in all threads to check if
   // the code is referenced.
   CodeMarkingVisitor code_marking_visitor;
   ThreadManager::IterateArchivedThreads(&code_marking_visitor);
 
   SharedFunctionInfoMarkingVisitor visitor;
   CompilationCache::IterateFunctions(&visitor);
   HandleScopeImplementer::Iterate(&visitor);
@@ skipping 12 matching lines @@
   void VisitPointers(Object** start, Object** end) {
     for (Object** p = start; p < end; p++) MarkObjectByPointer(p);
   }
 
  private:
   void MarkObjectByPointer(Object** p) {
     if (!(*p)->IsHeapObject()) return;
 
     // Replace flat cons strings in place.
     HeapObject* object = ShortCircuitConsString(p);
-    if (Marking::IsMarked(object)) return;
+    MarkBit mark_bit = Marking::MarkBitFrom(object);
+    if (mark_bit.Get()) return;
 
     Map* map = object->map();
     // Mark the object.
-    MarkCompactCollector::SetMark(object);
+    MarkCompactCollector::SetMark(object, mark_bit);
 
     // Mark the map pointer and body, and push them on the marking stack.
-    MarkCompactCollector::MarkObject(map);
+    MarkBit map_mark = Marking::MarkBitFrom(map);
+    MarkCompactCollector::MarkObject(map, map_mark);
     StaticMarkingVisitor::IterateBody(map, object);
 
     // Mark all the objects reachable from the map and body.  May leave
     // overflowed objects in the heap.
     MarkCompactCollector::EmptyMarkingStack();
   }
 };
 
 
 // Helper class for pruning the symbol table.
 class SymbolTableCleaner : public ObjectVisitor {
  public:
   SymbolTableCleaner() : pointers_removed_(0) { }
 
   virtual void VisitPointers(Object** start, Object** end) {
     // Visit all HeapObject pointers in [start, end).
     for (Object** p = start; p < end; p++) {
-      if ((*p)->IsHeapObject() &&
-          !Marking::IsMarked(HeapObject::cast(*p))) {
+      Object* o = *p;
+      if (o->IsHeapObject() &&
+          !Marking::MarkBitFrom(HeapObject::cast(o)).Get()) {
         // Check if the symbol being pruned is an external symbol. We need to
         // delete the associated external data as this symbol is going away.
 
         // Since no objects have yet been moved we can safely access the map of
         // the object.
-        if ((*p)->IsExternalString()) {
-          Heap::FinalizeExternalString(String::cast(*p));
+        if (o->IsExternalString()) {
+          Heap::FinalizeExternalString(String::cast(o));
         }
         // Set the entry to null_value (as deleted).
         *p = Heap::raw_unchecked_null_value();
         pointers_removed_++;
       }
     }
   }
 
   int PointersRemoved() {
     return pointers_removed_;
   }
  private:
   int pointers_removed_;
 };
 
 
 // Implementation of WeakObjectRetainer for mark compact GCs. All marked objects
 // are retained.
 class MarkCompactWeakObjectRetainer : public WeakObjectRetainer {
  public:
   virtual Object* RetainAs(Object* object) {
-    if (Marking::IsMarked(HeapObject::cast(object))) {
+    if (Marking::MarkBitFrom(HeapObject::cast(object)).Get()) {
       return object;
     } else {
       return NULL;
     }
   }
 };
 
 
 void MarkCompactCollector::ProcessNewlyMarkedObject(HeapObject* object) {
-  ASSERT(Marking::IsMarked(object));
+  ASSERT(IsMarked(object));
   ASSERT(Heap::Contains(object));
   if (object->IsMap()) {
     Map* map = Map::cast(object);
     if (FLAG_cleanup_caches_in_maps_at_gc) {
       map->ClearCodeCache();
     }
     if (FLAG_collect_maps &&
         map->instance_type() >= FIRST_JS_OBJECT_TYPE &&
         map->instance_type() <= JS_FUNCTION_TYPE) {
       MarkMapContents(map);
@@ skipping 17 matching lines @@
                                              Map::kPointerFieldsBeginOffset);
 
   Object** end_slot = HeapObject::RawField(map, Map::kPointerFieldsEndOffset);
 
   StaticMarkingVisitor::VisitPointers(start_slot, end_slot);
 }
 
 
 void MarkCompactCollector::MarkDescriptorArray(
     DescriptorArray* descriptors) {
-  if (Marking::IsMarked(descriptors)) return;
+  MarkBit descriptors_mark = Marking::MarkBitFrom(descriptors);
+  if (descriptors_mark.Get()) return;
   // Empty descriptor array is marked as a root before any maps are marked.
   ASSERT(descriptors != Heap::raw_unchecked_empty_descriptor_array());
-  SetMark(descriptors);
+  SetMark(descriptors, descriptors_mark);
 
   FixedArray* contents = reinterpret_cast<FixedArray*>(
       descriptors->get(DescriptorArray::kContentArrayIndex));
   ASSERT(contents->IsHeapObject());
-  ASSERT(!Marking::IsMarked(contents));
+  ASSERT(!IsMarked(contents));
   ASSERT(contents->IsFixedArray());
   ASSERT(contents->length() >= 2);
-  SetMark(contents);
+  MarkBit contents_mark = Marking::MarkBitFrom(contents);
+  SetMark(contents, contents_mark);
   // Contents contains (value, details) pairs.  If the details say that
   // the type of descriptor is MAP_TRANSITION, CONSTANT_TRANSITION, or
   // NULL_DESCRIPTOR, we don't mark the value as live.  Only for
   // MAP_TRANSITION and CONSTANT_TRANSITION is the value an Object* (a
   // Map*).
   for (int i = 0; i < contents->length(); i += 2) {
     // If the pair (value, details) at index i, i+1 is not
     // a transition or null descriptor, mark the value.
     PropertyDetails details(Smi::cast(contents->get(i + 1)));
     if (details.type() < FIRST_PHANTOM_PROPERTY_TYPE) {
       HeapObject* object = reinterpret_cast<HeapObject*>(contents->get(i));
-      if (object->IsHeapObject() && !Marking::IsMarked(object)) {
-        SetMark(object);
-        marking_stack.Push(object);
+      if (object->IsHeapObject()) {
+        MarkBit mark = Marking::MarkBitFrom(HeapObject::cast(object));
+        if (!mark.Get()) {
+          SetMark(HeapObject::cast(object), mark);
+          marking_stack.Push(object);
+        }
       }
     }
   }
   // The DescriptorArray descriptors contains a pointer to its contents array,
   // but the contents array is already marked.
   marking_stack.Push(descriptors);
 }
 
 
 void MarkCompactCollector::CreateBackPointers() {
@@ skipping 26 matching lines @@
 template<class T>
 static void ScanOverflowedObjects(T* it) {
 #if 0
   // The caller should ensure that the marking stack is initially not full,
   // so that we don't waste effort pointlessly scanning for objects.
   ASSERT(!marking_stack.is_full());
 
   for (HeapObject* object = it->next(); object != NULL; object = it->next()) {
     if (object->IsOverflowed()) {
       object->ClearOverflow();
-      ASSERT(Marking::IsMarked(object));
+      ASSERT(MarkCompactCollector::IsMarked(object));
       ASSERT(Heap::Contains(object));
       marking_stack.Push(object);
       if (marking_stack.is_full()) return;
     }
   }
 #endif
   UNREACHABLE();
 }
 
 
 bool MarkCompactCollector::IsUnmarkedHeapObject(Object** p) {
-  return (*p)->IsHeapObject() &&
-      !Marking::IsMarked(HeapObject::cast(*p));
+  Object* o = *p;
+  if (!o->IsHeapObject()) return false;
+  HeapObject* heap_object = HeapObject::cast(o);
+  MarkBit mark = Marking::MarkBitFrom(heap_object);
+  return !mark.Get();
 }
 
 
 void MarkCompactCollector::MarkSymbolTable() {
   SymbolTable* symbol_table = Heap::raw_unchecked_symbol_table();
   // Mark the symbol table itself.
-  SetMark(symbol_table);
+  MarkBit symbol_table_mark = Marking::MarkBitFrom(symbol_table);
+  SetMark(symbol_table, symbol_table_mark);
   // Explicitly mark the prefix.
   MarkingVisitor marker;
   symbol_table->IteratePrefix(&marker);
   ProcessMarkingStack();
 }
 
 
 void MarkCompactCollector::MarkRoots(RootMarkingVisitor* visitor) {
   // Mark the heap roots including global variables, stack variables,
   // etc., and all objects reachable from them.
@@ skipping 14 matching lines @@
   List<ObjectGroup*>* object_groups = GlobalHandles::ObjectGroups();
 
   for (int i = 0; i < object_groups->length(); i++) {
     ObjectGroup* entry = object_groups->at(i);
     if (entry == NULL) continue;
 
     List<Object**>& objects = entry->objects_;
     bool group_marked = false;
     for (int j = 0; j < objects.length(); j++) {
       Object* object = *objects[j];
-      if (object->IsHeapObject()
-          && Marking::IsMarked(HeapObject::cast(object))) {
-        group_marked = true;
-        break;
+      if (object->IsHeapObject()) {
+        HeapObject* heap_object = HeapObject::cast(object);
+        MarkBit mark = Marking::MarkBitFrom(heap_object);
+        if (mark.Get()) {
+          group_marked = true;
+          break;
+        }
       }
     }
 
     if (!group_marked) continue;
 
-    // An object in the group is marked, so mark as gray all white heap
+    // An object in the group is marked, so mark as grey all white heap
     // objects in the group.
     for (int j = 0; j < objects.length(); ++j) {
-      if ((*objects[j])->IsHeapObject()) {
-        MarkObject(HeapObject::cast(*objects[j]));
+      Object* object = *objects[j];
+      if (object->IsHeapObject()) {
+        HeapObject* heap_object = HeapObject::cast(object);
+        MarkBit mark = Marking::MarkBitFrom(heap_object);
+        MarkObject(heap_object, mark);
       }
     }
-    // Once the entire group has been colored gray, set the object group
+    // Once the entire group has been colored grey, set the object group
     // to NULL so it won't be processed again.
     delete object_groups->at(i);
     object_groups->at(i) = NULL;
   }
 }
 
 
 // Mark all objects reachable from the objects on the marking stack.
 // 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::EmptyMarkingStack() {
   while (!marking_stack.is_empty()) {
     HeapObject* object = marking_stack.Pop();
     ASSERT(object->IsHeapObject());
     ASSERT(Heap::Contains(object));
-    ASSERT(Marking::IsMarked(object));
+    ASSERT(IsMarked(object));
     ASSERT(!object->IsOverflowed());
 
-    // Because the object is marked, we have to recover the original map
-    // pointer and use it to mark the object's body.
     Map* map = object->map();
-    MarkObject(map);
+    MarkBit map_mark = Marking::MarkBitFrom(map);
+    MarkObject(map, map_mark);
 
     StaticMarkingVisitor::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
 // before sweeping completes.  If sweeping completes, there are no remaining
 // overflowed objects in the heap so the overflow flag on the markings stack
@@ skipping 177 matching lines @@
   // dropping the back pointers temporarily stored in the prototype field.
   // Setting the prototype field requires following the linked list of
   // back pointers, reversing them all at once.  This allows us to find
   // those maps with map transitions that need to be nulled, and only
   // scan the descriptor arrays of those maps, not all maps.
   // All of these actions are carried out only on maps of JSObjects
   // and related subtypes.
   for (HeapObject* obj = map_iterator.Next();
        obj != NULL; obj = map_iterator.Next()) {
     Map* map = reinterpret_cast<Map*>(obj);
-    if (!Marking::IsMarked(map) && map->IsFreeSpace()) continue;
+    MarkBit map_mark = Marking::MarkBitFrom(map);
+    if (!map_mark.Get() && map->IsFreeSpace()) continue;
 
     ASSERT(SafeIsMap(map));
     // Only JSObject and subtypes have map transitions and back pointers.
     if (map->instance_type() < FIRST_JS_OBJECT_TYPE) continue;
     if (map->instance_type() > JS_FUNCTION_TYPE) continue;
 
-    if (Marking::IsMarked(map) &&
+    if (map_mark.Get() &&
         map->attached_to_shared_function_info()) {
       // This map is used for inobject slack tracking and has been detached
       // from SharedFunctionInfo during the mark phase.
       // Since it survived the GC, reattach it now.
       map->unchecked_constructor()->unchecked_shared()->AttachInitialMap(map);
     }
 
     // Follow the chain of back pointers to find the prototype.
     Map* current = map;
     while (SafeIsMap(current)) {
       current = reinterpret_cast<Map*>(current->prototype());
       ASSERT(current->IsHeapObject());
     }
     Object* real_prototype = current;
 
     // Follow back pointers, setting them to prototype,
     // clearing map transitions when necessary.
-    current = map;
-    bool on_dead_path = !Marking::IsMarked(current);
+    bool on_dead_path = !map_mark.Get();
     Object* next;
     while (SafeIsMap(current)) {
       next = current->prototype();
       // There should never be a dead map above a live map.
-      ASSERT(on_dead_path || Marking::IsMarked(current));
+      MarkBit current_mark = Marking::MarkBitFrom(current);
+      ASSERT(on_dead_path || current_mark.Get());
 
       // A live map above a dead map indicates a dead transition.
       // This test will always be false on the first iteration.
-      if (on_dead_path && Marking::IsMarked(current)) {
+      if (on_dead_path && current_mark.Get()) {
         on_dead_path = false;
         current->ClearNonLiveTransitions(real_prototype);
       }
       *HeapObject::RawField(current, Map::kPrototypeOffset) =
           real_prototype;
       current = reinterpret_cast<Map*>(next);
     }
   }
 }
 
@@ skipping 154 matching lines @@
   space->ResetAllocationInfo();
 
   int size = 0;
   int survivors_size = 0;
 
   // First pass: traverse all objects in inactive semispace, remove marks,
   // migrate live objects and write forwarding addresses.
   for (Address current = from_bottom; current < from_top; current += size) {
     HeapObject* object = HeapObject::FromAddress(current);
 
-    if (Marking::IsMarked(object)) {
-      Marking::ClearMark(object);
+
+    MarkBit mark_bit = Marking::MarkBitFromNewSpace(object);
+    if (mark_bit.Get()) {
+      mark_bit.Clear();
       MarkCompactCollector::tracer()->decrement_marked_count();
 
       size = object->Size();
       survivors_size += size;
 
       // Aggressively promote young survivors to the old space.
       if (TryPromoteObject(object, size)) {
         continue;
       }
 
@@ skipping 404 matching lines @@
 
 // Sweeps a space conservatively.  After this has been done the larger free
 // spaces have been put on the free list and the smaller ones have been
 // ignored and left untouched.  A free space is always either ignored or put
 // on the free list, never split up into two parts.  This is important
 // because it means that any FreeSpace maps left actually describe a region of
 // memory that can be ignored when scanning.  Dead objects other than free
 // spaces will not contain the free space map.
 static void SweepConservatively(PagedSpace* space,
                                 Page* p) {
-  Page::MarkbitsBitmap* markbits = p->markbits();
-  Page::MarkbitsBitmap::CellType* cells = markbits->cells();
+  MarkBit::CellType* cells = p->markbits()->cells();
 
   p->SetFlag(MemoryChunk::WAS_SWEPT_CONSERVATIVELY);
 
   // This is the start of the 32 word block that we are currently looking at.
   Address block_address = p->ObjectAreaStart();
 
   int last_cell_index =
       Page::MarkbitsBitmap::IndexToCell(
           Page::MarkbitsBitmap::CellAlignIndex(
               p->AddressToMarkbitIndex(p->ObjectAreaEnd())));
@@ skipping 61 matching lines @@
   }
 }
 
 
 // Sweep a space precisely.  After this has been done the space can
 // be iterated precisely, hitting only the live objects.  Code space
 // is always swept precisely because we want to be able to iterate
 // over it.  Map space is swept precisely, because it is not compacted.
 static void SweepPrecisely(PagedSpace* space,
                            Page* p) {
-  Page::MarkbitsBitmap* markbits = p->markbits();
-  Page::MarkbitsBitmap::CellType* cells = markbits->cells();
+  MarkBit::CellType* cells = p->markbits()->cells();
 
   p->ClearFlag(MemoryChunk::WAS_SWEPT_CONSERVATIVELY);
 
   int last_cell_index =
       Page::MarkbitsBitmap::IndexToCell(
           Page::MarkbitsBitmap::CellAlignIndex(
               p->AddressToMarkbitIndex(p->ObjectAreaEnd())));
 
   int cell_index = Page::kFirstUsedCell;
   Address free_start = p->ObjectAreaStart();
@@ skipping 159 matching lines @@
 }
 
 
 void MarkCompactCollector::Initialize() {
   StaticPointersToNewGenUpdatingVisitor::Initialize();
   StaticMarkingVisitor::Initialize();
 }
 
 
 } }  // namespace v8::internal