webkitgtk-2.4.11webkitgtk-2.4.11

1 files changed, 44 insertions, 80 deletions

diff --git a/Source/JavaScriptCore/dfg/DFGCapabilities.cpp b/Source/JavaScriptCore/dfg/DFGCapabilities.cpp
index d100d97d5..e6fcd8c11 100644
--- a/Source/JavaScriptCore/dfg/DFGCapabilities.cpp
+++ b/Source/JavaScriptCore/dfg/DFGCapabilities.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011, 2013-2015 Apple Inc. All rights reserved.
+ * Copyright (C) 2011, 2013, 2014 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -31,65 +31,44 @@
 #include "CodeBlock.h"
 #include "DFGCommon.h"
 #include "Interpreter.h"
-#include "JSCInlines.h"
-#include "Options.h"
 
 namespace JSC { namespace DFG {
 
-bool isSupported()
-{
-    return Options::useDFGJIT()
-        && MacroAssembler::supportsFloatingPoint();
-}
-
-bool isSupportedForInlining(CodeBlock* codeBlock)
-{
-#if ENABLE(WEBASSEMBLY)
-    if (codeBlock->ownerExecutable()->isWebAssemblyExecutable())
-        return false;
-#endif
-    return codeBlock->ownerScriptExecutable()->isInliningCandidate();
-}
-
+#if ENABLE(DFG_JIT)
 bool mightCompileEval(CodeBlock* codeBlock)
 {
-    return isSupported()
-        && codeBlock->instructionCount() <= Options::maximumOptimizationCandidateInstructionCount()
-        && codeBlock->ownerScriptExecutable()->isOkToOptimize();
+    return codeBlock->instructionCount() <= Options::maximumOptimizationCandidateInstructionCount();
 }
 bool mightCompileProgram(CodeBlock* codeBlock)
 {
-    return isSupported()
-        && codeBlock->instructionCount() <= Options::maximumOptimizationCandidateInstructionCount()
-        && codeBlock->ownerScriptExecutable()->isOkToOptimize();
+    return codeBlock->instructionCount() <= Options::maximumOptimizationCandidateInstructionCount();
 }
 bool mightCompileFunctionForCall(CodeBlock* codeBlock)
 {
-    return isSupported()
-        && codeBlock->instructionCount() <= Options::maximumOptimizationCandidateInstructionCount()
-        && codeBlock->ownerScriptExecutable()->isOkToOptimize();
+    return codeBlock->instructionCount() <= Options::maximumOptimizationCandidateInstructionCount();
 }
 bool mightCompileFunctionForConstruct(CodeBlock* codeBlock)
 {
-    return isSupported()
-        && codeBlock->instructionCount() <= Options::maximumOptimizationCandidateInstructionCount()
-        && codeBlock->ownerScriptExecutable()->isOkToOptimize();
+    return codeBlock->instructionCount() <= Options::maximumOptimizationCandidateInstructionCount();
 }
 
 bool mightInlineFunctionForCall(CodeBlock* codeBlock)
 {
     return codeBlock->instructionCount() <= Options::maximumFunctionForCallInlineCandidateInstructionCount()
-        && isSupportedForInlining(codeBlock);
+        && !codeBlock->ownerExecutable()->needsActivation()
+        && codeBlock->ownerExecutable()->isInliningCandidate();
 }
 bool mightInlineFunctionForClosureCall(CodeBlock* codeBlock)
 {
     return codeBlock->instructionCount() <= Options::maximumFunctionForClosureCallInlineCandidateInstructionCount()
-        && isSupportedForInlining(codeBlock);
+        && !codeBlock->ownerExecutable()->needsActivation()
+        && codeBlock->ownerExecutable()->isInliningCandidate();
 }
 bool mightInlineFunctionForConstruct(CodeBlock* codeBlock)
 {
     return codeBlock->instructionCount() <= Options::maximumFunctionForConstructInlineCandidateInstructionCount()
-        && isSupportedForInlining(codeBlock);
+        && !codeBlock->ownerExecutable()->needsActivation()
+        && codeBlock->ownerExecutable()->isInliningCandidate();
 }
 
 inline void debugFail(CodeBlock* codeBlock, OpcodeID opcodeID, CapabilityLevel result)
@@ -100,13 +79,12 @@ inline void debugFail(CodeBlock* codeBlock, OpcodeID opcodeID, CapabilityLevel r
 
 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_touch_entry:
     case op_to_this:
-    case op_check_tdz:
     case op_create_this:
+    case op_get_callee:
     case op_bitand:
     case op_bitor:
     case op_bitxor:
@@ -125,18 +103,15 @@ CapabilityLevel capabilityLevel(OpcodeID opcodeID, CodeBlock* codeBlock, Instruc
     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_overrides_has_instance:
+    case op_captured_mov:
+    case op_check_has_instance:
     case op_instanceof:
-    case op_instanceof_custom:
     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:
@@ -153,13 +128,16 @@ CapabilityLevel capabilityLevel(OpcodeID opcodeID, CodeBlock* codeBlock, Instruc
     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_getter_by_id:
-    case op_put_setter_by_id:
-    case op_put_getter_setter_by_id:
-    case op_put_getter_by_val:
-    case op_put_setter_by_val:
+    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:
@@ -174,7 +152,6 @@ CapabilityLevel capabilityLevel(OpcodeID opcodeID, CodeBlock* codeBlock, Instruc
     case op_jngreater:
     case op_jngreatereq:
     case op_loop_hint:
-    case op_watchdog:
     case op_ret:
     case op_end:
     case op_new_object:
@@ -186,48 +163,23 @@ CapabilityLevel capabilityLevel(OpcodeID opcodeID, CodeBlock* codeBlock, Instruc
     case op_throw:
     case op_throw_static_error:
     case op_call:
-    case op_tail_call:
     case op_construct:
-    case op_call_varargs:
-    case op_tail_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_init_lazy_reg:
+    case op_create_arguments:
+    case op_tear_off_arguments:
+    case op_get_argument_by_val:
+    case op_get_arguments_length:
     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_new_generator_func:
-    case op_new_generator_func_exp:
-    case op_new_arrow_func_exp:
-    case op_create_lexical_environment:
-    case op_get_parent_scope:
-    case op_catch:
-    case op_copy_rest:
-    case op_get_rest_length:
         return CanCompileAndInline;
 
     case op_put_to_scope: {
-        ResolveType resolveType = GetPutInfo(pc[4].u.operand).resolveType();
+        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)
@@ -237,13 +189,23 @@ CapabilityLevel capabilityLevel(OpcodeID opcodeID, CodeBlock* codeBlock, Instruc
 
     case op_resolve_scope: {
         // We don't compile 'catch' or 'with', so there's no point in compiling variable resolution within them.
-        ResolveType resolveType = static_cast<ResolveType>(pc[4].u.operand);
+        ResolveType resolveType = ResolveModeAndType(pc[3].u.operand).type();
         if (resolveType == Dynamic)
             return CannotCompile;
         return CanCompileAndInline;
     }
 
-    case op_new_regexp:
+    case op_call_varargs:
+        if (codeBlock->usesArguments() && pc[4].u.operand == codeBlock->argumentsRegister().offset())
+            return CanInline;
+        return CannotCompile;
+
+    case op_new_regexp: 
+    case op_create_activation:
+    case op_tear_off_activation:
+    case op_new_func:
+    case op_new_captured_func:
+    case op_new_func_exp:
     case op_switch_string: // Don't inline because we don't want to copy string tables in the concurrent JIT.
         return CanCompile;
 
@@ -282,6 +244,8 @@ CapabilityLevel capabilityLevel(CodeBlock* codeBlock)
     return result;
 }
 
+#endif
+
 } } // namespace JSC::DFG
 
 #endif