DFGAbstractInterpreter.h [plain text]
#ifndef DFGAbstractInterpreter_h
#define DFGAbstractInterpreter_h
#if ENABLE(DFG_JIT)
#include "DFGAbstractValue.h"
#include "DFGBranchDirection.h"
#include "DFGGraph.h"
#include "DFGNode.h"
#include "DFGPhiChildren.h"
namespace JSC { namespace DFG {
template<typename AbstractStateType>
class AbstractInterpreter {
public:
AbstractInterpreter(Graph&, AbstractStateType&);
~AbstractInterpreter();
AbstractValue& forNode(Node* 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 executeEdges(unsigned indexInBlock);
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 StructureSet& 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);
}
FiltrationResult filter(AbstractValue&, const StructureSet&, SpeculatedType admittedTypes = SpecNone);
FiltrationResult filterArrayModes(AbstractValue&, ArrayModes);
FiltrationResult filter(AbstractValue&, SpeculatedType);
FiltrationResult filterByValue(AbstractValue&, FrozenValue);
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, Structure* from, Structure* 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);
if (!value.isType(type))
edge.setProofStatus(NeedsCheck);
else
edge.setProofStatus(IsProved);
filter(value, type);
}
void verifyEdge(Node*, Edge);
void verifyEdges(Node*);
CodeBlock* m_codeBlock;
Graph& m_graph;
AbstractStateType& m_state;
std::unique_ptr<PhiChildren> m_phiChildren;
};
} }
#endif // ENABLE(DFG_JIT)
#endif // DFGAbstractInterpreter_h