DFGMaximalFlushInsertionPhase.cpp [plain text]
#include "config.h"
#include "DFGMaximalFlushInsertionPhase.h"
#if ENABLE(DFG_JIT)
#include "DFGBasicBlockInlines.h"
#include "DFGGraph.h"
#include "DFGInsertionSet.h"
#include "DFGPhase.h"
#include "JSCInlines.h"
namespace JSC { namespace DFG {
class MaximalFlushInsertionPhase : public Phase {
public:
MaximalFlushInsertionPhase(Graph& graph)
: Phase(graph, "maximal flush insertion phase")
{
}
bool run()
{
DFG_ASSERT(m_graph, nullptr, m_graph.m_form == LoadStore);
InsertionSet insertionSet(m_graph);
for (BasicBlock* block : m_graph.blocksInNaturalOrder()) {
treatRegularBlock(block, insertionSet);
insertionSet.execute(block);
}
for (BasicBlock* entrypoint : m_graph.m_roots) {
treatRootBlock(entrypoint, insertionSet);
insertionSet.execute(entrypoint);
}
return true;
}
void treatRegularBlock(BasicBlock* block, InsertionSet& insertionSet)
{
Operands<VariableAccessData*> currentBlockAccessData(block->variablesAtTail.numberOfArguments(), block->variablesAtTail.numberOfLocals(), nullptr);
{
for (unsigned i = 0; i < block->size(); i++) {
Node* node = block->at(i);
bool isPrimordialSetArgument = false;
if (node->op() == SetArgument && node->local().isArgument()) {
auto iter = m_graph.m_rootToArguments.find(block);
if (iter != m_graph.m_rootToArguments.end())
isPrimordialSetArgument = node == iter->value[node->local().toArgument()];
}
if (node->op() == SetLocal || (node->op() == SetArgument && !isPrimordialSetArgument)) {
VirtualRegister operand = node->local();
VariableAccessData* flushAccessData = currentBlockAccessData.operand(operand);
if (!flushAccessData)
flushAccessData = newVariableAccessData(operand);
insertionSet.insertNode(i, SpecNone,
Flush, node->origin, OpInfo(flushAccessData));
}
if (node->accessesStack(m_graph))
currentBlockAccessData.operand(node->local()) = node->variableAccessData();
}
}
{
NodeOrigin origin = block->at(block->size() - 1)->origin;
auto insertFlushAtEnd = [&] (VirtualRegister operand) {
VariableAccessData* accessData = currentBlockAccessData.operand(operand);
if (!accessData)
accessData = newVariableAccessData(operand);
currentBlockAccessData.operand(operand) = accessData;
insertionSet.insertNode(block->size(), SpecNone,
Flush, origin, OpInfo(accessData));
};
for (unsigned i = 0; i < block->variablesAtTail.numberOfLocals(); i++)
insertFlushAtEnd(virtualRegisterForLocal(i));
for (unsigned i = 0; i < block->variablesAtTail.numberOfArguments(); i++)
insertFlushAtEnd(virtualRegisterForArgument(i));
}
}
void treatRootBlock(BasicBlock* block, InsertionSet& insertionSet)
{
Operands<VariableAccessData*> initialAccessData(block->variablesAtTail.numberOfArguments(), block->variablesAtTail.numberOfLocals(), nullptr);
Operands<Node*> initialAccessNodes(block->variablesAtTail.numberOfArguments(), block->variablesAtTail.numberOfLocals(), nullptr);
for (auto* node : *block) {
if (!node->accessesStack(m_graph))
continue;
VirtualRegister operand = node->local();
if (initialAccessData.operand(operand))
continue;
DFG_ASSERT(m_graph, node, node->op() != SetLocal); initialAccessData.operand(operand) = node->variableAccessData();
initialAccessNodes.operand(operand) = node;
}
NodeOrigin origin = block->at(0)->origin;
Node* undefined = insertionSet.insertConstant(0, origin, jsUndefined());
for (unsigned i = 0; i < block->variablesAtTail.numberOfLocals(); i++) {
VirtualRegister operand = virtualRegisterForLocal(i);
DFG_ASSERT(m_graph, nullptr, initialAccessNodes.operand(operand)->op() == Flush); VariableAccessData* accessData = initialAccessData.operand(operand);
DFG_ASSERT(m_graph, nullptr, accessData);
insertionSet.insertNode(0, SpecNone,
SetLocal, origin, OpInfo(accessData), Edge(undefined));
accessData->mergeShouldNeverUnbox(true); }
}
VariableAccessData* newVariableAccessData(VirtualRegister operand)
{
ASSERT(!operand.isConstant());
m_graph.m_variableAccessData.append(VariableAccessData(operand));
return &m_graph.m_variableAccessData.last();
}
};
bool performMaximalFlushInsertion(Graph& graph)
{
return runPhase<MaximalFlushInsertionPhase>(graph);
}
} }
#endif // ENABLE(DFG_JIT)