[NotForCommit] inline ensureMarked.

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 434 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 11 matching lines @@
 
 #if ENABLE(ASSERT)
 NO_SANITIZE_ADDRESS
 void HeapObjectHeader::zapMagic()
 {
     checkHeader();
     m_magic = zappedMagic;
 }
 #endif
 
-HeapObjectHeader* HeapObjectHeader::fromPayload(const void* payload)
-{
-    Address addr = reinterpret_cast<Address>(const_cast<void*>(payload));
-    HeapObjectHeader* header =
-        reinterpret_cast<HeapObjectHeader*>(addr - sizeof(HeapObjectHeader));
-    return header;
-}
-
 void HeapObjectHeader::finalize(const GCInfo* gcInfo, Address object, size_t objectSize)
 {
     ASSERT(gcInfo);
     if (gcInfo->hasFinalizer()) {
         gcInfo->m_finalize(object);
     }
 
 #if ENABLE(ASSERT) || defined(LEAK_SANITIZER) || defined(ADDRESS_SANITIZER)
     // In Debug builds, memory is zapped when it's freed, and the zapped memory is
     // zeroed out when the memory is reused. Memory is also zapped when using Leak
@@ skipping 100 matching lines @@
     heapObjectHeader()->finalize();
 }
 
 template<>
 void LargeObject<HeapObjectHeader>::finalize()
 {
     ASSERT(gcInfo());
     HeapObjectHeader::finalize(gcInfo(), payload(), payloadSize());
 }
 
-GeneralHeapObjectHeader* GeneralHeapObjectHeader::fromPayload(const void* payload)
-{
-    Address addr = reinterpret_cast<Address>(const_cast<void*>(payload));
-    GeneralHeapObjectHeader* header =
-        reinterpret_cast<GeneralHeapObjectHeader*>(addr - sizeof(GeneralHeapObjectHeader));
-    return header;
-}
-
 template<typename Header>
 ThreadHeap<Header>::ThreadHeap(ThreadState* state, int index)
     : m_currentAllocationPoint(0)
     , m_remainingAllocationSize(0)
     , m_lastRemainingAllocationSize(0)
     , m_firstPage(0)
     , m_firstLargeObject(0)
     , m_firstPageAllocatedDuringSweeping(0)
     , m_lastPageAllocatedDuringSweeping(0)
     , m_firstLargeObjectAllocatedDuringSweeping(0)
@@ skipping 1318 matching lines @@
 void Heap::flushHeapDoesNotContainCache()
 {
     s_heapDoesNotContainCache->flush();
 }
 
 static void markNoTracingCallback(Visitor* visitor, void* object)
 {
     visitor->markNoTracing(object);
 }
 
-enum MarkingMode {
-    GlobalMarking,
-    ThreadLocalMarking,
-};
-
 template<MarkingMode Mode>
 class MarkingVisitor final : public Visitor {
 public:
 #if ENABLE(GC_PROFILE_MARKING)
     typedef HashSet<uintptr_t> LiveObjectSet;
     typedef HashMap<String, LiveObjectSet> LiveObjectMap;
     typedef HashMap<uintptr_t, std::pair<uintptr_t, String> > ObjectGraph;
 #endif
 
     explicit MarkingVisitor(CallbackStack* markingStack)
-        : m_markingStack(markingStack)
+        : Visitor(Mode)
+        , m_markingStack(markingStack)
     {
     }
 
     inline void 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
@@ skipping 70 matching lines @@
     {
         return Heap::weakTableRegistered(closure);
     }
 #endif
 
     virtual bool isMarked(const void* objectPointer) override
     {
         return GeneralHeapObjectHeader::fromPayload(objectPointer)->isMarked();
     }
 
-    virtual bool ensureMarked(const void* objectPointer) override
-    {
-        if (!objectPointer)
-            return false;
-        if (Mode == ThreadLocalMarking && !objectInTerminatingThreadHeap(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;
-    }
-
+    /*
 #if ENABLE(ASSERT)
 #define DEFINE_ENSURE_MARKED_METHOD(Type)                                                       \
     virtual bool ensureMarked(const Type* objectPointer) override                               \
     {                                                                                           \
         if (!objectPointer)                                                                     \
             return false;                                                                       \
         COMPILE_ASSERT(!NeedsAdjustAndMark<Type>::value, CanOnlyUseIsMarkedOnNonAdjustedTypes); \
         if (Mode == ThreadLocalMarking && !objectInTerminatingThreadHeap(objectPointer))        \
             return false;                                                                       \
         if (isMarked(objectPointer))                                                            \
@@ skipping 10 matching lines @@
         if (Mode == ThreadLocalMarking && !objectInTerminatingThreadHeap(objectPointer))        \
             return false;                                                                       \
         HeapObjectHeader* header =                                                              \
             HeapObjectHeader::fromPayload(objectPointer);                                       \
         if (header->isMarked())                                                                 \
             return false;                                                                       \
         header->mark();                                                                         \
         return true;                                                                            \
     }
 #endif
+*/
 
     // This macro defines the necessary visitor methods for typed heaps
 #define DEFINE_VISITOR_METHODS(Type)                                              \
     virtual void mark(const Type* objectPointer, TraceCallback callback) override \
     {                                                                             \
         if (!objectPointer)                                                       \
             return;                                                               \
         HeapObjectHeader* header =                                                \
             HeapObjectHeader::fromPayload(objectPointer);                         \
         visitHeader(header, header->payload(), callback);                         \
     }                                                                             \
     virtual bool isMarked(const Type* objectPointer) override                     \
     {                                                                             \
         return HeapObjectHeader::fromPayload(objectPointer)->isMarked();          \
-    }                                                                             \
-    DEFINE_ENSURE_MARKED_METHOD(Type)
+    }
 
     FOR_EACH_TYPED_HEAP(DEFINE_VISITOR_METHODS)
 #undef DEFINE_VISITOR_METHODS
 
 #if ENABLE(GC_PROFILE_MARKING)
     void reportStats()
     {
         fprintf(stderr, "\n---------- AFTER MARKING -------------------\n");
         for (LiveObjectMap::iterator it = currentlyLive().begin(), end = currentlyLive().end(); it != end; ++it) {
             fprintf(stderr, "%s %u", it->key.ascii().data(), it->value.size());
@@ skipping 80 matching lines @@
         return graph;
     }
 
     static HashSet<uintptr_t>& objectsToFindPath()
     {
         DEFINE_STATIC_LOCAL(HashSet<uintptr_t>, set, ());
         return set;
     }
 #endif
 
-    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();
-    }
-
 protected:
     virtual void registerWeakCell(void** cell, WeakPointerCallback callback) override
     {
         Heap::pushWeakCellPointerCallback(cell, callback);
     }
 
 private:
     CallbackStack* m_markingStack;
 };
 
@@ skipping 668 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 = 0;
 size_t Heap::s_allocatedObjectSize = 0;
 size_t Heap::s_allocatedSpace = 0;
 size_t Heap::s_markedObjectSize = 0;
 
 } // namespace blink