Changeset 153218 in webkit for trunk/Source/JavaScriptCore/interpreter/CallFrame.cpp

Timestamp:

Jul 24, 2013, 9:02:28 PM (12 years ago)

Author:

[email protected]

Message:

fourthTier: Introducing the StackIterator class.

This was a non trivial merge as trunk has changed computation of line and column information

Introducing the StackIterator class.
​https://bugs.webkit.org/show_bug.cgi?id=117390.

Reviewed by Geoffrey Garen.

Source/JavaScriptCore:

The StackIterator class is meant to unify the way we iterate the JS
stack. It also makes it so that we don't have to copy the frame data
into the intermediate StackFrame struct before processing it.
Unfortunately we still can't get rid of StackFrame because it is used
to record frame information for the Exception stack that is expected
to persist beyond when the frames have been popped off the JS stack.

The StackIterator will iterate over all "logical" frames (i.e. including
inlined frames). As it iterates the JS stack, if it encounters a DFG
frame that has inlined frames, the iterator will canonicalize the
inlined frames before returning. Once canonicalized, the frame can be
read like any other frame.

The StackIterator implements a Frame class that inherits from CallFrame.
The StackIterator::Frame serves as reader of the CallFrame that makes
it easier to access information about the frame. The StackIterator::Frame
only adds functions, and no additional data fields.

• API/JSContextRef.cpp:

(JSContextCreateBacktrace):

• CMakeLists.txt:
• GNUmakefile.list.am:
• JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj:
• JavaScriptCore.vcxproj/JavaScriptCore.vcxproj:
• JavaScriptCore.vcxproj/JavaScriptCore.vcxproj.filters:
• JavaScriptCore.xcodeproj/project.pbxproj:
• Target.pri:
• interpreter/CallFrame.cpp:

(JSC::CallFrame::begin):
(JSC::CallFrame::beginAt):

• interpreter/CallFrame.h:

(JSC::ExecState::setInlineCallFrame):
(ExecState):
(JSC::ExecState::end):

• interpreter/Interpreter.cpp:

(JSC::Interpreter::dumpRegisters):
(JSC::Interpreter::unwindCallFrame):
(JSC::Interpreter::getStackTrace):
(JSC::Interpreter::throwException):
(JSC::Interpreter::debug):

• interpreter/Interpreter.h:

(Interpreter):

• interpreter/StackIterator.cpp: Added.

(JSC::StackIterator::StackIterator):
(JSC::StackIterator::beginAt):
(JSC::StackIterator::gotoNextFrame):

• Based on the deleted Interpreter::findFunctionCallFrameFromVMCode().

(JSC::StackIterator::findFrameForFunction):

• Based on the deleted Interpreter::retrieveCallerFromVMCode().

(JSC::StackIterator::Frame::codeType):

• Based on the deleted getStackFrameCodeType().

(JSC::StackIterator::Frame::functionName):

• Based on StackFrame::friendlyFunctionName().

(JSC::StackIterator::Frame::sourceURL):

• Based on StackFrame::friendlySourceURL().

(JSC::StackIterator::Frame::toString):

• Based on StackFrame::toString().

(JSC::StackIterator::Frame::bytecodeOffset):
(JSC::StackIterator::Frame::line):

• Based on StackFrame::line().

(JSC::StackIterator::Frame::column):

• Based on StackFrame::column().

(JSC::StackIterator::Frame::arguments):

• Based on the deleted Interpreter::retrieveArgumentsFromVMCode().

(JSC::StackIterator::Frame::retrieveExpressionInfo):

• Based on StackFrame::expressionInfo().

(JSC::StackIterator::Frame::logicalFrame):

• Based on the now deleted CallFrame::trueCallFrame().

(JSC::StackIterator::Frame::logicalCallerFrame):

• Based on the now deleted CallFrame::trueCallerFrame().

(JSC::jitTypeName):
(JSC::printIndents):
(JSC::printif):
(JSC::StackIterator::Frame::print):
(debugPrintCallFrame):

• Prints the contents of the frame for debugging purposes. There are 2 versions that can be used as follows:

1. When you have a valid StackIterator, you can print the current frame's content using the print instance method:

iter->print(indentLevel);

2. When you have a CallFrame* that you want to dump from a debugger console, you can print its content as follows:

(gdb) call debugPrintCallFrame(callFrame)

A sample of the output looks like this:

frame 0x1510c70b0 {

name 'shouldBe'
sourceURL 'testapi.js'
hostFlag 0
isInlinedFrame 0
callee 0x15154efb0
returnPC 0x10ed0786d
callerFrame 0x1510c7058
logicalCallerFrame 0x1510c7058
rawLocationBits 27 0x1b
codeBlock 0x7fe79b037200

bytecodeOffset 27 0x1b / 210
line 46
column 20
jitType 3 <BaselineJIT> isOptimizingJIT 0
hasCodeOrigins 0

}

• interpreter/StackIterator.h: Added.

(StackIterator::Frame):
(JSC::StackIterator::Frame::create):
(JSC::StackIterator::Frame::isJSFrame):
(JSC::StackIterator::Frame::callFrame):

• interpreter/StackIteratorPrivate.h: Added.

(StackIterator):
(JSC::StackIterator::operator*):
(JSC::StackIterator::operator->):
(JSC::StackIterator::operator==):
(JSC::StackIterator::operator!=):
(JSC::StackIterator::operator++):
(JSC::StackIterator::end):
(JSC::StackIterator::empty):

• jsc.cpp:

(functionJSCStack):

• profiler/ProfileGenerator.cpp:

(JSC::ProfileGenerator::addParentForConsoleStart):

• profiler/ProfileNode.h:

(ProfileNode):

• runtime/JSFunction.cpp:

(JSC::retrieveArguments):
(JSC::JSFunction::argumentsGetter):
(JSC::skipOverBoundFunctions):
(JSC::retrieveCallerFunction):
(JSC::JSFunction::callerGetter):
(JSC::JSFunction::getOwnPropertyDescriptor):
(JSC::JSFunction::defineOwnProperty):

• runtime/JSGlobalObjectFunctions.cpp:

(JSC::globalFuncProtoGetter):
(JSC::globalFuncProtoSetter):

• runtime/ObjectConstructor.cpp:

(JSC::objectConstructorGetPrototypeOf):

• runtime/Operations.h:

Source/WebCore:

No new tests.

• ForwardingHeaders/interpreter/StackIterator.h: Added.
• bindings/js/JSXMLHttpRequestCustom.cpp:

(WebCore::JSXMLHttpRequest::send):

• bindings/js/ScriptCallStackFactory.cpp:

(WebCore::createScriptCallStack):

File:

• trunk/Source/JavaScriptCore/interpreter/CallFrame.cpp (modified) (2 diffs)

trunk/Source/JavaScriptCore/interpreter/CallFrame.cpp

@@ -68 +68 @@
     
 #if ENABLE(DFG_JIT)
-CallFrame* CallFrame::trueCallFrame()
-{
-    // Am I an inline call frame? If so, we're done.
-    if (isInlinedFrame())
-        return this;
-    
-    // If I don't have a code block, then I'm not DFG code, so I'm the true call frame.
-    CodeBlock* machineCodeBlock = codeBlock();
-    if (!machineCodeBlock)
-        return this;
-    
-    // If the code block does not have any code origins, then there was no inlining, so
-    // I'm done.
-    if (!machineCodeBlock->hasCodeOrigins())
-        return this;
-    
-    // Try to determine the CodeOrigin. If we don't have a pc set then the only way
-    // that this makes sense is if the CodeOrigin index was set in the call frame.
-    CodeOrigin codeOrigin;
-    unsigned index = locationAsCodeOriginIndex();
-    ASSERT(machineCodeBlock->canGetCodeOrigin(index));
-    if (!machineCodeBlock->canGetCodeOrigin(index)) {
-        // See above. In release builds, we try to protect ourselves from crashing even
-        // though stack walking will be goofed up.
-        return 0;
-    }
-    codeOrigin = machineCodeBlock->codeOrigin(index);
-
-    if (!codeOrigin.inlineCallFrame)
-        return this; // Not currently in inlined code.
-
-    CodeOrigin innerMostCodeOrigin = codeOrigin;
-
-    for (InlineCallFrame* inlineCallFrame = codeOrigin.inlineCallFrame; inlineCallFrame;) {
-        InlineCallFrame* nextInlineCallFrame = inlineCallFrame->caller.inlineCallFrame;
-        
-        CallFrame* inlinedCaller = this + inlineCallFrame->stackOffset;
-        
-        JSFunction* calleeAsFunction = inlineCallFrame->callee.get();
-        
-        // Fill in the inlinedCaller
-        inlinedCaller->setCodeBlock(inlineCallFrame->baselineCodeBlock());
-        if (calleeAsFunction)
-            inlinedCaller->setScope(calleeAsFunction->scope());
-        if (nextInlineCallFrame)
-            inlinedCaller->setCallerFrame(this + nextInlineCallFrame->stackOffset);
-        else
-            inlinedCaller->setCallerFrame(this);
-        
-        inlinedCaller->setInlineCallFrame(inlineCallFrame);
-        inlinedCaller->setArgumentCountIncludingThis(inlineCallFrame->arguments.size());
-        inlinedCaller->setLocationAsBytecodeOffset(codeOrigin.bytecodeIndex);
-        inlinedCaller->setIsInlinedFrame();
-        if (calleeAsFunction)
-            inlinedCaller->setCallee(calleeAsFunction);
-        
-        codeOrigin = inlineCallFrame->caller;
-        inlineCallFrame = nextInlineCallFrame;
-    }
-    
-    return this + innerMostCodeOrigin.inlineCallFrame->stackOffset;
-}
-        
-CallFrame* CallFrame::trueCallerFrame()
-{
-    CallFrame* callerFrame = this->callerFrame()->removeHostCallFrameFlag();
-    if (!codeBlock())
-        return callerFrame;
-
-    // this -> The callee; this is either an inlined callee in which case it already has
-    //    a pointer to the true caller. Otherwise it contains current PC in the machine
-    //    caller.
-    //
-    // machineCaller -> The caller according to the machine, which may be zero or
-    //    more frames above the true caller due to inlining.
-
-    // Am I an inline call frame? If so, we're done.
-    if (isInlinedFrame())
-        return callerFrame;
-    
-    // I am a machine call frame, so the question is: is my caller a machine call frame
-    // that has inlines or a machine call frame that doesn't?
-    if (!callerFrame)
-        return 0;
-
-    if (!callerFrame->codeBlock())
-        return callerFrame;
-    ASSERT(!callerFrame->isInlinedFrame());
-    
-    return callerFrame->trueCallFrame()->removeHostCallFrameFlag();
-}
-
 unsigned CallFrame::bytecodeOffsetFromCodeOriginIndex()
 {
@@ -190 +98 @@
 }
 
+StackIterator CallFrame::begin(StackIterator::FrameFilter filter)
+{
+    ASSERT(this);
+    return StackIterator(this, filter);
 }
+
+StackIterator CallFrame::find(JSFunction* calleeFunctionObj, StackIterator::FrameFilter filter)
+{
+    ASSERT(this);
+    StackIterator iter = StackIterator(this, filter);
+    iter.find(calleeFunctionObj);
+    return iter;
+}
+
+StackIterator::Frame* CallFrame::end()
+{
+    return StackIterator::end();
+}
+
+}