Changeset 118240 in webkit for trunk/Source/JavaScriptCore/runtime/Arguments.h

Timestamp:

May 23, 2012, 1:52:42 PM (13 years ago)

Author:

[email protected]

Message:

DFG should be able to inline functions that use arguments reflectively
​https://bugs.webkit.org/show_bug.cgi?id=86132

Reviewed by Oliver Hunt.

Merged r116838 from dfgopt.

This turns on inlining of functions that use arguments reflectively, but it
does not do any of the obvious optimizations that this exposes. I'll save that
for another patch - the important thing for now is that this contains all of
the plumbing necessary to make this kind of inlining sound even in bizarro
cases like an inline callee escaping the arguments object to parts of the
inline caller where the arguments are otherwise dead. Or even more fun cases
like where you've inlined to an inline stack that is three-deep, and the
function on top of the inline stack reflectively accesses the arguments of a
function that is in the middle of the inline stack. Any subsequent
optimizations that we do for the obvious cases of arguments usage in inline
functions will have to take care not to break the baseline functionality that
this patch plumbs together.

• bytecode/CodeBlock.cpp:

(JSC::CodeBlock::printCallOp):
(JSC::CodeBlock::dump):

• bytecode/CodeBlock.h:
• dfg/DFGAssemblyHelpers.h:

(JSC::DFG::AssemblyHelpers::argumentsRegisterFor):
(AssemblyHelpers):

• dfg/DFGByteCodeParser.cpp:

(InlineStackEntry):
(JSC::DFG::ByteCodeParser::handleCall):
(JSC::DFG::ByteCodeParser::handleInlining):
(JSC::DFG::ByteCodeParser::InlineStackEntry::InlineStackEntry):
(JSC::DFG::ByteCodeParser::parse):

• dfg/DFGCCallHelpers.h:

(JSC::DFG::CCallHelpers::setupArgumentsWithExecState):
(CCallHelpers):

• dfg/DFGCapabilities.h:

(JSC::DFG::canInlineOpcode):

• dfg/DFGDriver.cpp:

(JSC::DFG::compile):

• dfg/DFGFixupPhase.cpp:

(JSC::DFG::FixupPhase::fixupNode):

• dfg/DFGOperations.cpp:
• dfg/DFGOperations.h:
• dfg/DFGSpeculativeJIT.h:

(JSC::DFG::SpeculativeJIT::callOperation):

• dfg/DFGSpeculativeJIT32_64.cpp:

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

• dfg/DFGSpeculativeJIT64.cpp:

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

• interpreter/CallFrame.cpp:

(JSC):
(JSC::CallFrame::someCodeBlockForPossiblyInlinedCode):

• interpreter/CallFrame.h:

(ExecState):
(JSC::ExecState::someCodeBlockForPossiblyInlinedCode):

• interpreter/Interpreter.cpp:

(JSC::Interpreter::retrieveArgumentsFromVMCode):

• runtime/Arguments.cpp:

(JSC::Arguments::tearOff):
(JSC):
(JSC::Arguments::tearOffForInlineCallFrame):

• runtime/Arguments.h:

(Arguments):
(JSC::Arguments::create):
(JSC::Arguments::finishCreation):
(JSC):

File:

• trunk/Source/JavaScriptCore/runtime/Arguments.h (modified) (5 diffs)

trunk/Source/JavaScriptCore/runtime/Arguments.h

@@ -68 +68 @@
             return arguments;
         }
+        
+        static Arguments* create(JSGlobalData& globalData, CallFrame* callFrame, InlineCallFrame* inlineCallFrame)
+        {
+            Arguments* arguments = new (NotNull, allocateCell<Arguments>(globalData.heap)) Arguments(callFrame);
+            arguments->finishCreation(callFrame, inlineCallFrame);
+            return arguments;
+        }
 
         enum { MaxArguments = 0x10000 };
@@ -76 +83 @@
         Arguments(CallFrame*);
         Arguments(CallFrame*, NoParametersType);
+        
+        void tearOffForInlineCallFrame(JSGlobalData& globalData, Register*, InlineCallFrame*);
 
     public:
@@ -93 +102 @@
         void copyToArguments(ExecState*, CallFrame*, uint32_t length);
         void tearOff(CallFrame*);
+        void tearOff(CallFrame*, InlineCallFrame*);
         bool isTornOff() const { return d->registerArray; }
         void didTearOffActivation(JSGlobalData& globalData, JSActivation* activation)
@@ -113 +123 @@
 
         void finishCreation(CallFrame*);
+        void finishCreation(CallFrame*, InlineCallFrame*);
 
     private:
@@ -180 +191 @@
     }
 
+    inline void Arguments::finishCreation(CallFrame* callFrame, InlineCallFrame* inlineCallFrame)
+    {
+        Base::finishCreation(callFrame->globalData());
+        ASSERT(inherits(&s_info));
+
+        JSFunction* callee = inlineCallFrame->callee.get();
+        d->numArguments = inlineCallFrame->arguments.size() - 1;
+        d->registers = reinterpret_cast<WriteBarrier<Unknown>*>(callFrame->registers()) + inlineCallFrame->stackOffset;
+        d->callee.set(callFrame->globalData(), this, callee);
+        d->overrodeLength = false;
+        d->overrodeCallee = false;
+        d->overrodeCaller = false;
+        d->isStrictMode = jsCast<FunctionExecutable*>(inlineCallFrame->executable.get())->isStrictMode();
+
+        // The bytecode generator omits op_tear_off_activation in cases of no
+        // declared parameters, so we need to tear off immediately.
+        if (d->isStrictMode || !callee->jsExecutable()->parameterCount())
+            tearOff(callFrame, inlineCallFrame);
+    }
+
 } // namespace JSC