DFGDesiredWatchpoints.h [plain text]
#ifndef DFGDesiredWatchpoints_h
#define DFGDesiredWatchpoints_h
#if ENABLE(DFG_JIT)
#include "CodeOrigin.h"
#include "DFGCommonData.h"
#include "InferredValue.h"
#include "JSArrayBufferView.h"
#include "Watchpoint.h"
#include <wtf/HashMap.h>
#include <wtf/HashSet.h>
#include <wtf/Noncopyable.h>
#include <wtf/Vector.h>
namespace JSC { namespace DFG {
class Graph;
template<typename T>
struct GenericSetAdaptor {
static void add(CodeBlock*, T* set, Watchpoint* watchpoint)
{
return set->add(watchpoint);
}
static bool hasBeenInvalidated(T* set) { return set->hasBeenInvalidated(); }
};
struct InferredValueAdaptor {
static void add(CodeBlock*, InferredValue*, Watchpoint*);
static bool hasBeenInvalidated(InferredValue* inferredValue)
{
return inferredValue->hasBeenInvalidated();
}
};
struct ArrayBufferViewWatchpointAdaptor {
static void add(CodeBlock*, JSArrayBufferView*, Watchpoint*);
static bool hasBeenInvalidated(JSArrayBufferView* view)
{
bool result = !view->length();
WTF::loadLoadFence();
return result;
}
};
template<typename WatchpointSetType, typename Adaptor = GenericSetAdaptor<WatchpointSetType>>
class GenericDesiredWatchpoints {
#if !ASSERT_DISABLED
typedef HashMap<WatchpointSetType*, bool> StateMap;
#endif
public:
GenericDesiredWatchpoints()
: m_reallyAdded(false)
{
}
void addLazily(WatchpointSetType* set)
{
m_sets.add(set);
}
void reallyAdd(CodeBlock* codeBlock, CommonData& common)
{
RELEASE_ASSERT(!m_reallyAdded);
typename HashSet<WatchpointSetType*>::iterator iter = m_sets.begin();
typename HashSet<WatchpointSetType*>::iterator end = m_sets.end();
for (; iter != end; ++iter) {
common.watchpoints.append(CodeBlockJettisoningWatchpoint(codeBlock));
Adaptor::add(codeBlock, *iter, &common.watchpoints.last());
}
m_reallyAdded = true;
}
bool areStillValid() const
{
typename HashSet<WatchpointSetType*>::iterator iter = m_sets.begin();
typename HashSet<WatchpointSetType*>::iterator end = m_sets.end();
for (; iter != end; ++iter) {
if (Adaptor::hasBeenInvalidated(*iter))
return false;
}
return true;
}
bool isWatched(WatchpointSetType* set) const
{
return m_sets.contains(set);
}
private:
HashSet<WatchpointSetType*> m_sets;
bool m_reallyAdded;
};
class DesiredWatchpoints {
public:
DesiredWatchpoints();
~DesiredWatchpoints();
void addLazily(WatchpointSet*);
void addLazily(InlineWatchpointSet&);
void addLazily(InferredValue*);
void addLazily(JSArrayBufferView*);
bool consider(Structure*);
void reallyAdd(CodeBlock*, CommonData&);
bool areStillValid() const;
bool isWatched(WatchpointSet* set)
{
return m_sets.isWatched(set);
}
bool isWatched(InlineWatchpointSet& set)
{
return m_inlineSets.isWatched(&set);
}
bool isWatched(InferredValue* inferredValue)
{
return m_inferredValues.isWatched(inferredValue);
}
bool isWatched(JSArrayBufferView* view)
{
return m_bufferViews.isWatched(view);
}
private:
GenericDesiredWatchpoints<WatchpointSet> m_sets;
GenericDesiredWatchpoints<InlineWatchpointSet> m_inlineSets;
GenericDesiredWatchpoints<InferredValue, InferredValueAdaptor> m_inferredValues;
GenericDesiredWatchpoints<JSArrayBufferView, ArrayBufferViewWatchpointAdaptor> m_bufferViews;
};
} }
#endif // ENABLE(DFG_JIT)
#endif // DFGDesiredWatchpoints_h