DFGTierUpCheckInjectionPhase.cpp [plain text]
#include "config.h"
#include "DFGTierUpCheckInjectionPhase.h"
#if ENABLE(DFG_JIT)
#include "DFGGraph.h"
#include "DFGInsertionSet.h"
#include "DFGPhase.h"
#include "FTLCapabilities.h"
#include "JSCInlines.h"
namespace JSC { namespace DFG {
class TierUpCheckInjectionPhase : public Phase {
public:
TierUpCheckInjectionPhase(Graph& graph)
: Phase(graph, "tier-up check injection")
{
}
bool run()
{
RELEASE_ASSERT(m_graph.m_plan.mode == DFGMode);
if (!Options::useFTLJIT())
return false;
if (m_graph.m_profiledBlock->m_didFailFTLCompilation)
return false;
#if ENABLE(FTL_JIT)
FTL::CapabilityLevel level = FTL::canCompile(m_graph);
if (level == FTL::CannotCompile)
return false;
if (!Options::enableOSREntryToFTL())
level = FTL::CanCompile;
NaturalLoops& naturalLoops = m_graph.m_naturalLoops;
naturalLoops.computeIfNecessary(m_graph);
HashSet<const NaturalLoop*> loopsContainingLoopHintWithoutOSREnter = findLoopsContainingLoopHintWithoutOSREnter(naturalLoops, level);
InsertionSet insertionSet(m_graph);
for (BlockIndex blockIndex = m_graph.numBlocks(); blockIndex--;) {
BasicBlock* block = m_graph.block(blockIndex);
if (!block)
continue;
for (unsigned nodeIndex = 0; nodeIndex < block->size(); ++nodeIndex) {
Node* node = block->at(nodeIndex);
if (node->op() != LoopHint)
continue;
NodeOrigin origin = node->origin;
if (canOSREnterAtLoopHint(level, block, nodeIndex)) {
const NaturalLoop* loop = naturalLoops.innerMostLoopOf(block);
if (loop && loopsContainingLoopHintWithoutOSREnter.contains(loop))
insertionSet.insertNode(nodeIndex + 1, SpecNone, CheckTierUpWithNestedTriggerAndOSREnter, origin);
else
insertionSet.insertNode(nodeIndex + 1, SpecNone, CheckTierUpAndOSREnter, origin);
} else
insertionSet.insertNode(nodeIndex + 1, SpecNone, CheckTierUpInLoop, origin);
break;
}
NodeAndIndex terminal = block->findTerminal();
if (terminal.node->op() == Return) {
insertionSet.insertNode(
terminal.index, SpecNone, CheckTierUpAtReturn, terminal.node->origin);
}
insertionSet.execute(block);
}
m_graph.m_plan.willTryToTierUp = true;
return true;
#else // ENABLE(FTL_JIT)
RELEASE_ASSERT_NOT_REACHED();
return false;
#endif // ENABLE(FTL_JIT)
}
private:
#if ENABLE(FTL_JIT)
bool canOSREnterAtLoopHint(FTL::CapabilityLevel level, const BasicBlock* block, unsigned nodeIndex)
{
Node* node = block->at(nodeIndex);
ASSERT(node->op() == LoopHint);
NodeOrigin origin = node->origin;
if (level != FTL::CanCompileAndOSREnter || origin.semantic.inlineCallFrame)
return false;
for (unsigned subNodeIndex = nodeIndex; subNodeIndex--;) {
if (!block->at(subNodeIndex)->isSemanticallySkippable())
return false;
}
return true;
}
HashSet<const NaturalLoop*> findLoopsContainingLoopHintWithoutOSREnter(const NaturalLoops& naturalLoops, FTL::CapabilityLevel level)
{
HashSet<const NaturalLoop*> loopsContainingLoopHintWithoutOSREnter;
for (BasicBlock* block : m_graph.blocksInNaturalOrder()) {
for (unsigned nodeIndex = 0; nodeIndex < block->size(); ++nodeIndex) {
Node* node = block->at(nodeIndex);
if (node->op() != LoopHint)
continue;
if (!canOSREnterAtLoopHint(level, block, nodeIndex)) {
const NaturalLoop* loop = naturalLoops.innerMostLoopOf(block);
while (loop) {
loopsContainingLoopHintWithoutOSREnter.add(loop);
loop = naturalLoops.innerMostOuterLoop(*loop);
}
}
}
}
return loopsContainingLoopHintWithoutOSREnter;
}
#endif
};
bool performTierUpCheckInjection(Graph& graph)
{
SamplingRegion samplingRegion("DFG Tier-up Check Injection");
return runPhase<TierUpCheckInjectionPhase>(graph);
}
} }
#endif // ENABLE(DFG_JIT)