ConcurrentJITLock.h [plain text]
#ifndef ConcurrentJITLock_h
#define ConcurrentJITLock_h
#include "DeferGC.h"
#include <wtf/ByteSpinLock.h>
#include <wtf/NoLock.h>
namespace JSC {
#if ENABLE(CONCURRENT_JIT)
typedef ByteSpinLock ConcurrentJITLock;
typedef ByteSpinLocker ConcurrentJITLockerImpl;
#else
typedef NoLock ConcurrentJITLock;
typedef NoLockLocker ConcurrentJITLockerImpl;
#endif
class ConcurrentJITLockerBase {
WTF_MAKE_NONCOPYABLE(ConcurrentJITLockerBase);
public:
explicit ConcurrentJITLockerBase(ConcurrentJITLock& lockable)
: m_locker(&lockable)
{
}
explicit ConcurrentJITLockerBase(ConcurrentJITLock* lockable)
: m_locker(lockable)
{
}
~ConcurrentJITLockerBase()
{
}
void unlockEarly()
{
m_locker.unlockEarly();
}
private:
ConcurrentJITLockerImpl m_locker;
};
class GCSafeConcurrentJITLocker : public ConcurrentJITLockerBase {
public:
GCSafeConcurrentJITLocker(ConcurrentJITLock& lockable, Heap& heap)
: ConcurrentJITLockerBase(lockable)
, m_deferGC(heap)
{
}
GCSafeConcurrentJITLocker(ConcurrentJITLock* lockable, Heap& heap)
: ConcurrentJITLockerBase(lockable)
, m_deferGC(heap)
{
}
~GCSafeConcurrentJITLocker()
{
unlockEarly();
}
private:
#if ENABLE(CONCURRENT_JIT)
DeferGC m_deferGC;
#else
struct NoDefer {
NoDefer(Heap& heap) : m_heap(heap) { }
Heap& m_heap;
};
NoDefer m_deferGC;
#endif
};
class ConcurrentJITLocker : public ConcurrentJITLockerBase {
public:
ConcurrentJITLocker(ConcurrentJITLock& lockable)
: ConcurrentJITLockerBase(lockable)
{
}
ConcurrentJITLocker(ConcurrentJITLock* lockable)
: ConcurrentJITLockerBase(lockable)
{
}
#if ENABLE(CONCURRENT_JIT) && !defined(NDEBUG)
private:
DisallowGC m_disallowGC;
#endif
};
}
#endif // ConcurrentJITLock_h