Adding upstream version 86.0.1.upstream/86.0.1upstream

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

1 files changed, 2261 insertions, 0 deletions

diff --git a/js/src/frontend/Stencil.cpp b/js/src/frontend/Stencil.cpp
new file mode 100644
index 0000000000..f1562d132b
--- /dev/null
+++ b/js/src/frontend/Stencil.cpp
@@ -0,0 +1,2261 @@
+/* -*- 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 "frontend/Stencil.h"
+
+#include "mozilla/OperatorNewExtensions.h"  // mozilla::KnownNotNull
+#include "mozilla/RefPtr.h"                 // RefPtr
+#include "mozilla/Sprintf.h"                // SprintfLiteral
+
+#include "frontend/AbstractScopePtr.h"     // ScopeIndex
+#include "frontend/BytecodeCompilation.h"  // CanLazilyParse
+#include "frontend/BytecodeSection.h"      // EmitScriptThingsVector
+#include "frontend/CompilationInfo.h"  // CompilationStencil, CompilationStencilSet, CompilationGCOutput
+#include "frontend/SharedContext.h"
+#include "gc/AllocKind.h"    // gc::AllocKind
+#include "js/CallArgs.h"     // JSNative
+#include "js/RootingAPI.h"   // Rooted
+#include "js/Transcoding.h"  // JS::TranscodeBuffer
+#include "js/Value.h"        // ObjectValue
+#include "js/WasmModule.h"   // JS::WasmModule
+#include "vm/EnvironmentObject.h"
+#include "vm/GeneratorAndAsyncKind.h"  // GeneratorKind, FunctionAsyncKind
+#include "vm/JSContext.h"              // JSContext
+#include "vm/JSFunction.h"  // JSFunction, GetFunctionPrototype, NewFunctionWithProto
+#include "vm/JSObject.h"      // JSObject
+#include "vm/JSONPrinter.h"   // js::JSONPrinter
+#include "vm/JSScript.h"      // BaseScript, JSScript
+#include "vm/ObjectGroup.h"   // TenuredObject
+#include "vm/Printer.h"       // js::Fprinter
+#include "vm/Scope.h"         // Scope, ScopeKindString
+#include "vm/StencilEnums.h"  // ImmutableScriptFlagsEnum
+#include "vm/StringType.h"    // JSAtom, js::CopyChars
+#include "vm/Xdr.h"           // XDRMode, XDRResult, XDREncoder
+#include "wasm/AsmJS.h"       // InstantiateAsmJS
+#include "wasm/WasmModule.h"  // wasm::Module
+
+#include "vm/JSFunction-inl.h"  // JSFunction::create
+
+using namespace js;
+using namespace js::frontend;
+
+AbstractScopePtr ScopeStencil::enclosing(
+    CompilationState& compilationState) const {
+  if (hasEnclosing()) {
+    return AbstractScopePtr(compilationState, enclosing());
+  }
+
+  return AbstractScopePtr(compilationState.input.enclosingScope);
+}
+
+Scope* ScopeStencil::enclosingExistingScope(
+    const CompilationInput& input, const CompilationGCOutput& gcOutput) const {
+  if (hasEnclosing()) {
+    Scope* result = gcOutput.scopes[enclosing()];
+    MOZ_ASSERT(result, "Scope must already exist to use this method");
+    return result;
+  }
+
+  return input.enclosingScope;
+}
+
+Scope* ScopeStencil::createScope(JSContext* cx, CompilationInput& input,
+                                 CompilationGCOutput& gcOutput,
+                                 BaseParserScopeData* baseScopeData) const {
+  Scope* scope = nullptr;
+  switch (kind()) {
+    case ScopeKind::Function: {
+      using ScopeType = FunctionScope;
+      MOZ_ASSERT(matchScopeKind<ScopeType>(kind()));
+      scope = createSpecificScope<ScopeType, CallObject>(cx, input, gcOutput,
+                                                         baseScopeData);
+      break;
+    }
+    case ScopeKind::Lexical:
+    case ScopeKind::SimpleCatch:
+    case ScopeKind::Catch:
+    case ScopeKind::NamedLambda:
+    case ScopeKind::StrictNamedLambda:
+    case ScopeKind::FunctionLexical:
+    case ScopeKind::ClassBody: {
+      using ScopeType = LexicalScope;
+      MOZ_ASSERT(matchScopeKind<ScopeType>(kind()));
+      scope = createSpecificScope<ScopeType, LexicalEnvironmentObject>(
+          cx, input, gcOutput, baseScopeData);
+      break;
+    }
+    case ScopeKind::FunctionBodyVar: {
+      using ScopeType = VarScope;
+      MOZ_ASSERT(matchScopeKind<ScopeType>(kind()));
+      scope = createSpecificScope<ScopeType, VarEnvironmentObject>(
+          cx, input, gcOutput, baseScopeData);
+      break;
+    }
+    case ScopeKind::Global:
+    case ScopeKind::NonSyntactic: {
+      using ScopeType = GlobalScope;
+      MOZ_ASSERT(matchScopeKind<ScopeType>(kind()));
+      scope = createSpecificScope<ScopeType, std::nullptr_t>(
+          cx, input, gcOutput, baseScopeData);
+      break;
+    }
+    case ScopeKind::Eval:
+    case ScopeKind::StrictEval: {
+      using ScopeType = EvalScope;
+      MOZ_ASSERT(matchScopeKind<ScopeType>(kind()));
+      scope = createSpecificScope<ScopeType, VarEnvironmentObject>(
+          cx, input, gcOutput, baseScopeData);
+      break;
+    }
+    case ScopeKind::Module: {
+      using ScopeType = ModuleScope;
+      MOZ_ASSERT(matchScopeKind<ScopeType>(kind()));
+      scope = createSpecificScope<ScopeType, ModuleEnvironmentObject>(
+          cx, input, gcOutput, baseScopeData);
+      break;
+    }
+    case ScopeKind::With: {
+      using ScopeType = WithScope;
+      MOZ_ASSERT(matchScopeKind<ScopeType>(kind()));
+      scope = createSpecificScope<ScopeType, std::nullptr_t>(
+          cx, input, gcOutput, baseScopeData);
+      break;
+    }
+    case ScopeKind::WasmFunction:
+    case ScopeKind::WasmInstance: {
+      MOZ_CRASH("Unexpected deferred type");
+    }
+  }
+  return scope;
+}
+
+static bool CreateLazyScript(JSContext* cx, CompilationInput& input,
+                             BaseCompilationStencil& stencil,
+                             CompilationGCOutput& gcOutput,
+                             const ScriptStencil& script,
+                             const ScriptStencilExtra& scriptExtra,
+                             ScriptIndex scriptIndex, HandleFunction function) {
+  Rooted<ScriptSourceObject*> sourceObject(cx, gcOutput.sourceObject);
+
+  size_t ngcthings = script.gcThingsLength;
+
+  Rooted<BaseScript*> lazy(
+      cx, BaseScript::CreateRawLazy(cx, ngcthings, function, sourceObject,
+                                    scriptExtra.extent,
+                                    scriptExtra.immutableFlags));
+  if (!lazy) {
+    return false;
+  }
+
+  if (ngcthings) {
+    if (!EmitScriptThingsVector(cx, input, stencil, gcOutput,
+                                script.gcthings(stencil),
+                                lazy->gcthingsForInit())) {
+      return false;
+    }
+  }
+
+  function->initScript(lazy);
+
+  return true;
+}
+
+// Parser-generated functions with the same prototype will share the same shape
+// and group. By computing the correct values up front, we can save a lot of
+// time in the Object creation code. For simplicity, we focus only on plain
+// synchronous functions which are by far the most common.
+//
+// This bypasses the `NewObjectCache`, but callers are expected to retrieve a
+// valid group and shape from the appropriate de-duplication tables.
+//
+// NOTE: Keep this in sync with `js::NewFunctionWithProto`.
+static JSFunction* CreateFunctionFast(JSContext* cx, CompilationInput& input,
+                                      HandleObjectGroup group,
+                                      HandleShape shape,
+                                      const ScriptStencil& script,
+                                      const ScriptStencilExtra& scriptExtra) {
+  MOZ_ASSERT(
+      !scriptExtra.immutableFlags.hasFlag(ImmutableScriptFlagsEnum::IsAsync));
+  MOZ_ASSERT(!scriptExtra.immutableFlags.hasFlag(
+      ImmutableScriptFlagsEnum::IsGenerator));
+  MOZ_ASSERT(!script.functionFlags.isAsmJSNative());
+
+  FunctionFlags flags = script.functionFlags;
+  gc::AllocKind allocKind = flags.isExtended()
+                                ? gc::AllocKind::FUNCTION_EXTENDED
+                                : gc::AllocKind::FUNCTION;
+
+  JSFunction* fun;
+  JS_TRY_VAR_OR_RETURN_NULL(
+      cx, fun,
+      JSFunction::create(cx, allocKind, gc::TenuredHeap, shape, group));
+
+  fun->setArgCount(scriptExtra.nargs);
+  fun->setFlags(flags);
+
+  fun->initScript(nullptr);
+  fun->initEnvironment(nullptr);
+
+  if (script.functionAtom) {
+    JSAtom* atom = input.atomCache.getExistingAtomAt(cx, script.functionAtom);
+    MOZ_ASSERT(atom);
+    fun->initAtom(atom);
+  }
+
+  if (flags.isExtended()) {
+    fun->initializeExtended();
+  }
+
+  return fun;
+}
+
+static JSFunction* CreateFunction(JSContext* cx, CompilationInput& input,
+                                  BaseCompilationStencil& stencil,
+                                  const ScriptStencil& script,
+                                  const ScriptStencilExtra& scriptExtra,
+                                  ScriptIndex functionIndex) {
+  GeneratorKind generatorKind =
+      scriptExtra.immutableFlags.hasFlag(ImmutableScriptFlagsEnum::IsGenerator)
+          ? GeneratorKind::Generator
+          : GeneratorKind::NotGenerator;
+  FunctionAsyncKind asyncKind =
+      scriptExtra.immutableFlags.hasFlag(ImmutableScriptFlagsEnum::IsAsync)
+          ? FunctionAsyncKind::AsyncFunction
+          : FunctionAsyncKind::SyncFunction;
+
+  // Determine the new function's proto. This must be done for singleton
+  // functions.
+  RootedObject proto(cx);
+  if (!GetFunctionPrototype(cx, generatorKind, asyncKind, &proto)) {
+    return nullptr;
+  }
+
+  gc::AllocKind allocKind = script.functionFlags.isExtended()
+                                ? gc::AllocKind::FUNCTION_EXTENDED
+                                : gc::AllocKind::FUNCTION;
+  bool isAsmJS = script.functionFlags.isAsmJSNative();
+
+  JSNative maybeNative = isAsmJS ? InstantiateAsmJS : nullptr;
+
+  RootedAtom displayAtom(cx);
+  if (script.functionAtom) {
+    displayAtom.set(input.atomCache.getExistingAtomAt(cx, script.functionAtom));
+    MOZ_ASSERT(displayAtom);
+  }
+  RootedFunction fun(
+      cx, NewFunctionWithProto(cx, maybeNative, scriptExtra.nargs,
+                               script.functionFlags, nullptr, displayAtom,
+                               proto, allocKind, TenuredObject));
+  if (!fun) {
+    return nullptr;
+  }
+
+  if (isAsmJS) {
+    RefPtr<const JS::WasmModule> asmJS =
+        stencil.asCompilationStencil().asmJS.lookup(functionIndex)->value();
+
+    JSObject* moduleObj = asmJS->createObjectForAsmJS(cx);
+    if (!moduleObj) {
+      return nullptr;
+    }
+
+    fun->setExtendedSlot(FunctionExtended::ASMJS_MODULE_SLOT,
+                         ObjectValue(*moduleObj));
+  }
+
+  return fun;
+}
+
+static bool InstantiateAtoms(JSContext* cx, CompilationInput& input,
+                             BaseCompilationStencil& stencil) {
+  return InstantiateMarkedAtoms(cx, stencil.parserAtomData, input.atomCache);
+}
+
+static bool InstantiateScriptSourceObject(JSContext* cx,
+                                          CompilationInput& input,
+                                          CompilationGCOutput& gcOutput) {
+  MOZ_ASSERT(input.source());
+
+  gcOutput.sourceObject = ScriptSourceObject::create(cx, input.source());
+  if (!gcOutput.sourceObject) {
+    return false;
+  }
+
+  // Off-thread compilations do all their GC heap allocation, including the
+  // SSO, in a temporary compartment. Hence, for the SSO to refer to the
+  // gc-heap-allocated values in |options|, it would need cross-compartment
+  // wrappers from the temporary compartment to the real compartment --- which
+  // would then be inappropriate once we merged the temporary and real
+  // compartments.
+  //
+  // Instead, we put off populating those SSO slots in off-thread compilations
+  // until after we've merged compartments.
+  if (!cx->isHelperThreadContext()) {
+    Rooted<ScriptSourceObject*> sourceObject(cx, gcOutput.sourceObject);
+    if (!ScriptSourceObject::initFromOptions(cx, sourceObject, input.options)) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+// Instantiate ModuleObject. Further initialization is done after the associated
+// BaseScript is instantiated in InstantiateTopLevel.
+static bool InstantiateModuleObject(JSContext* cx, CompilationInput& input,
+                                    CompilationStencil& stencil,
+                                    CompilationGCOutput& gcOutput) {
+  MOZ_ASSERT(stencil.scriptExtra[CompilationStencil::TopLevelIndex].isModule());
+
+  gcOutput.module = ModuleObject::create(cx);
+  if (!gcOutput.module) {
+    return false;
+  }
+
+  Rooted<ModuleObject*> module(cx, gcOutput.module);
+  return stencil.moduleMetadata->initModule(cx, input.atomCache, module);
+}
+
+// Instantiate JSFunctions for each FunctionBox.
+static bool InstantiateFunctions(JSContext* cx, CompilationInput& input,
+                                 BaseCompilationStencil& stencil,
+                                 CompilationGCOutput& gcOutput) {
+  using ImmutableFlags = ImmutableScriptFlagsEnum;
+
+  if (!gcOutput.functions.resize(stencil.scriptData.size())) {
+    ReportOutOfMemory(cx);
+    return false;
+  }
+
+  // Most JSFunctions will be have the same Shape / Group so we can compute it
+  // now to allow fast object creation. Generators / Async will use the slow
+  // path instead.
+  RootedObject proto(cx,
+                     GlobalObject::getOrCreatePrototype(cx, JSProto_Function));
+  if (!proto) {
+    return false;
+  }
+  RootedObjectGroup group(cx, ObjectGroup::defaultNewGroup(
+                                  cx, &JSFunction::class_, TaggedProto(proto)));
+  if (!group) {
+    return false;
+  }
+  RootedShape shape(
+      cx, EmptyShape::getInitialShape(cx, &JSFunction::class_,
+                                      TaggedProto(proto), /* nfixed = */ 0,
+                                      /* objectFlags = */ 0));
+  if (!shape) {
+    return false;
+  }
+
+  for (auto item :
+       CompilationStencil::functionScriptStencils(stencil, gcOutput)) {
+    const auto& scriptStencil = item.script;
+    const auto& scriptExtra = (*item.scriptExtra);
+    auto index = item.index;
+
+    MOZ_ASSERT(!item.function);
+
+    // Plain functions can use a fast path.
+    bool useFastPath =
+        !scriptExtra.immutableFlags.hasFlag(ImmutableFlags::IsAsync) &&
+        !scriptExtra.immutableFlags.hasFlag(ImmutableFlags::IsGenerator) &&
+        !scriptStencil.functionFlags.isAsmJSNative();
+
+    JSFunction* fun = useFastPath
+                          ? CreateFunctionFast(cx, input, group, shape,
+                                               scriptStencil, scriptExtra)
+                          : CreateFunction(cx, input, stencil, scriptStencil,
+                                           scriptExtra, index);
+    if (!fun) {
+      return false;
+    }
+
+    gcOutput.functions[index] = fun;
+  }
+
+  return true;
+}
+
+// Instantiate Scope for each ScopeStencil.
+//
+// This should be called after InstantiateFunctions, given FunctionScope needs
+// associated JSFunction pointer, and also should be called before
+// InstantiateScriptStencils, given JSScript needs Scope pointer in gc things.
+static bool InstantiateScopes(JSContext* cx, CompilationInput& input,
+                              BaseCompilationStencil& stencil,
+                              CompilationGCOutput& gcOutput) {
+  // While allocating Scope object from ScopeStencil, Scope object for the
+  // enclosing Scope should already be allocated.
+  //
+  // Enclosing scope of ScopeStencil can be either ScopeStencil or Scope*
+  // pointer.
+  //
+  // If the enclosing scope is ScopeStencil, it's guaranteed to be earlier
+  // element in stencil.scopeData, because enclosing_ field holds
+  // index into it, and newly created ScopeStencil is pushed back to the vector.
+  //
+  // If the enclosing scope is Scope*, it's CompilationInput.enclosingScope.
+
+  MOZ_ASSERT(stencil.scopeData.size() == stencil.scopeNames.size());
+  size_t scopeCount = stencil.scopeData.size();
+  for (size_t i = 0; i < scopeCount; i++) {
+    Scope* scope = stencil.scopeData[i].createScope(cx, input, gcOutput,
+                                                    stencil.scopeNames[i]);
+    if (!scope) {
+      return false;
+    }
+    gcOutput.scopes.infallibleAppend(scope);
+  }
+
+  return true;
+}
+
+// Instantiate js::BaseScripts from ScriptStencils for inner functions of the
+// compilation. Note that standalone functions and functions being delazified
+// are handled below with other top-levels.
+static bool InstantiateScriptStencils(JSContext* cx, CompilationInput& input,
+                                      CompilationStencil& stencil,
+                                      CompilationGCOutput& gcOutput) {
+  MOZ_ASSERT(input.lazy == nullptr);
+
+  Rooted<JSFunction*> fun(cx);
+  for (auto item :
+       CompilationStencil::functionScriptStencils(stencil, gcOutput)) {
+    auto& scriptStencil = item.script;
+    auto* scriptExtra = item.scriptExtra;
+    fun = item.function;
+    auto index = item.index;
+    if (scriptStencil.hasSharedData()) {
+      // If the function was not referenced by enclosing script's bytecode, we
+      // do not generate a BaseScript for it. For example, `(function(){});`.
+      //
+      // `wasFunctionEmitted` is false also for standalone functions. They are
+      // handled in InstantiateTopLevel.
+      if (!scriptStencil.wasFunctionEmitted()) {
+        continue;
+      }
+
+      RootedScript script(
+          cx, JSScript::fromStencil(cx, input, stencil, gcOutput, index));
+      if (!script) {
+        return false;
+      }
+
+      // NOTE: Inner functions can be marked `allowRelazify` after merging
+      // a stencil for delazification into the top-level stencil.
+      if (scriptStencil.allowRelazify()) {
+        MOZ_ASSERT(script->isRelazifiable());
+        script->setAllowRelazify();
+      }
+    } else if (scriptStencil.functionFlags.isAsmJSNative()) {
+      MOZ_ASSERT(fun->isAsmJSNative());
+    } else {
+      MOZ_ASSERT(fun->isIncomplete());
+      if (!CreateLazyScript(cx, input, stencil, gcOutput, scriptStencil,
+                            *scriptExtra, index, fun)) {
+        return false;
+      }
+    }
+  }
+
+  return true;
+}
+
+// Instantiate the Stencil for the top-level script of the compilation. This
+// includes standalone functions and functions being delazified.
+static bool InstantiateTopLevel(JSContext* cx, CompilationInput& input,
+                                BaseCompilationStencil& stencil,
+                                CompilationGCOutput& gcOutput) {
+  const ScriptStencil& scriptStencil =
+      stencil.scriptData[CompilationStencil::TopLevelIndex];
+
+  // Top-level asm.js does not generate a JSScript.
+  if (scriptStencil.functionFlags.isAsmJSNative()) {
+    return true;
+  }
+
+  MOZ_ASSERT(scriptStencil.hasSharedData());
+  MOZ_ASSERT(stencil.sharedData.get(CompilationStencil::TopLevelIndex));
+
+  if (input.lazy) {
+    RootedScript script(cx, JSScript::CastFromLazy(input.lazy));
+    if (!JSScript::fullyInitFromStencil(cx, input, stencil, gcOutput, script,
+                                        CompilationStencil::TopLevelIndex)) {
+      return false;
+    }
+
+    if (scriptStencil.allowRelazify()) {
+      MOZ_ASSERT(script->isRelazifiable());
+      script->setAllowRelazify();
+    }
+
+    gcOutput.script = script;
+    return true;
+  }
+
+  gcOutput.script =
+      JSScript::fromStencil(cx, input, stencil.asCompilationStencil(), gcOutput,
+                            CompilationStencil::TopLevelIndex);
+  if (!gcOutput.script) {
+    return false;
+  }
+
+  if (scriptStencil.allowRelazify()) {
+    MOZ_ASSERT(gcOutput.script->isRelazifiable());
+    gcOutput.script->setAllowRelazify();
+  }
+
+  const ScriptStencilExtra& scriptExtra =
+      stencil.asCompilationStencil()
+          .scriptExtra[CompilationStencil::TopLevelIndex];
+
+  // Finish initializing the ModuleObject if needed.
+  if (scriptExtra.isModule()) {
+    RootedScript script(cx, gcOutput.script);
+
+    gcOutput.module->initScriptSlots(script);
+    gcOutput.module->initStatusSlot();
+
+    RootedModuleObject module(cx, gcOutput.module);
+    if (!ModuleObject::createEnvironment(cx, module)) {
+      return false;
+    }
+
+    // Off-thread compilation with parseGlobal will freeze the module object
+    // in GlobalHelperThreadState::finishSingleParseTask instead.
+    if (!cx->isHelperThreadContext()) {
+      if (!ModuleObject::Freeze(cx, module)) {
+        return false;
+      }
+    }
+  }
+
+  return true;
+}
+
+// When a function is first referenced by enclosing script's bytecode, we need
+// to update it with information determined by the BytecodeEmitter. This applies
+// to both initial and delazification parses. The functions being update may or
+// may not have bytecode at this point.
+static void UpdateEmittedInnerFunctions(JSContext* cx, CompilationInput& input,
+                                        BaseCompilationStencil& stencil,
+                                        CompilationGCOutput& gcOutput) {
+  for (auto item :
+       CompilationStencil::functionScriptStencils(stencil, gcOutput)) {
+    auto& scriptStencil = item.script;
+    auto& fun = item.function;
+    if (!scriptStencil.wasFunctionEmitted()) {
+      continue;
+    }
+
+    if (scriptStencil.functionFlags.isAsmJSNative() ||
+        fun->baseScript()->hasBytecode()) {
+      // Non-lazy inner functions don't use the enclosingScope_ field.
+      MOZ_ASSERT(!scriptStencil.hasLazyFunctionEnclosingScopeIndex());
+    } else {
+      // Apply updates from FunctionEmitter::emitLazy().
+      BaseScript* script = fun->baseScript();
+
+      ScopeIndex index = scriptStencil.lazyFunctionEnclosingScopeIndex();
+      Scope* scope = gcOutput.scopes[index];
+      script->setEnclosingScope(scope);
+
+      if (scriptStencil.hasMemberInitializers()) {
+        script->setMemberInitializers(scriptStencil.memberInitializers());
+      }
+
+      // Inferred and Guessed names are computed by BytecodeEmitter and so may
+      // need to be applied to existing JSFunctions during delazification.
+      if (fun->displayAtom() == nullptr) {
+        JSAtom* funcAtom = nullptr;
+        if (scriptStencil.functionFlags.hasInferredName() ||
+            scriptStencil.functionFlags.hasGuessedAtom()) {
+          funcAtom =
+              input.atomCache.getExistingAtomAt(cx, scriptStencil.functionAtom);
+          MOZ_ASSERT(funcAtom);
+        }
+        if (scriptStencil.functionFlags.hasInferredName()) {
+          fun->setInferredName(funcAtom);
+        }
+        if (scriptStencil.functionFlags.hasGuessedAtom()) {
+          fun->setGuessedAtom(funcAtom);
+        }
+      }
+    }
+  }
+}
+
+// During initial parse we must link lazy-functions-inside-lazy-functions to
+// their enclosing script.
+static void LinkEnclosingLazyScript(BaseCompilationStencil& stencil,
+                                    CompilationGCOutput& gcOutput) {
+  for (auto item :
+       CompilationStencil::functionScriptStencils(stencil, gcOutput)) {
+    auto& scriptStencil = item.script;
+    auto& fun = item.function;
+    if (!scriptStencil.functionFlags.hasBaseScript()) {
+      continue;
+    }
+
+    if (fun->baseScript()->hasBytecode()) {
+      continue;
+    }
+
+    BaseScript* script = fun->baseScript();
+    MOZ_ASSERT(!script->hasBytecode());
+
+    for (auto inner : script->gcthings()) {
+      if (!inner.is<JSObject>()) {
+        continue;
+      }
+      inner.as<JSObject>().as<JSFunction>().setEnclosingLazyScript(script);
+    }
+  }
+}
+
+#ifdef DEBUG
+// Some fields aren't used in delazification, given the target functions and
+// scripts are already instantiated, but they still should match.
+static void AssertDelazificationFieldsMatch(BaseCompilationStencil& stencil,
+                                            CompilationGCOutput& gcOutput) {
+  for (auto item :
+       CompilationStencil::functionScriptStencils(stencil, gcOutput)) {
+    auto& scriptStencil = item.script;
+    auto* scriptExtra = item.scriptExtra;
+    auto& fun = item.function;
+
+    MOZ_ASSERT(scriptExtra == nullptr);
+
+    // Names are updated by UpdateInnerFunctions.
+    constexpr uint16_t HAS_INFERRED_NAME =
+        uint16_t(FunctionFlags::Flags::HAS_INFERRED_NAME);
+    constexpr uint16_t HAS_GUESSED_ATOM =
+        uint16_t(FunctionFlags::Flags::HAS_GUESSED_ATOM);
+    constexpr uint16_t MUTABLE_FLAGS =
+        uint16_t(FunctionFlags::Flags::MUTABLE_FLAGS);
+    constexpr uint16_t acceptableDifferenceForFunction =
+        HAS_INFERRED_NAME | HAS_GUESSED_ATOM | MUTABLE_FLAGS;
+
+    MOZ_ASSERT((fun->flags().toRaw() | acceptableDifferenceForFunction) ==
+               (scriptStencil.functionFlags.toRaw() |
+                acceptableDifferenceForFunction));
+
+    // Delazification shouldn't delazify inner scripts.
+    MOZ_ASSERT_IF(item.index == CompilationStencil::TopLevelIndex,
+                  scriptStencil.hasSharedData());
+    MOZ_ASSERT_IF(item.index > CompilationStencil::TopLevelIndex,
+                  !scriptStencil.hasSharedData());
+  }
+}
+#endif  // DEBUG
+
+// When delazifying, use the existing JSFunctions. The initial and delazifying
+// parse are required to generate the same sequence of functions for lazy
+// parsing to work at all.
+static void FunctionsFromExistingLazy(CompilationInput& input,
+                                      CompilationGCOutput& gcOutput) {
+  MOZ_ASSERT(gcOutput.functions.empty());
+  gcOutput.functions.infallibleAppend(input.lazy->function());
+
+  for (JS::GCCellPtr elem : input.lazy->gcthings()) {
+    if (!elem.is<JSObject>()) {
+      continue;
+    }
+    JSFunction* fun = &elem.as<JSObject>().as<JSFunction>();
+    gcOutput.functions.infallibleAppend(fun);
+  }
+}
+
+/* static */
+bool CompilationStencil::instantiateStencils(JSContext* cx,
+                                             CompilationStencil& stencil,
+                                             CompilationGCOutput& gcOutput) {
+  if (!stencil.preparationIsPerformed) {
+    if (!prepareForInstantiate(cx, stencil, gcOutput)) {
+      return false;
+    }
+  }
+
+  return instantiateStencilsAfterPreparation(cx, stencil.input, stencil,
+                                             gcOutput);
+}
+
+/* static */
+bool CompilationStencil::instantiateStencilsAfterPreparation(
+    JSContext* cx, CompilationInput& input, BaseCompilationStencil& stencil,
+    CompilationGCOutput& gcOutput) {
+  // Distinguish between the initial (possibly lazy) compile and any subsequent
+  // delazification compiles. Delazification will update existing GC things.
+  bool isInitialParse = (input.lazy == nullptr);
+
+  // Phase 1: Instantate JSAtoms.
+  if (!InstantiateAtoms(cx, input, stencil)) {
+    return false;
+  }
+
+  // Phase 2: Instantiate ScriptSourceObject, ModuleObject, JSFunctions.
+  if (isInitialParse) {
+    CompilationStencil& initialStencil = stencil.asCompilationStencil();
+
+    if (!InstantiateScriptSourceObject(cx, input, gcOutput)) {
+      return false;
+    }
+
+    if (initialStencil.moduleMetadata) {
+      // The enclosing script of a module is always the global scope. Fetch the
+      // scope of the current global and update input data.
+      MOZ_ASSERT(input.enclosingScope == nullptr);
+      input.enclosingScope = &cx->global()->emptyGlobalScope();
+      MOZ_ASSERT(input.enclosingScope->environmentChainLength() ==
+                 ModuleScope::EnclosingEnvironmentChainLength);
+
+      if (!InstantiateModuleObject(cx, input, initialStencil, gcOutput)) {
+        return false;
+      }
+    }
+
+    if (!InstantiateFunctions(cx, input, stencil, gcOutput)) {
+      return false;
+    }
+  } else {
+    MOZ_ASSERT(
+        stencil.scriptData[CompilationStencil::TopLevelIndex].isFunction());
+
+    // FunctionKey is used when caching to map a delazification stencil to a
+    // specific lazy script. It is not used by instantiation, but we should
+    // ensure it is correctly defined.
+    MOZ_ASSERT(stencil.functionKey ==
+               BaseCompilationStencil::toFunctionKey(input.lazy->extent()));
+
+    FunctionsFromExistingLazy(input, gcOutput);
+    MOZ_ASSERT(gcOutput.functions.length() == stencil.scriptData.size());
+
+#ifdef DEBUG
+    AssertDelazificationFieldsMatch(stencil, gcOutput);
+#endif
+  }
+
+  // Phase 3: Instantiate js::Scopes.
+  if (!InstantiateScopes(cx, input, stencil, gcOutput)) {
+    return false;
+  }
+
+  // Phase 4: Instantiate (inner) BaseScripts.
+  if (isInitialParse) {
+    if (!InstantiateScriptStencils(cx, input, stencil.asCompilationStencil(),
+                                   gcOutput)) {
+      return false;
+    }
+  }
+
+  // Phase 5: Finish top-level handling
+  if (!InstantiateTopLevel(cx, input, stencil, gcOutput)) {
+    return false;
+  }
+
+  // !! Must be infallible from here forward !!
+
+  // Phase 6: Update lazy scripts.
+  if (CanLazilyParse(input.options)) {
+    UpdateEmittedInnerFunctions(cx, input, stencil, gcOutput);
+
+    if (isInitialParse) {
+      LinkEnclosingLazyScript(stencil, gcOutput);
+    }
+  }
+
+  return true;
+}
+
+bool CompilationStencilSet::buildDelazificationIndices(JSContext* cx) {
+  // Standalone-functions are not supported by XDR.
+  MOZ_ASSERT(!scriptData[0].isFunction());
+
+  // If no delazifications, we are done.
+  if (delazifications.empty()) {
+    return true;
+  }
+
+  if (!delazificationIndices.resize(delazifications.length())) {
+    ReportOutOfMemory(cx);
+    return false;
+  }
+
+  HashMap<BaseCompilationStencil::FunctionKey, size_t> keyToIndex(cx);
+  if (!keyToIndex.reserve(delazifications.length())) {
+    return false;
+  }
+
+  for (size_t i = 0; i < delazifications.length(); i++) {
+    const auto& delazification = delazifications[i];
+    auto key = delazification.functionKey;
+    keyToIndex.putNewInfallible(key, i);
+  }
+
+  MOZ_ASSERT(keyToIndex.count() == delazifications.length());
+
+  for (size_t i = 1; i < scriptData.size(); i++) {
+    auto key = BaseCompilationStencil::toFunctionKey(scriptExtra[i].extent);
+    auto ptr = keyToIndex.lookup(key);
+    if (!ptr) {
+      continue;
+    }
+    delazificationIndices[ptr->value()] = ScriptIndex(i);
+  }
+
+  return true;
+}
+
+bool CompilationStencilSet::instantiateStencils(
+    JSContext* cx, CompilationGCOutput& gcOutput,
+    CompilationGCOutput& gcOutputForDelazification) {
+  if (!prepareForInstantiate(cx, gcOutput, gcOutputForDelazification)) {
+    return false;
+  }
+
+  return instantiateStencilsAfterPreparation(cx, gcOutput,
+                                             gcOutputForDelazification);
+}
+
+bool CompilationStencilSet::instantiateStencilsAfterPreparation(
+    JSContext* cx, CompilationGCOutput& gcOutput,
+    CompilationGCOutput& gcOutputForDelazification) {
+  if (!CompilationStencil::instantiateStencilsAfterPreparation(cx, input, *this,
+                                                               gcOutput)) {
+    return false;
+  }
+
+  CompilationAtomCache::AtomCacheVector reusableAtomCache;
+  input.atomCache.releaseBuffer(reusableAtomCache);
+
+  for (size_t i = 0; i < delazifications.length(); i++) {
+    auto& delazification = delazifications[i];
+    auto index = delazificationIndices[i];
+
+    JSFunction* fun = gcOutput.functions[index];
+    MOZ_ASSERT(fun);
+
+    BaseScript* lazy = fun->baseScript();
+    MOZ_ASSERT(!lazy->hasBytecode());
+
+    if (!lazy->isReadyForDelazification()) {
+      MOZ_ASSERT(false, "Delazification target is not ready. Bad XDR?");
+      continue;
+    }
+
+    Rooted<CompilationInput> delazificationInput(
+        cx, CompilationInput(input.options));
+    delazificationInput.get().initFromLazy(lazy);
+
+    delazificationInput.get().atomCache.stealBuffer(reusableAtomCache);
+
+    if (!CompilationStencil::prepareGCOutputForInstantiate(
+            cx, delazification, gcOutputForDelazification)) {
+      return false;
+    }
+    if (!CompilationStencil::instantiateStencilsAfterPreparation(
+            cx, delazificationInput.get(), delazification,
+            gcOutputForDelazification)) {
+      return false;
+    }
+
+    // Destroy elements, without unreserving.
+    gcOutputForDelazification.functions.clear();
+    gcOutputForDelazification.scopes.clear();
+
+    delazificationInput.get().atomCache.releaseBuffer(reusableAtomCache);
+  }
+
+  input.atomCache.stealBuffer(reusableAtomCache);
+
+  return true;
+}
+
+/* static */
+bool CompilationStencil::prepareInputAndStencilForInstantiate(
+    JSContext* cx, CompilationInput& input, BaseCompilationStencil& stencil) {
+  if (!input.atomCache.allocate(cx, stencil.parserAtomData.size())) {
+    return false;
+  }
+
+  return true;
+}
+
+/* static */
+bool CompilationStencil::prepareGCOutputForInstantiate(
+    JSContext* cx, BaseCompilationStencil& stencil,
+    CompilationGCOutput& gcOutput) {
+  if (!gcOutput.functions.reserve(stencil.scriptData.size())) {
+    ReportOutOfMemory(cx);
+    return false;
+  }
+  if (!gcOutput.scopes.reserve(stencil.scopeData.size())) {
+    ReportOutOfMemory(cx);
+    return false;
+  }
+
+  return true;
+}
+
+/* static */
+bool CompilationStencil::prepareForInstantiate(JSContext* cx,
+                                               CompilationStencil& stencil,
+                                               CompilationGCOutput& gcOutput) {
+  auto& input = stencil.input;
+
+  if (!prepareInputAndStencilForInstantiate(cx, input, stencil)) {
+    return false;
+  }
+  if (!prepareGCOutputForInstantiate(cx, stencil, gcOutput)) {
+    return false;
+  }
+
+  stencil.preparationIsPerformed = true;
+  return true;
+}
+
+bool CompilationStencilSet::prepareForInstantiate(
+    JSContext* cx, CompilationGCOutput& gcOutput,
+    CompilationGCOutput& gcOutputForDelazification) {
+  if (!CompilationStencil::prepareForInstantiate(cx, *this, gcOutput)) {
+    return false;
+  }
+
+  size_t maxScriptDataLength = 0;
+  size_t maxScopeDataLength = 0;
+  size_t maxParserAtomDataLength = 0;
+  for (auto& delazification : delazifications) {
+    if (maxParserAtomDataLength < delazification.parserAtomData.size()) {
+      maxParserAtomDataLength = delazification.parserAtomData.size();
+    }
+    if (maxScriptDataLength < delazification.scriptData.size()) {
+      maxScriptDataLength = delazification.scriptData.size();
+    }
+    if (maxScopeDataLength < delazification.scopeData.size()) {
+      maxScopeDataLength = delazification.scopeData.size();
+    }
+  }
+
+  if (!input.atomCache.extendIfNecessary(cx, maxParserAtomDataLength)) {
+    return false;
+  }
+  if (!gcOutput.functions.reserve(maxScriptDataLength)) {
+    ReportOutOfMemory(cx);
+    return false;
+  }
+  if (!gcOutput.scopes.reserve(maxScopeDataLength)) {
+    ReportOutOfMemory(cx);
+    return false;
+  }
+
+  if (!buildDelazificationIndices(cx)) {
+    return false;
+  }
+
+  return true;
+}
+
+bool CompilationStencil::serializeStencils(JSContext* cx,
+                                           JS::TranscodeBuffer& buf,
+                                           bool* succeededOut) {
+  if (succeededOut) {
+    *succeededOut = false;
+  }
+  XDRIncrementalStencilEncoder encoder(cx);
+
+  XDRResult res = encoder.codeStencil(*this);
+  if (res.isErr()) {
+    if (res.unwrapErr() & JS::TranscodeResult_Failure) {
+      buf.clear();
+      return true;
+    }
+    MOZ_ASSERT(res.unwrapErr() == JS::TranscodeResult_Throw);
+
+    return false;
+  }
+
+  // Linearize the encoder, return empty buffer on failure.
+  res = encoder.linearize(buf, input.source());
+  if (res.isErr()) {
+    MOZ_ASSERT(cx->isThrowingOutOfMemory());
+    buf.clear();
+    return false;
+  }
+
+  if (succeededOut) {
+    *succeededOut = true;
+  }
+  return true;
+}
+
+bool CompilationStencilSet::deserializeStencils(JSContext* cx,
+                                                const JS::TranscodeRange& range,
+                                                bool* succeededOut) {
+  if (succeededOut) {
+    *succeededOut = false;
+  }
+  MOZ_ASSERT(parserAtomData.empty());
+  XDRStencilDecoder decoder(cx, &input.options, range);
+
+  XDRResult res = decoder.codeStencils(*this);
+  if (res.isErr()) {
+    if (res.unwrapErr() & JS::TranscodeResult_Failure) {
+      return true;
+    }
+    MOZ_ASSERT(res.unwrapErr() == JS::TranscodeResult_Throw);
+
+    return false;
+  }
+
+  if (succeededOut) {
+    *succeededOut = true;
+  }
+  return true;
+}
+
+CompilationState::CompilationState(
+    JSContext* cx, LifoAllocScope& frontendAllocScope,
+    const JS::ReadOnlyCompileOptions& options, CompilationStencil& stencil,
+    InheritThis inheritThis /* = InheritThis::No */,
+    Scope* enclosingScope /* = nullptr */,
+    JSObject* enclosingEnv /* = nullptr */)
+    : directives(options.forceStrictMode()),
+      scopeContext(cx, inheritThis, enclosingScope, enclosingEnv),
+      usedNames(cx),
+      allocScope(frontendAllocScope),
+      input(stencil.input),
+      parserAtoms(cx->runtime(), stencil.alloc) {}
+
+SharedDataContainer::~SharedDataContainer() {
+  if (isEmpty()) {
+    // Nothing to do.
+  } else if (isSingle()) {
+    asSingle()->Release();
+  } else if (isVector()) {
+    js_delete(asVector());
+  } else {
+    MOZ_ASSERT(isMap());
+    js_delete(asMap());
+  }
+}
+
+bool SharedDataContainer::initVector(JSContext* cx) {
+  auto* vec = js_new<SharedDataVector>();
+  if (!vec) {
+    ReportOutOfMemory(cx);
+    return false;
+  }
+  data_ = uintptr_t(vec) | VectorTag;
+  return true;
+}
+
+bool SharedDataContainer::initMap(JSContext* cx) {
+  auto* map = js_new<SharedDataMap>();
+  if (!map) {
+    ReportOutOfMemory(cx);
+    return false;
+  }
+  data_ = uintptr_t(map) | MapTag;
+  return true;
+}
+
+bool SharedDataContainer::prepareStorageFor(JSContext* cx,
+                                            size_t nonLazyScriptCount,
+                                            size_t allScriptCount) {
+  if (nonLazyScriptCount <= 1) {
+    MOZ_ASSERT(isSingle());
+    return true;
+  }
+
+  // If the ratio of scripts with bytecode is small, allocating the Vector
+  // storage with the number of all scripts isn't space-efficient.
+  // In that case use HashMap instead.
+  //
+  // In general, we expect either all scripts to contain bytecode (priviledge
+  // and self-hosted), or almost none to (eg standard lazy parsing output).
+  constexpr size_t thresholdRatio = 8;
+  bool useHashMap = nonLazyScriptCount < allScriptCount / thresholdRatio;
+  if (useHashMap) {
+    if (!initMap(cx)) {
+      return false;
+    }
+    if (!asMap()->reserve(nonLazyScriptCount)) {
+      ReportOutOfMemory(cx);
+      return false;
+    }
+  } else {
+    if (!initVector(cx)) {
+      return false;
+    }
+    if (!asVector()->resize(allScriptCount)) {
+      ReportOutOfMemory(cx);
+      return false;
+    }
+  }
+
+  return true;
+}
+
+js::SharedImmutableScriptData* SharedDataContainer::get(ScriptIndex index) {
+  if (isSingle()) {
+    if (index == CompilationStencil::TopLevelIndex) {
+      return asSingle();
+    }
+    return nullptr;
+  }
+
+  if (isVector()) {
+    auto& vec = *asVector();
+    if (index.index < vec.length()) {
+      return vec[index];
+    }
+    return nullptr;
+  }
+
+  MOZ_ASSERT(isMap());
+  auto& map = *asMap();
+  auto p = map.lookup(index);
+  if (p) {
+    return p->value();
+  }
+  return nullptr;
+}
+
+bool SharedDataContainer::addAndShare(JSContext* cx, ScriptIndex index,
+                                      js::SharedImmutableScriptData* data) {
+  if (isSingle()) {
+    MOZ_ASSERT(index == CompilationStencil::TopLevelIndex);
+    RefPtr<SharedImmutableScriptData> ref(data);
+    if (!SharedImmutableScriptData::shareScriptData(cx, ref)) {
+      return false;
+    }
+    setSingle(ref.forget());
+    return true;
+  }
+
+  if (isVector()) {
+    auto& vec = *asVector();
+    // Resized by SharedDataContainer::prepareStorageFor.
+    vec[index] = data;
+    return SharedImmutableScriptData::shareScriptData(cx, vec[index]);
+  }
+
+  MOZ_ASSERT(isMap());
+  auto& map = *asMap();
+  // Reserved by SharedDataContainer::prepareStorageFor.
+  map.putNewInfallible(index, data);
+  auto p = map.lookup(index);
+  MOZ_ASSERT(p);
+  return SharedImmutableScriptData::shareScriptData(cx, p->value());
+}
+
+template <typename T, typename VectorT>
+bool CopyVectorToSpan(JSContext* cx, LifoAlloc& alloc, mozilla::Span<T>& span,
+                      VectorT& vec) {
+  auto len = vec.length();
+  if (len == 0) {
+    return true;
+  }
+
+  auto* p = alloc.newArrayUninitialized<T>(len);
+  if (!p) {
+    js::ReportOutOfMemory(cx);
+    return false;
+  }
+  span = mozilla::Span(p, len);
+  memcpy(span.data(), vec.begin(), sizeof(T) * len);
+  return true;
+}
+
+bool CompilationState::finish(JSContext* cx, CompilationStencil& stencil) {
+  if (!CopyVectorToSpan(cx, stencil.alloc, stencil.regExpData, regExpData)) {
+    return false;
+  }
+
+  if (!CopyVectorToSpan(cx, stencil.alloc, stencil.scriptData, scriptData)) {
+    return false;
+  }
+
+  if (!CopyVectorToSpan(cx, stencil.alloc, stencil.scriptExtra, scriptExtra)) {
+    return false;
+  }
+
+  if (!CopyVectorToSpan(cx, stencil.alloc, stencil.scopeData, scopeData)) {
+    return false;
+  }
+
+  if (!CopyVectorToSpan(cx, stencil.alloc, stencil.scopeNames, scopeNames)) {
+    return false;
+  }
+
+  if (!CopyVectorToSpan(cx, stencil.alloc, stencil.parserAtomData,
+                        parserAtoms.entries())) {
+    return false;
+  }
+
+  if (!CopyVectorToSpan(cx, stencil.alloc, stencil.gcThingData, gcThingData)) {
+    return false;
+  }
+
+  return true;
+}
+
+mozilla::Span<TaggedScriptThingIndex> ScriptStencil::gcthings(
+    BaseCompilationStencil& stencil) const {
+  return stencil.gcThingData.Subspan(gcThingsOffset, gcThingsLength);
+}
+
+#if defined(DEBUG) || defined(JS_JITSPEW)
+
+void frontend::DumpTaggedParserAtomIndex(js::JSONPrinter& json,
+                                         TaggedParserAtomIndex taggedIndex,
+                                         BaseCompilationStencil* stencil) {
+  if (taggedIndex.isParserAtomIndex()) {
+    json.property("tag", "AtomIndex");
+    auto index = taggedIndex.toParserAtomIndex();
+    if (stencil && stencil->parserAtomData[index]) {
+      GenericPrinter& out = json.beginStringProperty("atom");
+      stencil->parserAtomData[index]->dumpCharsNoQuote(out);
+      json.endString();
+    } else {
+      json.property("index", size_t(index));
+    }
+    return;
+  }
+
+  if (taggedIndex.isWellKnownAtomId()) {
+    json.property("tag", "WellKnown");
+    auto index = taggedIndex.toWellKnownAtomId();
+    switch (index) {
+      case WellKnownAtomId::empty:
+        json.property("atom", "");
+        break;
+
+#  define CASE_(_, name, _2)                                  \
+    case WellKnownAtomId::name: {                             \
+      GenericPrinter& out = json.beginStringProperty("atom"); \
+      WellKnownParserAtoms::rom_.name.dumpCharsNoQuote(out);  \
+      json.endString();                                       \
+      break;                                                  \
+    }
+        FOR_EACH_NONTINY_COMMON_PROPERTYNAME(CASE_)
+#  undef CASE_
+
+#  define CASE_(name, _)                                      \
+    case WellKnownAtomId::name: {                             \
+      GenericPrinter& out = json.beginStringProperty("atom"); \
+      WellKnownParserAtoms::rom_.name.dumpCharsNoQuote(out);  \
+      json.endString();                                       \
+      break;                                                  \
+    }
+        JS_FOR_EACH_PROTOTYPE(CASE_)
+#  undef CASE_
+
+      default:
+        // This includes tiny WellKnownAtomId atoms, which is invalid.
+        json.property("index", size_t(index));
+        break;
+    }
+    return;
+  }
+
+  if (taggedIndex.isStaticParserString1()) {
+    json.property("tag", "Static1");
+    auto index = taggedIndex.toStaticParserString1();
+    GenericPrinter& out = json.beginStringProperty("atom");
+    WellKnownParserAtoms::getStatic1(index)->dumpCharsNoQuote(out);
+    json.endString();
+    return;
+  }
+
+  if (taggedIndex.isStaticParserString2()) {
+    json.property("tag", "Static2");
+    auto index = taggedIndex.toStaticParserString2();
+    GenericPrinter& out = json.beginStringProperty("atom");
+    WellKnownParserAtoms::getStatic2(index)->dumpCharsNoQuote(out);
+    json.endString();
+    return;
+  }
+
+  MOZ_ASSERT(taggedIndex.isNull());
+  json.property("tag", "null");
+}
+
+void RegExpStencil::dump() {
+  js::Fprinter out(stderr);
+  js::JSONPrinter json(out);
+  dump(json, nullptr);
+}
+
+void RegExpStencil::dump(js::JSONPrinter& json,
+                         BaseCompilationStencil* stencil) {
+  json.beginObject();
+  dumpFields(json, stencil);
+  json.endObject();
+}
+
+void RegExpStencil::dumpFields(js::JSONPrinter& json,
+                               BaseCompilationStencil* stencil) {
+  json.beginObjectProperty("pattern");
+  DumpTaggedParserAtomIndex(json, atom_, stencil);
+  json.endObject();
+
+  GenericPrinter& out = json.beginStringProperty("flags");
+
+  if (flags().global()) {
+    out.put("g");
+  }
+  if (flags().ignoreCase()) {
+    out.put("i");
+  }
+  if (flags().multiline()) {
+    out.put("m");
+  }
+  if (flags().dotAll()) {
+    out.put("s");
+  }
+  if (flags().unicode()) {
+    out.put("u");
+  }
+  if (flags().sticky()) {
+    out.put("y");
+  }
+
+  json.endStringProperty();
+}
+
+void BigIntStencil::dump() {
+  js::Fprinter out(stderr);
+  js::JSONPrinter json(out);
+  dump(json);
+}
+
+void BigIntStencil::dump(js::JSONPrinter& json) {
+  GenericPrinter& out = json.beginString();
+  dumpCharsNoQuote(out);
+  json.endString();
+}
+
+void BigIntStencil::dumpCharsNoQuote(GenericPrinter& out) {
+  for (size_t i = 0; i < length_; i++) {
+    out.putChar(char(buf_[i]));
+  }
+}
+
+void ScopeStencil::dump() {
+  js::Fprinter out(stderr);
+  js::JSONPrinter json(out);
+  dump(json, nullptr, nullptr);
+}
+
+void ScopeStencil::dump(js::JSONPrinter& json,
+                        BaseParserScopeData* baseScopeData,
+                        BaseCompilationStencil* stencil) {
+  json.beginObject();
+  dumpFields(json, baseScopeData, stencil);
+  json.endObject();
+}
+
+void ScopeStencil::dumpFields(js::JSONPrinter& json,
+                              BaseParserScopeData* baseScopeData,
+                              BaseCompilationStencil* stencil) {
+  json.property("kind", ScopeKindString(kind_));
+
+  if (hasEnclosing()) {
+    json.formatProperty("enclosing", "ScopeIndex(%zu)", size_t(enclosing()));
+  }
+
+  json.property("firstFrameSlot", firstFrameSlot_);
+
+  if (hasEnvironmentShape()) {
+    json.formatProperty("numEnvironmentSlots", "%zu",
+                        size_t(numEnvironmentSlots_));
+  }
+
+  if (isFunction()) {
+    json.formatProperty("functionIndex", "ScriptIndex(%zu)",
+                        size_t(functionIndex_));
+  }
+
+  json.beginListProperty("flags");
+  if (flags_ & HasEnclosing) {
+    json.value("HasEnclosing");
+  }
+  if (flags_ & HasEnvironmentShape) {
+    json.value("HasEnvironmentShape");
+  }
+  if (flags_ & IsArrow) {
+    json.value("IsArrow");
+  }
+  json.endList();
+
+  if (!baseScopeData) {
+    return;
+  }
+
+  json.beginObjectProperty("data");
+
+  AbstractTrailingNamesArray<TaggedParserAtomIndex>* trailingNames = nullptr;
+  uint32_t length = 0;
+
+  switch (kind_) {
+    case ScopeKind::Function: {
+      auto* data = static_cast<FunctionScope::ParserData*>(baseScopeData);
+      json.property("nextFrameSlot", data->slotInfo.nextFrameSlot);
+      json.property("hasParameterExprs", data->slotInfo.hasParameterExprs());
+      json.property("nonPositionalFormalStart",
+                    data->slotInfo.nonPositionalFormalStart);
+      json.property("varStart", data->slotInfo.varStart);
+
+      trailingNames = &data->trailingNames;
+      length = data->slotInfo.length;
+      break;
+    }
+
+    case ScopeKind::FunctionBodyVar: {
+      auto* data = static_cast<VarScope::ParserData*>(baseScopeData);
+      json.property("nextFrameSlot", data->slotInfo.nextFrameSlot);
+
+      trailingNames = &data->trailingNames;
+      length = data->slotInfo.length;
+      break;
+    }
+
+    case ScopeKind::Lexical:
+    case ScopeKind::SimpleCatch:
+    case ScopeKind::Catch:
+    case ScopeKind::NamedLambda:
+    case ScopeKind::StrictNamedLambda:
+    case ScopeKind::FunctionLexical:
+    case ScopeKind::ClassBody: {
+      auto* data = static_cast<LexicalScope::ParserData*>(baseScopeData);
+      json.property("nextFrameSlot", data->slotInfo.nextFrameSlot);
+      json.property("constStart", data->slotInfo.constStart);
+
+      trailingNames = &data->trailingNames;
+      length = data->slotInfo.length;
+      break;
+    }
+
+    case ScopeKind::With: {
+      break;
+    }
+
+    case ScopeKind::Eval:
+    case ScopeKind::StrictEval: {
+      auto* data = static_cast<EvalScope::ParserData*>(baseScopeData);
+      json.property("nextFrameSlot", data->slotInfo.nextFrameSlot);
+
+      trailingNames = &data->trailingNames;
+      length = data->slotInfo.length;
+      break;
+    }
+
+    case ScopeKind::Global:
+    case ScopeKind::NonSyntactic: {
+      auto* data = static_cast<GlobalScope::ParserData*>(baseScopeData);
+      json.property("letStart", data->slotInfo.letStart);
+      json.property("constStart", data->slotInfo.constStart);
+
+      trailingNames = &data->trailingNames;
+      length = data->slotInfo.length;
+      break;
+    }
+
+    case ScopeKind::Module: {
+      auto* data = static_cast<ModuleScope::ParserData*>(baseScopeData);
+      json.property("nextFrameSlot", data->slotInfo.nextFrameSlot);
+      json.property("varStart", data->slotInfo.varStart);
+      json.property("letStart", data->slotInfo.letStart);
+      json.property("constStart", data->slotInfo.constStart);
+
+      trailingNames = &data->trailingNames;
+      length = data->slotInfo.length;
+      break;
+    }
+
+    case ScopeKind::WasmInstance: {
+      auto* data = static_cast<WasmInstanceScope::ParserData*>(baseScopeData);
+      json.property("nextFrameSlot", data->slotInfo.nextFrameSlot);
+      json.property("globalsStart", data->slotInfo.globalsStart);
+
+      trailingNames = &data->trailingNames;
+      length = data->slotInfo.length;
+      break;
+    }
+
+    case ScopeKind::WasmFunction: {
+      auto* data = static_cast<WasmFunctionScope::ParserData*>(baseScopeData);
+      json.property("nextFrameSlot", data->slotInfo.nextFrameSlot);
+
+      trailingNames = &data->trailingNames;
+      length = data->slotInfo.length;
+      break;
+    }
+
+    default: {
+      MOZ_CRASH("Unexpected ScopeKind");
+      break;
+    }
+  }
+
+  if (trailingNames) {
+    char index[64];
+    json.beginObjectProperty("trailingNames");
+    for (size_t i = 0; i < length; i++) {
+      auto& name = (*trailingNames)[i];
+      SprintfLiteral(index, "%zu", i);
+      json.beginObjectProperty(index);
+
+      json.boolProperty("closedOver", name.closedOver());
+
+      json.boolProperty("isTopLevelFunction", name.isTopLevelFunction());
+
+      json.beginObjectProperty("name");
+      DumpTaggedParserAtomIndex(json, name.name(), stencil);
+      json.endObject();
+
+      json.endObject();
+    }
+    json.endObject();
+  }
+
+  json.endObject();
+}
+
+static void DumpModuleEntryVectorItems(
+    js::JSONPrinter& json, const StencilModuleMetadata::EntryVector& entries,
+    BaseCompilationStencil* stencil) {
+  for (const auto& entry : entries) {
+    json.beginObject();
+    if (entry.specifier) {
+      json.beginObjectProperty("specifier");
+      DumpTaggedParserAtomIndex(json, entry.specifier, stencil);
+      json.endObject();
+    }
+    if (entry.localName) {
+      json.beginObjectProperty("localName");
+      DumpTaggedParserAtomIndex(json, entry.localName, stencil);
+      json.endObject();
+    }
+    if (entry.importName) {
+      json.beginObjectProperty("importName");
+      DumpTaggedParserAtomIndex(json, entry.importName, stencil);
+      json.endObject();
+    }
+    if (entry.exportName) {
+      json.beginObjectProperty("exportName");
+      DumpTaggedParserAtomIndex(json, entry.exportName, stencil);
+      json.endObject();
+    }
+    json.endObject();
+  }
+}
+
+void StencilModuleMetadata::dump() {
+  js::Fprinter out(stderr);
+  js::JSONPrinter json(out);
+  dump(json, nullptr);
+}
+
+void StencilModuleMetadata::dump(js::JSONPrinter& json,
+                                 BaseCompilationStencil* stencil) {
+  json.beginObject();
+  dumpFields(json, stencil);
+  json.endObject();
+}
+
+void StencilModuleMetadata::dumpFields(js::JSONPrinter& json,
+                                       BaseCompilationStencil* stencil) {
+  json.beginListProperty("requestedModules");
+  DumpModuleEntryVectorItems(json, requestedModules, stencil);
+  json.endList();
+
+  json.beginListProperty("importEntries");
+  DumpModuleEntryVectorItems(json, importEntries, stencil);
+  json.endList();
+
+  json.beginListProperty("localExportEntries");
+  DumpModuleEntryVectorItems(json, localExportEntries, stencil);
+  json.endList();
+
+  json.beginListProperty("indirectExportEntries");
+  DumpModuleEntryVectorItems(json, indirectExportEntries, stencil);
+  json.endList();
+
+  json.beginListProperty("starExportEntries");
+  DumpModuleEntryVectorItems(json, starExportEntries, stencil);
+  json.endList();
+
+  json.beginListProperty("functionDecls");
+  for (auto& index : functionDecls) {
+    json.value("ScriptIndex(%zu)", size_t(index));
+  }
+  json.endList();
+
+  json.boolProperty("isAsync", isAsync);
+}
+
+static void DumpImmutableScriptFlags(js::JSONPrinter& json,
+                                     ImmutableScriptFlags immutableFlags) {
+  for (uint32_t i = 1; i; i = i << 1) {
+    if (uint32_t(immutableFlags) & i) {
+      switch (ImmutableScriptFlagsEnum(i)) {
+        case ImmutableScriptFlagsEnum::IsForEval:
+          json.value("IsForEval");
+          break;
+        case ImmutableScriptFlagsEnum::IsModule:
+          json.value("IsModule");
+          break;
+        case ImmutableScriptFlagsEnum::IsFunction:
+          json.value("IsFunction");
+          break;
+        case ImmutableScriptFlagsEnum::SelfHosted:
+          json.value("SelfHosted");
+          break;
+        case ImmutableScriptFlagsEnum::ForceStrict:
+          json.value("ForceStrict");
+          break;
+        case ImmutableScriptFlagsEnum::HasNonSyntacticScope:
+          json.value("HasNonSyntacticScope");
+          break;
+        case ImmutableScriptFlagsEnum::NoScriptRval:
+          json.value("NoScriptRval");
+          break;
+        case ImmutableScriptFlagsEnum::TreatAsRunOnce:
+          json.value("TreatAsRunOnce");
+          break;
+        case ImmutableScriptFlagsEnum::Strict:
+          json.value("Strict");
+          break;
+        case ImmutableScriptFlagsEnum::HasModuleGoal:
+          json.value("HasModuleGoal");
+          break;
+        case ImmutableScriptFlagsEnum::HasInnerFunctions:
+          json.value("HasInnerFunctions");
+          break;
+        case ImmutableScriptFlagsEnum::HasDirectEval:
+          json.value("HasDirectEval");
+          break;
+        case ImmutableScriptFlagsEnum::BindingsAccessedDynamically:
+          json.value("BindingsAccessedDynamically");
+          break;
+        case ImmutableScriptFlagsEnum::HasCallSiteObj:
+          json.value("HasCallSiteObj");
+          break;
+        case ImmutableScriptFlagsEnum::IsAsync:
+          json.value("IsAsync");
+          break;
+        case ImmutableScriptFlagsEnum::IsGenerator:
+          json.value("IsGenerator");
+          break;
+        case ImmutableScriptFlagsEnum::FunHasExtensibleScope:
+          json.value("FunHasExtensibleScope");
+          break;
+        case ImmutableScriptFlagsEnum::FunctionHasThisBinding:
+          json.value("FunctionHasThisBinding");
+          break;
+        case ImmutableScriptFlagsEnum::NeedsHomeObject:
+          json.value("NeedsHomeObject");
+          break;
+        case ImmutableScriptFlagsEnum::IsDerivedClassConstructor:
+          json.value("IsDerivedClassConstructor");
+          break;
+        case ImmutableScriptFlagsEnum::IsFieldInitializer:
+          json.value("IsFieldInitializer");
+          break;
+        case ImmutableScriptFlagsEnum::HasRest:
+          json.value("HasRest");
+          break;
+        case ImmutableScriptFlagsEnum::NeedsFunctionEnvironmentObjects:
+          json.value("NeedsFunctionEnvironmentObjects");
+          break;
+        case ImmutableScriptFlagsEnum::FunctionHasExtraBodyVarScope:
+          json.value("FunctionHasExtraBodyVarScope");
+          break;
+        case ImmutableScriptFlagsEnum::ShouldDeclareArguments:
+          json.value("ShouldDeclareArguments");
+          break;
+        case ImmutableScriptFlagsEnum::ArgumentsHasVarBinding:
+          json.value("ArgumentsHasVarBinding");
+          break;
+        case ImmutableScriptFlagsEnum::AlwaysNeedsArgsObj:
+          json.value("AlwaysNeedsArgsObj");
+          break;
+        case ImmutableScriptFlagsEnum::HasMappedArgsObj:
+          json.value("HasMappedArgsObj");
+          break;
+        default:
+          json.value("Unknown(%x)", i);
+          break;
+      }
+    }
+  }
+}
+
+static void DumpFunctionFlagsItems(js::JSONPrinter& json,
+                                   FunctionFlags functionFlags) {
+  switch (functionFlags.kind()) {
+    case FunctionFlags::FunctionKind::NormalFunction:
+      json.value("NORMAL_KIND");
+      break;
+    case FunctionFlags::FunctionKind::AsmJS:
+      json.value("ASMJS_KIND");
+      break;
+    case FunctionFlags::FunctionKind::Wasm:
+      json.value("WASM_KIND");
+      break;
+    case FunctionFlags::FunctionKind::Arrow:
+      json.value("ARROW_KIND");
+      break;
+    case FunctionFlags::FunctionKind::Method:
+      json.value("METHOD_KIND");
+      break;
+    case FunctionFlags::FunctionKind::ClassConstructor:
+      json.value("CLASSCONSTRUCTOR_KIND");
+      break;
+    case FunctionFlags::FunctionKind::Getter:
+      json.value("GETTER_KIND");
+      break;
+    case FunctionFlags::FunctionKind::Setter:
+      json.value("SETTER_KIND");
+      break;
+    default:
+      json.value("Unknown(%x)", uint8_t(functionFlags.kind()));
+      break;
+  }
+
+  static_assert(FunctionFlags::FUNCTION_KIND_MASK == 0x0007,
+                "FunctionKind should use the lowest 3 bits");
+  for (uint16_t i = 1 << 3; i; i = i << 1) {
+    if (functionFlags.toRaw() & i) {
+      switch (FunctionFlags::Flags(i)) {
+        case FunctionFlags::Flags::EXTENDED:
+          json.value("EXTENDED");
+          break;
+        case FunctionFlags::Flags::SELF_HOSTED:
+          json.value("SELF_HOSTED");
+          break;
+        case FunctionFlags::Flags::BASESCRIPT:
+          json.value("BASESCRIPT");
+          break;
+        case FunctionFlags::Flags::SELFHOSTLAZY:
+          json.value("SELFHOSTLAZY");
+          break;
+        case FunctionFlags::Flags::CONSTRUCTOR:
+          json.value("CONSTRUCTOR");
+          break;
+        case FunctionFlags::Flags::BOUND_FUN:
+          json.value("BOUND_FUN");
+          break;
+        case FunctionFlags::Flags::LAMBDA:
+          json.value("LAMBDA");
+          break;
+        case FunctionFlags::Flags::WASM_JIT_ENTRY:
+          json.value("WASM_JIT_ENTRY");
+          break;
+        case FunctionFlags::Flags::HAS_INFERRED_NAME:
+          json.value("HAS_INFERRED_NAME");
+          break;
+        case FunctionFlags::Flags::ATOM_EXTRA_FLAG:
+          json.value("ATOM_EXTRA_FLAG");
+          break;
+        case FunctionFlags::Flags::RESOLVED_NAME:
+          json.value("RESOLVED_NAME");
+          break;
+        case FunctionFlags::Flags::RESOLVED_LENGTH:
+          json.value("RESOLVED_LENGTH");
+          break;
+        default:
+          json.value("Unknown(%x)", i);
+          break;
+      }
+    }
+  }
+}
+
+static void DumpScriptThing(js::JSONPrinter& json,
+                            BaseCompilationStencil* stencil,
+                            TaggedScriptThingIndex& thing) {
+  switch (thing.tag()) {
+    case TaggedScriptThingIndex::Kind::ParserAtomIndex:
+    case TaggedScriptThingIndex::Kind::WellKnown:
+      json.beginObject();
+      json.property("type", "Atom");
+      DumpTaggedParserAtomIndex(json, thing.toAtom(), stencil);
+      json.endObject();
+      break;
+    case TaggedScriptThingIndex::Kind::Null:
+      json.nullValue();
+      break;
+    case TaggedScriptThingIndex::Kind::BigInt:
+      json.value("BigIntIndex(%zu)", size_t(thing.toBigInt()));
+      break;
+    case TaggedScriptThingIndex::Kind::ObjLiteral:
+      json.value("ObjLiteralIndex(%zu)", size_t(thing.toObjLiteral()));
+      break;
+    case TaggedScriptThingIndex::Kind::RegExp:
+      json.value("RegExpIndex(%zu)", size_t(thing.toRegExp()));
+      break;
+    case TaggedScriptThingIndex::Kind::Scope:
+      json.value("ScopeIndex(%zu)", size_t(thing.toScope()));
+      break;
+    case TaggedScriptThingIndex::Kind::Function:
+      json.value("ScriptIndex(%zu)", size_t(thing.toFunction()));
+      break;
+    case TaggedScriptThingIndex::Kind::EmptyGlobalScope:
+      json.value("EmptyGlobalScope");
+      break;
+  }
+}
+
+void ScriptStencil::dump() {
+  js::Fprinter out(stderr);
+  js::JSONPrinter json(out);
+  dump(json, nullptr);
+}
+
+void ScriptStencil::dump(js::JSONPrinter& json,
+                         BaseCompilationStencil* stencil) {
+  json.beginObject();
+  dumpFields(json, stencil);
+  json.endObject();
+}
+
+void ScriptStencil::dumpFields(js::JSONPrinter& json,
+                               BaseCompilationStencil* stencil) {
+  if (hasMemberInitializers()) {
+    json.property("memberInitializers", memberInitializers_);
+  }
+
+  json.formatProperty("gcThingsOffset", "CompilationGCThingIndex(%u)",
+                      gcThingsOffset.index);
+  json.property("gcThingsLength", gcThingsLength);
+
+  if (stencil) {
+    json.beginListProperty("gcThings");
+    for (auto& thing : gcthings(*stencil)) {
+      DumpScriptThing(json, stencil, thing);
+    }
+    json.endList();
+  }
+
+  json.beginListProperty("flags");
+  if (flags_ & WasFunctionEmittedFlag) {
+    json.value("WasFunctionEmittedFlag");
+  }
+  if (flags_ & AllowRelazifyFlag) {
+    json.value("AllowRelazifyFlag");
+  }
+  if (flags_ & HasSharedDataFlag) {
+    json.value("HasSharedDataFlag");
+  }
+  if (flags_ & HasMemberInitializersFlag) {
+    json.value("HasMemberInitializersFlag");
+  }
+  if (flags_ & HasLazyFunctionEnclosingScopeIndexFlag) {
+    json.value("HasLazyFunctionEnclosingScopeIndexFlag");
+  }
+  json.endList();
+
+  if (isFunction()) {
+    json.beginObjectProperty("functionAtom");
+    DumpTaggedParserAtomIndex(json, functionAtom, stencil);
+    json.endObject();
+
+    json.beginListProperty("functionFlags");
+    DumpFunctionFlagsItems(json, functionFlags);
+    json.endList();
+
+    if (hasLazyFunctionEnclosingScopeIndex()) {
+      json.formatProperty("lazyFunctionEnclosingScopeIndex", "ScopeIndex(%zu)",
+                          size_t(lazyFunctionEnclosingScopeIndex_));
+    }
+  }
+}
+
+void ScriptStencilExtra::dump() {
+  js::Fprinter out(stderr);
+  js::JSONPrinter json(out);
+  dump(json);
+}
+
+void ScriptStencilExtra::dump(js::JSONPrinter& json) {
+  json.beginObject();
+  dumpFields(json);
+  json.endObject();
+}
+
+void ScriptStencilExtra::dumpFields(js::JSONPrinter& json) {
+  json.beginListProperty("immutableFlags");
+  DumpImmutableScriptFlags(json, immutableFlags);
+  json.endList();
+
+  json.beginObjectProperty("extent");
+  json.property("sourceStart", extent.sourceStart);
+  json.property("sourceEnd", extent.sourceEnd);
+  json.property("toStringStart", extent.toStringStart);
+  json.property("toStringEnd", extent.toStringEnd);
+  json.property("lineno", extent.lineno);
+  json.property("column", extent.column);
+  json.endObject();
+
+  json.property("nargs", nargs);
+}
+
+void SharedDataContainer::dump() {
+  js::Fprinter out(stderr);
+  js::JSONPrinter json(out);
+  dump(json);
+}
+
+void SharedDataContainer::dump(js::JSONPrinter& json) {
+  json.beginObject();
+  dumpFields(json);
+  json.endObject();
+}
+
+void SharedDataContainer::dumpFields(js::JSONPrinter& json) {
+  if (isEmpty()) {
+    json.nullProperty("ScriptIndex(0)");
+    return;
+  }
+
+  if (isSingle()) {
+    json.formatProperty("ScriptIndex(0)", "u8[%zu]",
+                        asSingle()->immutableDataLength());
+    return;
+  }
+
+  if (isVector()) {
+    auto& vec = *asVector();
+
+    char index[64];
+    for (size_t i = 0; i < vec.length(); i++) {
+      SprintfLiteral(index, "ScriptIndex(%zu)", i);
+      if (vec[i]) {
+        json.formatProperty(index, "u8[%zu]", vec[i]->immutableDataLength());
+      } else {
+        json.nullProperty(index);
+      }
+    }
+    return;
+  }
+
+  MOZ_ASSERT(isMap());
+  auto& map = *asMap();
+
+  char index[64];
+  for (auto iter = map.iter(); !iter.done(); iter.next()) {
+    SprintfLiteral(index, "ScriptIndex(%u)", iter.get().key().index);
+    json.formatProperty(index, "u8[%zu]",
+                        iter.get().value()->immutableDataLength());
+  }
+}
+
+void BaseCompilationStencil::dump() {
+  js::Fprinter out(stderr);
+  js::JSONPrinter json(out);
+  dump(json);
+  out.put("\n");
+}
+
+void BaseCompilationStencil::dump(js::JSONPrinter& json) {
+  json.beginObject();
+  dumpFields(json);
+  json.endObject();
+}
+
+void BaseCompilationStencil::dumpFields(js::JSONPrinter& json) {
+  char index[64];
+
+  json.beginObjectProperty("scriptData");
+  for (size_t i = 0; i < scriptData.size(); i++) {
+    SprintfLiteral(index, "ScriptIndex(%zu)", i);
+    json.beginObjectProperty(index);
+    scriptData[i].dumpFields(json, this);
+    json.endObject();
+  }
+  json.endObject();
+
+  json.beginObjectProperty("regExpData");
+  for (size_t i = 0; i < regExpData.size(); i++) {
+    SprintfLiteral(index, "RegExpIndex(%zu)", i);
+    json.beginObjectProperty(index);
+    regExpData[i].dumpFields(json, this);
+    json.endObject();
+  }
+  json.endObject();
+
+  json.beginObjectProperty("bigIntData");
+  for (size_t i = 0; i < bigIntData.length(); i++) {
+    SprintfLiteral(index, "BigIntIndex(%zu)", i);
+    GenericPrinter& out = json.beginStringProperty(index);
+    bigIntData[i].dumpCharsNoQuote(out);
+    json.endStringProperty();
+  }
+  json.endObject();
+
+  json.beginObjectProperty("objLiteralData");
+  for (size_t i = 0; i < objLiteralData.length(); i++) {
+    SprintfLiteral(index, "ObjLiteralIndex(%zu)", i);
+    json.beginObjectProperty(index);
+    objLiteralData[i].dumpFields(json, this);
+    json.endObject();
+  }
+  json.endObject();
+
+  json.beginObjectProperty("scopeData");
+  MOZ_ASSERT(scopeData.size() == scopeNames.size());
+  for (size_t i = 0; i < scopeData.size(); i++) {
+    SprintfLiteral(index, "ScopeIndex(%zu)", i);
+    json.beginObjectProperty(index);
+    scopeData[i].dumpFields(json, scopeNames[i], this);
+    json.endObject();
+  }
+  json.endObject();
+
+  json.beginObjectProperty("sharedData");
+  sharedData.dumpFields(json);
+  json.endObject();
+}
+
+void CompilationStencil::dump() {
+  js::Fprinter out(stderr);
+  js::JSONPrinter json(out);
+  dump(json);
+  out.put("\n");
+}
+
+void CompilationStencil::dump(js::JSONPrinter& json) {
+  json.beginObject();
+  dumpFields(json);
+  json.endObject();
+}
+
+void CompilationStencil::dumpFields(js::JSONPrinter& json) {
+  BaseCompilationStencil::dumpFields(json);
+
+  char index[64];
+  json.beginObjectProperty("scriptExtra");
+  for (size_t i = 0; i < scriptExtra.size(); i++) {
+    SprintfLiteral(index, "ScriptIndex(%zu)", i);
+    json.beginObjectProperty(index);
+    scriptExtra[i].dumpFields(json);
+    json.endObject();
+  }
+  json.endObject();
+
+  if (moduleMetadata) {
+    json.beginObjectProperty("moduleMetadata");
+    moduleMetadata->dumpFields(json, this);
+    json.endObject();
+  }
+
+  json.beginObjectProperty("asmJS");
+  for (auto iter = asmJS.iter(); !iter.done(); iter.next()) {
+    SprintfLiteral(index, "ScriptIndex(%u)", iter.get().key().index);
+    json.formatProperty(index, "asm.js");
+  }
+  json.endObject();
+}
+
+#endif  // defined(DEBUG) || defined(JS_JITSPEW)
+
+JSAtom* CompilationAtomCache::getExistingAtomAt(ParserAtomIndex index) const {
+  return atoms_[index];
+}
+
+JSAtom* CompilationAtomCache::getExistingAtomAt(
+    JSContext* cx, TaggedParserAtomIndex taggedIndex) const {
+  if (taggedIndex.isParserAtomIndex()) {
+    auto index = taggedIndex.toParserAtomIndex();
+    return getExistingAtomAt(index);
+  }
+
+  if (taggedIndex.isWellKnownAtomId()) {
+    auto index = taggedIndex.toWellKnownAtomId();
+    return GetWellKnownAtom(cx, index);
+  }
+
+  if (taggedIndex.isStaticParserString1()) {
+    auto index = taggedIndex.toStaticParserString1();
+    return cx->staticStrings().getUnit(char16_t(index));
+  }
+
+  MOZ_ASSERT(taggedIndex.isStaticParserString2());
+  auto index = taggedIndex.toStaticParserString2();
+  return cx->staticStrings().getLength2FromIndex(size_t(index));
+}
+
+JSAtom* CompilationAtomCache::getAtomAt(ParserAtomIndex index) const {
+  if (size_t(index) >= atoms_.length()) {
+    return nullptr;
+  }
+  return atoms_[index];
+}
+
+bool CompilationAtomCache::hasAtomAt(ParserAtomIndex index) const {
+  if (size_t(index) >= atoms_.length()) {
+    return false;
+  }
+  return !!atoms_[index];
+}
+
+bool CompilationAtomCache::setAtomAt(JSContext* cx, ParserAtomIndex index,
+                                     JSAtom* atom) {
+  if (size_t(index) < atoms_.length()) {
+    atoms_[index] = atom;
+    return true;
+  }
+
+  if (!atoms_.resize(size_t(index) + 1)) {
+    ReportOutOfMemory(cx);
+    return false;
+  }
+
+  atoms_[index] = atom;
+  return true;
+}
+
+bool CompilationAtomCache::allocate(JSContext* cx, size_t length) {
+  MOZ_ASSERT(length >= atoms_.length());
+  if (length == atoms_.length()) {
+    return true;
+  }
+
+  if (!atoms_.resize(length)) {
+    ReportOutOfMemory(cx);
+    return false;
+  }
+
+  return true;
+}
+
+bool CompilationAtomCache::extendIfNecessary(JSContext* cx, size_t length) {
+  if (length <= atoms_.length()) {
+    return true;
+  }
+
+  if (!atoms_.resize(length)) {
+    ReportOutOfMemory(cx);
+    return false;
+  }
+
+  return true;
+}
+
+void CompilationAtomCache::stealBuffer(AtomCacheVector& atoms) {
+  atoms_ = std::move(atoms);
+  // Destroy elements, without unreserving.
+  atoms_.clear();
+}
+
+void CompilationAtomCache::releaseBuffer(AtomCacheVector& atoms) {
+  atoms = std::move(atoms_);
+}
+
+const ParserAtom* GetWellKnownParserAtomAt(JSContext* cx,
+                                           TaggedParserAtomIndex taggedIndex) {
+  MOZ_ASSERT(!taggedIndex.isParserAtomIndex());
+
+  if (taggedIndex.isWellKnownAtomId()) {
+    auto index = taggedIndex.toWellKnownAtomId();
+    return cx->runtime()->commonParserNames->getWellKnown(index);
+  }
+
+  if (taggedIndex.isStaticParserString1()) {
+    auto index = taggedIndex.toStaticParserString1();
+    return WellKnownParserAtoms::getStatic1(index);
+  }
+
+  MOZ_ASSERT(taggedIndex.isStaticParserString2());
+  auto index = taggedIndex.toStaticParserString2();
+  return WellKnownParserAtoms::getStatic2(index);
+}
+
+const ParserAtom* CompilationState::getParserAtomAt(
+    JSContext* cx, TaggedParserAtomIndex taggedIndex) const {
+  if (taggedIndex.isParserAtomIndex()) {
+    auto index = taggedIndex.toParserAtomIndex();
+    MOZ_ASSERT(index < parserAtoms.entries().length());
+    return parserAtoms.entries()[index]->asAtom();
+  }
+
+  return GetWellKnownParserAtomAt(cx, taggedIndex);
+}
+
+bool CompilationState::allocateGCThingsUninitialized(
+    JSContext* cx, ScriptIndex scriptIndex, size_t length,
+    TaggedScriptThingIndex** cursor) {
+  MOZ_ASSERT(gcThingData.length() <= UINT32_MAX);
+
+  auto gcThingsOffset = CompilationGCThingIndex(gcThingData.length());
+
+  if (length > INDEX_LIMIT) {
+    ReportAllocationOverflow(cx);
+    return false;
+  }
+  uint32_t gcThingsLength = length;
+
+  if (!gcThingData.growByUninitialized(length)) {
+    js::ReportOutOfMemory(cx);
+    return false;
+  }
+
+  if (gcThingData.length() > UINT32_MAX) {
+    ReportAllocationOverflow(cx);
+    return false;
+  }
+
+  ScriptStencil& script = scriptData[scriptIndex];
+  script.gcThingsOffset = gcThingsOffset;
+  script.gcThingsLength = gcThingsLength;
+
+  *cursor = gcThingData.begin() + gcThingsOffset;
+  return true;
+}
+
+bool CompilationState::appendGCThings(
+    JSContext* cx, ScriptIndex scriptIndex,
+    mozilla::Span<const TaggedScriptThingIndex> things) {
+  MOZ_ASSERT(gcThingData.length() <= UINT32_MAX);
+
+  auto gcThingsOffset = CompilationGCThingIndex(gcThingData.length());
+
+  if (things.size() > INDEX_LIMIT) {
+    ReportAllocationOverflow(cx);
+    return false;
+  }
+  uint32_t gcThingsLength = uint32_t(things.size());
+
+  if (!gcThingData.append(things.data(), things.size())) {
+    js::ReportOutOfMemory(cx);
+    return false;
+  }
+
+  if (gcThingData.length() > UINT32_MAX) {
+    ReportAllocationOverflow(cx);
+    return false;
+  }
+
+  ScriptStencil& script = scriptData[scriptIndex];
+  script.gcThingsOffset = gcThingsOffset;
+  script.gcThingsLength = gcThingsLength;
+  return true;
+}
+
+const ParserAtom* BaseCompilationStencil::getParserAtomAt(
+    JSContext* cx, TaggedParserAtomIndex taggedIndex) const {
+  if (taggedIndex.isParserAtomIndex()) {
+    auto index = taggedIndex.toParserAtomIndex();
+    MOZ_ASSERT(index < parserAtomData.size());
+    return parserAtomData[index]->asAtom();
+  }
+
+  return GetWellKnownParserAtomAt(cx, taggedIndex);
+}