void StackIterator::Frame::print(int indentLevel)
{
int i = indentLevel;
if (!this->callFrame()) {
printif(i, "frame 0x0\n");
return;
}
CodeBlock* codeBlock = this->codeBlock();
printif(i, "frame %p {\n", this->callFrame());
CallFrame* callFrame = m_callFrame;
CallFrame* callerFrame = this->callerFrame();
void* returnPC = callFrame->hasReturnPC() ? callFrame->returnPC().value() : 0;
printif(i, " name '%s'\n", functionName().utf8().data());
printif(i, " sourceURL '%s'\n", sourceURL().utf8().data());
printif(i, " hostFlag %d\n", callerFrame->hasHostCallFrameFlag());
#if ENABLE(DFG_JIT)
printif(i, " isInlinedFrame %d\n", isInlinedFrame());
if (isInlinedFrame())
printif(i, " InlineCallFrame %p\n", m_inlineCallFrame);
#endif
printif(i, " callee %p\n", callee());
printif(i, " returnPC %p\n", returnPC);
printif(i, " callerFrame %p\n", callerFrame->removeHostCallFrameFlag());
unsigned locationRawBits = callFrame->locationAsRawBits();
printif(i, " rawLocationBits %u 0x%x\n", locationRawBits, locationRawBits);
printif(i, " codeBlock %p\n", codeBlock);
if (codeBlock) {
JITCode::JITType jitType = codeBlock->jitType();
if (callFrame->hasLocationAsBytecodeOffset()) {
unsigned bytecodeOffset = callFrame->locationAsBytecodeOffset();
printif(i, " bytecodeOffset %u %p / %zu\n", bytecodeOffset, reinterpret_cast<void*>(bytecodeOffset), codeBlock->instructions().size());
#if ENABLE(DFG_JIT)
} else {
unsigned codeOriginIndex = callFrame->locationAsCodeOriginIndex();
printif(i, " codeOriginIdex %u %p / %zu\n", codeOriginIndex, reinterpret_cast<void*>(codeOriginIndex), codeBlock->codeOrigins().size());
#endif
}
unsigned line = 0;
unsigned column = 0;
computeLineAndColumn(line, column);
printif(i, " line %d\n", line);
printif(i, " column %d\n", column);
printif(i, " jitType %d <%s> isOptimizingJIT %d\n", jitType, jitTypeName(jitType), JITCode::isOptimizingJIT(jitType));
#if ENABLE(DFG_JIT)
printif(i, " hasCodeOrigins %d\n", codeBlock->hasCodeOrigins());
if (codeBlock->hasCodeOrigins()) {
JITCode* jitCode = codeBlock->jitCode().get();
printif(i, " jitCode %p start %p end %p\n", jitCode, jitCode->start(), jitCode->end());
}
#endif
}
printif(i, "}\n");
}
Arguments* StackVisitor::Frame::existingArguments()
{
if (codeBlock()->codeType() != FunctionCode)
return 0;
if (!codeBlock()->usesArguments())
return 0;
VirtualRegister reg;
#if ENABLE(DFG_JIT)
if (isInlinedFrame())
reg = inlineCallFrame()->argumentsRegister;
else
#endif // ENABLE(DFG_JIT)
reg = codeBlock()->argumentsRegister();
// Care should be taken here since exception fuzzing may raise exceptions in
// places where they would be otherwise impossible. Therefore, callFrame may
// lack activation even if the codeBlock signals need of activation. Also,
// even if codeBlock signals the use of arguments, the
// unmodifiedArgumentsRegister may not be initialized yet (neither locally
// nor in lexicalEnvironment).
JSValue result = jsUndefined();
if (codeBlock()->needsActivation() && callFrame()->hasActivation())
result = callFrame()->lexicalEnvironment()->registerAt(unmodifiedArgumentsRegister(reg).offset()).get();
if (!result || !result.isCell()) // Try local unmodifiedArgumentsRegister if lexicalEnvironment is not present (generally possible) or has not set up registers yet (only possible if fuzzing exceptions).
result = callFrame()->r(unmodifiedArgumentsRegister(reg).offset()).jsValue();
if (!result || !result.isCell()) // Protect against the case when exception fuzzing throws when unmodifiedArgumentsRegister is not set up yet (e.g., in op_enter).
return 0;
return jsCast<Arguments*>(result);
}
Arguments* StackVisitor::Frame::createArguments()
{
ASSERT(m_callFrame);
CallFrame* physicalFrame = m_callFrame;
VM& vm = physicalFrame->vm();
Arguments* arguments;
ArgumentsMode mode;
if (Options::enableFunctionDotArguments())
mode = ClonedArgumentsCreationMode;
else
mode = FakeArgumentValuesCreationMode;
#if ENABLE(DFG_JIT)
if (isInlinedFrame()) {
ASSERT(m_inlineCallFrame);
arguments = Arguments::create(vm, physicalFrame, m_inlineCallFrame, mode);
arguments->tearOff(physicalFrame, m_inlineCallFrame);
jsCast<Arguments*>((JSCell*)arguments);
} else
#endif
{
JSLexicalEnvironment* lexicalEnvironment = nullptr;
arguments = Arguments::create(vm, physicalFrame, lexicalEnvironment, mode);
arguments->tearOff(physicalFrame);
}
return arguments;
}
const RegisterAtOffsetList* StackVisitor::Frame::calleeSaveRegisters()
{
if (isInlinedFrame())
return nullptr;
#if !ENABLE(C_LOOP) && NUMBER_OF_CALLEE_SAVES_REGISTERS > 0
#if ENABLE(WEBASSEMBLY)
if (isWasmFrame()) {
if (callee().isCell()) {
RELEASE_ASSERT(isWebAssemblyToJSCallee(callee().asCell()));
return nullptr;
}
Wasm::Callee* wasmCallee = callee().asWasmCallee();
return wasmCallee->calleeSaveRegisters();
}
#endif // ENABLE(WEBASSEMBLY)
if (CodeBlock* codeBlock = this->codeBlock())
return codeBlock->calleeSaveRegisters();
#endif // !ENABLE(C_LOOP) && NUMBER_OF_CALLEE_SAVES_REGISTERS > 0
return nullptr;
}
Arguments* StackVisitor::Frame::createArguments()
{
ASSERT(m_callFrame);
CallFrame* physicalFrame = m_callFrame;
VM& vm = physicalFrame->vm();
Arguments* arguments;
#if ENABLE(DFG_JIT)
if (isInlinedFrame()) {
ASSERT(m_inlineCallFrame);
arguments = Arguments::create(vm, physicalFrame, m_inlineCallFrame);
arguments->tearOff(physicalFrame, m_inlineCallFrame);
} else
#endif
{
arguments = Arguments::create(vm, physicalFrame);
arguments->tearOff(physicalFrame);
}
return arguments;
}
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;
}
Arguments* StackVisitor::Frame::existingArguments()
{
if (codeBlock()->codeType() != FunctionCode)
return 0;
if (!codeBlock()->usesArguments())
return 0;
VirtualRegister reg;
#if ENABLE(DFG_JIT)
if (isInlinedFrame())
reg = inlineCallFrame()->argumentsRegister;
else
#endif // ENABLE(DFG_JIT)
reg = codeBlock()->argumentsRegister();
JSValue result = callFrame()->r(unmodifiedArgumentsRegister(reg).offset()).jsValue();
if (!result || !result.isCell()) // Protect against Undefined in case we throw in op_enter.
return 0;
return jsCast<Arguments*>(result);
}
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");
JITCode::JITType jitType = codeBlock->jitType();
if (jitType != JITCode::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");
}
void StackVisitor::Frame::print(int indent)
{
if (!this->callFrame()) {
log(indent, "frame 0x0\n");
return;
}
CodeBlock* codeBlock = this->codeBlock();
logF(indent, "frame %p {\n", this->callFrame());
{
indent++;
CallFrame* callFrame = m_callFrame;
CallFrame* callerFrame = this->callerFrame();
void* returnPC = callFrame->hasReturnPC() ? callFrame->returnPC().value() : nullptr;
log(indent, "name: ", functionName(), "\n");
log(indent, "sourceURL: ", sourceURL(), "\n");
bool isInlined = false;
#if ENABLE(DFG_JIT)
isInlined = isInlinedFrame();
log(indent, "isInlinedFrame: ", isInlinedFrame(), "\n");
if (isInlinedFrame())
logF(indent, "InlineCallFrame: %p\n", m_inlineCallFrame);
#endif
logF(indent, "callee: %p\n", callee());
logF(indent, "returnPC: %p\n", returnPC);
logF(indent, "callerFrame: %p\n", callerFrame);
unsigned locationRawBits = callFrame->callSiteAsRawBits();
logF(indent, "rawLocationBits: %u 0x%x\n", locationRawBits, locationRawBits);
logF(indent, "codeBlock: %p ", codeBlock);
if (codeBlock)
dataLog(*codeBlock);
dataLog("\n");
if (codeBlock && !isInlined) {
indent++;
if (callFrame->callSiteBitsAreBytecodeOffset()) {
unsigned bytecodeOffset = callFrame->bytecodeOffset();
log(indent, "bytecodeOffset: ", bytecodeOffset, " of ", codeBlock->instructions().size(), "\n");
#if ENABLE(DFG_JIT)
} else {
log(indent, "hasCodeOrigins: ", codeBlock->hasCodeOrigins(), "\n");
if (codeBlock->hasCodeOrigins()) {
CallSiteIndex callSiteIndex = callFrame->callSiteIndex();
log(indent, "callSiteIndex: ", callSiteIndex.bits(), " of ", codeBlock->codeOrigins().size(), "\n");
JITCode::JITType jitType = codeBlock->jitType();
if (jitType != JITCode::FTLJIT) {
JITCode* jitCode = codeBlock->jitCode().get();
logF(indent, "jitCode: %p start %p end %p\n", jitCode, jitCode->start(), jitCode->end());
}
}
#endif
}
unsigned line = 0;
unsigned column = 0;
computeLineAndColumn(line, column);
log(indent, "line: ", line, "\n");
log(indent, "column: ", column, "\n");
indent--;
}
indent--;
}
log(indent, "}\n");
}
