DFGVarargsForwardingPhase.cpp [plain text]
#include "config.h"
#include "DFGVarargsForwardingPhase.h"
#if ENABLE(DFG_JIT)
#include "DFGArgumentsUtilities.h"
#include "DFGClobberize.h"
#include "DFGForAllKills.h"
#include "DFGGraph.h"
#include "DFGPhase.h"
#include "JSCInlines.h"
#include <wtf/ListDump.h>
namespace JSC { namespace DFG {
namespace {
bool verbose = false;
class VarargsForwardingPhase : public Phase {
public:
VarargsForwardingPhase(Graph& graph)
: Phase(graph, "varargs forwarding")
{
}
bool run()
{
DFG_ASSERT(m_graph, nullptr, m_graph.m_form != SSA);
if (verbose) {
dataLog("Graph before varargs forwarding:\n");
m_graph.dump();
}
m_changed = false;
for (BasicBlock* block : m_graph.blocksInNaturalOrder())
handleBlock(block);
return m_changed;
}
private:
void handleBlock(BasicBlock* block)
{
for (unsigned nodeIndex = 0; nodeIndex < block->size(); ++nodeIndex) {
Node* node = block->at(nodeIndex);
switch (node->op()) {
case CreateDirectArguments:
case CreateClonedArguments:
handleCandidate(block, nodeIndex);
break;
default:
break;
}
}
}
void handleCandidate(BasicBlock* block, unsigned candidateNodeIndex)
{
Node* candidate = block->at(candidateNodeIndex);
if (verbose)
dataLog("Handling candidate ", candidate, "\n");
unsigned lastUserIndex = candidateNodeIndex;
Vector<VirtualRegister, 2> relevantLocals; for (unsigned nodeIndex = candidateNodeIndex + 1; nodeIndex < block->size(); ++nodeIndex) {
Node* node = block->at(nodeIndex);
switch (node->op()) {
case MovHint:
if (node->child1() != candidate)
break;
lastUserIndex = nodeIndex;
if (!relevantLocals.contains(node->unlinkedLocal()))
relevantLocals.append(node->unlinkedLocal());
break;
case Check: {
bool sawEscape = false;
m_graph.doToChildren(
node,
[&] (Edge edge) {
if (edge == candidate)
lastUserIndex = nodeIndex;
if (edge.willNotHaveCheck())
return;
if (alreadyChecked(edge.useKind(), SpecObject))
return;
sawEscape = true;
});
if (sawEscape) {
if (verbose)
dataLog(" Escape at ", node, "\n");
return;
}
break;
}
case LoadVarargs:
if (m_graph.uses(node, candidate))
lastUserIndex = nodeIndex;
break;
case CallVarargs:
case ConstructVarargs:
case TailCallVarargs:
case TailCallVarargsInlinedCaller:
if (node->child1() == candidate || node->child2() == candidate) {
if (verbose)
dataLog(" Escape at ", node, "\n");
return;
}
if (node->child2() == candidate)
lastUserIndex = nodeIndex;
break;
case SetLocal:
if (node->child1() == candidate && node->variableAccessData()->isLoadedFrom()) {
if (verbose)
dataLog(" Escape at ", node, "\n");
return;
}
break;
default:
if (m_graph.uses(node, candidate)) {
if (verbose)
dataLog(" Escape at ", node, "\n");
return;
}
}
forAllKilledOperands(
m_graph, node, block->tryAt(nodeIndex + 1),
[&] (VirtualRegister reg) {
if (verbose)
dataLog(" Killing ", reg, " while we are interested in ", listDump(relevantLocals), "\n");
for (unsigned i = 0; i < relevantLocals.size(); ++i) {
if (relevantLocals[i] == reg) {
relevantLocals[i--] = relevantLocals.last();
relevantLocals.removeLast();
lastUserIndex = nodeIndex;
}
}
});
}
if (verbose)
dataLog("Selected lastUserIndex = ", lastUserIndex, ", ", block->at(lastUserIndex), "\n");
for (unsigned nodeIndex = candidateNodeIndex + 1; nodeIndex <= lastUserIndex; ++nodeIndex) {
Node* node = block->at(nodeIndex);
switch (node->op()) {
case MovHint:
case ZombieHint:
case KillStack:
if (argumentsInvolveStackSlot(candidate, node->unlinkedLocal())) {
if (verbose)
dataLog(" Interference at ", node, "\n");
return;
}
break;
case PutStack:
if (argumentsInvolveStackSlot(candidate, node->stackAccessData()->local)) {
if (verbose)
dataLog(" Interference at ", node, "\n");
return;
}
break;
case SetLocal:
case Flush:
if (argumentsInvolveStackSlot(candidate, node->local())) {
if (verbose)
dataLog(" Interference at ", node, "\n");
return;
}
break;
default: {
bool doesInterfere = false;
clobberize(
m_graph, node, NoOpClobberize(),
[&] (AbstractHeap heap) {
if (heap.kind() != Stack) {
ASSERT(!heap.overlaps(Stack));
return;
}
ASSERT(!heap.payload().isTop());
VirtualRegister reg(heap.payload().value32());
if (argumentsInvolveStackSlot(candidate, reg))
doesInterfere = true;
},
NoOpClobberize());
if (doesInterfere) {
if (verbose)
dataLog(" Interference at ", node, "\n");
return;
}
} }
}
if (verbose)
dataLog(" Will do forwarding!\n");
m_changed = true;
switch (candidate->op()) {
case CreateDirectArguments:
candidate->setOpAndDefaultFlags(PhantomDirectArguments);
break;
case CreateClonedArguments:
candidate->setOpAndDefaultFlags(PhantomClonedArguments);
break;
default:
DFG_CRASH(m_graph, candidate, "bad node type");
break;
}
for (unsigned nodeIndex = candidateNodeIndex + 1; nodeIndex <= lastUserIndex; ++nodeIndex) {
Node* node = block->at(nodeIndex);
switch (node->op()) {
case Check:
case MovHint:
case PutHint:
break;
case LoadVarargs:
if (node->child1() != candidate)
break;
node->setOpAndDefaultFlags(ForwardVarargs);
break;
case CallVarargs:
if (node->child3() != candidate)
break;
node->setOpAndDefaultFlags(CallForwardVarargs);
break;
case ConstructVarargs:
if (node->child3() != candidate)
break;
node->setOpAndDefaultFlags(ConstructForwardVarargs);
break;
case TailCallVarargs:
if (node->child3() != candidate)
break;
node->setOpAndDefaultFlags(TailCallForwardVarargs);
break;
case TailCallVarargsInlinedCaller:
if (node->child3() != candidate)
break;
node->setOpAndDefaultFlags(TailCallForwardVarargsInlinedCaller);
break;
case SetLocal:
break;
default:
if (ASSERT_DISABLED)
break;
m_graph.doToChildren(
node,
[&] (Edge edge) {
DFG_ASSERT(m_graph, node, edge != candidate);
});
break;
}
}
}
bool m_changed;
};
}
bool performVarargsForwarding(Graph& graph)
{
return runPhase<VarargsForwardingPhase>(graph);
}
} }
#endif // ENABLE(DFG_JIT)