DFGAbstractInterpreter.h [plain text]
#pragma once
#if ENABLE(DFG_JIT)
#include "DFGAbstractValue.h"
#include "DFGGraph.h"
#include "DFGNode.h"
#include "DFGNodeFlowProjection.h"
#include "DFGPhiChildren.h"
namespace JSC { namespace DFG {
template<typename AbstractStateType>
class AbstractInterpreter {
public:
AbstractInterpreter(Graph&, AbstractStateType&);
~AbstractInterpreter();
AbstractValue& forNode(NodeFlowProjection node)
{
return m_state.forNode(node);
}
AbstractValue& forNode(Edge edge)
{
return forNode(edge.node());
}
Operands<AbstractValue>& variables()
{
return m_state.variables();
}
bool needsTypeCheck(Node* node, SpeculatedType typesPassedThrough)
{
return !forNode(node).isType(typesPassedThrough);
}
bool needsTypeCheck(Edge edge, SpeculatedType typesPassedThrough)
{
return needsTypeCheck(edge.node(), typesPassedThrough);
}
bool needsTypeCheck(Edge edge)
{
return needsTypeCheck(edge, typeFilterFor(edge.useKind()));
}
bool execute(unsigned indexInBlock);
bool execute(Node*);
void startExecuting();
void executeEdges(Node*);
void executeKnownEdgeTypes(Node*);
ALWAYS_INLINE void filterEdgeByUse(Edge& edge)
{
filterByType(edge, typeFilterFor(edge.useKind()));
}
bool executeEffects(unsigned indexInBlock);
bool executeEffects(unsigned clobberLimit, Node*);
void dump(PrintStream& out) const;
void dump(PrintStream& out);
template<typename T>
FiltrationResult filter(T node, const RegisteredStructureSet& set, SpeculatedType admittedTypes = SpecNone)
{
return filter(forNode(node), set, admittedTypes);
}
template<typename T>
FiltrationResult filterArrayModes(T node, ArrayModes arrayModes)
{
return filterArrayModes(forNode(node), arrayModes);
}
template<typename T>
FiltrationResult filter(T node, SpeculatedType type)
{
return filter(forNode(node), type);
}
template<typename T>
FiltrationResult filterByValue(T node, FrozenValue value)
{
return filterByValue(forNode(node), value);
}
template<typename T>
FiltrationResult filterClassInfo(T node, const ClassInfo* classInfo)
{
return filterClassInfo(forNode(node), classInfo);
}
FiltrationResult filter(AbstractValue&, const RegisteredStructureSet&, SpeculatedType admittedTypes = SpecNone);
FiltrationResult filterArrayModes(AbstractValue&, ArrayModes);
FiltrationResult filter(AbstractValue&, SpeculatedType);
FiltrationResult filterByValue(AbstractValue&, FrozenValue);
FiltrationResult filterClassInfo(AbstractValue&, const ClassInfo*);
PhiChildren* phiChildren() { return m_phiChildren.get(); }
private:
void clobberWorld(const CodeOrigin&, unsigned indexInBlock);
template<typename Functor>
void forAllValues(unsigned indexInBlock, Functor&);
void clobberStructures(unsigned indexInBlock);
void observeTransition(unsigned indexInBlock, RegisteredStructure from, RegisteredStructure to);
void observeTransitions(unsigned indexInBlock, const TransitionVector&);
void setDidClobber();
enum BooleanResult {
UnknownBooleanResult,
DefinitelyFalse,
DefinitelyTrue
};
BooleanResult booleanResult(Node*, AbstractValue&);
void setBuiltInConstant(Node* node, FrozenValue value)
{
AbstractValue& abstractValue = forNode(node);
abstractValue.set(m_graph, value, m_state.structureClobberState());
abstractValue.fixTypeForRepresentation(m_graph, node);
}
void setConstant(Node* node, FrozenValue value)
{
setBuiltInConstant(node, value);
m_state.setFoundConstants(true);
}
ALWAYS_INLINE void filterByType(Edge& edge, SpeculatedType type)
{
AbstractValue& value = forNode(edge);
m_state.setProofStatus(edge, value.isType(type) ? IsProved : NeedsCheck);
filter(value, type);
}
void verifyEdge(Node*, Edge);
void verifyEdges(Node*);
void executeDoubleUnaryOpEffects(Node*, unsigned clobberLimit, double(*equivalentFunction)(double));
CodeBlock* m_codeBlock;
Graph& m_graph;
VM& m_vm;
AbstractStateType& m_state;
std::unique_ptr<PhiChildren> m_phiChildren;
};
} }
#endif // ENABLE(DFG_JIT)