Introduce InlinedGlobalMarkingVisitor

Source/platform/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 167 matching lines @@
 
     virtual void checkAndMarkPointer(Visitor*, Address) override;
     virtual bool isLargeObject() override { return true; }
 
 #if ENABLE(GC_PROFILE_MARKING)
     virtual const GCInfo* findGCInfo(Address address)
     {
         if (!objectContains(address))
             return nullptr;
         return gcInfo();
-    }
+    h
 #endif
 
 #if ENABLE(GC_PROFILE_HEAP)
     void snapshot(TracedValue*, ThreadState::SnapshotInfo*);
 #endif
 
     void link(LargeObject<Header>** previousNext)
     {
         m_next = *previousNext;
         *previousNext = this;
@@ skipping 1227 matching lines @@
         return ThreadState::current()->isAllocationAllowed();
     }
 
     static void markUsingGCInfo(Visitor* visitor, const void* buffer)
     {
         visitor->mark(buffer, GeneralHeapObjectHeader::fromPayload(buffer)->traceCallback());
     }
 
     static void markNoTracing(Visitor* visitor, const void* t) { visitor->markNoTracing(t); }
 
-    template<typename T, typename Traits>
-    static void trace(Visitor* visitor, T& t)
+    template<typename T, typename Traits, typename VisitorDispatcher>
+    static void trace(VisitorDispatcher visitor, T& t)
     {
         CollectionBackingTraceTrait<WTF::ShouldBeTraced<Traits>::value, Traits::weakHandlingFlag, WTF::WeakPointersActWeak, T, Traits>::trace(visitor, t);
     }
 
     static void registerDelayedMarkNoTracing(Visitor* visitor, const void* object)
     {
         visitor->registerDelayedMarkNoTracing(object);
     }
 
     static void registerWeakMembers(Visitor* visitor, const void* closure, const void* object, WeakPointerCallback callback)
@@ skipping 552 matching lines @@
 namespace WTF {
 
 // Catch-all for types that have a way to trace that don't have special
 // handling for weakness in collections.  This means that if this type
 // contains WeakMember fields, they will simply be zeroed, but the entry
 // will not be removed from the collection.  This always happens for
 // things in vectors, which don't currently support special handling of
 // weak elements.
 template<ShouldWeakPointersBeMarkedStrongly strongify, typename T, typename Traits>
 struct TraceInCollectionTrait<NoWeakHandlingInCollections, strongify, T, Traits> {
-    static bool trace(blink::Visitor* visitor, T& t)
+    template<typename VisitorDispatcher>
+    static bool trace(VisitorDispatcher visitor, T& t)
     {
         blink::TraceTrait<T>::trace(visitor, &t);
         return false;
     }
 };
 
 template<ShouldWeakPointersBeMarkedStrongly strongify, typename T, typename Traits>
 struct TraceInCollectionTrait<NoWeakHandlingInCollections, strongify, blink::Member<T>, Traits> {
-    static bool trace(blink::Visitor* visitor, blink::Member<T>& t)
+    template<typename VisitorDispatcher>
+    static bool trace(VisitorDispatcher visitor, blink::Member<T>& t)
     {
         blink::TraceTrait<T>::mark(visitor, const_cast<typename RemoveConst<T>::Type*>(t.get()));
         return false;
     }
 };
 
 // Catch-all for things that have HashTrait support for tracing with weakness.
 template<ShouldWeakPointersBeMarkedStrongly strongify, typename T, typename Traits>
 struct TraceInCollectionTrait<WeakHandlingInCollections, strongify, T, Traits> {
     static bool trace(blink::Visitor* visitor, T& t)
@@ skipping 164 matching lines @@
 
 namespace blink {
 
 // CollectionBackingTraceTrait.  Do nothing for things in collections that don't
 // need tracing, or call TraceInCollectionTrait for those that do.
 
 // Specialization for things that don't need marking and have no weak pointers.
 // We do nothing, even if WTF::WeakPointersActStrong.
 template<WTF::ShouldWeakPointersBeMarkedStrongly strongify, typename T, typename Traits>
 struct CollectionBackingTraceTrait<false, WTF::NoWeakHandlingInCollections, strongify, T, Traits> {
-    static bool trace(Visitor*, T&) { return false; }
+    template<typename VisitorDispatcher> static bool trace(VisitorDispatcher, T&) { return false; }
 };
 
 template<typename T>
 static void verifyGarbageCollectedIfMember(T*)
 {
 }
 
 template<typename T>
 static void verifyGarbageCollectedIfMember(Member<T>* t)
 {
     COMPILE_ASSERT_IS_GARBAGE_COLLECTED(T, NonGarbageCollectedObjectInMember);
 }
 
 // Specialization for things that either need marking or have weak pointers or
 // both.
 template<bool needsTracing, WTF::WeakHandlingFlag weakHandlingFlag, WTF::ShouldWeakPointersBeMarkedStrongly strongify, typename T, typename Traits>
 struct CollectionBackingTraceTrait {
-    static bool trace(Visitor* visitor, T&t)
+    template<typename VisitorDispatcher> static bool trace(VisitorDispatcher visitor, T& t)
     {
         verifyGarbageCollectedIfMember(reinterpret_cast<T*>(0));
         return WTF::TraceInCollectionTrait<weakHandlingFlag, strongify, T, Traits>::trace(visitor, t);
     }
 };
 
 template<typename T> struct WeakHandlingHashTraits : WTF::SimpleClassHashTraits<T> {
     // We want to treat the object as a weak object in the sense that it can
     // disappear from hash sets and hash maps.
     static const WTF::WeakHandlingFlag weakHandlingFlag = WTF::WeakHandlingInCollections;
@@ skipping 94 matching lines @@
 struct GCInfoTrait<HeapLinkedHashSet<T, U, V>> : public GCInfoTrait<LinkedHashSet<T, U, V, HeapAllocator>> { };
 template<typename T, size_t inlineCapacity, typename U>
 struct GCInfoTrait<HeapListHashSet<T, inlineCapacity, U>> : public GCInfoTrait<ListHashSet<T, inlineCapacity, U, HeapListHashSetAllocator<T, inlineCapacity>> > { };
 template<typename T, size_t inlineCapacity>
 struct GCInfoTrait<HeapVector<T, inlineCapacity>> : public GCInfoTrait<Vector<T, inlineCapacity, HeapAllocator>> { };
 template<typename T, size_t inlineCapacity>
 struct GCInfoTrait<HeapDeque<T, inlineCapacity>> : public GCInfoTrait<Deque<T, inlineCapacity, HeapAllocator>> { };
 template<typename T, typename U, typename V>
 struct GCInfoTrait<HeapHashCountedSet<T, U, V>> : public GCInfoTrait<HashCountedSet<T, U, V, HeapAllocator>> { };
 
+NO_SANITIZE_ADDRESS inline
+bool HeapObjectHeader::isMarked() const
+{
+    checkHeader();
+    return m_size & markBitMask;
+}
+
+NO_SANITIZE_ADDRESS inline
+void HeapObjectHeader::mark()
+{
+    checkHeader();
+    ASSERT(!isMarked());
+    m_size = m_size | markBitMask;
+}
+
+ALWAYS_INLINE bool InlinedGlobalMarkingVisitor::isMarked(const void* objectPointer)
+{
+    return GeneralHeapObjectHeader::fromPayload(objectPointer)->isMarked();
+}
+
+ALWAYS_INLINE void InlinedGlobalMarkingVisitor::visitHeader(HeapObjectHeader* header, const void* objectPointer, TraceCallback callback)
+{
+    ASSERT(header);
+    ASSERT(objectPointer);
+    // Check that we are not marking objects that are outside
+    // the heap by calling Heap::contains.  However we cannot
+    // call Heap::contains when outside a GC and we call mark
+    // when doing weakness for ephemerons.  Hence we only check
+    // when called within.
+    ASSERT(!ThreadState::current()->isInGC() || Heap::containedInHeapOrOrphanedPage(header));
+
+    // If you hit this ASSERT, it means that there is a dangling pointer
+    // from a live thread heap to a dead thread heap.  We must eliminate
+    // the dangling pointer.
+    // Release builds don't have the ASSERT, but it is OK because
+    // release builds will crash in the following header->isMarked()
+    // because all the entries of the orphaned heaps are zapped.
+    ASSERT(!pageFromObject(objectPointer)->orphaned());
+
+    if (header->isMarked())
+        return;
+    header->mark();
+
+#if ENABLE(GC_PROFILE_MARKING)
+    QUACK!
+#endif
+    if (callback)
+        m_visitor->pushTraceCallback(const_cast<void*>(objectPointer), callback);
+}
+
+ALWAYS_INLINE void InlinedGlobalMarkingVisitor::mark(const void* objectPointer, TraceCallback callback)
+{
+    if (!objectPointer)
+        return;
+    GeneralHeapObjectHeader* header = GeneralHeapObjectHeader::fromPayload(objectPointer);
+    visitHeader(header, header->payload(), callback);
+}
+
+ALWAYS_INLINE bool InlinedGlobalMarkingVisitor::ensureMarked(const void* objectPointer)
+{
+    if (!objectPointer)
+        return false;
+#if ENABLE(ASSERT)
+    if (isMarked(objectPointer))
+        return false;
+
+    markNoTracing(objectPointer);
+#else
+    // Inline what the above markNoTracing() call expands to,
+    // so as to make sure that we do get all the benefits.
+    GeneralHeapObjectHeader* header =
+        GeneralHeapObjectHeader::fromPayload(objectPointer);
+    if (header->isMarked())
+        return false;
+    header->mark();
+#endif
+    return true;
+}
+
 } // namespace blink
 
 #endif // Heap_h