Ignore:
Timestamp:
Apr 6, 2013, 3:47:56 PM (12 years ago)
Author:
[email protected]
Message:

Unify the many and varied stack trace mechanisms, and make the result sane.
​https://bugs.webkit.org/show_bug.cgi?id=114072

Reviewed by Filip Pizlo.

Source/JavaScriptCore:

Makes JSC::StackFrame record the bytecode offset and other necessary data
rather than requiring us to perform eager evaluation of the line number, etc.
Then remove most of the users of retrieveLastCaller, as most of them were
using it to create a stack trace in a fairly incomplete and inefficient way.

StackFrame now also has a couple of helpers to get the line and column info.

  • API/JSContextRef.cpp:

(JSContextCreateBacktrace):

  • bytecompiler/BytecodeGenerator.cpp:

(JSC::BytecodeGenerator::emitDebugHook):

  • interpreter/Interpreter.cpp:

(JSC):
(JSC::Interpreter::dumpRegisters):
(JSC::Interpreter::unwindCallFrame):
(JSC::getBytecodeOffsetForCallFrame):
(JSC::getCallerInfo):
(JSC::StackFrame::line):
(JSC::StackFrame::column):
(JSC::StackFrame::expressionInfo):
(JSC::StackFrame::toString):
(JSC::Interpreter::getStackTrace):
(JSC::Interpreter::addStackTraceIfNecessary):
(JSC::Interpreter::retrieveCallerFromVMCode):

  • interpreter/Interpreter.h:

(StackFrame):
(Interpreter):

  • runtime/Error.cpp:

(JSC::throwError):

  • runtime/JSGlobalData.h:

(JSC):
(JSGlobalData):

  • runtime/JSGlobalObject.cpp:

(JSC::DynamicGlobalObjectScope::DynamicGlobalObjectScope):

Source/WebCore:

Now that we've fleshed out the StackFrames from Interpreter::getStackTrace
WebCore can just ask us for a stack trace rather than implementing its own
stack walking.

  • bindings/js/ScriptCallStackFactory.cpp:

(WebCore::createScriptCallStack):

  • inspector/ScriptCallFrame.cpp:

(WebCore::ScriptCallFrame::isEqual):

  • inspector/ScriptCallFrame.h:

(ScriptCallFrame):
(WebCore::ScriptCallFrame::columnNumber):

Tools:

The commandline jsc executable no longer requires arguments, so
I've made run-jsc work without them.

  • Scripts/run-jsc:
Location:
trunk/Source/JavaScriptCore/interpreter
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/interpreter/Interpreter.cpp

    r147851 r147858  
    200200
    201201
    202 static CallFrame* getCallerInfo(JSGlobalData*, CallFrame*, int& lineNumber, unsigned& bytecodeOffset, CodeBlock*& callerOut);
     202static CallFrame* getCallerInfo(JSGlobalData*, CallFrame*, unsigned& bytecodeOffset, CodeBlock*& callerOut);
    203203
    204204// Returns the depth of the scope chain within a given call frame.
    … …  
    423423    unsigned bytecodeOffset = 0;
    424424    int line = 0;
    425     CodeBlock* unusedCallerCodeBlock = 0;
    426     getCallerInfo(&callFrame->globalData(), callFrame, line, bytecodeOffset, unusedCallerCodeBlock);
     425    CodeBlock* callerCodeBlock = 0;
     426    getCallerInfo(&callFrame->globalData(), callFrame, bytecodeOffset, callerCodeBlock);
     427    line = callerCodeBlock->lineNumberForBytecodeOffset(bytecodeOffset);
    427428    dataLogF("[ReturnVPC]                | %10p | %d (line %d)\n", it, bytecodeOffset, line);
    428429    ++it;
    … …  
    508509    if (callerFrame->hasHostCallFrameFlag())
    509510        return false;
    510     int unusedLineNumber = 0;
    511     callFrame = getCallerInfo(&callFrame->globalData(), callFrame, unusedLineNumber, bytecodeOffset, codeBlock);
     511    callFrame = getCallerInfo(&callFrame->globalData(), callFrame, bytecodeOffset, codeBlock);
    512512    return true;
    513513}
    … …  
    565565}
    566566
    567 static int getLineNumberForCallFrame(JSGlobalData* globalData, CallFrame* callFrame)
    568 {
    569     UNUSED_PARAM(globalData);
     567static unsigned getBytecodeOffsetForCallFrame(CallFrame* callFrame)
     568{
    570569    callFrame = callFrame->removeHostCallFrameFlag();
    571570    CodeBlock* codeBlock = callFrame->codeBlock();
    572571    if (!codeBlock)
    573         return -1;
    574 #if ENABLE(JIT) || ENABLE(LLINT)
     572        return 0;
     573#if ENABLE(JIT)
    575574#if ENABLE(DFG_JIT)
    576575    if (codeBlock->getJITType() == JITCode::DFGJIT)
    577         return codeBlock->lineNumberForBytecodeOffset(codeBlock->codeOrigin(callFrame->codeOriginIndexForDFG()).bytecodeIndex);
    578 #endif
    579     return codeBlock->lineNumberForBytecodeOffset(callFrame->bytecodeOffsetForNonDFGCode());
     576        return codeBlock->codeOrigin(callFrame->codeOriginIndexForDFG()).bytecodeIndex;
     577#endif
     578    return callFrame->bytecodeOffsetForNonDFGCode();
    580579#else
    581580    return 0;
    … …  
    583582}
    584583
    585 static CallFrame* getCallerInfo(JSGlobalData* globalData, CallFrame* callFrame, int& lineNumber, unsigned& bytecodeOffset, CodeBlock*& caller)
     584static CallFrame* getCallerInfo(JSGlobalData* globalData, CallFrame* callFrame, unsigned& bytecodeOffset, CodeBlock*& caller)
    586585{
    587586    ASSERT_UNUSED(globalData, globalData);
    588587    bytecodeOffset = 0;
    589     lineNumber = -1;
    590588    ASSERT(!callFrame->hasHostCallFrameFlag());
    591589    CallFrame* callerFrame = callFrame->codeBlock() ? callFrame->trueCallerFrame() : callFrame->callerFrame()->removeHostCallFrameFlag();
    … …  
    657655    RELEASE_ASSERT(callerCodeBlock);
    658656    caller = callerCodeBlock;
    659     lineNumber = callerCodeBlock->lineNumberForBytecodeOffset(bytecodeOffset);
    660657    return callerFrame;
    661658}
    … …  
    683680}
    684681
    685 void Interpreter::getStackTrace(JSGlobalData* globalData, Vector<StackFrame>& results)
     682unsigned StackFrame::line()
     683{
     684    return codeBlock ? codeBlock->lineNumberForBytecodeOffset(bytecodeOffset) + lineOffset : 0;
     685}
     686
     687unsigned StackFrame::column()
     688{
     689    if (!code)
     690        return 0;
     691    int divot = 0;
     692    int unusedStartOffset = 0;
     693    int unusedEndOffset = 0;
     694    expressionInfo(divot, unusedStartOffset, unusedEndOffset);
     695    return code->charPositionToColumnNumber(divot);
     696}
     697
     698void StackFrame::expressionInfo(int& divot, int& startOffset, int& endOffset)
     699{
     700    codeBlock->expressionRangeForBytecodeOffset(bytecodeOffset, divot, startOffset, endOffset);
     701    divot += startOffset;
     702}
     703
     704String StackFrame::toString(CallFrame* callFrame)
     705{
     706    StringBuilder traceBuild;
     707    String functionName = friendlyFunctionName(callFrame);
     708    String sourceURL = friendlySourceURL();
     709    traceBuild.append(functionName);
     710    if (!sourceURL.isEmpty()) {
     711        if (!functionName.isEmpty())
     712            traceBuild.append('@');
     713        traceBuild.append(sourceURL);
     714        if (codeType != StackFrameNativeCode) {
     715            traceBuild.append(':');
     716            traceBuild.appendNumber(line());
     717        }
     718    }
     719    return traceBuild.toString().impl();
     720}
     721
     722void Interpreter::getStackTrace(JSGlobalData* globalData, Vector<StackFrame>& results, size_t maxStackSize)
    686723{
    687724    CallFrame* callFrame = globalData->topCallFrame->removeHostCallFrameFlag();
    688725    if (!callFrame || callFrame == CallFrame::noCaller())
    689726        return;
    690     int line = getLineNumberForCallFrame(globalData, callFrame);
    691 
     727    unsigned bytecodeOffset = getBytecodeOffsetForCallFrame(callFrame);
    692728    callFrame = callFrame->trueCallFrameFromVMCode();
    693729    if (!callFrame)
    694730        return;
    695 
    696     while (callFrame && callFrame != CallFrame::noCaller()) {
     731    CodeBlock* callerCodeBlock = callFrame->codeBlock();
     732
     733    while (callFrame && callFrame != CallFrame::noCaller() && maxStackSize--) {
    697734        String sourceURL;
    698         if (callFrame->codeBlock()) {
     735        if (callerCodeBlock) {
    699736            sourceURL = getSourceURLFromCallFrame(callFrame);
    700             StackFrame s = { Strong<JSObject>(*globalData, callFrame->callee()), getStackFrameCodeType(callFrame), Strong<ExecutableBase>(*globalData, callFrame->codeBlock()->ownerExecutable()), line, sourceURL};
     737            StackFrame s = {
     738                Strong<JSObject>(*globalData, callFrame->callee()),
     739                getStackFrameCodeType(callFrame),
     740                Strong<ExecutableBase>(*globalData, callerCodeBlock->ownerExecutable()),
     741                Strong<UnlinkedCodeBlock>(*globalData, callerCodeBlock->unlinkedCodeBlock()),
     742                callerCodeBlock->source(),
     743                callerCodeBlock->ownerExecutable()->lineNo(),
     744                callerCodeBlock->sourceOffset(),
     745                bytecodeOffset,
     746                sourceURL
     747            };
    701748            results.append(s);
    702749        } else {
    703             StackFrame s = { Strong<JSObject>(*globalData, callFrame->callee()), StackFrameNativeCode, Strong<ExecutableBase>(), -1, String()};
     750            StackFrame s = { Strong<JSObject>(*globalData, callFrame->callee()), StackFrameNativeCode, Strong<ExecutableBase>(), Strong<UnlinkedCodeBlock>(), 0, 0, 0, 0, String()};
    704751            results.append(s);
    705752        }
    706         unsigned unusedBytecodeOffset = 0;
    707         CodeBlock* unusedCallerCodeBlock = 0;
    708         callFrame = getCallerInfo(globalData, callFrame, line, unusedBytecodeOffset, unusedCallerCodeBlock);
    709     }
    710 }
    711 
    712 void Interpreter::addStackTraceIfNecessary(CallFrame* callFrame, JSObject* error)
     753        callFrame = getCallerInfo(globalData, callFrame, bytecodeOffset, callerCodeBlock);
     754    }
     755}
     756
     757void Interpreter::addStackTraceIfNecessary(CallFrame* callFrame, JSValue error)
    713758{
    714759    JSGlobalData* globalData = &callFrame->globalData();
    715760    ASSERT(callFrame == globalData->topCallFrame || callFrame == callFrame->lexicalGlobalObject()->globalExec() || callFrame == callFrame->dynamicGlobalObject()->globalExec());
    716     if (error->hasProperty(callFrame, globalData->propertyNames->stack))
    717         return;
    718761
    719762    Vector<StackFrame> stackTrace;
    720763    getStackTrace(&callFrame->globalData(), stackTrace);
    721764   
    722     if (stackTrace.isEmpty())
     765    if (stackTrace.isEmpty() || !error.isObject())
    723766        return;
    724    
     767    JSObject* errorObject = asObject(error);
    725768    JSGlobalObject* globalObject = 0;
    726769    if (isTerminatedExecutionException(error) || isInterruptedExecutionException(error))
    727770        globalObject = globalData->dynamicGlobalObject;
    728771    else
    729         globalObject = error->globalObject();
     772        globalObject = errorObject->globalObject();
    730773
    731774    // FIXME: JSStringJoiner could be more efficient than StringBuilder here.
    … …  
    736779            builder.append('\n');
    737780    }
    738    
    739     error->putDirect(*globalData, globalData->propertyNames->stack, jsString(globalData, builder.toString()), ReadOnly | DontDelete);
     781
     782    if (errorObject->hasProperty(callFrame, globalData->propertyNames->stack))
     783        return;
     784    errorObject->putDirect(*globalData, globalData->propertyNames->stack, jsString(globalData, builder.toString()), ReadOnly | DontDelete);
    740785}
    741786
    … …  
    13801425        return jsNull();
    13811426   
    1382     int lineNumber;
    13831427    unsigned bytecodeOffset;
    13841428    CodeBlock* unusedCallerCodeBlock = 0;
    1385     CallFrame* callerFrame = getCallerInfo(&callFrame->globalData(), functionCallFrame, lineNumber, bytecodeOffset, unusedCallerCodeBlock);
     1429    CallFrame* callerFrame = getCallerInfo(&callFrame->globalData(), functionCallFrame, bytecodeOffset, unusedCallerCodeBlock);
    13861430    if (!callerFrame)
    13871431        return jsNull();
    … …  
    13931437    ASSERT(caller.isObject());
    13941438    while (asObject(caller)->inherits(&JSBoundFunction::s_info)) {
    1395         callerFrame = getCallerInfo(&callFrame->globalData(), callerFrame, lineNumber, bytecodeOffset, unusedCallerCodeBlock);
     1439        callerFrame = getCallerInfo(&callFrame->globalData(), callerFrame, bytecodeOffset, unusedCallerCodeBlock);
    13961440        if (!callerFrame)
    13971441            return jsNull();

  • trunk/Source/JavaScriptCore/interpreter/Interpreter.h

    r147846 r147858  
    8080        StackFrameCodeType codeType;
    8181        Strong<ExecutableBase> executable;
    82         int line;
     82        Strong<UnlinkedCodeBlock> codeBlock;
     83        RefPtr<SourceProvider> code;
     84        int lineOffset;
     85        unsigned characterOffset;
     86        unsigned bytecodeOffset;
    8387        String sourceURL;
    84         String toString(CallFrame* callFrame) const
    85         {
    86             StringBuilder traceBuild;
    87             String functionName = friendlyFunctionName(callFrame);
    88             String sourceURL = friendlySourceURL();
    89             traceBuild.append(functionName);
    90             if (!sourceURL.isEmpty()) {
    91                 if (!functionName.isEmpty())
    92                     traceBuild.append('@');
    93                 traceBuild.append(sourceURL);
    94                 if (line > -1) {
    95                     traceBuild.append(':');
    96                     traceBuild.appendNumber(line);
    97                 }
    98             }
    99             return traceBuild.toString().impl();
    100         }
     88        JS_EXPORT_PRIVATE String toString(CallFrame*);
    10189        String friendlySourceURL() const
    10290        {
    … …  
    138126            return traceLine.isNull() ? emptyString() : traceLine;
    139127        }
    140         unsigned friendlyLineNumber() const
    141         {
    142             return line > -1 ? line : 0;
    143         }
     128        JS_EXPORT_PRIVATE unsigned line();
     129        JS_EXPORT_PRIVATE unsigned column();
     130        JS_EXPORT_PRIVATE void expressionInfo(int& divot, int& startOffset, int& endOffset);
    144131    };
    145132
    … …  
    233220        NEVER_INLINE void debug(CallFrame*, DebugHookID, int firstLine, int lastLine, int column);
    234221        static const String getTraceLine(CallFrame*, StackFrameCodeType, const String&, int);
    235         JS_EXPORT_PRIVATE static void getStackTrace(JSGlobalData*, Vector<StackFrame>& results);
    236         static void addStackTraceIfNecessary(CallFrame*, JSObject* error);
     222        JS_EXPORT_PRIVATE static void getStackTrace(JSGlobalData*, Vector<StackFrame>& results, size_t maxStackSize = std::numeric_limits<size_t>::max());
     223        static void addStackTraceIfNecessary(CallFrame*, JSValue error);
    237224
    238225        void dumpSampleData(ExecState* exec);
Note: See TracChangeset for help on using the changeset viewer.