Changeset 118270 in webkit for trunk/Source/JavaScriptCore/dfg/DFGCapabilities.h

Timestamp:

May 23, 2012, 5:05:21 PM (13 years ago)

Author:

[email protected]

Message:

DFG should be able to optimize foo.apply(bar, arguments)
​https://bugs.webkit.org/show_bug.cgi?id=86306

Reviewed by Gavin Barraclough.

Merge r116912 from dfgopt.

Enables compilation of op_jneq_ptr and some forms of op_call_varargs.

Also includes a bunch of bug fixes that were made necessary by the increased
pressure on the CFG simplifier.

This is a 1-2% win on V8.

• bytecode/CodeBlock.cpp:

(JSC::CodeBlock::printCallOp):
(JSC::CodeBlock::CodeBlock):
(JSC::ProgramCodeBlock::canCompileWithDFGInternal):
(JSC::EvalCodeBlock::canCompileWithDFGInternal):
(JSC::FunctionCodeBlock::canCompileWithDFGInternal):

• bytecode/CodeBlock.h:

(CodeBlock):
(JSC::CodeBlock::canCompileWithDFG):
(JSC::CodeBlock::canCompileWithDFGState):
(ProgramCodeBlock):
(EvalCodeBlock):
(FunctionCodeBlock):

• dfg/DFGAbstractState.cpp:

(JSC::DFG::AbstractState::execute):

• dfg/DFGByteCodeParser.cpp:

(JSC::DFG::ByteCodeParser::parseBlock):
(JSC::DFG::ByteCodeParser::processPhiStack):
(JSC::DFG::ByteCodeParser::parse):

• dfg/DFGCFGSimplificationPhase.cpp:

(JSC::DFG::CFGSimplificationPhase::run):
(JSC::DFG::CFGSimplificationPhase::fixPossibleGetLocal):
(JSC::DFG::CFGSimplificationPhase::fixTailOperand):
(JSC::DFG::CFGSimplificationPhase::mergeBlocks):

• dfg/DFGCSEPhase.cpp:

(JSC::DFG::CSEPhase::getLocalLoadElimination):
(CSEPhase):
(JSC::DFG::CSEPhase::setReplacement):
(JSC::DFG::CSEPhase::performNodeCSE):

• dfg/DFGCapabilities.cpp:

(JSC::DFG::debugFail):
(DFG):
(JSC::DFG::canHandleOpcodes):
(JSC::DFG::canCompileOpcodes):
(JSC::DFG::canInlineOpcodes):

• dfg/DFGCapabilities.h:

(JSC::DFG::canCompileOpcode):
(JSC::DFG::canInlineOpcode):
(DFG):
(JSC::DFG::canCompileOpcodes):
(JSC::DFG::canCompileEval):
(JSC::DFG::canCompileProgram):
(JSC::DFG::canCompileFunctionForCall):
(JSC::DFG::canCompileFunctionForConstruct):

• dfg/DFGCommon.h:
• dfg/DFGGraph.cpp:

(JSC::DFG::Graph::dump):

• dfg/DFGNodeType.h:

(DFG):

• dfg/DFGPredictionPropagationPhase.cpp:

(JSC::DFG::PredictionPropagationPhase::propagate):

• dfg/DFGSpeculativeJIT32_64.cpp:

(JSC::DFG::SpeculativeJIT::compile):

• dfg/DFGSpeculativeJIT64.cpp:

(JSC::DFG::SpeculativeJIT::emitCall):
(JSC::DFG::SpeculativeJIT::compile):

• dfg/DFGValidate.cpp:

(Validate):
(JSC::DFG::Validate::validate):
(JSC::DFG::Validate::checkOperand):
(JSC::DFG::Validate::reportValidationContext):

• jit/JIT.cpp:

(JSC::JIT::emitOptimizationCheck):
(JSC::JIT::privateCompileSlowCases):
(JSC::JIT::privateCompile):

• jit/JIT.h:
• jit/JITArithmetic.cpp:

(JSC::JIT::compileBinaryArithOp):

• jit/JITPropertyAccess.cpp:

(JSC::JIT::privateCompilePutByIdTransition):

• jit/JITPropertyAccess32_64.cpp:

(JSC::JIT::privateCompilePutByIdTransition):

• tools/CodeProfile.cpp:

(JSC::CodeProfile::sample):

File:

• trunk/Source/JavaScriptCore/dfg/DFGCapabilities.h (modified) (7 diffs)

trunk/Source/JavaScriptCore/dfg/DFGCapabilities.h

@@ -1 +1 @@
 /*
- * Copyright (C) 2011 Apple Inc. All rights reserved.
+ * Copyright (C) 2011, 2012 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -28 +28 @@
 
 #include "Intrinsic.h"
+#include "DFGCommon.h"
 #include "DFGNode.h"
 #include "Executable.h"
@@ -68 +69 @@
 
 // Opcode checking.
-inline bool canCompileOpcode(OpcodeID opcodeID)
+inline CapabilityLevel canCompileOpcode(OpcodeID opcodeID, CodeBlock*, Instruction*)
 {
     switch (opcodeID) {
@@ -170 +171 @@
     case op_get_argument_by_val:
     case op_get_arguments_length:
-        return true;
-        
+    case op_jneq_ptr:
+        return CanCompile;
+        
+    case op_call_varargs:
+        return ShouldProfile;
+
     default:
-        return false;
+        return CannotCompile;
     }
 }
 
-inline bool canInlineOpcode(OpcodeID opcodeID)
+inline bool canInlineOpcode(OpcodeID opcodeID, CodeBlock* codeBlock, Instruction* pc)
 {
     switch (opcodeID) {
@@ -195 +200 @@
     // Inlining doesn't correctly remap regular expression operands.
     case op_new_regexp:
-        return false;
         
     // We don't support inlining code that creates activations or has nested functions.
@@ -204 +208 @@
         return false;
         
+    // Inlining supports op_call_varargs if it's a call that just forwards the caller's
+    // arguments.
+    case op_call_varargs:
+        return pc[3].u.operand == codeBlock->argumentsRegister();
+        
     default:
-        return canCompileOpcode(opcodeID);
+        return canCompileOpcode(opcodeID, codeBlock, pc) == CanCompile;
     }
 }
 
-bool canCompileOpcodes(CodeBlock*);
+CapabilityLevel canCompileOpcodes(CodeBlock*);
 bool canInlineOpcodes(CodeBlock*);
 #else // ENABLE(DFG_JIT)
@@ -219 +228 @@
 inline bool mightInlineFunctionForConstruct(CodeBlock*) { return false; }
 
-inline bool canCompileOpcode(OpcodeID) { return false; }
-inline bool canInlineOpcode(OpcodeID) { return false; }
-inline bool canCompileOpcodes(CodeBlock*) { return false; }
+inline CapabilityLevel canCompileOpcode(OpcodeID, CodeBlock*, Instruction*) { return false; }
+inline bool canInlineOpcode(OpcodeID, CodeBlock*, Instruction*) { return false; }
+inline CapabilityLevel canCompileOpcodes(CodeBlock*) { return false; }
 inline bool canInlineOpcodes(CodeBlock*) { return false; }
 #endif // ENABLE(DFG_JIT)
 
-inline bool canCompileEval(CodeBlock* codeBlock)
-{
-    return mightCompileEval(codeBlock) && canCompileOpcodes(codeBlock);
-}
-
-inline bool canCompileProgram(CodeBlock* codeBlock)
-{
-    return mightCompileProgram(codeBlock) && canCompileOpcodes(codeBlock);
-}
-
-inline bool canCompileFunctionForCall(CodeBlock* codeBlock)
-{
-    return mightCompileFunctionForCall(codeBlock) && canCompileOpcodes(codeBlock);
-}
-
-inline bool canCompileFunctionForConstruct(CodeBlock* codeBlock)
-{
-    return mightCompileFunctionForConstruct(codeBlock) && canCompileOpcodes(codeBlock);
+inline CapabilityLevel canCompileEval(CodeBlock* codeBlock)
+{
+    if (!mightCompileEval(codeBlock))
+        return CannotCompile;
+    
+    return canCompileOpcodes(codeBlock);
+}
+
+inline CapabilityLevel canCompileProgram(CodeBlock* codeBlock)
+{
+    if (!mightCompileProgram(codeBlock))
+        return CannotCompile;
+    
+    return canCompileOpcodes(codeBlock);
+}
+
+inline CapabilityLevel canCompileFunctionForCall(CodeBlock* codeBlock)
+{
+    if (!mightCompileFunctionForCall(codeBlock))
+        return CannotCompile;
+    
+    return canCompileOpcodes(codeBlock);
+}
+
+inline CapabilityLevel canCompileFunctionForConstruct(CodeBlock* codeBlock)
+{
+    if (!mightCompileFunctionForConstruct(codeBlock))
+        return CannotCompile;
+    
+    return canCompileOpcodes(codeBlock);
 }