#ifndef SlotVisitor_h
#define SlotVisitor_h
#include "CellState.h"
#include "CopyToken.h"
#include "HandleTypes.h"
#include "MarkStack.h"
#include "OpaqueRootSet.h"
namespace JSC {
class ConservativeRoots;
class GCThreadSharedData;
class Heap;
class HeapSnapshotBuilder;
template<typename T> class JITWriteBarrier;
class UnconditionalFinalizer;
template<typename T> class Weak;
class WeakReferenceHarvester;
template<typename T> class WriteBarrierBase;
class SlotVisitor {
WTF_MAKE_NONCOPYABLE(SlotVisitor);
WTF_MAKE_FAST_ALLOCATED;
friend class SetCurrentCellScope;
friend class HeapRootVisitor; friend class Heap;
public:
SlotVisitor(Heap&);
~SlotVisitor();
MarkStackArray& markStack() { return m_stack; }
const MarkStackArray& markStack() const { return m_stack; }
VM& vm();
const VM& vm() const;
Heap* heap() const;
void append(ConservativeRoots&);
template<typename T> void append(JITWriteBarrier<T>*);
template<typename T> void append(WriteBarrierBase<T>*);
template<typename T> void appendHidden(WriteBarrierBase<T>*);
template<typename Iterator> void append(Iterator begin , Iterator end);
void appendValues(WriteBarrierBase<Unknown>*, size_t count);
void appendValuesHidden(WriteBarrierBase<Unknown>*, size_t count);
template<typename T>
void appendUnbarrieredPointer(T**);
void appendUnbarrieredValue(JSValue*);
template<typename T>
void appendUnbarrieredWeak(Weak<T>*);
template<typename T>
void appendUnbarrieredReadOnlyPointer(T*);
void appendUnbarrieredReadOnlyValue(JSValue);
JS_EXPORT_PRIVATE void addOpaqueRoot(void*);
JS_EXPORT_PRIVATE bool containsOpaqueRoot(void*) const;
TriState containsOpaqueRootTriState(void*) const;
int opaqueRootCount();
bool isEmpty() { return m_stack.isEmpty(); }
void didStartMarking();
void reset();
void clearMarkStack();
size_t bytesVisited() const { return m_bytesVisited; }
size_t bytesCopied() const { return m_bytesCopied; }
size_t visitCount() const { return m_visitCount; }
void donate();
void drain();
void donateAndDrain();
enum SharedDrainMode { SlaveDrain, MasterDrain };
void drainFromShared(SharedDrainMode);
void harvestWeakReferences();
void finalizeUnconditionalFinalizers();
void copyLater(JSCell*, CopyToken, void*, size_t);
void reportExtraMemoryVisited(size_t);
#if ENABLE(RESOURCE_USAGE)
void reportExternalMemoryVisited(size_t);
#endif
void addWeakReferenceHarvester(WeakReferenceHarvester*);
void addUnconditionalFinalizer(UnconditionalFinalizer*);
void dump(PrintStream&) const;
bool isBuildingHeapSnapshot() const { return !!m_heapSnapshotBuilder; }
private:
friend class ParallelModeEnabler;
JS_EXPORT_PRIVATE void append(JSValue); void appendHidden(JSValue);
JS_EXPORT_PRIVATE void setMarkedAndAppendToMarkStack(JSCell*);
void appendToMarkStack(JSCell*);
JS_EXPORT_PRIVATE void mergeOpaqueRoots();
void mergeOpaqueRootsIfNecessary();
void mergeOpaqueRootsIfProfitable();
void visitChildren(const JSCell*);
void donateKnownParallel();
MarkStackArray m_stack;
OpaqueRootSet m_opaqueRoots;
size_t m_bytesVisited;
size_t m_bytesCopied;
size_t m_visitCount;
bool m_isInParallelMode;
Heap& m_heap;
HeapSnapshotBuilder* m_heapSnapshotBuilder { nullptr };
JSCell* m_currentCell { nullptr };
CellState m_currentObjectCellStateBeforeVisiting { CellState::NewWhite };
public:
#if !ASSERT_DISABLED
bool m_isCheckingForDefaultMarkViolation;
bool m_isDraining;
#endif
};
class ParallelModeEnabler {
public:
ParallelModeEnabler(SlotVisitor& stack)
: m_stack(stack)
{
ASSERT(!m_stack.m_isInParallelMode);
m_stack.m_isInParallelMode = true;
}
~ParallelModeEnabler()
{
ASSERT(m_stack.m_isInParallelMode);
m_stack.m_isInParallelMode = false;
}
private:
SlotVisitor& m_stack;
};
}
#endif // SlotVisitor_h