Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 221 insertions, 0 deletions

diff --git a/js/src/jit/RematerializedFrame.cpp b/js/src/jit/RematerializedFrame.cpp
new file mode 100644
index 0000000000..c9544057f7
--- /dev/null
+++ b/js/src/jit/RematerializedFrame.cpp
@@ -0,0 +1,221 @@
+/* -*- 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);
+}