DFGCapabilities.cpp [plain text]
#include "config.h"
#include "DFGCapabilities.h"
#include "CodeBlock.h"
#include "DFGCommon.h"
#include "Interpreter.h"
namespace JSC { namespace DFG {
#if ENABLE(DFG_JIT)
bool mightCompileEval(CodeBlock* codeBlock)
{
return codeBlock->instructionCount() <= Options::maximumOptimizationCandidateInstructionCount();
}
bool mightCompileProgram(CodeBlock* codeBlock)
{
return codeBlock->instructionCount() <= Options::maximumOptimizationCandidateInstructionCount();
}
bool mightCompileFunctionForCall(CodeBlock* codeBlock)
{
return codeBlock->instructionCount() <= Options::maximumOptimizationCandidateInstructionCount();
}
bool mightCompileFunctionForConstruct(CodeBlock* codeBlock)
{
return codeBlock->instructionCount() <= Options::maximumOptimizationCandidateInstructionCount();
}
bool mightInlineFunctionForCall(CodeBlock* codeBlock)
{
return codeBlock->instructionCount() <= Options::maximumFunctionForCallInlineCandidateInstructionCount()
&& !codeBlock->ownerExecutable()->needsActivation();
}
bool mightInlineFunctionForClosureCall(CodeBlock* codeBlock)
{
return codeBlock->instructionCount() <= Options::maximumFunctionForClosureCallInlineCandidateInstructionCount()
&& !codeBlock->ownerExecutable()->needsActivation();
}
bool mightInlineFunctionForConstruct(CodeBlock* codeBlock)
{
return codeBlock->instructionCount() <= Options::maximumFunctionForConstructInlineCandidateInstructionCount()
&& !codeBlock->ownerExecutable()->needsActivation();
}
static inline void debugFail(CodeBlock* codeBlock, OpcodeID opcodeID, bool result)
{
ASSERT_UNUSED(result, !result);
#if DFG_ENABLE(DEBUG_VERBOSE)
dataLogF("Cannot handle code block %p because of opcode %s.\n", codeBlock, opcodeNames[opcodeID]);
#else
UNUSED_PARAM(codeBlock);
UNUSED_PARAM(opcodeID);
UNUSED_PARAM(result);
#endif
}
static inline void debugFail(CodeBlock* codeBlock, OpcodeID opcodeID, CapabilityLevel result)
{
ASSERT(result != CanCompile);
#if DFG_ENABLE(DEBUG_VERBOSE)
if (result == CannotCompile)
dataLogF("Cannot handle code block %p because of opcode %s.\n", codeBlock, opcodeNames[opcodeID]);
else {
dataLogF("Cannot compile code block %p because of opcode %s, but inlining might be possible.\n", codeBlock, opcodeNames[opcodeID]);
}
#else
UNUSED_PARAM(codeBlock);
UNUSED_PARAM(opcodeID);
UNUSED_PARAM(result);
#endif
}
template<typename ReturnType, ReturnType (*canHandleOpcode)(OpcodeID, CodeBlock*, Instruction*)>
ReturnType canHandleOpcodes(CodeBlock* codeBlock, ReturnType initialValue)
{
Interpreter* interpreter = codeBlock->vm()->interpreter;
Instruction* instructionsBegin = codeBlock->instructions().begin();
unsigned instructionCount = codeBlock->instructions().size();
ReturnType result = initialValue;
for (unsigned bytecodeOffset = 0; bytecodeOffset < instructionCount; ) {
switch (interpreter->getOpcodeID(instructionsBegin[bytecodeOffset].u.opcode)) {
#define DEFINE_OP(opcode, length) \
case opcode: { \
ReturnType current = canHandleOpcode( \
opcode, codeBlock, instructionsBegin + bytecodeOffset); \
if (current < result) { \
result = current; \
debugFail(codeBlock, opcode, current); \
} \
bytecodeOffset += length; \
break; \
}
FOR_EACH_OPCODE_ID(DEFINE_OP)
#undef DEFINE_OP
default:
RELEASE_ASSERT_NOT_REACHED();
break;
}
}
return result;
}
CapabilityLevel canCompileOpcodes(CodeBlock* codeBlock)
{
if (!MacroAssembler::supportsFloatingPoint())
return CannotCompile;
return canHandleOpcodes<CapabilityLevel, canCompileOpcode>(codeBlock, CanCompile);
}
bool canInlineOpcodes(CodeBlock* codeBlock)
{
return canHandleOpcodes<bool, canInlineOpcode>(codeBlock, true);
}
#endif
} }