Introduce InlinedGlobalMarkingVisitor

Source/platform/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 432 matching lines @@
         }
     }
 
 private:
     ThreadState* m_state;
     ThreadState::SafePointScope m_safePointScope;
     bool m_parkedAllThreads; // False if we fail to park all threads
 };
 
 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;
-}
-
-NO_SANITIZE_ADDRESS inline
 void HeapObjectHeader::unmark()
 {
     checkHeader();
     ASSERT(isMarked());
     m_size &= ~markBitMask;
 }
 
 NO_SANITIZE_ADDRESS inline
 bool HeapObjectHeader::isDead() const
 {
@@ skipping 1542 matching lines @@
             result.storedValue->value.add(reinterpret_cast<uintptr_t>(objectPointer));
         }
         ObjectGraph::AddResult result = objectGraph().add(reinterpret_cast<uintptr_t>(objectPointer), std::make_pair(reinterpret_cast<uintptr_t>(m_hostObject), m_hostName));
         ASSERT(result.isNewEntry);
         // fprintf(stderr, "%s[%p] -> %s[%p]\n", m_hostName.ascii().data(), m_hostObject, className.ascii().data(), objectPointer);
 #endif
         if (callback)
             Heap::pushTraceCallback(m_markingStack, const_cast<void*>(objectPointer), callback);
     }
 
+    virtual void pushTraceCallback(void* objectPointer, TraceCallback callback)
+    {
+        ASSERT(callback);
+        Heap::pushTraceCallback(m_markingStack, objectPointer, callback);
+    }
+
     // We need both HeapObjectHeader and GeneralHeapObjectHeader versions to
     // correctly find the payload.
     virtual void mark(HeapObjectHeader* header, TraceCallback callback) override
     {
         visitHeader(header, header->payload(), callback);
     }
 
     virtual void mark(GeneralHeapObjectHeader* header, TraceCallback callback) override
     {
         visitHeader(header, header->payload(), callback);
@@ skipping 206 matching lines @@
     static inline bool objectInTerminatingThreadHeap(const void* objectPointer)
     {
         BaseHeapPage* page = pageFromObject(objectPointer);
         ASSERT(!page->orphaned());
         // When doing a thread local GC, the marker checks if
         // the object resides in another thread's heap. The
         // object should not be traced, if it does.
         return page->terminating();
     }
 
+    virtual bool isGlobalMarkingVisitor() override { return Mode == GlobalMarking; }
+
 protected:
     virtual void registerWeakCell(void** cell, WeakPointerCallback callback) override
     {
         Heap::pushWeakCellPointerCallback(cell, callback);
     }
 
 private:
     CallbackStack* m_markingStack;
 };
 
@@ skipping 676 matching lines @@
 bool Heap::s_shutdownCalled = false;
 bool Heap::s_lastGCWasConservative = false;
 FreePagePool* Heap::s_freePagePool;
 OrphanedPagePool* Heap::s_orphanedPagePool;
 Heap::RegionTree* Heap::s_regionTree = nullptr;
 size_t Heap::s_allocatedObjectSize = 0;
 size_t Heap::s_allocatedSpace = 0;
 size_t Heap::s_markedObjectSize = 0;
 
 } // namespace blink