/*
- * Copyright (C) 2011 Apple Inc. All rights reserved.
+ * Copyright (C) 2011, 2013-2015 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
#include "config.h"
#include "DFGCapabilities.h"
+#if ENABLE(DFG_JIT)
+
#include "CodeBlock.h"
#include "DFGCommon.h"
#include "Interpreter.h"
+#include "JSCInlines.h"
+#include "Options.h"
namespace JSC { namespace DFG {
-#if ENABLE(DFG_JIT)
+bool isSupported()
+{
+ return Options::useDFGJIT()
+ && MacroAssembler::supportsFloatingPoint();
+}
-static inline void debugFail(CodeBlock* codeBlock, OpcodeID opcodeID)
+bool isSupportedForInlining(CodeBlock* codeBlock)
{
-#if DFG_ENABLE(DEBUG_VERBOSE)
- dataLog("Cannot handle code block %p because of opcode %s.\n", codeBlock, opcodeNames[opcodeID]);
-#else
- UNUSED_PARAM(codeBlock);
- UNUSED_PARAM(opcodeID);
-#endif
+ return codeBlock->ownerExecutable()->isInliningCandidate();
+}
+
+bool mightCompileEval(CodeBlock* codeBlock)
+{
+ return isSupported()
+ && codeBlock->instructionCount() <= Options::maximumOptimizationCandidateInstructionCount();
+}
+bool mightCompileProgram(CodeBlock* codeBlock)
+{
+ return isSupported()
+ && codeBlock->instructionCount() <= Options::maximumOptimizationCandidateInstructionCount();
+}
+bool mightCompileFunctionForCall(CodeBlock* codeBlock)
+{
+ return isSupported()
+ && codeBlock->instructionCount() <= Options::maximumOptimizationCandidateInstructionCount();
+}
+bool mightCompileFunctionForConstruct(CodeBlock* codeBlock)
+{
+ return isSupported()
+ && codeBlock->instructionCount() <= Options::maximumOptimizationCandidateInstructionCount();
+}
+
+bool mightInlineFunctionForCall(CodeBlock* codeBlock)
+{
+ return codeBlock->instructionCount() <= Options::maximumFunctionForCallInlineCandidateInstructionCount()
+ && isSupportedForInlining(codeBlock);
+}
+bool mightInlineFunctionForClosureCall(CodeBlock* codeBlock)
+{
+ return codeBlock->instructionCount() <= Options::maximumFunctionForClosureCallInlineCandidateInstructionCount()
+ && isSupportedForInlining(codeBlock);
+}
+bool mightInlineFunctionForConstruct(CodeBlock* codeBlock)
+{
+ return codeBlock->instructionCount() <= Options::maximumFunctionForConstructInlineCandidateInstructionCount()
+ && isSupportedForInlining(codeBlock);
}
-template<bool (*canHandleOpcode)(OpcodeID)>
-bool canHandleOpcodes(CodeBlock* codeBlock)
+inline void debugFail(CodeBlock* codeBlock, OpcodeID opcodeID, CapabilityLevel result)
{
- Interpreter* interpreter = codeBlock->globalData()->interpreter;
+ if (Options::verboseCompilation() && !canCompile(result))
+ dataLog("Cannot compile code block ", *codeBlock, " because of opcode ", opcodeNames[opcodeID], "\n");
+}
+
+CapabilityLevel capabilityLevel(OpcodeID opcodeID, CodeBlock* codeBlock, Instruction* pc)
+{
+ UNUSED_PARAM(codeBlock); // This function does some bytecode parsing. Ordinarily bytecode parsing requires the owning CodeBlock. It's sort of strange that we don't use it here right now.
+
+ switch (opcodeID) {
+ case op_enter:
+ case op_to_this:
+ case op_check_tdz:
+ case op_create_this:
+ case op_bitand:
+ case op_bitor:
+ case op_bitxor:
+ case op_rshift:
+ case op_lshift:
+ case op_urshift:
+ case op_unsigned:
+ case op_inc:
+ case op_dec:
+ case op_add:
+ case op_sub:
+ case op_negate:
+ case op_mul:
+ case op_mod:
+ case op_div:
+ case op_debug:
+ case op_profile_will_call:
+ case op_profile_did_call:
+ case op_profile_type:
+ case op_profile_control_flow:
+ case op_mov:
+ case op_check_has_instance:
+ case op_instanceof:
+ case op_is_undefined:
+ case op_is_boolean:
+ case op_is_number:
+ case op_is_string:
+ case op_is_object:
+ case op_is_object_or_null:
+ case op_is_function:
+ case op_not:
+ case op_less:
+ case op_lesseq:
+ case op_greater:
+ case op_greatereq:
+ case op_eq:
+ case op_eq_null:
+ case op_stricteq:
+ case op_neq:
+ case op_neq_null:
+ case op_nstricteq:
+ case op_get_by_val:
+ case op_put_by_val:
+ case op_put_by_val_direct:
+ case op_get_by_id:
+ case op_get_by_id_out_of_line:
+ case op_get_array_length:
+ case op_put_by_id:
+ case op_put_by_id_out_of_line:
+ case op_put_by_id_transition_direct:
+ case op_put_by_id_transition_direct_out_of_line:
+ case op_put_by_id_transition_normal:
+ case op_put_by_id_transition_normal_out_of_line:
+ case op_init_global_const_nop:
+ case op_init_global_const:
+ case op_jmp:
+ case op_jtrue:
+ case op_jfalse:
+ case op_jeq_null:
+ case op_jneq_null:
+ case op_jless:
+ case op_jlesseq:
+ case op_jgreater:
+ case op_jgreatereq:
+ case op_jnless:
+ case op_jnlesseq:
+ case op_jngreater:
+ case op_jngreatereq:
+ case op_loop_hint:
+ case op_ret:
+ case op_end:
+ case op_new_object:
+ case op_new_array:
+ case op_new_array_with_size:
+ case op_new_array_buffer:
+ case op_strcat:
+ case op_to_primitive:
+ case op_throw:
+ case op_throw_static_error:
+ case op_call:
+ case op_construct:
+ case op_call_varargs:
+ case op_construct_varargs:
+ case op_create_direct_arguments:
+ case op_create_scoped_arguments:
+ case op_create_out_of_band_arguments:
+ case op_get_from_arguments:
+ case op_put_to_arguments:
+ case op_jneq_ptr:
+ case op_typeof:
+ case op_to_number:
+ case op_to_string:
+ case op_switch_imm:
+ case op_switch_char:
+ case op_in:
+ case op_get_scope:
+ case op_get_from_scope:
+ case op_get_enumerable_length:
+ case op_has_generic_property:
+ case op_has_structure_property:
+ case op_has_indexed_property:
+ case op_get_direct_pname:
+ case op_get_property_enumerator:
+ case op_enumerator_structure_pname:
+ case op_enumerator_generic_pname:
+ case op_to_index_string:
+ case op_new_func:
+ case op_new_func_exp:
+ case op_create_lexical_environment:
+ return CanCompileAndInline;
+
+ case op_put_to_scope: {
+ ResolveType resolveType = ResolveModeAndType(pc[4].u.operand).type();
+ // If we're writing to a readonly property we emit a Dynamic put that
+ // the DFG can't currently handle.
+ if (resolveType == Dynamic)
+ return CannotCompile;
+ return CanCompileAndInline;
+ }
+
+ case op_resolve_scope: {
+ // We don't compile 'catch' or 'with', so there's no point in compiling variable resolution within them.
+ ResolveType resolveType = ResolveModeAndType(pc[4].u.operand).type();
+ if (resolveType == Dynamic)
+ return CannotCompile;
+ return CanCompileAndInline;
+ }
+
+ case op_new_regexp:
+ case op_switch_string: // Don't inline because we don't want to copy string tables in the concurrent JIT.
+ return CanCompile;
+
+ default:
+ return CannotCompile;
+ }
+}
+
+CapabilityLevel capabilityLevel(CodeBlock* codeBlock)
+{
+ Interpreter* interpreter = codeBlock->vm()->interpreter;
Instruction* instructionsBegin = codeBlock->instructions().begin();
unsigned instructionCount = codeBlock->instructions().size();
+ CapabilityLevel result = CanCompileAndInline;
for (unsigned bytecodeOffset = 0; bytecodeOffset < instructionCount; ) {
switch (interpreter->getOpcodeID(instructionsBegin[bytecodeOffset].u.opcode)) {
-#define DEFINE_OP(opcode, length) \
- case opcode: \
- if (!canHandleOpcode(opcode)) { \
- debugFail(codeBlock, opcode); \
- return false; \
- } \
- bytecodeOffset += length; \
- break;
+#define DEFINE_OP(opcode, length) \
+ case opcode: { \
+ CapabilityLevel newResult = leastUpperBound(result, capabilityLevel(opcode, codeBlock, instructionsBegin + bytecodeOffset)); \
+ if (newResult != result) { \
+ debugFail(codeBlock, opcode, newResult); \
+ result = newResult; \
+ } \
+ bytecodeOffset += length; \
+ break; \
+ }
FOR_EACH_OPCODE_ID(DEFINE_OP)
#undef DEFINE_OP
default:
- ASSERT_NOT_REACHED();
+ RELEASE_ASSERT_NOT_REACHED();
break;
}
}
- return true;
-}
-
-bool canCompileOpcodes(CodeBlock* codeBlock)
-{
- if (!MacroAssembler::supportsFloatingPoint())
- return false;
- return canHandleOpcodes<canCompileOpcode>(codeBlock);
+ return result;
}
-bool canInlineOpcodes(CodeBlock* codeBlock)
-{
- return canHandleOpcodes<canInlineOpcode>(codeBlock);
-}
-
-#endif
-
} } // namespace JSC::DFG
+#endif
projects / apple / javascriptcore.git / blobdiff