blob: de84be82e9870ea581a2c1d499193f765f03a8d2 [file] [log] [blame]
/*
* Copyright (C) 2013-2018 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "config.h"
#include "StackVisitor.h"
#include "CallFrameInlines.h"
#include "ClonedArguments.h"
#include "DebuggerPrimitives.h"
#include "InlineCallFrame.h"
#include "Interpreter.h"
#include "JSCInlines.h"
#include "WasmCallee.h"
#include "WasmIndexOrName.h"
#include "WebAssemblyFunction.h"
#include <wtf/text/StringBuilder.h>
namespace JSC {
StackVisitor::StackVisitor(CallFrame* startFrame, VM* vm)
{
m_frame.m_index = 0;
m_frame.m_isWasmFrame = false;
CallFrame* topFrame;
if (startFrame) {
ASSERT(vm);
ASSERT(!vm->topCallFrame || reinterpret_cast<void*>(vm->topCallFrame) != vm->topEntryFrame);
m_frame.m_entryFrame = vm->topEntryFrame;
topFrame = vm->topCallFrame;
if (topFrame && topFrame->isStackOverflowFrame()) {
topFrame = topFrame->callerFrame(m_frame.m_entryFrame);
m_topEntryFrameIsEmpty = (m_frame.m_entryFrame != vm->topEntryFrame);
if (startFrame == vm->topCallFrame)
startFrame = topFrame;
}
} else {
m_frame.m_entryFrame = 0;
topFrame = 0;
}
m_frame.m_callerIsEntryFrame = false;
readFrame(topFrame);
// Find the frame the caller wants to start unwinding from.
while (m_frame.callFrame() && m_frame.callFrame() != startFrame)
gotoNextFrame();
}
void StackVisitor::gotoNextFrame()
{
m_frame.m_index++;
#if ENABLE(DFG_JIT)
if (m_frame.isInlinedFrame()) {
InlineCallFrame* inlineCallFrame = m_frame.inlineCallFrame();
CodeOrigin* callerCodeOrigin = inlineCallFrame->getCallerSkippingTailCalls();
if (!callerCodeOrigin) {
while (inlineCallFrame) {
readInlinedFrame(m_frame.callFrame(), &inlineCallFrame->directCaller);
inlineCallFrame = m_frame.inlineCallFrame();
}
m_frame.m_entryFrame = m_frame.m_callerEntryFrame;
readFrame(m_frame.callerFrame());
} else
readInlinedFrame(m_frame.callFrame(), callerCodeOrigin);
return;
}
#endif // ENABLE(DFG_JIT)
m_frame.m_entryFrame = m_frame.m_callerEntryFrame;
readFrame(m_frame.callerFrame());
}
void StackVisitor::unwindToMachineCodeBlockFrame()
{
#if ENABLE(DFG_JIT)
if (m_frame.isInlinedFrame()) {
CodeOrigin codeOrigin = m_frame.inlineCallFrame()->directCaller;
while (codeOrigin.inlineCallFrame())
codeOrigin = codeOrigin.inlineCallFrame()->directCaller;
readNonInlinedFrame(m_frame.callFrame(), &codeOrigin);
}
#endif
}
void StackVisitor::readFrame(CallFrame* callFrame)
{
if (!callFrame) {
m_frame.setToEnd();
return;
}
if (callFrame->isAnyWasmCallee()) {
readNonInlinedFrame(callFrame);
return;
}
#if !ENABLE(DFG_JIT)
readNonInlinedFrame(callFrame);
#else // !ENABLE(DFG_JIT)
// If the frame doesn't have a code block, then it's not a DFG frame.
// Hence, we're not at an inlined frame.
CodeBlock* codeBlock = callFrame->codeBlock();
if (!codeBlock) {
readNonInlinedFrame(callFrame);
return;
}
// If the code block does not have any code origins, then there's no
// inlining. Hence, we're not at an inlined frame.
if (!codeBlock->hasCodeOrigins()) {
readNonInlinedFrame(callFrame);
return;
}
CallSiteIndex index = callFrame->callSiteIndex();
ASSERT(codeBlock->canGetCodeOrigin(index));
if (!codeBlock->canGetCodeOrigin(index)) {
// See assertion above. In release builds, we try to protect ourselves
// from crashing even though stack walking will be goofed up.
m_frame.setToEnd();
return;
}
CodeOrigin codeOrigin = codeBlock->codeOrigin(index);
if (!codeOrigin.inlineCallFrame()) {
readNonInlinedFrame(callFrame, &codeOrigin);
return;
}
readInlinedFrame(callFrame, &codeOrigin);
#endif // !ENABLE(DFG_JIT)
}
void StackVisitor::readNonInlinedFrame(CallFrame* callFrame, CodeOrigin* codeOrigin)
{
m_frame.m_callFrame = callFrame;
m_frame.m_argumentCountIncludingThis = callFrame->argumentCountIncludingThis();
m_frame.m_callerEntryFrame = m_frame.m_entryFrame;
m_frame.m_callerFrame = callFrame->callerFrame(m_frame.m_callerEntryFrame);
m_frame.m_callerIsEntryFrame = m_frame.m_callerEntryFrame != m_frame.m_entryFrame;
m_frame.m_isWasmFrame = false;
CalleeBits callee = callFrame->callee();
m_frame.m_callee = callee;
if (callFrame->isAnyWasmCallee()) {
m_frame.m_isWasmFrame = true;
m_frame.m_codeBlock = nullptr;
m_frame.m_bytecodeOffset = 0;
#if ENABLE(WEBASSEMBLY)
CalleeBits bits = callFrame->callee();
if (bits.isWasm())
m_frame.m_wasmFunctionIndexOrName = bits.asWasmCallee()->indexOrName();
#endif
} else {
m_frame.m_codeBlock = callFrame->codeBlock();
m_frame.m_bytecodeOffset = !m_frame.codeBlock() ? 0
: codeOrigin ? codeOrigin->bytecodeIndex()
: callFrame->bytecodeOffset();
}
#if ENABLE(DFG_JIT)
m_frame.m_inlineCallFrame = 0;
#endif
}
#if ENABLE(DFG_JIT)
static int inlinedFrameOffset(CodeOrigin* codeOrigin)
{
InlineCallFrame* inlineCallFrame = codeOrigin->inlineCallFrame();
int frameOffset = inlineCallFrame ? inlineCallFrame->stackOffset : 0;
return frameOffset;
}
void StackVisitor::readInlinedFrame(CallFrame* callFrame, CodeOrigin* codeOrigin)
{
ASSERT(codeOrigin);
m_frame.m_isWasmFrame = false;
int frameOffset = inlinedFrameOffset(codeOrigin);
bool isInlined = !!frameOffset;
if (isInlined) {
InlineCallFrame* inlineCallFrame = codeOrigin->inlineCallFrame();
m_frame.m_callFrame = callFrame;
m_frame.m_inlineCallFrame = inlineCallFrame;
if (inlineCallFrame->argumentCountRegister.isValid())
m_frame.m_argumentCountIncludingThis = callFrame->r(inlineCallFrame->argumentCountRegister.offset()).unboxedInt32();
else
m_frame.m_argumentCountIncludingThis = inlineCallFrame->argumentCountIncludingThis;
m_frame.m_codeBlock = inlineCallFrame->baselineCodeBlock.get();
m_frame.m_bytecodeOffset = codeOrigin->bytecodeIndex();
JSFunction* callee = inlineCallFrame->calleeForCallFrame(callFrame);
m_frame.m_callee = callee;
ASSERT(!!m_frame.callee().rawPtr());
// The callerFrame just needs to be non-null to indicate that we
// haven't reached the last frame yet. Setting it to the root
// frame (i.e. the callFrame that this inlined frame is called from)
// would work just fine.
m_frame.m_callerFrame = callFrame;
return;
}
readNonInlinedFrame(callFrame, codeOrigin);
}
#endif // ENABLE(DFG_JIT)
StackVisitor::Frame::CodeType StackVisitor::Frame::codeType() const
{
if (isWasmFrame())
return CodeType::Wasm;
if (!codeBlock())
return CodeType::Native;
switch (codeBlock()->codeType()) {
case EvalCode:
return CodeType::Eval;
case ModuleCode:
return CodeType::Module;
case FunctionCode:
return CodeType::Function;
case GlobalCode:
return CodeType::Global;
}
RELEASE_ASSERT_NOT_REACHED();
return CodeType::Global;
}
#if ENABLE(ASSEMBLER)
Optional<RegisterAtOffsetList> StackVisitor::Frame::calleeSaveRegistersForUnwinding()
{
if (!NUMBER_OF_CALLEE_SAVES_REGISTERS)
return WTF::nullopt;
if (isInlinedFrame())
return WTF::nullopt;
#if ENABLE(WEBASSEMBLY)
if (isWasmFrame()) {
if (callee().isCell()) {
RELEASE_ASSERT(isWebAssemblyToJSCallee(callee().asCell()));
return WTF::nullopt;
}
Wasm::Callee* wasmCallee = callee().asWasmCallee();
return *wasmCallee->calleeSaveRegisters();
}
if (callee().isCell()) {
if (auto* jsToWasmICCallee = jsDynamicCast<JSToWasmICCallee*>(*callee().asCell()->vm(), callee().asCell()))
return jsToWasmICCallee->function()->usedCalleeSaveRegisters();
}
#endif // ENABLE(WEBASSEMBLY)
if (CodeBlock* codeBlock = this->codeBlock())
return *codeBlock->calleeSaveRegisters();
return WTF::nullopt;
}
#endif // ENABLE(ASSEMBLER)
String StackVisitor::Frame::functionName() const
{
String traceLine;
switch (codeType()) {
case CodeType::Wasm:
traceLine = makeString(m_wasmFunctionIndexOrName);
break;
case CodeType::Eval:
traceLine = "eval code"_s;
break;
case CodeType::Module:
traceLine = "module code"_s;
break;
case CodeType::Native: {
JSCell* callee = this->callee().asCell();
if (callee)
traceLine = getCalculatedDisplayName(callFrame()->vm(), jsCast<JSObject*>(callee)).impl();
break;
}
case CodeType::Function:
traceLine = getCalculatedDisplayName(callFrame()->vm(), jsCast<JSObject*>(this->callee().asCell())).impl();
break;
case CodeType::Global:
traceLine = "global code"_s;
break;
}
return traceLine.isNull() ? emptyString() : traceLine;
}
String StackVisitor::Frame::sourceURL() const
{
String traceLine;
switch (codeType()) {
case CodeType::Eval:
case CodeType::Module:
case CodeType::Function:
case CodeType::Global: {
String sourceURL = codeBlock()->ownerExecutable()->sourceURL();
if (!sourceURL.isEmpty())
traceLine = sourceURL.impl();
break;
}
case CodeType::Native:
traceLine = "[native code]"_s;
break;
case CodeType::Wasm:
traceLine = "[wasm code]"_s;
break;
}
return traceLine.isNull() ? emptyString() : traceLine;
}
String StackVisitor::Frame::toString() const
{
StringBuilder traceBuild;
String functionName = this->functionName();
String sourceURL = this->sourceURL();
traceBuild.append(functionName);
if (!sourceURL.isEmpty()) {
if (!functionName.isEmpty())
traceBuild.append('@');
traceBuild.append(sourceURL);
if (hasLineAndColumnInfo()) {
unsigned line = 0;
unsigned column = 0;
computeLineAndColumn(line, column);
traceBuild.append(':');
traceBuild.appendNumber(line);
traceBuild.append(':');
traceBuild.appendNumber(column);
}
}
return traceBuild.toString().impl();
}
intptr_t StackVisitor::Frame::sourceID()
{
if (CodeBlock* codeBlock = this->codeBlock())
return codeBlock->ownerExecutable()->sourceID();
return noSourceID;
}
ClonedArguments* StackVisitor::Frame::createArguments()
{
ASSERT(m_callFrame);
CallFrame* physicalFrame = m_callFrame;
ClonedArguments* arguments;
ArgumentsMode mode;
if (Options::useFunctionDotArguments())
mode = ArgumentsMode::Cloned;
else
mode = ArgumentsMode::FakeValues;
#if ENABLE(DFG_JIT)
if (isInlinedFrame()) {
ASSERT(m_inlineCallFrame);
arguments = ClonedArguments::createWithInlineFrame(physicalFrame, physicalFrame, m_inlineCallFrame, mode);
} else
#endif
arguments = ClonedArguments::createWithMachineFrame(physicalFrame, physicalFrame, mode);
return arguments;
}
bool StackVisitor::Frame::hasLineAndColumnInfo() const
{
return !!codeBlock();
}
void StackVisitor::Frame::computeLineAndColumn(unsigned& line, unsigned& column) const
{
CodeBlock* codeBlock = this->codeBlock();
if (!codeBlock) {
line = 0;
column = 0;
return;
}
int divot = 0;
int unusedStartOffset = 0;
int unusedEndOffset = 0;
unsigned divotLine = 0;
unsigned divotColumn = 0;
retrieveExpressionInfo(divot, unusedStartOffset, unusedEndOffset, divotLine, divotColumn);
line = divotLine + codeBlock->ownerExecutable()->firstLine();
column = divotColumn + (divotLine ? 1 : codeBlock->firstLineColumnOffset());
if (Optional<int> overrideLineNumber = codeBlock->ownerExecutable()->overrideLineNumber(*codeBlock->vm()))
line = overrideLineNumber.value();
}
void StackVisitor::Frame::retrieveExpressionInfo(int& divot, int& startOffset, int& endOffset, unsigned& line, unsigned& column) const
{
CodeBlock* codeBlock = this->codeBlock();
codeBlock->unlinkedCodeBlock()->expressionRangeForBytecodeOffset(bytecodeOffset(), divot, startOffset, endOffset, line, column);
divot += codeBlock->sourceOffset();
}
void StackVisitor::Frame::setToEnd()
{
m_callFrame = 0;
#if ENABLE(DFG_JIT)
m_inlineCallFrame = 0;
#endif
m_isWasmFrame = false;
}
void StackVisitor::Frame::dump(PrintStream& out, Indenter indent) const
{
dump(out, indent, [] (PrintStream&) { });
}
void StackVisitor::Frame::dump(PrintStream& out, Indenter indent, WTF::Function<void(PrintStream&)> prefix) const
{
if (!this->callFrame()) {
out.print(indent, "frame 0x0\n");
return;
}
CodeBlock* codeBlock = this->codeBlock();
out.print(indent);
prefix(out);
out.print("frame ", RawPointer(this->callFrame()), " {\n");
{
indent++;
CallFrame* callFrame = m_callFrame;
CallFrame* callerFrame = this->callerFrame();
const void* returnPC = callFrame->hasReturnPC() ? callFrame->returnPC().value() : nullptr;
out.print(indent, "name: ", functionName(), "\n");
out.print(indent, "sourceURL: ", sourceURL(), "\n");
bool isInlined = false;
#if ENABLE(DFG_JIT)
isInlined = isInlinedFrame();
out.print(indent, "isInlinedFrame: ", isInlinedFrame(), "\n");
if (isInlinedFrame())
out.print(indent, "InlineCallFrame: ", RawPointer(m_inlineCallFrame), "\n");
#endif
out.print(indent, "callee: ", RawPointer(callee().rawPtr()), "\n");
out.print(indent, "returnPC: ", RawPointer(returnPC), "\n");
out.print(indent, "callerFrame: ", RawPointer(callerFrame), "\n");
uintptr_t locationRawBits = callFrame->callSiteAsRawBits();
out.print(indent, "rawLocationBits: ", locationRawBits,
" ", RawPointer(reinterpret_cast<void*>(locationRawBits)), "\n");
out.print(indent, "codeBlock: ", RawPointer(codeBlock));
if (codeBlock)
out.print(" ", *codeBlock);
out.print("\n");
if (codeBlock && !isInlined) {
indent++;
if (callFrame->callSiteBitsAreBytecodeOffset()) {
unsigned bytecodeOffset = callFrame->bytecodeOffset();
out.print(indent, "bytecodeOffset: ", bytecodeOffset, " of ", codeBlock->instructions().size(), "\n");
#if ENABLE(DFG_JIT)
} else {
out.print(indent, "hasCodeOrigins: ", codeBlock->hasCodeOrigins(), "\n");
if (codeBlock->hasCodeOrigins()) {
CallSiteIndex callSiteIndex = callFrame->callSiteIndex();
out.print(indent, "callSiteIndex: ", callSiteIndex.bits(), " of ", codeBlock->codeOrigins().size(), "\n");
JITType jitType = codeBlock->jitType();
if (jitType != JITType::FTLJIT) {
JITCode* jitCode = codeBlock->jitCode().get();
out.print(indent, "jitCode: ", RawPointer(jitCode),
" start ", RawPointer(jitCode->start()),
" end ", RawPointer(jitCode->end()), "\n");
}
}
#endif
}
unsigned line = 0;
unsigned column = 0;
computeLineAndColumn(line, column);
out.print(indent, "line: ", line, "\n");
out.print(indent, "column: ", column, "\n");
indent--;
}
out.print(indent, "EntryFrame: ", RawPointer(m_entryFrame), "\n");
indent--;
}
out.print(indent, "}\n");
}
} // namespace JSC