Source code
Revision control
Copy as Markdown
Other Tools
/* -*- 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
#ifndef jit_RematerializedFrame_h
#define jit_RematerializedFrame_h
#include "mozilla/Assertions.h"
#include <algorithm>
#include <stddef.h>
#include <stdint.h>
#include "jstypes.h"
#include "jit/JitFrames.h"
#include "jit/ScriptFromCalleeToken.h"
#include "js/GCVector.h"
#include "js/TypeDecls.h"
#include "js/UniquePtr.h"
#include "js/Value.h"
#include "vm/JSFunction.h"
#include "vm/JSScript.h"
#include "vm/Stack.h"
class JS_PUBLIC_API JSTracer;
namespace js {
class ArgumentsObject;
class CallObject;
namespace jit {
class InlineFrameIterator;
struct MaybeReadFallback;
// RematerializedFrame: An optimized frame that has been rematerialized with
// values read out of Snapshots.
//
// If the Debugger API tries to inspect or modify an IonMonkey frame, much of
// the information it expects to find in a frame is missing: function calls may
// have been inlined, variables may have been optimized out, and so on. So when
// this happens, SpiderMonkey builds one or more Rematerialized frames from the
// IonMonkey frame, using the snapshot metadata built by Ion to reconstruct the
// missing parts. The Rematerialized frames are now the authority on the state
// of those frames, and the Ion frame is ignored: stack iterators ignore the Ion
// frame, producing the Rematerialized frames in their stead; and when control
// returns to the Ion frame, we pop it, rebuild Baseline frames from the
// Rematerialized frames, and resume execution in Baseline.
class RematerializedFrame {
// See DebugScopes::updateLiveScopes.
bool prevUpToDate_;
// Propagated to the Baseline frame once this is popped.
bool isDebuggee_;
// Has an initial environment has been pushed on the environment chain for
// function frames that need a CallObject or eval frames that need a
// VarEnvironmentObject?
bool hasInitialEnv_;
// Is this frame constructing?
bool isConstructing_;
// If true, this frame has been on the stack when
// |js::SavedStacks::saveCurrentStack| was called, and so there is a
// |js::SavedFrame| object cached for this frame.
bool hasCachedSavedFrame_;
// The fp of the top frame associated with this possibly inlined frame.
uint8_t* top_;
// The bytecode at the time of rematerialization.
jsbytecode* pc_;
size_t frameNo_;
unsigned numActualArgs_;
JSScript* script_;
JSObject* envChain_;
JSFunction* callee_;
ArgumentsObject* argsObj_;
Value returnValue_;
Value thisArgument_;
Value slots_[1];
RematerializedFrame(JSContext* cx, uint8_t* top, unsigned numActualArgs,
InlineFrameIterator& iter, MaybeReadFallback& fallback);
public:
static RematerializedFrame* New(JSContext* cx, uint8_t* top,
InlineFrameIterator& iter,
MaybeReadFallback& fallback);
// RematerializedFrame are allocated on non-GC heap, so use GCVector and
// UniquePtr to ensure they are traced and cleaned up correctly.
using RematerializedFrameVector = GCVector<UniquePtr<RematerializedFrame>>;
// Rematerialize all remaining frames pointed to by |iter| into |frames|
// in older-to-younger order, e.g., frames[0] is the oldest frame.
[[nodiscard]] static bool RematerializeInlineFrames(
JSContext* cx, uint8_t* top, InlineFrameIterator& iter,
MaybeReadFallback& fallback, RematerializedFrameVector& frames);
bool prevUpToDate() const { return prevUpToDate_; }
void setPrevUpToDate() { prevUpToDate_ = true; }
void unsetPrevUpToDate() { prevUpToDate_ = false; }
bool isDebuggee() const { return isDebuggee_; }
void setIsDebuggee() { isDebuggee_ = true; }
inline void unsetIsDebuggee();
uint8_t* top() const { return top_; }
JSScript* outerScript() const {
JitFrameLayout* jsFrame = (JitFrameLayout*)top_;
return ScriptFromCalleeToken(jsFrame->calleeToken());
}
jsbytecode* pc() const { return pc_; }
size_t frameNo() const { return frameNo_; }
bool inlined() const { return frameNo_ > 0; }
JSObject* environmentChain() const { return envChain_; }
template <typename SpecificEnvironment>
void pushOnEnvironmentChain(SpecificEnvironment& env) {
MOZ_ASSERT(*environmentChain() == env.enclosingEnvironment());
envChain_ = &env;
if (IsFrameInitialEnvironment(this, env)) {
hasInitialEnv_ = true;
}
}
template <typename SpecificEnvironment>
void popOffEnvironmentChain() {
MOZ_ASSERT(envChain_->is<SpecificEnvironment>());
envChain_ = &envChain_->as<SpecificEnvironment>().enclosingEnvironment();
}
[[nodiscard]] bool initFunctionEnvironmentObjects(JSContext* cx);
[[nodiscard]] bool pushVarEnvironment(JSContext* cx, Handle<Scope*> scope);
bool hasInitialEnvironment() const { return hasInitialEnv_; }
CallObject& callObj() const;
bool hasArgsObj() const { return !!argsObj_; }
ArgumentsObject& argsObj() const {
MOZ_ASSERT(hasArgsObj());
MOZ_ASSERT(script()->needsArgsObj());
return *argsObj_;
}
bool isFunctionFrame() const { return script_->isFunction(); }
bool isGlobalFrame() const { return script_->isGlobalCode(); }
bool isModuleFrame() const { return script_->isModule(); }
JSScript* script() const { return script_; }
JSFunction* callee() const {
MOZ_ASSERT(isFunctionFrame());
MOZ_ASSERT(callee_);
return callee_;
}
Value calleev() const { return ObjectValue(*callee()); }
Value& thisArgument() { return thisArgument_; }
bool isConstructing() const { return isConstructing_; }
bool hasCachedSavedFrame() const { return hasCachedSavedFrame_; }
void setHasCachedSavedFrame() { hasCachedSavedFrame_ = true; }
void clearHasCachedSavedFrame() { hasCachedSavedFrame_ = false; }
unsigned numFormalArgs() const {
return isFunctionFrame() ? callee()->nargs() : 0;
}
unsigned numActualArgs() const { return numActualArgs_; }
unsigned numArgSlots() const {
return (std::max)(numFormalArgs(), numActualArgs());
}
Value* argv() { return slots_; }
Value* locals() { return slots_ + numArgSlots(); }
Value& unaliasedLocal(unsigned i) {
MOZ_ASSERT(i < script()->nfixed());
return locals()[i];
}
Value& unaliasedFormal(unsigned i,
MaybeCheckAliasing checkAliasing = CHECK_ALIASING) {
MOZ_ASSERT(i < numFormalArgs());
MOZ_ASSERT_IF(checkAliasing, !script()->argsObjAliasesFormals() &&
!script()->formalIsAliased(i));
return argv()[i];
}
Value& unaliasedActual(unsigned i,
MaybeCheckAliasing checkAliasing = CHECK_ALIASING) {
MOZ_ASSERT(i < numActualArgs());
MOZ_ASSERT_IF(checkAliasing, !script()->argsObjAliasesFormals());
MOZ_ASSERT_IF(checkAliasing && i < numFormalArgs(),
!script()->formalIsAliased(i));
return argv()[i];
}
void setReturnValue(const Value& value) { returnValue_ = value; }
Value& returnValue() {
MOZ_ASSERT(!script()->noScriptRval());
return returnValue_;
}
void trace(JSTracer* trc);
void dump();
};
} // namespace jit
} // namespace js
#endif // jit_RematerializedFrame_h