#pragma once
#include <wtf/Atomics.h>
#include <wtf/FastMalloc.h>
#include <wtf/Noncopyable.h>
#include <wtf/PrintStream.h>
#include <wtf/ScopedLambda.h>
#include <wtf/SentinelLinkedList.h>
#include <wtf/ThreadSafeRefCounted.h>
namespace JSC {
class VM;
class FireDetail {
void* operator new(size_t) = delete;
public:
FireDetail()
{
}
virtual ~FireDetail()
{
}
virtual void dump(PrintStream&) const = 0;
};
class StringFireDetail : public FireDetail {
public:
StringFireDetail(const char* string)
: m_string(string)
{
}
void dump(PrintStream& out) const override;
private:
const char* m_string;
};
template<typename... Types>
class LazyFireDetail : public FireDetail {
public:
LazyFireDetail(const Types&... args)
{
m_lambda = scopedLambda<void(PrintStream&)>([&] (PrintStream& out) {
out.print(args...);
});
}
void dump(PrintStream& out) const override { m_lambda(out); }
private:
ScopedLambda<void(PrintStream&)> m_lambda;
};
template<typename... Types>
LazyFireDetail<Types...> createLazyFireDetail(const Types&... types)
{
return LazyFireDetail<Types...>(types...);
}
class WatchpointSet;
class Watchpoint : public BasicRawSentinelNode<Watchpoint> {
WTF_MAKE_NONCOPYABLE(Watchpoint);
WTF_MAKE_FAST_ALLOCATED;
public:
Watchpoint() = default;
virtual ~Watchpoint();
protected:
virtual void fireInternal(VM&, const FireDetail&) = 0;
private:
friend class WatchpointSet;
void fire(VM&, const FireDetail&);
};
enum WatchpointState {
ClearWatchpoint,
IsWatched,
IsInvalidated
};
class InlineWatchpointSet;
class DeferredWatchpointFire;
class VM;
class WatchpointSet : public ThreadSafeRefCounted<WatchpointSet> {
friend class LLIntOffsetsExtractor;
friend class DeferredWatchpointFire;
public:
JS_EXPORT_PRIVATE WatchpointSet(WatchpointState);
JS_EXPORT_PRIVATE ~WatchpointSet();
WatchpointState stateOnJSThread() const
{
return static_cast<WatchpointState>(m_state);
}
WatchpointState state() const
{
WTF::loadLoadFence();
WatchpointState result = static_cast<WatchpointState>(m_state);
WTF::loadLoadFence();
return result;
}
bool isStillValid() const
{
return state() != IsInvalidated;
}
bool hasBeenInvalidated() const { return !isStillValid(); }
void add(Watchpoint*);
void startWatching()
{
ASSERT(m_state != IsInvalidated);
if (m_state == IsWatched)
return;
WTF::storeStoreFence();
m_state = IsWatched;
WTF::storeStoreFence();
}
template <typename T>
void fireAll(VM& vm, T& fireDetails)
{
if (LIKELY(m_state != IsWatched))
return;
fireAllSlow(vm, fireDetails);
}
void touch(VM& vm, const FireDetail& detail)
{
if (state() == ClearWatchpoint)
startWatching();
else
fireAll(vm, detail);
}
void touch(VM& vm, const char* reason)
{
touch(vm, StringFireDetail(reason));
}
void invalidate(VM& vm, const FireDetail& detail)
{
if (state() == IsWatched)
fireAll(vm, detail);
m_state = IsInvalidated;
}
void invalidate(VM& vm, const char* reason)
{
invalidate(vm, StringFireDetail(reason));
}
bool isBeingWatched() const
{
return m_setIsNotEmpty;
}
int8_t* addressOfState() { return &m_state; }
static ptrdiff_t offsetOfState() { return OBJECT_OFFSETOF(WatchpointSet, m_state); }
int8_t* addressOfSetIsNotEmpty() { return &m_setIsNotEmpty; }
JS_EXPORT_PRIVATE void fireAllSlow(VM&, const FireDetail&); JS_EXPORT_PRIVATE void fireAllSlow(VM&, DeferredWatchpointFire* deferredWatchpoints); JS_EXPORT_PRIVATE void fireAllSlow(VM&, const char* reason);
private:
void fireAllWatchpoints(VM&, const FireDetail&);
void take(WatchpointSet* other);
friend class InlineWatchpointSet;
int8_t m_state;
int8_t m_setIsNotEmpty;
SentinelLinkedList<Watchpoint, BasicRawSentinelNode<Watchpoint>> m_set;
};
class InlineWatchpointSet {
WTF_MAKE_NONCOPYABLE(InlineWatchpointSet);
public:
InlineWatchpointSet(WatchpointState state)
: m_data(encodeState(state))
{
}
~InlineWatchpointSet()
{
if (isThin())
return;
freeFat();
}
WatchpointState stateOnJSThread() const
{
uintptr_t data = m_data;
if (isFat(data))
return fat(data)->stateOnJSThread();
return decodeState(data);
}
WatchpointState state() const
{
WTF::loadLoadFence();
uintptr_t data = m_data;
WTF::loadLoadFence();
if (isFat(data))
return fat(data)->state();
return decodeState(data);
}
bool hasBeenInvalidated() const
{
return state() == IsInvalidated;
}
bool isStillValid() const
{
return !hasBeenInvalidated();
}
void add(Watchpoint*);
void startWatching()
{
if (isFat()) {
fat()->startWatching();
return;
}
ASSERT(decodeState(m_data) != IsInvalidated);
m_data = encodeState(IsWatched);
}
template <typename T>
void fireAll(VM& vm, T fireDetails)
{
if (isFat()) {
fat()->fireAll(vm, fireDetails);
return;
}
if (decodeState(m_data) == ClearWatchpoint)
return;
m_data = encodeState(IsInvalidated);
WTF::storeStoreFence();
}
void invalidate(VM& vm, const FireDetail& detail)
{
if (isFat())
fat()->invalidate(vm, detail);
else
m_data = encodeState(IsInvalidated);
}
JS_EXPORT_PRIVATE void fireAll(VM&, const char* reason);
void touch(VM& vm, const FireDetail& detail)
{
if (isFat()) {
fat()->touch(vm, detail);
return;
}
uintptr_t data = m_data;
if (decodeState(data) == IsInvalidated)
return;
WTF::storeStoreFence();
if (decodeState(data) == ClearWatchpoint)
m_data = encodeState(IsWatched);
else
m_data = encodeState(IsInvalidated);
WTF::storeStoreFence();
}
void touch(VM& vm, const char* reason)
{
touch(vm, StringFireDetail(reason));
}
bool isBeingWatched() const
{
if (isFat())
return fat()->isBeingWatched();
return false;
}
WatchpointSet* inflate()
{
if (LIKELY(isFat()))
return fat();
return inflateSlow();
}
private:
static const uintptr_t IsThinFlag = 1;
static const uintptr_t StateMask = 6;
static const uintptr_t StateShift = 1;
static bool isThin(uintptr_t data) { return data & IsThinFlag; }
static bool isFat(uintptr_t data) { return !isThin(data); }
static WatchpointState decodeState(uintptr_t data)
{
ASSERT(isThin(data));
return static_cast<WatchpointState>((data & StateMask) >> StateShift);
}
static uintptr_t encodeState(WatchpointState state)
{
return (static_cast<uintptr_t>(state) << StateShift) | IsThinFlag;
}
bool isThin() const { return isThin(m_data); }
bool isFat() const { return isFat(m_data); };
static WatchpointSet* fat(uintptr_t data)
{
return bitwise_cast<WatchpointSet*>(data);
}
WatchpointSet* fat()
{
ASSERT(isFat());
return fat(m_data);
}
const WatchpointSet* fat() const
{
ASSERT(isFat());
return fat(m_data);
}
JS_EXPORT_PRIVATE WatchpointSet* inflateSlow();
JS_EXPORT_PRIVATE void freeFat();
uintptr_t m_data;
};
class DeferredWatchpointFire : public FireDetail {
WTF_MAKE_NONCOPYABLE(DeferredWatchpointFire);
public:
JS_EXPORT_PRIVATE DeferredWatchpointFire(VM&);
JS_EXPORT_PRIVATE ~DeferredWatchpointFire();
JS_EXPORT_PRIVATE void takeWatchpointsToFire(WatchpointSet*);
JS_EXPORT_PRIVATE void fireAll();
void dump(PrintStream& out) const override = 0;
private:
VM& m_vm;
WatchpointSet m_watchpointsToFire;
};
}