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
#include "jit/RematerializedFrame.h"
#include <algorithm>
#include <utility>
#include "jit/Bailouts.h"
#include "jit/JSJitFrameIter.h"
#include "js/friend/DumpFunctions.h" // js::DumpValue
#include "vm/ArgumentsObject.h"
#include "vm/EnvironmentObject-inl.h"
#include "vm/JSScript-inl.h"
using namespace js;
using namespace jit;
struct CopyValueToRematerializedFrame {
Value* slots;
explicit CopyValueToRematerializedFrame(Value* slots) : slots(slots) {}
void operator()(const Value& v) { *slots++ = v; }
};
RematerializedFrame::RematerializedFrame(JSContext* cx, uint8_t* top,
unsigned numActualArgs,
InlineFrameIterator& iter,
MaybeReadFallback& fallback)
: prevUpToDate_(false),
isDebuggee_(iter.script()->isDebuggee()),
hasInitialEnv_(false),
isConstructing_(iter.isConstructing()),
hasCachedSavedFrame_(false),
top_(top),
pc_(iter.pc()),
frameNo_(iter.frameNo()),
numActualArgs_(numActualArgs),
script_(iter.script()),
envChain_(nullptr),
argsObj_(nullptr) {
if (iter.isFunctionFrame()) {
callee_ = iter.callee(fallback);
} else {
callee_ = nullptr;
}
CopyValueToRematerializedFrame op(slots_);
iter.readFrameArgsAndLocals(
cx, op, op, &envChain_, &hasInitialEnv_, &returnValue_, &argsObj_,
&thisArgument_, ReadFrameArgsBehavior::ActualsAndFormals, fallback);
}
/* static */
RematerializedFrame* RematerializedFrame::New(JSContext* cx, uint8_t* top,
InlineFrameIterator& iter,
MaybeReadFallback& fallback) {
unsigned numFormals =
iter.isFunctionFrame() ? iter.calleeTemplate()->nargs() : 0;
unsigned argSlots = std::max(numFormals, iter.numActualArgs());
unsigned extraSlots = argSlots + iter.script()->nfixed();
// One Value slot is included in sizeof(RematerializedFrame), so we can
// reduce the extra slot count by one. However, if there are zero slot
// allocations total, then reducing the slots by one will lead to
// the memory allocation being smaller than sizeof(RematerializedFrame).
if (extraSlots > 0) {
extraSlots -= 1;
}
RematerializedFrame* buf =
cx->pod_calloc_with_extra<RematerializedFrame, Value>(extraSlots);
if (!buf) {
return nullptr;
}
return new (buf)
RematerializedFrame(cx, top, iter.numActualArgs(), iter, fallback);
}
/* static */
bool RematerializedFrame::RematerializeInlineFrames(
JSContext* cx, uint8_t* top, InlineFrameIterator& iter,
MaybeReadFallback& fallback, RematerializedFrameVector& frames) {
Rooted<RematerializedFrameVector> tempFrames(cx,
RematerializedFrameVector(cx));
if (!tempFrames.resize(iter.frameCount())) {
return false;
}
while (true) {
size_t frameNo = iter.frameNo();
tempFrames[frameNo].reset(
RematerializedFrame::New(cx, top, iter, fallback));
if (!tempFrames[frameNo]) {
return false;
}
if (tempFrames[frameNo]->environmentChain()) {
if (!EnsureHasEnvironmentObjects(cx, tempFrames[frameNo].get().get())) {
return false;
}
}
if (!iter.more()) {
break;
}
++iter;
}
frames = std::move(tempFrames.get());
return true;
}
CallObject& RematerializedFrame::callObj() const {
MOZ_ASSERT(hasInitialEnvironment());
MOZ_ASSERT(callee()->needsCallObject());
JSObject* env = environmentChain();
while (!env->is<CallObject>()) {
env = env->enclosingEnvironment();
}
return env->as<CallObject>();
}
bool RematerializedFrame::initFunctionEnvironmentObjects(JSContext* cx) {
return js::InitFunctionEnvironmentObjects(cx, this);
}
bool RematerializedFrame::pushVarEnvironment(JSContext* cx,
Handle<Scope*> scope) {
return js::PushVarEnvironmentObject(cx, scope, this);
}
void RematerializedFrame::trace(JSTracer* trc) {
TraceRoot(trc, &script_, "remat ion frame script");
TraceRoot(trc, &envChain_, "remat ion frame env chain");
if (callee_) {
TraceRoot(trc, &callee_, "remat ion frame callee");
}
if (argsObj_) {
TraceRoot(trc, &argsObj_, "remat ion frame argsobj");
}
TraceRoot(trc, &returnValue_, "remat ion frame return value");
TraceRoot(trc, &thisArgument_, "remat ion frame this");
TraceRootRange(trc, numArgSlots() + script_->nfixed(), slots_,
"remat ion frame stack");
}
void RematerializedFrame::dump() {
fprintf(stderr, " Rematerialized Ion Frame%s\n",
inlined() ? " (inlined)" : "");
if (isFunctionFrame()) {
fprintf(stderr, " callee fun: ");
#ifdef DEBUG
DumpValue(ObjectValue(*callee()));
#else
fprintf(stderr, "?\n");
#endif
} else {
fprintf(stderr, " global frame, no callee\n");
}
fprintf(stderr, " file %s line %u offset %zu\n", script()->filename(),
script()->lineno(), script()->pcToOffset(pc()));
fprintf(stderr, " script = %p\n", (void*)script());
if (isFunctionFrame()) {
fprintf(stderr, " env chain: ");
#ifdef DEBUG
DumpValue(ObjectValue(*environmentChain()));
#else
fprintf(stderr, "?\n");
#endif
if (hasArgsObj()) {
fprintf(stderr, " args obj: ");
#ifdef DEBUG
DumpValue(ObjectValue(argsObj()));
#else
fprintf(stderr, "?\n");
#endif
}
fprintf(stderr, " this: ");
#ifdef DEBUG
DumpValue(thisArgument());
#else
fprintf(stderr, "?\n");
#endif
for (unsigned i = 0; i < numActualArgs(); i++) {
if (i < numFormalArgs()) {
fprintf(stderr, " formal (arg %u): ", i);
} else {
fprintf(stderr, " overflown (arg %u): ", i);
}
#ifdef DEBUG
DumpValue(argv()[i]);
#else
fprintf(stderr, "?\n");
#endif
}
for (unsigned i = 0; i < script()->nfixed(); i++) {
fprintf(stderr, " local %u: ", i);
#ifdef DEBUG
DumpValue(locals()[i]);
#else
fprintf(stderr, "?\n");
#endif
}
}
fputc('\n', stderr);
}