tor-browser

RematerializedFrame.cpp (6430B)

---

/* -*- 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 "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);
}