DFGPredictionInjectionPhase.cpp [plain text]
#include "config.h"
#include "DFGPredictionInjectionPhase.h"
#if ENABLE(DFG_JIT)
#include "DFGBasicBlockInlines.h"
#include "DFGGraph.h"
#include "DFGPhase.h"
#include "JSCInlines.h"
namespace JSC { namespace DFG {
class PredictionInjectionPhase : public Phase {
public:
PredictionInjectionPhase(Graph& graph)
: Phase(graph, "prediction injection")
{
}
bool run()
{
ASSERT(m_graph.m_form == ThreadedCPS);
ASSERT(m_graph.m_unificationState == GloballyUnified);
ASSERT(codeBlock()->numParameters() >= 1);
{
ConcurrentJITLocker locker(profiledBlock()->m_lock);
for (size_t arg = 0; arg < static_cast<size_t>(codeBlock()->numParameters()); ++arg) {
ValueProfile* profile = profiledBlock()->valueProfileForArgument(arg);
if (!profile)
continue;
m_graph.m_arguments[arg]->variableAccessData()->predict(
profile->computeUpdatedPrediction(locker));
}
}
for (BlockIndex blockIndex = 0; blockIndex < m_graph.numBlocks(); ++blockIndex) {
BasicBlock* block = m_graph.block(blockIndex);
if (!block)
continue;
if (!block->isOSRTarget)
continue;
if (block->bytecodeBegin != m_graph.m_plan.osrEntryBytecodeIndex)
continue;
for (size_t i = 0; i < m_graph.m_plan.mustHandleValues.size(); ++i) {
int operand = m_graph.m_plan.mustHandleValues.operandForIndex(i);
Node* node = block->variablesAtHead.operand(operand);
if (!node)
continue;
ASSERT(node->hasLocal(m_graph));
node->variableAccessData()->predict(
speculationFromValue(m_graph.m_plan.mustHandleValues[i]));
}
}
return true;
}
};
bool performPredictionInjection(Graph& graph)
{
SamplingRegion samplingRegion("DFG Prediction Injection Phase");
return runPhase<PredictionInjectionPhase>(graph);
}
} }
#endif // ENABLE(DFG_JIT)