diff options
Diffstat (limited to '')
| -rw-r--r-- | js/src/vm/FrameIter.cpp | 1060 |
1 files changed, 1060 insertions, 0 deletions
diff --git a/js/src/vm/FrameIter.cpp b/js/src/vm/FrameIter.cpp new file mode 100644 index 0000000000..b317168ede --- /dev/null +++ b/js/src/vm/FrameIter.cpp @@ -0,0 +1,1060 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- + * vim: set ts=8 sts=2 et sw=2 tw=80: + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "vm/FrameIter-inl.h" + +#include "mozilla/Assertions.h" // MOZ_ASSERT, MOZ_CRASH +#include "mozilla/MaybeOneOf.h" // mozilla::MaybeOneOf + +#include <stddef.h> // size_t +#include <stdint.h> // uint8_t, uint32_t +#include <stdlib.h> // getenv + +#include "jit/BaselineFrame.h" // js::jit::BaselineFrame +#include "jit/JitFrames.h" // js::jit::EnsureUnwoundJitExitFrame +#include "jit/JSJitFrameIter.h" // js::jit::{FrameType,InlineFrameIterator,JSJitFrameIter,MaybeReadFallback,SnapshotIterator} +#include "js/GCAPI.h" // JS::AutoSuppressGCAnalysis +#include "js/Principals.h" // JSSubsumesOp +#include "js/RootingAPI.h" // JS::Rooted +#include "vm/Activation.h" // js::Activation{,Iterator} +#include "vm/EnvironmentObject.h" // js::CallObject +#include "vm/JitActivation.h" // js::jit::JitActivation +#include "vm/JSContext.h" // JSContext +#include "vm/JSFunction.h" // JSFunction +#include "vm/JSScript.h" // js::PCToLineNumber, JSScript, js::ScriptSource +#include "vm/Runtime.h" // JSRuntime +#include "vm/Stack.h" // js::{AbstractFramePtr,InterpreterFrame,MaybeCheckAliasing} +#include "wasm/WasmFrameIter.h" // js::wasm::WasmFrameIter +#include "wasm/WasmInstance.h" // js::wasm::Instance + +#include "jit/JSJitFrameIter-inl.h" // js::jit::JSJitFrameIter::baselineFrame{,NumValueSlots} +#include "vm/Stack-inl.h" // js::AbstractFramePtr::* + +namespace JS { +class JS_PUBLIC_API Realm; +} // namespace JS + +namespace js { +class ArgumentsObject; +} // namespace js + +using JS::Realm; +using JS::Rooted; +using JS::Value; + +using js::AbstractFramePtr; +using js::ArgumentsObject; +using js::CallObject; +using js::FrameIter; +using js::JitFrameIter; +using js::NonBuiltinFrameIter; +using js::NonBuiltinScriptFrameIter; +using js::OnlyJSJitFrameIter; +using js::ScriptSource; +using js::jit::JSJitFrameIter; + +JitFrameIter::JitFrameIter(const JitFrameIter& another) { *this = another; } + +JitFrameIter& JitFrameIter::operator=(const JitFrameIter& another) { + MOZ_ASSERT(this != &another); + + act_ = another.act_; + mustUnwindActivation_ = another.mustUnwindActivation_; + + if (isSome()) { + iter_.destroy(); + } + if (!another.isSome()) { + return *this; + } + + if (another.isJSJit()) { + iter_.construct<jit::JSJitFrameIter>(another.asJSJit()); + } else { + MOZ_ASSERT(another.isWasm()); + iter_.construct<wasm::WasmFrameIter>(another.asWasm()); + } + + return *this; +} + +JitFrameIter::JitFrameIter(jit::JitActivation* act, bool mustUnwindActivation) { + act_ = act; + mustUnwindActivation_ = mustUnwindActivation; + MOZ_ASSERT(act->hasExitFP(), + "packedExitFP is used to determine if JSJit or wasm"); + if (act->hasJSExitFP()) { + iter_.construct<jit::JSJitFrameIter>(act); + } else { + MOZ_ASSERT(act->hasWasmExitFP()); + iter_.construct<wasm::WasmFrameIter>(act); + } + settle(); +} + +void JitFrameIter::skipNonScriptedJSFrames() { + if (isJSJit()) { + // Stop at the first scripted frame. + jit::JSJitFrameIter& frames = asJSJit(); + while (!frames.isScripted() && !frames.done()) { + ++frames; + } + settle(); + } +} + +bool JitFrameIter::isSelfHostedIgnoringInlining() const { + MOZ_ASSERT(!done()); + + if (isWasm()) { + return false; + } + + return asJSJit().script()->selfHosted(); +} + +JS::Realm* JitFrameIter::realm() const { + MOZ_ASSERT(!done()); + + if (isWasm()) { + return asWasm().instance()->realm(); + } + + return asJSJit().script()->realm(); +} + +uint8_t* JitFrameIter::resumePCinCurrentFrame() const { + if (isWasm()) { + return asWasm().resumePCinCurrentFrame(); + } + return asJSJit().resumePCinCurrentFrame(); +} + +bool JitFrameIter::done() const { + if (!isSome()) { + return true; + } + if (isJSJit()) { + return asJSJit().done(); + } + if (isWasm()) { + return asWasm().done(); + } + MOZ_CRASH("unhandled case"); +} + +void JitFrameIter::settle() { + if (isJSJit()) { + const jit::JSJitFrameIter& jitFrame = asJSJit(); + if (jitFrame.type() != jit::FrameType::WasmToJSJit) { + return; + } + + // Transition from js jit frames to wasm frames: we're on the + // wasm-to-jit fast path. The current stack layout is as follows: + // (stack grows downward) + // + // [--------------------] + // [WASM FUNC ] + // [WASM JIT EXIT FRAME ] + // [JIT WASM ENTRY FRAME] <-- we're here. + // + // So prevFP points to the wasm jit exit FP, maintaing the invariant in + // WasmFrameIter that the first frame is an exit frame and can be + // popped. + + wasm::Frame* prevFP = (wasm::Frame*)jitFrame.prevFp(); + + if (mustUnwindActivation_) { + act_->setWasmExitFP(prevFP); + } + + iter_.destroy(); + iter_.construct<wasm::WasmFrameIter>(act_, prevFP); + MOZ_ASSERT(!asWasm().done()); + return; + } + + if (isWasm()) { + const wasm::WasmFrameIter& wasmFrame = asWasm(); + if (!wasmFrame.hasUnwoundJitFrame()) { + return; + } + + // Transition from wasm frames to jit frames: we're on the + // jit-to-wasm fast path. The current stack layout is as follows: + // (stack grows downward) + // + // [--------------------] + // [JIT FRAME ] + // [WASM JIT ENTRY FRAME] <-- we're here + // + // The wasm iterator has saved the previous jit frame pointer for us. + + MOZ_ASSERT(wasmFrame.done()); + uint8_t* prevFP = wasmFrame.unwoundCallerFP(); + jit::FrameType prevFrameType = wasmFrame.unwoundJitFrameType(); + + if (mustUnwindActivation_) { + act_->setJSExitFP(prevFP); + } + + iter_.destroy(); + iter_.construct<jit::JSJitFrameIter>(act_, prevFrameType, prevFP); + MOZ_ASSERT(!asJSJit().done()); + return; + } +} + +void JitFrameIter::operator++() { + MOZ_ASSERT(isSome()); + if (isJSJit()) { + const jit::JSJitFrameIter& jitFrame = asJSJit(); + + jit::JitFrameLayout* prevFrame = nullptr; + if (mustUnwindActivation_ && jitFrame.isScripted()) { + prevFrame = jitFrame.jsFrame(); + } + + ++asJSJit(); + + if (prevFrame) { + // Unwind the frame by updating packedExitFP. This is necessary + // so that (1) debugger exception unwind and leave frame hooks + // don't see this frame when they use ScriptFrameIter, and (2) + // ScriptFrameIter does not crash when accessing an IonScript + // that's destroyed by the ionScript->decref call. + EnsureUnwoundJitExitFrame(act_, prevFrame); + } + } else if (isWasm()) { + ++asWasm(); + } else { + MOZ_CRASH("unhandled case"); + } + settle(); +} + +OnlyJSJitFrameIter::OnlyJSJitFrameIter(jit::JitActivation* act) + : JitFrameIter(act) { + settle(); +} + +OnlyJSJitFrameIter::OnlyJSJitFrameIter(const ActivationIterator& iter) + : OnlyJSJitFrameIter(iter->asJit()) {} + +/*****************************************************************************/ + +void FrameIter::popActivation() { + ++data_.activations_; + settleOnActivation(); +} + +bool FrameIter::principalsSubsumeFrame() const { + // If the caller supplied principals, only show frames which are + // subsumed (of the same origin or of an origin accessible) by these + // principals. + + MOZ_ASSERT(!done()); + + if (!data_.principals_) { + return true; + } + + JSSubsumesOp subsumes = data_.cx_->runtime()->securityCallbacks->subsumes; + if (!subsumes) { + return true; + } + + JS::AutoSuppressGCAnalysis nogc; + return subsumes(data_.principals_, realm()->principals()); +} + +void FrameIter::popInterpreterFrame() { + MOZ_ASSERT(data_.state_ == INTERP); + + ++data_.interpFrames_; + + if (data_.interpFrames_.done()) { + popActivation(); + } else { + data_.pc_ = data_.interpFrames_.pc(); + } +} + +void FrameIter::settleOnActivation() { + MOZ_ASSERT(!data_.cx_->inUnsafeCallWithABI); + + while (true) { + if (data_.activations_.done()) { + data_.state_ = DONE; + return; + } + + Activation* activation = data_.activations_.activation(); + + if (activation->isJit()) { + data_.jitFrames_ = JitFrameIter(activation->asJit()); + data_.jitFrames_.skipNonScriptedJSFrames(); + if (data_.jitFrames_.done()) { + // It's possible to have an JitActivation with no scripted + // frames, for instance if we hit an over-recursion during + // bailout. + ++data_.activations_; + continue; + } + data_.state_ = JIT; + nextJitFrame(); + return; + } + + MOZ_ASSERT(activation->isInterpreter()); + + InterpreterActivation* interpAct = activation->asInterpreter(); + data_.interpFrames_ = InterpreterFrameIterator(interpAct); + + // If we OSR'ed into JIT code, skip the interpreter frame so that + // the same frame is not reported twice. + if (data_.interpFrames_.frame()->runningInJit()) { + ++data_.interpFrames_; + if (data_.interpFrames_.done()) { + ++data_.activations_; + continue; + } + } + + MOZ_ASSERT(!data_.interpFrames_.frame()->runningInJit()); + data_.pc_ = data_.interpFrames_.pc(); + data_.state_ = INTERP; + return; + } +} + +FrameIter::Data::Data(JSContext* cx, DebuggerEvalOption debuggerEvalOption, + JSPrincipals* principals) + : cx_(cx), + debuggerEvalOption_(debuggerEvalOption), + principals_(principals), + state_(DONE), + pc_(nullptr), + interpFrames_(nullptr), + activations_(cx), + ionInlineFrameNo_(0) {} + +FrameIter::Data::Data(const FrameIter::Data& other) = default; + +FrameIter::FrameIter(JSContext* cx, DebuggerEvalOption debuggerEvalOption) + : data_(cx, debuggerEvalOption, nullptr), + ionInlineFrames_(cx, (js::jit::JSJitFrameIter*)nullptr) { + settleOnActivation(); + + // No principals so we can see all frames. + MOZ_ASSERT_IF(!done(), principalsSubsumeFrame()); +} + +FrameIter::FrameIter(JSContext* cx, DebuggerEvalOption debuggerEvalOption, + JSPrincipals* principals) + : data_(cx, debuggerEvalOption, principals), + ionInlineFrames_(cx, (js::jit::JSJitFrameIter*)nullptr) { + settleOnActivation(); + + // If we're not allowed to see this frame, call operator++ to skip this (and + // other) cross-origin frames. + if (!done() && !principalsSubsumeFrame()) { + ++*this; + } +} + +FrameIter::FrameIter(const FrameIter& other) + : data_(other.data_), + ionInlineFrames_(other.data_.cx_, + isIonScripted() ? &other.ionInlineFrames_ : nullptr) {} + +FrameIter::FrameIter(const Data& data) + : data_(data), + ionInlineFrames_(data.cx_, isIonScripted() ? &jsJitFrame() : nullptr) { + MOZ_ASSERT(data.cx_); + if (isIonScripted()) { + while (ionInlineFrames_.frameNo() != data.ionInlineFrameNo_) { + ++ionInlineFrames_; + } + } +} + +void FrameIter::nextJitFrame() { + MOZ_ASSERT(data_.jitFrames_.isSome()); + + if (isJSJit()) { + if (jsJitFrame().isIonScripted()) { + ionInlineFrames_.resetOn(&jsJitFrame()); + data_.pc_ = ionInlineFrames_.pc(); + } else { + MOZ_ASSERT(jsJitFrame().isBaselineJS()); + jsJitFrame().baselineScriptAndPc(nullptr, &data_.pc_); + } + return; + } + + MOZ_ASSERT(isWasm()); + data_.pc_ = nullptr; +} + +void FrameIter::popJitFrame() { + MOZ_ASSERT(data_.state_ == JIT); + MOZ_ASSERT(data_.jitFrames_.isSome()); + + if (isJSJit() && jsJitFrame().isIonScripted() && ionInlineFrames_.more()) { + ++ionInlineFrames_; + data_.pc_ = ionInlineFrames_.pc(); + return; + } + + ++data_.jitFrames_; + data_.jitFrames_.skipNonScriptedJSFrames(); + + if (!data_.jitFrames_.done()) { + nextJitFrame(); + } else { + data_.jitFrames_.reset(); + popActivation(); + } +} + +FrameIter& FrameIter::operator++() { + while (true) { + switch (data_.state_) { + case DONE: + MOZ_CRASH("Unexpected state"); + case INTERP: + if (interpFrame()->isDebuggerEvalFrame() && + data_.debuggerEvalOption_ == FOLLOW_DEBUGGER_EVAL_PREV_LINK) { + AbstractFramePtr eifPrev = interpFrame()->evalInFramePrev(); + + popInterpreterFrame(); + + while (!hasUsableAbstractFramePtr() || + abstractFramePtr() != eifPrev) { + if (data_.state_ == JIT) { + popJitFrame(); + } else { + popInterpreterFrame(); + } + } + + break; + } + popInterpreterFrame(); + break; + case JIT: + popJitFrame(); + break; + } + + if (done() || principalsSubsumeFrame()) { + break; + } + } + + return *this; +} + +FrameIter::Data* FrameIter::copyData() const { + Data* data = data_.cx_->new_<Data>(data_); + if (!data) { + return nullptr; + } + + if (data && isIonScripted()) { + data->ionInlineFrameNo_ = ionInlineFrames_.frameNo(); + } + return data; +} + +void* FrameIter::rawFramePtr() const { + switch (data_.state_) { + case DONE: + return nullptr; + case INTERP: + return interpFrame(); + case JIT: + if (isJSJit()) { + return jsJitFrame().fp(); + } + MOZ_ASSERT(isWasm()); + return nullptr; + } + MOZ_CRASH("Unexpected state"); +} + +JS::Compartment* FrameIter::compartment() const { + switch (data_.state_) { + case DONE: + break; + case INTERP: + case JIT: + return data_.activations_->compartment(); + } + MOZ_CRASH("Unexpected state"); +} + +Realm* FrameIter::realm() const { + MOZ_ASSERT(!done()); + + if (hasScript()) { + return script()->realm(); + } + + return wasmInstance()->realm(); +} + +bool FrameIter::isEvalFrame() const { + switch (data_.state_) { + case DONE: + break; + case INTERP: + return interpFrame()->isEvalFrame(); + case JIT: + if (isJSJit()) { + if (jsJitFrame().isBaselineJS()) { + return jsJitFrame().baselineFrame()->isEvalFrame(); + } + MOZ_ASSERT(!script()->isForEval()); + return false; + } + MOZ_ASSERT(isWasm()); + return false; + } + MOZ_CRASH("Unexpected state"); +} + +bool FrameIter::isModuleFrame() const { + MOZ_ASSERT(!done()); + + if (hasScript()) { + return script()->isModule(); + } + MOZ_CRASH("Unexpected state"); +} + +bool FrameIter::isFunctionFrame() const { + MOZ_ASSERT(!done()); + switch (data_.state_) { + case DONE: + break; + case INTERP: + return interpFrame()->isFunctionFrame(); + case JIT: + if (isJSJit()) { + if (jsJitFrame().isBaselineJS()) { + return jsJitFrame().baselineFrame()->isFunctionFrame(); + } + return script()->isFunction(); + } + MOZ_ASSERT(isWasm()); + return false; + } + MOZ_CRASH("Unexpected state"); +} + +JSAtom* FrameIter::maybeFunctionDisplayAtom() const { + switch (data_.state_) { + case DONE: + break; + case INTERP: + case JIT: + if (isWasm()) { + return wasmFrame().functionDisplayAtom(); + } + if (isFunctionFrame()) { + return calleeTemplate()->displayAtom(); + } + return nullptr; + } + + MOZ_CRASH("Unexpected state"); +} + +ScriptSource* FrameIter::scriptSource() const { + switch (data_.state_) { + case DONE: + break; + case INTERP: + case JIT: + return script()->scriptSource(); + } + + MOZ_CRASH("Unexpected state"); +} + +const char* FrameIter::filename() const { + switch (data_.state_) { + case DONE: + break; + case INTERP: + case JIT: + if (isWasm()) { + return wasmFrame().filename(); + } + return script()->filename(); + } + + MOZ_CRASH("Unexpected state"); +} + +const char16_t* FrameIter::displayURL() const { + switch (data_.state_) { + case DONE: + break; + case INTERP: + case JIT: + if (isWasm()) { + return wasmFrame().displayURL(); + } + ScriptSource* ss = script()->scriptSource(); + return ss->hasDisplayURL() ? ss->displayURL() : nullptr; + } + MOZ_CRASH("Unexpected state"); +} + +unsigned FrameIter::computeLine(uint32_t* column) const { + switch (data_.state_) { + case DONE: + break; + case INTERP: + case JIT: + if (isWasm()) { + return wasmFrame().computeLine(column); + } + return PCToLineNumber(script(), pc(), column); + } + + MOZ_CRASH("Unexpected state"); +} + +bool FrameIter::mutedErrors() const { + switch (data_.state_) { + case DONE: + break; + case INTERP: + case JIT: + if (isWasm()) { + return wasmFrame().mutedErrors(); + } + return script()->mutedErrors(); + } + MOZ_CRASH("Unexpected state"); +} + +bool FrameIter::isConstructing() const { + switch (data_.state_) { + case DONE: + break; + case JIT: + MOZ_ASSERT(isJSJit()); + if (jsJitFrame().isIonScripted()) { + return ionInlineFrames_.isConstructing(); + } + MOZ_ASSERT(jsJitFrame().isBaselineJS()); + return jsJitFrame().isConstructing(); + case INTERP: + return interpFrame()->isConstructing(); + } + + MOZ_CRASH("Unexpected state"); +} + +bool FrameIter::ensureHasRematerializedFrame(JSContext* cx) { + MOZ_ASSERT(isIon()); + return !!activation()->asJit()->getRematerializedFrame(cx, jsJitFrame()); +} + +bool FrameIter::hasUsableAbstractFramePtr() const { + switch (data_.state_) { + case DONE: + return false; + case JIT: + if (isJSJit()) { + if (jsJitFrame().isBaselineJS()) { + return true; + } + + MOZ_ASSERT(jsJitFrame().isIonScripted()); + return !!activation()->asJit()->lookupRematerializedFrame( + jsJitFrame().fp(), ionInlineFrames_.frameNo()); + } + MOZ_ASSERT(isWasm()); + return wasmFrame().debugEnabled(); + case INTERP: + return true; + } + MOZ_CRASH("Unexpected state"); +} + +AbstractFramePtr FrameIter::abstractFramePtr() const { + MOZ_ASSERT(hasUsableAbstractFramePtr()); + switch (data_.state_) { + case DONE: + break; + case JIT: { + if (isJSJit()) { + if (jsJitFrame().isBaselineJS()) { + return jsJitFrame().baselineFrame(); + } + MOZ_ASSERT(isIonScripted()); + return activation()->asJit()->lookupRematerializedFrame( + jsJitFrame().fp(), ionInlineFrames_.frameNo()); + } + MOZ_ASSERT(isWasm()); + MOZ_ASSERT(wasmFrame().debugEnabled()); + return wasmFrame().debugFrame(); + } + case INTERP: + MOZ_ASSERT(interpFrame()); + return AbstractFramePtr(interpFrame()); + } + MOZ_CRASH("Unexpected state"); +} + +void FrameIter::updatePcQuadratic() { + switch (data_.state_) { + case DONE: + break; + case INTERP: { + InterpreterFrame* frame = interpFrame(); + InterpreterActivation* activation = data_.activations_->asInterpreter(); + + // Look for the current frame. + data_.interpFrames_ = InterpreterFrameIterator(activation); + while (data_.interpFrames_.frame() != frame) { + ++data_.interpFrames_; + } + + // Update the pc. + MOZ_ASSERT(data_.interpFrames_.frame() == frame); + data_.pc_ = data_.interpFrames_.pc(); + return; + } + case JIT: + if (jsJitFrame().isBaselineJS()) { + jit::BaselineFrame* frame = jsJitFrame().baselineFrame(); + jit::JitActivation* activation = data_.activations_->asJit(); + + // activation's exitFP may be invalid, so create a new + // activation iterator. + data_.activations_ = ActivationIterator(data_.cx_); + while (data_.activations_.activation() != activation) { + ++data_.activations_; + } + + // Look for the current frame. + data_.jitFrames_ = JitFrameIter(data_.activations_->asJit()); + while (!isJSJit() || !jsJitFrame().isBaselineJS() || + jsJitFrame().baselineFrame() != frame) { + ++data_.jitFrames_; + } + + // Update the pc. + MOZ_ASSERT(jsJitFrame().baselineFrame() == frame); + jsJitFrame().baselineScriptAndPc(nullptr, &data_.pc_); + return; + } + break; + } + MOZ_CRASH("Unexpected state"); +} + +void FrameIter::wasmUpdateBytecodeOffset() { + MOZ_RELEASE_ASSERT(isWasm(), "Unexpected state"); + + wasm::DebugFrame* frame = wasmFrame().debugFrame(); + + // Relookup the current frame, updating the bytecode offset in the process. + data_.jitFrames_ = JitFrameIter(data_.activations_->asJit()); + while (wasmFrame().debugFrame() != frame) { + ++data_.jitFrames_; + } + + MOZ_ASSERT(wasmFrame().debugFrame() == frame); +} + +JSFunction* FrameIter::calleeTemplate() const { + switch (data_.state_) { + case DONE: + break; + case INTERP: + MOZ_ASSERT(isFunctionFrame()); + return &interpFrame()->callee(); + case JIT: + if (jsJitFrame().isBaselineJS()) { + return jsJitFrame().callee(); + } + MOZ_ASSERT(jsJitFrame().isIonScripted()); + return ionInlineFrames_.calleeTemplate(); + } + MOZ_CRASH("Unexpected state"); +} + +JSFunction* FrameIter::callee(JSContext* cx) const { + switch (data_.state_) { + case DONE: + break; + case INTERP: + return calleeTemplate(); + case JIT: + if (isIonScripted()) { + jit::MaybeReadFallback recover(cx, activation()->asJit(), + &jsJitFrame()); + return ionInlineFrames_.callee(recover); + } + MOZ_ASSERT(jsJitFrame().isBaselineJS()); + return calleeTemplate(); + } + MOZ_CRASH("Unexpected state"); +} + +bool FrameIter::matchCallee(JSContext* cx, JS::Handle<JSFunction*> fun) const { + // Use the calleeTemplate to rule out a match without needing to invalidate to + // find the actual callee. The real callee my be a clone of the template which + // should *not* be considered a match. + Rooted<JSFunction*> currentCallee(cx, calleeTemplate()); + + if (currentCallee->nargs() != fun->nargs()) { + return false; + } + + if (currentCallee->flags().stableAcrossClones() != + fun->flags().stableAcrossClones()) { + return false; + } + + // The calleeTemplate for a callee will always have the same BaseScript. If + // the script clones do not use the same script, they also have a different + // group and Ion will not inline them interchangeably. + // + // See: js::jit::InlineFrameIterator::findNextFrame() + if (currentCallee->hasBaseScript()) { + if (currentCallee->baseScript() != fun->baseScript()) { + return false; + } + } + + return callee(cx) == fun; +} + +unsigned FrameIter::numActualArgs() const { + switch (data_.state_) { + case DONE: + break; + case INTERP: + MOZ_ASSERT(isFunctionFrame()); + return interpFrame()->numActualArgs(); + case JIT: + if (isIonScripted()) { + return ionInlineFrames_.numActualArgs(); + } + MOZ_ASSERT(jsJitFrame().isBaselineJS()); + return jsJitFrame().numActualArgs(); + } + MOZ_CRASH("Unexpected state"); +} + +unsigned FrameIter::numFormalArgs() const { + return script()->function()->nargs(); +} + +Value FrameIter::unaliasedActual(unsigned i, + MaybeCheckAliasing checkAliasing) const { + return abstractFramePtr().unaliasedActual(i, checkAliasing); +} + +JSObject* FrameIter::environmentChain(JSContext* cx) const { + switch (data_.state_) { + case DONE: + break; + case JIT: + if (isJSJit()) { + if (isIonScripted()) { + jit::MaybeReadFallback recover(cx, activation()->asJit(), + &jsJitFrame()); + return ionInlineFrames_.environmentChain(recover); + } + return jsJitFrame().baselineFrame()->environmentChain(); + } + MOZ_ASSERT(isWasm()); + return wasmFrame().debugFrame()->environmentChain(); + case INTERP: + return interpFrame()->environmentChain(); + } + MOZ_CRASH("Unexpected state"); +} + +bool FrameIter::hasInitialEnvironment(JSContext* cx) const { + if (hasUsableAbstractFramePtr()) { + return abstractFramePtr().hasInitialEnvironment(); + } + + if (isWasm()) { + // See JSFunction::needsFunctionEnvironmentObjects(). + return false; + } + + MOZ_ASSERT(isJSJit()); + MOZ_ASSERT(isIonScripted()); + + bool hasInitialEnv = false; + jit::MaybeReadFallback recover(cx, activation()->asJit(), &jsJitFrame()); + ionInlineFrames_.environmentChain(recover, &hasInitialEnv); + + return hasInitialEnv; +} + +CallObject& FrameIter::callObj(JSContext* cx) const { + MOZ_ASSERT(calleeTemplate()->needsCallObject()); + MOZ_ASSERT(hasInitialEnvironment(cx)); + + JSObject* pobj = environmentChain(cx); + while (!pobj->is<CallObject>()) { + pobj = pobj->enclosingEnvironment(); + } + return pobj->as<CallObject>(); +} + +bool FrameIter::hasArgsObj() const { return abstractFramePtr().hasArgsObj(); } + +ArgumentsObject& FrameIter::argsObj() const { + MOZ_ASSERT(hasArgsObj()); + return abstractFramePtr().argsObj(); +} + +Value FrameIter::thisArgument(JSContext* cx) const { + MOZ_ASSERT(isFunctionFrame()); + + switch (data_.state_) { + case DONE: + break; + case JIT: + if (isIonScripted()) { + jit::MaybeReadFallback recover(cx, activation()->asJit(), + &jsJitFrame()); + return ionInlineFrames_.thisArgument(recover); + } + return jsJitFrame().baselineFrame()->thisArgument(); + case INTERP: + return interpFrame()->thisArgument(); + } + MOZ_CRASH("Unexpected state"); +} + +Value FrameIter::returnValue() const { + switch (data_.state_) { + case DONE: + break; + case JIT: + if (jsJitFrame().isBaselineJS()) { + return jsJitFrame().baselineFrame()->returnValue(); + } + break; + case INTERP: + return interpFrame()->returnValue(); + } + MOZ_CRASH("Unexpected state"); +} + +void FrameIter::setReturnValue(const Value& v) { + switch (data_.state_) { + case DONE: + break; + case JIT: + if (jsJitFrame().isBaselineJS()) { + jsJitFrame().baselineFrame()->setReturnValue(v); + return; + } + break; + case INTERP: + interpFrame()->setReturnValue(v); + return; + } + MOZ_CRASH("Unexpected state"); +} + +size_t FrameIter::numFrameSlots() const { + switch (data_.state_) { + case DONE: + break; + case JIT: { + if (isIonScripted()) { + return ionInlineFrames_.snapshotIterator().numAllocations() - + ionInlineFrames_.script()->nfixed(); + } + uint32_t numValueSlots = jsJitFrame().baselineFrameNumValueSlots(); + return numValueSlots - jsJitFrame().script()->nfixed(); + } + case INTERP: + MOZ_ASSERT(data_.interpFrames_.sp() >= interpFrame()->base()); + return data_.interpFrames_.sp() - interpFrame()->base(); + } + MOZ_CRASH("Unexpected state"); +} + +Value FrameIter::frameSlotValue(size_t index) const { + switch (data_.state_) { + case DONE: + break; + case JIT: + if (isIonScripted()) { + jit::SnapshotIterator si(ionInlineFrames_.snapshotIterator()); + index += ionInlineFrames_.script()->nfixed(); + return si.maybeReadAllocByIndex(index); + } + index += jsJitFrame().script()->nfixed(); + return *jsJitFrame().baselineFrame()->valueSlot(index); + case INTERP: + return interpFrame()->base()[index]; + } + MOZ_CRASH("Unexpected state"); +} + +#ifdef DEBUG +bool js::SelfHostedFramesVisible() { + static bool checked = false; + static bool visible = false; + if (!checked) { + checked = true; + char* env = getenv("MOZ_SHOW_ALL_JS_FRAMES"); + visible = !!env; + } + return visible; +} +#endif + +void NonBuiltinFrameIter::settle() { + if (!SelfHostedFramesVisible()) { + while (!done() && hasScript() && script()->selfHosted()) { + FrameIter::operator++(); + } + } +} + +void NonBuiltinScriptFrameIter::settle() { + if (!SelfHostedFramesVisible()) { + while (!done() && script()->selfHosted()) { + ScriptFrameIter::operator++(); + } + } +} + +bool FrameIter::inPrologue() const { + if (pc() < script()->main()) { + return true; + } + // If we do a VM call before pushing locals in baseline, the stack frame will + // not include space for those locals. + if (pc() == script()->code() && isBaseline() && + jsJitFrame().baselineFrameNumValueSlots() < script()->nfixed()) { + return true; + } + + return false; +} |