[oilpan] Rename visit to mark.

Source/heap/Heap.h

 /*
  * 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 207 matching lines @@
 
     inline Address payload();
     inline size_t payloadSize();
     inline Address payloadEnd();
 
     inline void setDebugMark();
     inline void clearDebugMark();
     inline bool hasDebugMark() const;
 
     // Zap magic number with a new magic number that means there was once an
-    // object allocated here, but it was freed because nobody visited it during
+    // object allocated here, but it was freed because nobody marked it during
     // GC.
     void zapMagic();
 
     static void finalize(const GCInfo*, Address, size_t);
     static HeapObjectHeader* fromPayload(const void*);
 
     static const intptr_t magic = 0xc0de247;
     static const intptr_t zappedMagic = 0xC0DEdead;
     static const intptr_t zappedVTable = 0xd0d; // should be < 4K to ensure it cannot be used for dispatch
 
@@ skipping 102 matching lines @@
 public:
     BaseHeapPage(PageMemory* storage, const GCInfo* gcInfo)
         : m_storage(storage)
         , m_gcInfo(gcInfo)
     {
         ASSERT(isPageHeaderAddress(reinterpret_cast<Address>(this)));
     }
 
     Address address() { return reinterpret_cast<Address>(this); }
     const GCInfo* gcInfo() { return m_gcInfo; }
-    virtual bool checkAndVisitPointer(Visitor*, Address) = 0;
+    virtual bool checkAndMarkPointer(Visitor*, Address) = 0;
 
     PageMemory* storage() const { return m_storage; }
 
 private:
     union {
         PageMemory* m_storage;
         uint64_t m_dummy;
     };
     const GCInfo* m_gcInfo;
 };
@@ skipping 39 matching lines @@
 
     Header* heapObjectHeader()
     {
         Address headerAddress = address() + sizeof(LargeHeapObject<Header>);
         return reinterpret_cast<Header*>(headerAddress);
     }
 
     bool isMarked();
     void unmark();
     void getStats(HeapStats&);
-    void visit(Visitor*);
+    void trace(Visitor*);

[Erik Corry, 2013/12/06 10:30:33]

Should this not be mark?

[Mads Ager (chromium), 2013/12/06 11:00:10]

Yeah, I probably went a little bit too far with this one. We are tracing the
LargeHeapObject to mark to actual object in there, but that is far-fetched. I'll
rename to mark. Thanks!

     void finalize();
-    virtual bool checkAndVisitPointer(Visitor*, Address);
+    virtual bool checkAndMarkPointer(Visitor*, Address);
 
 private:
     friend class Heap;
     friend class ThreadHeap<Header>;
 
     LargeHeapObject<Header>* m_next;
 };
 
 template<typename T>
 void heapAllocatedFinalizer(void* object)
@@ skipping 82 matching lines @@
     HeapPage* next() { return m_next; }
     Address payload() { return address() + sizeof(*this); }
     static size_t payloadSize() { return (writablePageSize() - sizeof(HeapPage)) & ~allocationMask; }
     Address end() { return payload() + payloadSize(); }
 
     void getStats(HeapStats&);
     void clearMarks();
     void sweep();
     void clearObjectStartBitMap();
     void finalize(Header*);
-    virtual bool checkAndVisitPointer(Visitor*, Address);
+    virtual bool checkAndMarkPointer(Visitor*, Address);
     ThreadHeap<Header>* heap() { return m_heap; }
 #if USE_ASAN
     void poisonUnmarkedObjects();
 #endif
 
 protected:
     void populateObjectStartBitMap();
     bool isObjectStartBitMapComputed() { return m_union.m_objectStartBitMapComputed; }
     TraceCallback traceCallback(Header*);
 
@@ skipping 60 matching lines @@
     };
 
     static const int numberOfEntriesLog2 = 12;
     static const int numberOfEntries = 1 << numberOfEntriesLog2;
 
     OwnArrayPtr<HeapContainsCache::Entry> m_entries;
 
     friend class ThreadState;
 };
 
-enum TraceRequirement {
-    // TraceChecker does not perform checks, because there are weak pointers
-    // present that cannot be distinguished from pointers that were incorrectly
-    // not visited. Later, however, we can check that the weak pointers were
-    // cleared by the weak pointer callback.
-    NoRequirement,
-    // The trace method must visit all member pointers.
-    AllPointersMustBeVisited,
-    // All member pointers must be marked live if they were not already. This
-    // also means that all weak pointers must be cleared if they are not
-    // pointing to objects that are marked live.
-    AllPointersMustBeMarked
-};
-
 typedef void (*TraceTrampoline)(VisitorCallback, Visitor*, void*);
 
 class Heap {
 public:
     static void init(intptr_t* startOfStack);
     static void shutdown();
 
     static bool contains(Address);
     static bool contains(void* pointer) { return contains(reinterpret_cast<Address>(pointer)); }
     static bool contains(const void* pointer) { return contains(const_cast<void*>(pointer)); }
@@ skipping 20 matching lines @@
 
     enum CollectionType {
         Normal,
         ForcedForTesting
     };
     static void collectGarbage(ThreadState::StackState, CollectionType = Normal);
 
     static void prepareForGC();
 
     static void visitRoots(Visitor*);
-    static Address checkAndVisitPointer(Visitor*, Address);
+    static Address checkAndMarkPointer(Visitor*, Address);
 
     static void getStats(HeapStats*);
 
     static bool isConsistentForGC();
     static void makeConsistentForGC();
     static BaseHeapPage* heapPageFromAddress(Address);
 
     static bool s_heapWasInitialized;
 
 #ifdef ENABLE_PERF_STATS
@@ skipping 18 matching lines @@
 };
 
 // Non-template super class used to pass a heap around to other classes.
 class BaseHeap {
 public:
     virtual ~BaseHeap() { }
 
     // Large objects and adding pages are handled by the ThreadHeap
     virtual BaseHeapPage* heapPageFromAddress(Address) = 0;
     virtual BaseHeapPage* largeHeapObjectFromAddress(Address) = 0;
-    virtual bool checkAndVisitLargeHeapObjects(Visitor*, Address) = 0;
+    virtual bool checkAndMarkLargeHeapObjects(Visitor*, Address) = 0;
     virtual void sweep() = 0;
     virtual void finalizeAll(const void* except = 0) = 0;
     virtual bool inFinalizeAll() = 0;
     virtual void clearFreeLists() = 0;
     virtual void clearMarks() = 0;
 #ifndef NDEBUG
     virtual void getScannedStats(HeapStats&) = 0;
 #endif
 
     // Heap can be either ready for allocation or in a consistent state for
     // scanning.
     virtual void makeConsistentForGC() = 0;
     virtual bool isConsistentForGC() = 0;
 
     // Returns a bucket number for inserting a FreeListEntry of a given size.
     // All FreeListEntries in the given bucket, n, have size >= 2^n.
     static int bucketIndexForSize(size_t);
 };
 
 template<typename Header>
 class ThreadHeap : public BaseHeap {
 public:
     ThreadHeap(ThreadState*);
     virtual ~ThreadHeap();
 
     virtual BaseHeapPage* heapPageFromAddress(Address);
     virtual BaseHeapPage* largeHeapObjectFromAddress(Address);
-    virtual bool checkAndVisitLargeHeapObjects(Visitor*, Address);
+    virtual bool checkAndMarkLargeHeapObjects(Visitor*, Address);
     virtual void sweep();
     virtual void finalizeAll(const void* except = 0);
     virtual bool inFinalizeAll() { return m_inFinalizeAll; }
     virtual void clearFreeLists();
     virtual void clearMarks();
 #ifndef NDEBUG
     virtual void getScannedStats(HeapStats&);
 #endif
 
     // Heap can be either ready for allocation or in a consistent state for
@@ skipping 337 matching lines @@
         void* object() { return m_object; }
         VisitorCallback callback() { return m_callback; }
 
     private:
         void* m_object;
         VisitorCallback m_callback;
     };
 
     static void init(CallbackStack** first);
     static void shutdown(CallbackStack** first);
-    bool popAndTrace(CallbackStack** first, Visitor*, TraceRequirement, TraceTrampoline);
+    bool popAndTrace(CallbackStack** first, Visitor*, TraceTrampoline);
 
     Item* allocateEntry(CallbackStack** first)
     {
         if (m_current < m_limit)
             return m_current++;
         return (new CallbackStack(first))->allocateEntry(first);
     }
 
 private:
     static const int bufferSize = 8000;
@@ skipping 61 matching lines @@
     int length = header->payloadSize() / sizeof(Value);
     // The hash table backing is unreachable and is going away, so it is not
     // important what is in this memory, but the entries have destructors, and
     // they need to be called.
     for (int i = 0; i < length; i++) {
         if (!WTF::HashTableHelper<Value, Extractor, KeyTraits>::isEmptyOrDeletedBucket(array[i]))
             array[i].~Value();
     }
 }
 
-template<bool visitWeakPointersStrongly, typename T, typename Traits>
+template<bool markWeakPointersStrongly, typename T, typename Traits>
 struct BaseVisitVectorBackingTrait {
-    static void visit(WebCore::Visitor* visitor, void* self)
+    static void mark(WebCore::Visitor* visitor, void* self)
     {
         // The alllocator can oversize the allocation a little, according to
         // the allocation granularity. The extra size is included in the
         // payloadSize call below, since there is nowhere to store the
         // originally allocated memory. This assert ensures that visiting the
         // last bit of memory can't cause trouble.
-        COMPILE_ASSERT(!Traits::needsVisiting || sizeof(T) > allocationGranularity || Traits::canInitializeWithMemset, HeapOverallocationCanCauseSpuriousVisits);
+        COMPILE_ASSERT(!Traits::needsMarking || sizeof(T) > allocationGranularity || Traits::canInitializeWithMemset, HeapOverallocationCanCauseSpuriousVisits);
 
         T* array = reinterpret_cast<T*>(self);
         WebCore::FinalizedHeapObjectHeader* header = WebCore::FinalizedHeapObjectHeader::fromPayload(self);
         // Use the payload size as recorded by the heap to determine how many
-        // elements to visit.
+        // elements to mark.
         int length = header->payloadSize() / sizeof(T);
         for (int i = 0; i < length; i++)
-            VisitCollectionBackingTrait<Traits::needsVisiting, Traits::isWeak, visitWeakPointersStrongly, T, Traits>::visit(visitor, array[i]);
+            CollectionBackingTraceTrait<Traits::needsMarking, Traits::isWeak, markWeakPointersStrongly, T, Traits>::mark(visitor, array[i]);
     }
 };
 
-template<bool visitWeakPointersStrongly, typename Key, typename Value, typename Extractor, typename Traits, typename KeyTraits>
+template<bool markWeakPointersStrongly, typename Key, typename Value, typename Extractor, typename Traits, typename KeyTraits>
 struct BaseVisitHashTableBackingTrait {
-    static void visit(WebCore::Visitor* visitor, void* self)
+    static void mark(WebCore::Visitor* visitor, void* self)
     {
         Value* array = reinterpret_cast<Value*>(self);
         WebCore::FinalizedHeapObjectHeader* header = WebCore::FinalizedHeapObjectHeader::fromPayload(self);
         int length = header->payloadSize() / sizeof(Value);
         for (int i = 0; i < length; i++) {
             if (!WTF::HashTableHelper<Value, Extractor, KeyTraits>::isEmptyOrDeletedBucket(array[i]))
-                VisitCollectionBackingTrait<Traits::needsVisiting, Traits::isWeak, visitWeakPointersStrongly, Value, Traits>::visit(visitor, array[i]);
+                CollectionBackingTraceTrait<Traits::needsMarking, Traits::isWeak, markWeakPointersStrongly, Value, Traits>::mark(visitor, array[i]);
         }
     }
 };
 
-template<bool visitWeakPointersStrongly, typename Key, typename Value, typename Traits>
+template<bool markWeakPointersStrongly, typename Key, typename Value, typename Traits>
 struct BaseVisitKeyValuePairTrait {
-    static void visit(WebCore::Visitor* visitor, WTF::KeyValuePair<Key, Value>& self)
+    static void mark(WebCore::Visitor* visitor, WTF::KeyValuePair<Key, Value>& self)
     {
-        ASSERT(Traits::needsVisiting || (Traits::isWeak && visitWeakPointersStrongly));
-        VisitCollectionBackingTrait<Traits::KeyTraits::needsVisiting, Traits::KeyTraits::isWeak, visitWeakPointersStrongly, Key, typename Traits::KeyTraits>::visit(visitor, self.key);
-        VisitCollectionBackingTrait<Traits::ValueTraits::needsVisiting, Traits::ValueTraits::isWeak, visitWeakPointersStrongly, Value, typename Traits::ValueTraits>::visit(visitor, self.value);
+        ASSERT(Traits::needsMarking || (Traits::isWeak && markWeakPointersStrongly));
+        CollectionBackingTraceTrait<Traits::KeyTraits::needsMarking, Traits::KeyTraits::isWeak, markWeakPointersStrongly, Key, typename Traits::KeyTraits>::mark(visitor, self.key);
+        CollectionBackingTraceTrait<Traits::ValueTraits::needsMarking, Traits::ValueTraits::isWeak, markWeakPointersStrongly, Value, typename Traits::ValueTraits>::mark(visitor, self.value);
     }
 };
 
-// FFX - Things that don't need visiting and have no weak pointers.
-template<bool visitWeakPointersStrongly, typename T, typename U>
-struct VisitCollectionBackingTrait<false, false, visitWeakPointersStrongly, T, U> {
-    static void visit(Visitor*, const T&) { }
-    static void visit(Visitor*, const void*) { }
+// FFX - Things that don't need marking and have no weak pointers.
+template<bool markWeakPointersStrongly, typename T, typename U>
+struct CollectionBackingTraceTrait<false, false, markWeakPointersStrongly, T, U> {
+    static void mark(Visitor*, const T&) { }
+    static void mark(Visitor*, const void*) { }
 };
 
-// FTF - Things that don't need visiting. They have weak pointers, but we are
-// not visiting weak pointers in this object in this GC.
+// FTF - Things that don't need marking. They have weak pointers, but we are
+// not marking weak pointers in this object in this GC.
 template<typename T, typename U>
-struct VisitCollectionBackingTrait<false, true, false, T, U> {
-    static void visit(Visitor*, const T&) { }
-    static void visit(Visitor*, const void*) { }
+struct CollectionBackingTraceTrait<false, true, false, T, U> {
+    static void mark(Visitor*, const T&) { }
+    static void mark(Visitor*, const void*) { }
 };
 
 // For each type that we understand we have the FTT case and the TXX case. The
-// FTT case is where we would not normally need to visit it, but it has weak
-// pointers, and we are visiting them as strong. The TXX case is the regular
-// case for things that need visiting.
+// FTT case is where we would not normally need to mark it, but it has weak
+// pointers, and we are marking them as strong. The TXX case is the regular
+// case for things that need marking.
 
 // FTT (vector)
 template<typename T, typename Traits>
-struct VisitCollectionBackingTrait<false, true, true, HeapVectorBacking<T, Traits>, void> : public BaseVisitVectorBackingTrait<true, T, Traits> {
+struct CollectionBackingTraceTrait<false, true, true, HeapVectorBacking<T, Traits>, void> : public BaseVisitVectorBackingTrait<true, T, Traits> {
 };
 
 // TXX (vector)
-template<bool isWeak, bool visitWeakPointersStrongly, typename T, typename Traits>
-struct VisitCollectionBackingTrait<true, isWeak, visitWeakPointersStrongly, HeapVectorBacking<T, Traits>, void> : public BaseVisitVectorBackingTrait<visitWeakPointersStrongly, T, Traits> {
+template<bool isWeak, bool markWeakPointersStrongly, typename T, typename Traits>
+struct CollectionBackingTraceTrait<true, isWeak, markWeakPointersStrongly, HeapVectorBacking<T, Traits>, void> : public BaseVisitVectorBackingTrait<markWeakPointersStrongly, T, Traits> {
 };
 
 // FTT (hash table)
 template<typename Key, typename Value, typename Extractor, typename Traits, typename KeyTraits>
-struct VisitCollectionBackingTrait<false, true, true, HeapHashTableBacking<Key, Value, Extractor, Traits, KeyTraits>, void> : public BaseVisitHashTableBackingTrait<true, Key, Value, Extractor, Traits, KeyTraits> {
+struct CollectionBackingTraceTrait<false, true, true, HeapHashTableBacking<Key, Value, Extractor, Traits, KeyTraits>, void> : public BaseVisitHashTableBackingTrait<true, Key, Value, Extractor, Traits, KeyTraits> {
 };
 
 // TXX (hash table)
-template<bool isWeak, bool visitWeakPointersStrongly, typename Key, typename Value, typename Extractor, typename Traits, typename KeyTraits>
-struct VisitCollectionBackingTrait<true, isWeak, visitWeakPointersStrongly, HeapHashTableBacking<Key, Value, Extractor, Traits, KeyTraits>, void> : public BaseVisitHashTableBackingTrait<visitWeakPointersStrongly, Key, Value, Extractor, Traits, KeyTraits> {
+template<bool isWeak, bool markWeakPointersStrongly, typename Key, typename Value, typename Extractor, typename Traits, typename KeyTraits>
+struct CollectionBackingTraceTrait<true, isWeak, markWeakPointersStrongly, HeapHashTableBacking<Key, Value, Extractor, Traits, KeyTraits>, void> : public BaseVisitHashTableBackingTrait<markWeakPointersStrongly, Key, Value, Extractor, Traits, KeyTraits> {
 };
 
 // FTT (key value pair)
 template<typename Key, typename Value, typename Traits>
-struct VisitCollectionBackingTrait<false, true, true, WTF::KeyValuePair<Key, Value>, Traits> : public BaseVisitKeyValuePairTrait<true, Key, Value, Traits> {
+struct CollectionBackingTraceTrait<false, true, true, WTF::KeyValuePair<Key, Value>, Traits> : public BaseVisitKeyValuePairTrait<true, Key, Value, Traits> {
 };
 
 // TXX (key value pair)
-template<bool isWeak, bool visitWeakPointersStrongly, typename Key, typename Value, typename Traits>
-struct VisitCollectionBackingTrait<true, isWeak, visitWeakPointersStrongly, WTF::KeyValuePair<Key, Value>, Traits> : public BaseVisitKeyValuePairTrait<visitWeakPointersStrongly, Key, Value, Traits> {
+template<bool isWeak, bool markWeakPointersStrongly, typename Key, typename Value, typename Traits>
+struct CollectionBackingTraceTrait<true, isWeak, markWeakPointersStrongly, WTF::KeyValuePair<Key, Value>, Traits> : public BaseVisitKeyValuePairTrait<markWeakPointersStrongly, Key, Value, Traits> {
 };
 
 // TFX (member)
-template<bool visitWeakPointersStrongly, typename T, typename Traits>
-struct VisitCollectionBackingTrait<true, false, visitWeakPointersStrongly, Member<T>, Traits> {
-    static void visit(WebCore::Visitor* visitor, Member<T> self)
+template<bool markWeakPointersStrongly, typename T, typename Traits>
+struct CollectionBackingTraceTrait<true, false, markWeakPointersStrongly, Member<T>, Traits> {
+    static void mark(WebCore::Visitor* visitor, Member<T> self)
     {
-        visitor->visit(self.raw());
+        visitor->mark(self.raw());
     }
 };
 
 // FTT (weak member)
 template<typename T, typename Traits>
-struct VisitCollectionBackingTrait<false, true, true, WeakMember<T>, Traits> {
-    static void visit(WebCore::Visitor* visitor, WeakMember<T> self)
+struct CollectionBackingTraceTrait<false, true, true, WeakMember<T>, Traits> {
+    static void mark(WebCore::Visitor* visitor, WeakMember<T> self)
     {
-        // This can visit weak members as if they were strong. The reason we
+        // This can mark weak members as if they were strong. The reason we
         // need this is that we don't do weak processing unless we reach the
         // backing only through the hash table. Reaching it in any other way
         // makes it impossible to update the size and deleted slot count of the
         // table, and exposes us to weak processing during iteration issues.
-        visitor->visit(self.raw());
+        visitor->mark(self.raw());
     }
 };
 
 // Catch-all for things that have a way to trace. For things that contain weak
 // pointers they will generally be visited weakly even if
-// visitWeakPointersStrongly is true. This is what you want.
-template<bool isWeak, bool visitWeakPointersStrongly, typename T, typename Traits>
-struct VisitCollectionBackingTrait<true, isWeak, visitWeakPointersStrongly, T, Traits> {
-    static void visit(WebCore::Visitor* visitor, T& t)
+// markWeakPointersStrongly is true. This is what you want.
+template<bool isWeak, bool markWeakPointersStrongly, typename T, typename Traits>
+struct CollectionBackingTraceTrait<true, isWeak, markWeakPointersStrongly, T, Traits> {
+    static void mark(WebCore::Visitor* visitor, T& t)
     {
         TraceTrait<T>::trace(visitor, reinterpret_cast<void*>(&t));
     }
 };
 
 template<typename T, typename Traits>
 struct TraceTrait<HeapVectorBacking<T, Traits> > {
     typedef HeapVectorBacking<T, Traits> Backing;
     static void trace(WebCore::Visitor* visitor, void* self)
     {
         COMPILE_ASSERT(!Traits::isWeak, WeDontSupportWeaknessInHeapVectors);
-        if (Traits::needsVisiting)
-            VisitCollectionBackingTrait<Traits::needsVisiting, false, false, HeapVectorBacking<T, Traits>, void>::visit(visitor, self);
+        if (Traits::needsMarking)

[Erik Corry, 2013/12/06 10:30:33]

I think this should be needsTracing

[Mads Ager (chromium), 2013/12/06 11:00:10]

Yes, will fix.

+            CollectionBackingTraceTrait<Traits::needsMarking, false, false, HeapVectorBacking<T, Traits>, void>::mark(visitor, self);
     }
-    static void visit(Visitor* v, const Backing* p)
+    static void mark(Visitor* v, const Backing* p)
     {
-        v->visit(p, &trace);
+        v->mark(p, &trace);
     }
     static void checkTypeMarker(Visitor* visitor, const Backing* t)
     {
 #ifndef NDEBUG
         visitor->checkTypeMarker(const_cast<Backing*>(t), getTypeMarker<Backing>());
 #endif
     }
 };
 
 // The trace trait for the heap hashtable backing is used when we find a
 // direct pointer to the backing from the conservative stack scanner. This
 // normally indicates that there is an ongoing iteration over the table, and so
 // we disable weak processing of table entries. When the backing is found
 // through the owning hash table we mark differently, in order to do weak
 // processing.
 template<typename Key, typename Value, typename Extractor, typename Traits, typename KeyTraits>
 struct TraceTrait<HeapHashTableBacking<Key, Value, Extractor, Traits, KeyTraits> > {
     typedef HeapHashTableBacking<Key, Value, Extractor, Traits, KeyTraits> Backing;
-    static const bool needsVisiting = (Traits::needsVisiting || Traits::isWeak);
+    static const bool needsMarking = (Traits::needsMarking || Traits::isWeak);
     static void trace(WebCore::Visitor* visitor, void* self)
     {
-        if (needsVisiting)
-            VisitCollectionBackingTrait<Traits::needsVisiting, Traits::isWeak, true, HeapHashTableBacking<Key, Value, Extractor, Traits, KeyTraits>, void>::visit(visitor, self);
+        if (needsMarking)
+            CollectionBackingTraceTrait<Traits::needsMarking, Traits::isWeak, true, HeapHashTableBacking<Key, Value, Extractor, Traits, KeyTraits>, void>::mark(visitor, self);
     }
-    static void visit(Visitor* v, const Backing* p)
+    static void mark(Visitor* v, const Backing* p)
     {
-        if (needsVisiting)
-            v->visit(p, &trace);
+        if (needsMarking)
+            v->mark(p, &trace);
         else
-            v->visit(p, nullptr);
+            v->mark(p, nullptr);
     }
     static void checkTypeMarker(Visitor* visitor, const Backing* t)
     {
 #ifndef NDEBUG
         visitor->checkTypeMarker(const_cast<Backing*>(t), getTypeMarker<Backing>());
 #endif
     }
 };
 
 template<typename T, typename Traits>
 class HeapVectorBacking { };
 template<typename Key, typename Value, typename Extractor, typename Traits, typename KeyTraits>
 class HeapHashTableBacking { };
 
 
 } // namespace WebCore
 
 #endif