[oilpan] Rename visit to mark.

Source/heap/Heap.cpp

 /*
  * Copyright (C) 2013 Google Inc. 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
@@ skipping 453 matching lines @@
     return heapObjectHeader()->unmark();
 }
 
 template<typename Header>
 bool LargeHeapObject<Header>::isMarked()
 {
     return heapObjectHeader()->isMarked();
 }
 
 template<typename Header>
-bool LargeHeapObject<Header>::checkAndVisitPointer(Visitor* visitor, Address address)
+bool LargeHeapObject<Header>::checkAndMarkPointer(Visitor* visitor, Address address)
 {
     if (contains(address)) {
 #if defined(TRACE_GC_MARKING) && TRACE_GC_MARKING
         visitor->setHostInfo(&address, "stack");
 #endif
-        visit(visitor);
+        trace(visitor);
         return true;
     }
     return false;
 }
 
 template<>
-void LargeHeapObject<FinalizedHeapObjectHeader>::visit(Visitor* visitor)
+void LargeHeapObject<FinalizedHeapObjectHeader>::trace(Visitor* visitor)
 {
-    visitor->visit(heapObjectHeader(), heapObjectHeader()->traceCallback());
+    visitor->mark(heapObjectHeader(), heapObjectHeader()->traceCallback());
 }
 
 template<>
-void LargeHeapObject<HeapObjectHeader>::visit(Visitor* visitor)
+void LargeHeapObject<HeapObjectHeader>::trace(Visitor* visitor)
 {
     ASSERT(gcInfo());
-    visitor->visit(heapObjectHeader(), gcInfo()->m_trace);
+    visitor->mark(heapObjectHeader(), gcInfo()->m_trace);
 }
 
 template<>
 void LargeHeapObject<FinalizedHeapObjectHeader>::finalize()
 {
     heapObjectHeader()->finalize();
 }
 
 template<>
 void LargeHeapObject<HeapObjectHeader>::finalize()
@@ skipping 91 matching lines @@
 {
     ASSERT(ThreadState::isAnyThreadInGC());
     ThreadState::AttachedThreadStateSet& threads = ThreadState::attachedThreads();
     for (ThreadState::AttachedThreadStateSet::iterator it = threads.begin(), end = threads.end(); it != end; ++it) {
         if ((*it)->contains(address))
             return true;
     }
     return false;
 }
 
-Address Heap::checkAndVisitPointer(Visitor* visitor, Address address)
+Address Heap::checkAndMarkPointer(Visitor* visitor, Address address)
 {
     ASSERT(ThreadState::isAnyThreadInGC());
     ThreadState::AttachedThreadStateSet& threads = ThreadState::attachedThreads();
     for (ThreadState::AttachedThreadStateSet::iterator it = threads.begin(), end = threads.end(); it != end; ++it) {
-        if ((*it)->checkAndVisitPointer(visitor, address)) {
-            // Pointer found and visited
+        if ((*it)->checkAndMarkPointer(visitor, address)) {
+            // Pointer found and marked.
             return address;
         }
     }
     return 0;
 }
 
 template<typename Header>
 BaseHeapPage* ThreadHeap<Header>::heapPageFromAddress(Address address)
 {
     for (HeapPage<Header>* page = m_firstPage; page; page = page->next()) {
         if (page->contains(address))
             return page;
     }
     return 0;
 }
 
 template<typename Header>
 BaseHeapPage* ThreadHeap<Header>::largeHeapObjectFromAddress(Address address)
 {
     for (LargeHeapObject<Header>* current = m_firstLargeHeapObject; current; current = current->next()) {
         if (current->contains(address))
             return current;
     }
     return 0;
 }
 
 template<typename Header>
-bool ThreadHeap<Header>::checkAndVisitLargeHeapObjects(Visitor* visitor, Address address)
+bool ThreadHeap<Header>::checkAndMarkLargeHeapObjects(Visitor* visitor, Address address)
 {
     for (LargeHeapObject<Header>* current = m_firstLargeHeapObject; current; current = current->next()) {
-        if (current->checkAndVisitPointer(visitor, address))
+        if (current->checkAndMarkPointer(visitor, address))
             return true;
     }
     return false;
 }
 
 template<typename Header>
 void ThreadHeap<Header>::addToFreeList(Address address, size_t size)
 {
     ASSERT(heapPageFromAddress(address));
     ASSERT(heapPageFromAddress(address + size - 1));
@@ skipping 217 matching lines @@
     // FIXME(oilpan): It's unsafe to iterate threads outside of GC. Enable the ASSERT.
     // ASSERT(ThreadState::isAnyThreadInGC());
     ThreadState::AttachedThreadStateSet& threads = ThreadState::attachedThreads();
     for (ThreadState::AttachedThreadStateSet::iterator it = threads.begin(), end = threads.end(); it != end; ++it) {
         HeapStats temp;
         (*it)->getStats(temp);
         stats->add(&temp);
     }
 }
 
-#ifndef NDEBUG
-// #define ENABLE_TRACE_CHECKER
-#endif
-
-#ifdef ENABLE_TRACE_CHECKER
-class TraceChecker {
-public:
-    TraceChecker(void* object, TraceCallback callback, TraceRequirement requirement)
-        : m_object(object)
-        , m_callback(callback)
-        , m_traceRequirement(requirement)
-        , m_previous(s_current)
-    {
-        s_current = this;
-        // Unmark the object pointed to by each intra-heap pointer we find by
-        // conservative scanning.
-        iteratePointers(clearMarksAction);
-    }
-
-    ~TraceChecker()
-    {
-        // Check the marks on the objects pointed to by each intra-heap pointer
-        // we find by conservative scanning.
-        if (m_traceRequirement == AllPointersMustBeVisited)
-            iteratePointers(checkDebugMarksAction);
-        else if (m_traceRequirement == AllPointersMustBeMarked)
-            iteratePointers(checkMarkedAction);
-        s_current = m_previous;
-    }
-
-    static void rememberedToVisit(HeapObjectHeader* header)
-    {
-        header->setDebugMark();
-    }
-
-    static void registerWeakPointers()
-    {
-        s_current->m_traceRequirement = NoRequirement;
-    }
-
-    static void init()
-    {
-        s_current = 0;
-    }
-
-private:
-    typedef void (*IntraHeapPointerAction)(TraceChecker* self, Address);
-
-    // Find the intra-heap pointers by scanning the allocated object
-    // conservatively.
-    void iteratePointers(IntraHeapPointerAction action)
-    {
-        HeapObjectHeader* header = HeapObjectHeader::fromPayload(m_object);
-        Address* start = reinterpret_cast<Address*>(m_object);
-        Address* limit = reinterpret_cast<Address*>(header->payloadEnd());
-
-        for (Address* p = start; p < limit; p++) {
-            Address address = *p;
-            Address* castAddress = reinterpret_cast<Address*>(address);
-            // Find out whether the pointer looks like a pointer to another
-            // object on the heap. We ignore pointers within the object itself.
-            // We assume that things that are not object aligned are not
-            // actually pointers.
-            if ((castAddress < start || castAddress >= limit)
-                && Heap::contains(address) && isObjectAligned(address))
-                action(this, address);
-        }
-    }
-
-    static void clearMarksAction(TraceChecker* self, Address address)
-    {
-        HeapObjectHeader* header = HeapObjectHeader::fromPayload(address);
-        // Unmark the object (if it was already marked) so that we can check
-        // the mark after the trace method to see if it has been marked again.
-        header->clearDebugMark();
-    }
-
-    static void checkDebugMarksAction(TraceChecker* self, Address address)
-    {
-        HeapObjectHeader* header = HeapObjectHeader::fromPayload(address);
-        if (!header->hasDebugMark()) {
-            self->reportMishandledPointer(
-                address,
-                "Failure to visit all intra-heap pointers in trace method");
-        }
-    }
-
-    static void checkMarkedAction(TraceChecker* self, Address address)
-    {
-        HeapObjectHeader* header = HeapObjectHeader::fromPayload(address);
-        if (!header->isMarked()) {
-            self->reportMishandledPointer(
-                address,
-                "Failure to visit all strong pointers or clear all weak pointers to dead objects");
-        }
-    }
-
-
-    void reportMishandledPointer(Address unvisitedAddress, const char* reason)
-    {
-        // Getting an assert in this method means either the trace method
-        // failed to visit a strong pointer, or the weak pointer callback failed
-        // to clear a weak pointer to an object that is dead.
-        class YouForgotToVisitAllPointersVisitor : public Visitor {
-        public:
-            virtual void visit(const void* objectPointer, TraceCallback callback)
-            {
-                ASSERT_NOT_REACHED(); // See comment below.
-            }
-        };
-
-        YouForgotToVisitAllPointersVisitor youForgotToVisitAllPointersVisitor;
-        // If the callback calls the visitor at least once it will assert, and
-        // we can catch the assert in the debugger with the offending callback
-        // on the stack, and the object that was insufficiently visited/cleared
-        // as its argument. In this frame, 'address' will tell you the pointer
-        // that was in the object, but which was not visited.
-        m_callback(&youForgotToVisitAllPointersVisitor, m_object);
-        // If we get here the callback did not even visit one pointer. Cause an
-        // assert here, and in the debugger you can get the address of the
-        // offending callback from the this->m_callback variable, and the
-        // unvisited/uncleared pointer from the 'address' argument. The object that
-        // contained the unvisited pointer is in this->m_object.
-        ASSERT_NOT_REACHED();
-    }
-
-    static bool isObjectAligned(Address address)
-    {
-        return !(reinterpret_cast<uintptr_t>(address) & allocationMask);
-    }
-
-    void* m_object;
-    TraceCallback m_callback;
-    TraceRequirement m_traceRequirement;
-    TraceChecker* m_previous;
-    static TraceChecker* s_current;
-};
-
-TraceChecker* TraceChecker::s_current;
-
-#else // !ENABLE_TRACE_CHECKER
-
-class TraceChecker {
-public:
-    TraceChecker(void*, TraceCallback, TraceRequirement) { }
-    static void rememberedToVisit(const HeapObjectHeader*) { }
-    static void init() { }
-    static void registerWeakPointers() { }
-};
-#endif // ENABLE_TRACE_CHECKER
-
 #if TRACE_GC_USING_CLASSOF
 static const char* classOf(const void* object)
 {
     void* obj = const_cast<void*>(object);
     BaseHeapPage* page =
         reinterpret_cast<BaseHeapPage*>(pageHeaderAddress(reinterpret_cast<Address>(obj)));
     const GCMap* info = page->gcInfo();
     if (info) {
         // The GCInfo is set only on typed heap pages.
         ASSERT(info->m_classOf);
         return info->m_classOf(obj);
     }
     return FinalizedHeapObjectHeader::fromPayload(object)->classOf();
 }
 #endif
 
 class MarkingVisitor : public Visitor {
 public:
 #if defined(TRACE_GC_MARKING) && TRACE_GC_MARKING
     typedef std::set<intptr_t> LiveObjectSet;
     typedef std::map<std::string, std::set<intptr_t> > LiveObjectMap;
 #endif
 
     inline void visitHeader(HeapObjectHeader* header, const void* objectPointer, TraceCallback callback)
     {
         ASSERT(header);
         ASSERT(objectPointer);
-        TraceChecker::rememberedToVisit(header);
         if (header->isMarked())
             return;
         header->mark();
 #if defined(TRACE_GC_MARKING) && TRACE_GC_MARKING
         const std::string className(classOf(objectPointer));
         currentlyLive()[className].insert(reinterpret_cast<intptr_t>(objectPointer));
         printf("%s[%p] -> %s[%p]\n", m_hostName, m_hostObject, className.c_str(), objectPointer);
 #endif
         if (callback)
             Heap::pushTraceCallback(const_cast<void*>(objectPointer), callback);
     }
 
-    virtual void visit(HeapObjectHeader* header, TraceCallback callback)
+    virtual void mark(HeapObjectHeader* header, TraceCallback callback)
     {
         // We need both the HeapObjectHeader and FinalizedHeapObjectHeader version to
         // correctly find the payload.
         visitHeader(header, header->payload(), callback);
     }
 
-    virtual void visit(FinalizedHeapObjectHeader* header, TraceCallback callback)
+    virtual void mark(FinalizedHeapObjectHeader* header, TraceCallback callback)
     {
         // We need both the HeapObjectHeader and FinalizedHeapObjectHeader version to
         // correctly find the payload.
         visitHeader(header, header->payload(), callback);
     }
 
-    virtual void visit(const void* objectPointer, TraceCallback callback)
+    virtual void mark(const void* objectPointer, TraceCallback callback)
     {
         if (!objectPointer)
             return;
         FinalizedHeapObjectHeader* header = FinalizedHeapObjectHeader::fromPayload(objectPointer);
         visitHeader(header, header->payload(), callback);
     }
 
     virtual void registerWeakPointers(const void* containingObject, WeakPointerCallback callback)
     {
-        TraceChecker::registerWeakPointers();
         Heap::pushWeakCallback(const_cast<void*>(containingObject), callback);
     }
 
     virtual bool isMarked(const void* objectPointer)
     {
         return FinalizedHeapObjectHeader::fromPayload(objectPointer)->isMarked();
     }
 
 // Macro to help defining the necessary visitor methods for typed heaps
 #define DEFINE_VISITOR_METHODS(Type)                                             \
-    virtual void visit(const Type* objectPointer, TraceCallback callback)       \
+    virtual void mark(const Type* objectPointer, TraceCallback callback)         \
     {                                                                            \
         if (!objectPointer)                                                      \
             return;                                                              \
         HeapObjectHeader* header = HeapObjectHeader::fromPayload(objectPointer); \
         visitHeader(header, header->payload(), callback);                        \
     }                                                                            \
     virtual bool isMarked(const Type* objectPointer)                             \
     {                                                                            \
         return HeapObjectHeader::fromPayload(objectPointer)->isMarked();         \
     }
@@ skipping 153 matching lines @@
     if (byte <= 0x3F) {
         result += 2;
         byte = byte << 2;
     }
     if (byte <= 0x7F)
         result++;
     return result;
 }
 
 template<typename Header>
-bool HeapPage<Header>::checkAndVisitPointer(Visitor* visitor, Address addr)
+bool HeapPage<Header>::checkAndMarkPointer(Visitor* visitor, Address addr)
 {
     if (addr < payload())
         return false;
     if (!isObjectStartBitMapComputed())
         populateObjectStartBitMap();
     size_t objectOffset = addr - payload();
     size_t objectStartNumber = objectOffset / allocationGranularity;
     size_t mapIndex = objectStartNumber / 8;
     ASSERT(mapIndex < objectStartBitMapSize);
     size_t bit = objectStartNumber & 7;
     uint8_t byte = m_objectStartBitMap[mapIndex] & ((1 << (bit + 1)) - 1);
     while (!byte) {
         ASSERT(mapIndex > 0);
         byte = m_objectStartBitMap[--mapIndex];
     }
     int leadingZeroes = numberOfLeadingZeroes(byte);
     objectStartNumber = (mapIndex * 8) + 7 - leadingZeroes;
     objectOffset = objectStartNumber * allocationGranularity;
     Address objectAddress = objectOffset + payload();
     Header* header = reinterpret_cast<Header*>(objectAddress);
     if (header->isFree())
         return false;
 
 #if defined(TRACE_GC_MARKING) && TRACE_GC_MARKING
     visitor->setHostInfo(&addr, "stack");
 #endif
-    visitor->visit(header, traceCallback(header));
+    visitor->mark(header, traceCallback(header));
     return true;
 }
 
 #if USE_ASAN
 template<typename Header>
 void HeapPage<Header>::poisonUnmarkedObjects()
 {
     for (Address headerAddress = payload(); headerAddress < end(); ) {
         Header* header = reinterpret_cast<Header*>(headerAddress);
         ASSERT(header->size() < writablePageSize());
@@ skipping 79 matching lines @@
 static void markingTrampoline(VisitorCallback callback, Visitor* visitor, void* p)
 {
 #if defined(TRACE_GC_MARKING) && TRACE_GC_MARKING
     visitor->setHostInfo(p, classOf(p));
 #endif
     callback(visitor, p);
 }
 
 bool Heap::popAndTraceMarkingStack(Visitor* visitor)
 {
-    return s_markingStack->popAndTrace(&s_markingStack, visitor, AllPointersMustBeVisited, markingTrampoline);
+    return s_markingStack->popAndTrace(&s_markingStack, visitor, markingTrampoline);
 }
 
 static void weakTrampoline(VisitorCallback callback, Visitor* visitor, void* p)
 {
     callback(visitor, p);
 }
 
 bool Heap::popAndCallbackWeakPointer(Visitor* visitor)
 {
-    return s_weakCallbackStack->popAndTrace(&s_weakCallbackStack, visitor, AllPointersMustBeMarked, weakTrampoline);
+    return s_weakCallbackStack->popAndTrace(&s_weakCallbackStack, visitor, weakTrampoline);
 }
 
 class GCScope {
 public:
     GCScope(ThreadState::StackState stackState)
         : m_state(ThreadState::Current())
     {
         m_state->setGCRequested(false);
         m_state->checkThread();
 
@@ skipping 101 matching lines @@
 #if defined(TRACE_GC_MARKING) && TRACE_GC_MARKING
     marker.reportStats();
 #endif
 
     {
         PERF_STATS(ScopedTimer weakCallbackTimer(collectStats ? PerfStats::get(PerfStats::WeakCallback) : 0));
         // Call weak callbacks on objects that may now be pointing to dead
         // objects.
         while (popAndCallbackWeakPointer(&marker)) { }
     }
-    // It is not permitted to visit pointers of live objects in the weak
+    // It is not permitted to trace pointers of live objects in the weak
     // callback phase, so the marking stack should still be empty here.
     s_markingStack->assertIsEmpty();
 }
 
 void Heap::pushTraceCallback(void* object, TraceCallback callback)
 {
     ASSERT(Heap::contains(object));
     CallbackStack::Item* slot = s_markingStack->allocateEntry(&s_markingStack);
     *slot = CallbackStack::Item(object, callback);
 }
 
 void Heap::pushWeakCallback(void* object, WeakPointerCallback callback)
 {
     CallbackStack::Item* slot = s_weakCallbackStack->allocateEntry(&s_weakCallbackStack);
     *slot = CallbackStack::Item(object, callback);
 }
 
 bool CallbackStack::popAndTrace(
     CallbackStack** first,
     Visitor* visitor,
-    TraceRequirement requirement,
     TraceTrampoline trampoline)
 {
     if (m_current == &(m_buffer[0])) {
         if (!m_next) {
 #ifndef NDEBUG
             clearUnused();
 #endif
             return false;
         }
         CallbackStack* nextStack = m_next;
         *first = nextStack;
         delete this;
-        return nextStack->popAndTrace(first, visitor, requirement, trampoline);
+        return nextStack->popAndTrace(first, visitor, trampoline);
     }
     Item* item = --m_current;
-    TraceChecker checker(item->object(), item->callback(), requirement);
     trampoline(item->callback(), visitor, item->object());
 
     return true;
 }
 
 template<typename Header>
 ThreadHeap<Header>::ThreadHeap(ThreadState* state)
     : m_inFinalizeAll(false)
     , m_firstPage(0)
     , m_firstLargeHeapObject(0)
@@ skipping 108 matching lines @@
     doNothingTrace,
     0,
     false
 };
 
 #ifdef ENABLE_PERF_STATS
 bool Heap::s_isCollectingStats = false;
 #endif
 
 } // namespace WebCore