JavaScriptCore-7601.1.46.3.tar.gz

[apple/javascriptcore.git] / dfg / DFGCapabilities.cpp

diff --git a/dfg/DFGCapabilities.cpp b/dfg/DFGCapabilities.cpp
index 450a5d83e4eb98d627aff6448119b82b680ea203..ef4c24749b78fa6e09a4c3d9c29013eaa65daa92 100644 (file)
--- a/dfg/DFGCapabilities.cpp
+++ b/dfg/DFGCapabilities.cpp
@@ -1,5 +1,5 @@
 /*
 /*

- * 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
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions


@@ -26,65 +26,246 @@
 #include "config.h"
 #include "DFGCapabilities.h"
 
 #include "config.h"
 #include "DFGCapabilities.h"
 

+#if ENABLE(DFG_JIT)
+

 #include "CodeBlock.h"
 #include "DFGCommon.h"
 #include "Interpreter.h"
 #include "CodeBlock.h"
 #include "DFGCommon.h"
 #include "Interpreter.h"

+#include "JSCInlines.h"
+#include "Options.h"

 
 namespace JSC { namespace DFG {
 
 
 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();
     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)) {
     
     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:
             FOR_EACH_OPCODE_ID(DEFINE_OP)
 #undef DEFINE_OP
         default:

-            ASSERT_NOT_REACHED();
+            RELEASE_ASSERT_NOT_REACHED();

             break;
         }
     }
     
             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
 
 } } // namespace JSC::DFG
 

+#endif