Changeset 147818 in webkit


Ignore:
Timestamp:
Apr 5, 2013 4:53:12 PM (11 years ago)
Author:
oliver@apple.com
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
Files:
14 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/API/JSContextRef.cpp

    r141321 r147818  
    3737#include "JSObject.h"
    3838#include "Operations.h"
     39#include "SourceProvider.h"
    3940#include <wtf/text/StringBuilder.h>
    4041#include <wtf/text/StringHash.h>
    … …  
    176177    ExecState* exec = toJS(ctx);
    177178    JSLockHolder lock(exec);
    178 
    179     unsigned count = 0;
    180179    StringBuilder builder;
    181     CallFrame* callFrame = exec;
    182     String functionName;
    183     if (exec->callee()) {
    184         if (asObject(exec->callee())->inherits(&InternalFunction::s_info)) {
    185             functionName = asInternalFunction(exec->callee())->name(exec);
    186             builder.appendLiteral("#0 ");
    187             builder.append(functionName);
    188             builder.appendLiteral("() ");
    189             count++;
    190         }
    191     }
    192     while (true) {
    193         RELEASE_ASSERT(callFrame);
    194         int signedLineNumber;
    195         intptr_t sourceID;
     180    Vector<StackFrame> stackTrace;
     181    Interpreter::getStackTrace(&exec->globalData(), stackTrace, maxStackSize);
     182
     183    for (size_t i = 0; i < stackTrace.size(); i++) {
    196184        String urlString;
    197         JSValue function;
    198 
    199         exec->interpreter()->retrieveLastCaller(callFrame, signedLineNumber, sourceID, urlString, function);
    200 
    201         if (function)
    202             functionName = jsCast<JSFunction*>(function)->name(exec);
     185        String functionName;
     186        StackFrame& frame = stackTrace[i];
     187        JSValue function = frame.callee.get();
     188        if (frame.callee)
     189            functionName = frame.friendlyFunctionName(exec);
    203190        else {
    204191            // Caller is unknown, but if frame is empty we should still add the frame, because
    205192            // something called us, and gave us arguments.
    206             if (count)
     193            if (i)
    207194                break;
    208195        }
    209         unsigned lineNumber = signedLineNumber >= 0 ? signedLineNumber : 0;
     196        unsigned lineNumber = frame.line();
    210197        if (!builder.isEmpty())
    211198            builder.append('\n');
    212199        builder.append('#');
    213         builder.appendNumber(count);
     200        builder.appendNumber(i);
    214201        builder.append(' ');
    215202        builder.append(functionName);
    216203        builder.appendLiteral("() at ");
    217204        builder.append(urlString);
    218         builder.append(':');
    219         builder.appendNumber(lineNumber);
    220         if (!function || ++count == maxStackSize)
     205        if (frame.codeType != StackFrameNativeCode) {
     206            builder.append(':');
     207            builder.appendNumber(lineNumber);
     208        }
     209        if (!function)
    221210            break;
    222         callFrame = callFrame->callerFrame();
    223211    }
    224212    return OpaqueJSString::create(builder.toString()).leakRef();

  • trunk/Source/JavaScriptCore/ChangeLog

    r147816 r147818  
     12013-04-05  Oliver Hunt  <oliver@apple.com>
     2
     3        Unify the many and varied stack trace mechanisms, and make the result sane.
     4        https://bugs.webkit.org/show_bug.cgi?id=114072
     5
     6        Reviewed by Filip Pizlo.
     7
     8        Makes JSC::StackFrame record the bytecode offset and other necessary data
     9        rather than requiring us to perform eager evaluation of the line number, etc.
     10        Then remove most of the users of retrieveLastCaller, as most of them were
     11        using it to create a stack trace in a fairly incomplete and inefficient way.
     12
     13        StackFrame now also has a couple of helpers to get the line and column info.
     14
     15        * API/JSContextRef.cpp:
     16        (JSContextCreateBacktrace):
     17        * bytecompiler/BytecodeGenerator.cpp:
     18        (JSC::BytecodeGenerator::emitDebugHook):
     19        * interpreter/Interpreter.cpp:
     20        (JSC):
     21        (JSC::Interpreter::dumpRegisters):
     22        (JSC::Interpreter::unwindCallFrame):
     23        (JSC::getBytecodeOffsetForCallFrame):
     24        (JSC::getCallerInfo):
     25        (JSC::StackFrame::line):
     26        (JSC::StackFrame::column):
     27        (JSC::StackFrame::expressionInfo):
     28        (JSC::StackFrame::toString):
     29        (JSC::Interpreter::getStackTrace):
     30        (JSC::Interpreter::addStackTraceIfNecessary):
     31        (JSC::Interpreter::retrieveCallerFromVMCode):
     32        * interpreter/Interpreter.h:
     33        (StackFrame):
     34        (Interpreter):
     35        * runtime/Error.cpp:
     36        (JSC::throwError):
     37        * runtime/JSGlobalData.h:
     38        (JSC):
     39        (JSGlobalData):
     40        * runtime/JSGlobalObject.cpp:
     41        (JSC::DynamicGlobalObjectScope::DynamicGlobalObjectScope):
     42
    1432013-04-05  Mark Hahnenberg  <mhahnenberg@apple.com>
    244

  • trunk/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.cpp

    r147669 r147818  
    20562056        return;
    20572057#endif
     2058    emitExpressionInfo(charPosition, 0, 0);
    20582059    emitOpcode(op_debug);
    20592060    instructions().append(debugHookID);

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

    r147798 r147818  
    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)
    573572        return -1;
    574 #if ENABLE(JIT) || ENABLE(LLINT)
     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());
    580 #endif
    581 }
    582 
    583 static CallFrame* getCallerInfo(JSGlobalData* globalData, CallFrame* callFrame, int& lineNumber, unsigned& bytecodeOffset, CodeBlock*& caller)
     576        return codeBlock->codeOrigin(callFrame->codeOriginIndexForDFG()).bytecodeIndex;
     577#endif
     578    return callFrame->bytecodeOffsetForNonDFGCode();
     579#endif
     580}
     581
     582static CallFrame* getCallerInfo(JSGlobalData* globalData, CallFrame* callFrame, unsigned& bytecodeOffset, CodeBlock*& caller)
    584583{
    585584    ASSERT_UNUSED(globalData, globalData);
    586585    bytecodeOffset = 0;
    587     lineNumber = -1;
    588586    ASSERT(!callFrame->hasHostCallFrameFlag());
    589587    CallFrame* callerFrame = callFrame->codeBlock() ? callFrame->trueCallerFrame() : callFrame->callerFrame()->removeHostCallFrameFlag();
    … …  
    655653    RELEASE_ASSERT(callerCodeBlock);
    656654    caller = callerCodeBlock;
    657     lineNumber = callerCodeBlock->lineNumberForBytecodeOffset(bytecodeOffset);
    658655    return callerFrame;
    659656}
    … …  
    681678}
    682679
    683 void Interpreter::getStackTrace(JSGlobalData* globalData, Vector<StackFrame>& results)
     680unsigned StackFrame::line()
     681{
     682    return codeBlock ? codeBlock->lineNumberForBytecodeOffset(bytecodeOffset) + lineOffset : 0;
     683}
     684
     685unsigned StackFrame::column()
     686{
     687    if (!code)
     688        return 0;
     689    int divot = 0;
     690    int unusedStartOffset = 0;
     691    int unusedEndOffset = 0;
     692    expressionInfo(divot, unusedStartOffset, unusedEndOffset);
     693    return code->charPositionToColumnNumber(divot);
     694}
     695
     696void StackFrame::expressionInfo(int& divot, int& startOffset, int& endOffset)
     697{
     698    codeBlock->expressionRangeForBytecodeOffset(bytecodeOffset, divot, startOffset, endOffset);
     699    divot += startOffset;
     700}
     701
     702String StackFrame::toString(CallFrame* callFrame)
     703{
     704    StringBuilder traceBuild;
     705    String functionName = friendlyFunctionName(callFrame);
     706    String sourceURL = friendlySourceURL();
     707    traceBuild.append(functionName);
     708    if (!sourceURL.isEmpty()) {
     709        if (!functionName.isEmpty())
     710            traceBuild.append('@');
     711        traceBuild.append(sourceURL);
     712        if (codeType != StackFrameNativeCode) {
     713            traceBuild.append(':');
     714            traceBuild.appendNumber(line());
     715        }
     716    }
     717    return traceBuild.toString().impl();
     718}
     719
     720void Interpreter::getStackTrace(JSGlobalData* globalData, Vector<StackFrame>& results, size_t maxStackSize)
    684721{
    685722    CallFrame* callFrame = globalData->topCallFrame->removeHostCallFrameFlag();
    686723    if (!callFrame || callFrame == CallFrame::noCaller())
    687724        return;
    688     int line = getLineNumberForCallFrame(globalData, callFrame);
    689 
     725    unsigned bytecodeOffset = getBytecodeOffsetForCallFrame(callFrame);
    690726    callFrame = callFrame->trueCallFrameFromVMCode();
    691727    if (!callFrame)
    692728        return;
    693 
    694     while (callFrame && callFrame != CallFrame::noCaller()) {
     729    CodeBlock* callerCodeBlock = callFrame->codeBlock();
     730
     731    while (callFrame && callFrame != CallFrame::noCaller() && maxStackSize--) {
    695732        String sourceURL;
    696         if (callFrame->codeBlock()) {
     733        if (callerCodeBlock) {
    697734            sourceURL = getSourceURLFromCallFrame(callFrame);
    698             StackFrame s = { Strong<JSObject>(*globalData, callFrame->callee()), getStackFrameCodeType(callFrame), Strong<ExecutableBase>(*globalData, callFrame->codeBlock()->ownerExecutable()), line, sourceURL};
     735            StackFrame s = {
     736                Strong<JSObject>(*globalData, callFrame->callee()),
     737                getStackFrameCodeType(callFrame),
     738                Strong<ExecutableBase>(*globalData, callerCodeBlock->ownerExecutable()),
     739                Strong<UnlinkedCodeBlock>(*globalData, callerCodeBlock->unlinkedCodeBlock()),
     740                callerCodeBlock->source(),
     741                callerCodeBlock->ownerExecutable()->lineNo(),
     742                callerCodeBlock->sourceOffset(),
     743                bytecodeOffset,
     744                sourceURL
     745            };
    699746            results.append(s);
    700747        } else {
    701             StackFrame s = { Strong<JSObject>(*globalData, callFrame->callee()), StackFrameNativeCode, Strong<ExecutableBase>(), -1, String()};
     748            StackFrame s = { Strong<JSObject>(*globalData, callFrame->callee()), StackFrameNativeCode, Strong<ExecutableBase>(), Strong<UnlinkedCodeBlock>(), 0, 0, 0, 0, String()};
    702749            results.append(s);
    703750        }
    704         unsigned unusedBytecodeOffset = 0;
    705         CodeBlock* unusedCallerCodeBlock = 0;
    706         callFrame = getCallerInfo(globalData, callFrame, line, unusedBytecodeOffset, unusedCallerCodeBlock);
    707     }
    708 }
    709 
    710 void Interpreter::addStackTraceIfNecessary(CallFrame* callFrame, JSObject* error)
     751        callFrame = getCallerInfo(globalData, callFrame, bytecodeOffset, callerCodeBlock);
     752    }
     753}
     754
     755void Interpreter::addStackTraceIfNecessary(CallFrame* callFrame, JSValue error)
    711756{
    712757    JSGlobalData* globalData = &callFrame->globalData();
    713758    ASSERT(callFrame == globalData->topCallFrame || callFrame == callFrame->lexicalGlobalObject()->globalExec() || callFrame == callFrame->dynamicGlobalObject()->globalExec());
    714     if (error->hasProperty(callFrame, globalData->propertyNames->stack))
    715         return;
    716759
    717760    Vector<StackFrame> stackTrace;
    718761    getStackTrace(&callFrame->globalData(), stackTrace);
    719762   
    720     if (stackTrace.isEmpty())
     763    if (stackTrace.isEmpty() || !error.isObject())
    721764        return;
    722    
     765    JSObject* errorObject = asObject(error);
    723766    JSGlobalObject* globalObject = 0;
    724767    if (isTerminatedExecutionException(error) || isInterruptedExecutionException(error))
    725768        globalObject = globalData->dynamicGlobalObject;
    726769    else
    727         globalObject = error->globalObject();
     770        globalObject = errorObject->globalObject();
    728771
    729772    // FIXME: JSStringJoiner could be more efficient than StringBuilder here.
    … …  
    734777            builder.append('\n');
    735778    }
    736    
    737     error->putDirect(*globalData, globalData->propertyNames->stack, jsString(globalData, builder.toString()), ReadOnly | DontDelete);
     779
     780    if (errorObject->hasProperty(callFrame, globalData->propertyNames->stack))
     781        return;
     782    errorObject->putDirect(*globalData, globalData->propertyNames->stack, jsString(globalData, builder.toString()), ReadOnly | DontDelete);
    738783}
    739784
    … …  
    13781423        return jsNull();
    13791424   
    1380     int lineNumber;
    13811425    unsigned bytecodeOffset;
    13821426    CodeBlock* unusedCallerCodeBlock = 0;
    1383     CallFrame* callerFrame = getCallerInfo(&callFrame->globalData(), functionCallFrame, lineNumber, bytecodeOffset, unusedCallerCodeBlock);
     1427    CallFrame* callerFrame = getCallerInfo(&callFrame->globalData(), functionCallFrame, bytecodeOffset, unusedCallerCodeBlock);
    13841428    if (!callerFrame)
    13851429        return jsNull();
    … …  
    13911435    ASSERT(caller.isObject());
    13921436    while (asObject(caller)->inherits(&JSBoundFunction::s_info)) {
    1393         callerFrame = getCallerInfo(&callFrame->globalData(), callerFrame, lineNumber, bytecodeOffset, unusedCallerCodeBlock);
     1437        callerFrame = getCallerInfo(&callFrame->globalData(), callerFrame, bytecodeOffset, unusedCallerCodeBlock);
    13941438        if (!callerFrame)
    13951439            return jsNull();

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

    r146552 r147818  
    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);

  • trunk/Source/JavaScriptCore/runtime/Error.cpp

    r139541 r147818  
    156156JSValue throwError(ExecState* exec, JSValue error)
    157157{
    158     if (error.isObject())
    159         return throwError(exec, asObject(error));
     158    Interpreter::addStackTraceIfNecessary(exec, error);
    160159    exec->globalData().exception = error;
    161160    return error;

  • trunk/Source/JavaScriptCore/runtime/JSGlobalData.h

    r146682 r147818  
    5555#include <wtf/Forward.h>
    5656#include <wtf/HashMap.h>
     57#include <wtf/RefCountedArray.h>
    5758#include <wtf/SimpleStats.h>
    5859#include <wtf/ThreadSafeRefCounted.h>
    … …  
    8283    class SourceProvider;
    8384    class SourceProviderCache;
     85    struct StackFrame;
    8486    class Stringifier;
    8587    class Structure;
    … …  
    329331
    330332        JSValue exception;
     333        RefCountedArray<StackFrame> exceptionStack;
    331334
    332335        const ClassInfo* const jsArrayClassInfo;

  • trunk/Source/JavaScriptCore/runtime/JSGlobalObject.cpp

    r146494 r147818  
    598598        globalData.resetDateCache();
    599599    }
     600    // Clear the exception stack between entries
     601    globalData.exceptionStack = RefCountedArray<StackFrame>();
    600602}
    601603

  • trunk/Source/WebCore/ChangeLog

    r147806 r147818  
     12013-04-05  Oliver Hunt  <oliver@apple.com>
     2
     3        Unify the many and varied stack trace mechanisms, and make the result sane.
     4        https://bugs.webkit.org/show_bug.cgi?id=114072
     5
     6        Reviewed by Filip Pizlo.
     7
     8        Now that we've fleshed out the StackFrames from Interpreter::getStackTrace
     9        WebCore can just ask us for a stack trace rather than implementing its own
     10        stack walking.
     11
     12        * bindings/js/ScriptCallStackFactory.cpp:
     13        (WebCore::createScriptCallStack):
     14        * inspector/ScriptCallFrame.cpp:
     15        (WebCore::ScriptCallFrame::isEqual):
     16        * inspector/ScriptCallFrame.h:
     17        (ScriptCallFrame):
     18        (WebCore::ScriptCallFrame::columnNumber):
     19
    1202013-04-05  Beth Dakin  <bdakin@apple.com>
    221

  • trunk/Source/WebCore/bindings/js/ScriptCallStackFactory.cpp

    r140718 r147818  
    5959    if (JSC::ExecState* exec = JSMainThreadExecState::currentState()) {
    6060        Vector<StackFrame> stackTrace;
    61         Interpreter::getStackTrace(&exec->globalData(), stackTrace);
    62         for (Vector<StackFrame>::const_iterator iter = stackTrace.begin(); iter < stackTrace.end(); iter++) {
    63             frames.append(ScriptCallFrame(iter->friendlyFunctionName(exec), iter->friendlySourceURL(), iter->friendlyLineNumber()));
    64             if (frames.size() >= maxStackSize)
    65                 break;
    66         }
     61        Interpreter::getStackTrace(&exec->globalData(), stackTrace, maxStackSize);
     62        for (size_t i = 0; i < stackTrace.size(); i++)
     63            frames.append(ScriptCallFrame(stackTrace[i].friendlyFunctionName(exec), stackTrace[i].friendlySourceURL(), stackTrace[i].line(), stackTrace[i].column()));
    6764    }
    6865    if (frames.isEmpty() && !emptyIsAllowed) {
    … …  
    7067        // a bound function is called from native code for example.
    7168        // Fallback to setting lineNumber to 0, and source and function name to "undefined".
    72         frames.append(ScriptCallFrame("undefined", "undefined", 0));
     69        frames.append(ScriptCallFrame("undefined", "undefined", 0, 0));
    7370    }
    7471    return ScriptCallStack::create(frames);
    … …  
    7875{
    7976    Vector<ScriptCallFrame> frames;
    80     CallFrame* callFrame = exec;
    81     while (true) {
    82         ASSERT(callFrame);
    83         int signedLineNumber;
    84         intptr_t sourceID;
    85         String urlString;
    86         JSValue function;
     77    Vector<StackFrame> stackTrace;
     78    Interpreter::getStackTrace(&exec->globalData(), stackTrace, maxStackSize + 1);
     79    for (size_t i = 1; i < stackTrace.size(); i++) {
     80        // This early exit is necessary to maintain our old behaviour
     81        // but the stack trace we produce now is complete and handles all
     82        // ways in which code may be running
     83        if (!stackTrace[i].callee && frames.size())
     84            break;
     85        String functionName = stackTrace[i].friendlyFunctionName(exec);
     86        frames.append(ScriptCallFrame(functionName, stackTrace[i].sourceURL, stackTrace[i].line(), stackTrace[i].column()));
     87    }
    8788
    88         exec->interpreter()->retrieveLastCaller(callFrame, signedLineNumber, sourceID, urlString, function);
    89         String functionName;
    90         if (function)
    91             functionName = jsCast<JSFunction*>(function)->name(exec);
    92         else {
    93             // Caller is unknown, but if frames is empty we should still add the frame, because
    94             // something called us, and gave us arguments.
    95             if (!frames.isEmpty())
    96                 break;
    97         }
    98         unsigned lineNumber = signedLineNumber >= 0 ? signedLineNumber : 0;
    99         frames.append(ScriptCallFrame(functionName, urlString, lineNumber));
    100         if (!function || frames.size() == maxStackSize)
    101             break;
    102         callFrame = callFrame->callerFrame();
    103     }
    10489    return ScriptCallStack::create(frames);
    10590}

  • trunk/Source/WebCore/inspector/ScriptCallFrame.cpp

    r115965 r147818  
    5454    return m_functionName == o.m_functionName
    5555        && m_scriptName == o.m_scriptName
    56         && m_lineNumber == o.m_lineNumber;
     56        && m_lineNumber == o.m_lineNumber
     57        && m_column == o.m_column;
    5758}
    5859

  • trunk/Source/WebCore/inspector/ScriptCallFrame.h

    r127757 r147818  
    4545class ScriptCallFrame  {
    4646public:
    47     ScriptCallFrame(const String& functionName, const String& scriptName, unsigned lineNumber, unsigned column = 0);
     47    ScriptCallFrame(const String& functionName, const String& scriptName, unsigned lineNumber, unsigned column);
    4848    ~ScriptCallFrame();
    4949
    … …  
    5151    const String& sourceURL() const { return m_scriptName; }
    5252    unsigned lineNumber() const { return m_lineNumber; }
     53    unsigned columnNumber() const { return m_column; }
    5354
    5455    bool isEqual(const ScriptCallFrame&) const;

  • trunk/Tools/ChangeLog

    r147802 r147818  
     12013-04-05  Oliver Hunt  <oliver@apple.com>
     2
     3        Unify the many and varied stack trace mechanisms, and make the result sane.
     4        https://bugs.webkit.org/show_bug.cgi?id=114072
     5
     6        Reviewed by Filip Pizlo.
     7
     8        The commandline jsc executable no longer requires arguments, so
     9        I've made run-jsc work without them.
     10
     11        * Scripts/run-jsc:
     12
    1132013-04-05  Chris Fleizach  <cfleizach@apple.com>
    214

  • trunk/Tools/Scripts/run-jsc

    r50080 r147818  
    4343GetOptions("count|c=i" => \$count,
    4444           "verbose|v" => \$verbose);
    45 die "$usage\n" if (@ARGV < 1);
    4645
    4746my $jsc = jscProductDir() . "/jsc @ARGV";
Note: See TracChangeset for help on using the changeset viewer.