summaryrefslogtreecommitdiffstats
path: root/js/src/vm/Scope.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'js/src/vm/Scope.cpp')
-rw-r--r--js/src/vm/Scope.cpp1698
1 files changed, 1698 insertions, 0 deletions
diff --git a/js/src/vm/Scope.cpp b/js/src/vm/Scope.cpp
new file mode 100644
index 0000000000..c48d0976d8
--- /dev/null
+++ b/js/src/vm/Scope.cpp
@@ -0,0 +1,1698 @@
+/* -*- 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 "vm/Scope.h"
+
+#include <new>
+
+#include "jsnum.h"
+
+#include "frontend/CompilationStencil.h" // ScopeStencilRef, CompilationStencil, CompilationState, CompilationAtomCache
+#include "frontend/ParserAtom.h" // frontend::ParserAtomsTable, frontend::ParserAtom
+#include "frontend/ScriptIndex.h" // ScriptIndex
+#include "frontend/Stencil.h"
+#include "util/StringBuffer.h"
+#include "vm/EnvironmentObject.h"
+#include "vm/ErrorReporting.h" // MaybePrintAndClearPendingException
+#include "vm/JSScript.h"
+#include "wasm/WasmDebug.h"
+#include "wasm/WasmInstance.h"
+
+#include "gc/GCContext-inl.h"
+#include "gc/ObjectKind-inl.h"
+#include "gc/TraceMethods-inl.h"
+#include "vm/JSContext-inl.h"
+#include "wasm/WasmInstance-inl.h"
+
+using namespace js;
+using namespace js::frontend;
+
+using mozilla::Maybe;
+
+const char* js::BindingKindString(BindingKind kind) {
+ switch (kind) {
+ case BindingKind::Import:
+ return "import";
+ case BindingKind::FormalParameter:
+ return "formal parameter";
+ case BindingKind::Var:
+ return "var";
+ case BindingKind::Let:
+ return "let";
+ case BindingKind::Const:
+ return "const";
+ case BindingKind::NamedLambdaCallee:
+ return "named lambda callee";
+ case BindingKind::Synthetic:
+ return "synthetic";
+ case BindingKind::PrivateMethod:
+ return "private method";
+ }
+ MOZ_CRASH("Bad BindingKind");
+}
+
+const char* js::ScopeKindString(ScopeKind kind) {
+ switch (kind) {
+ case ScopeKind::Function:
+ return "function";
+ case ScopeKind::FunctionBodyVar:
+ return "function body var";
+ case ScopeKind::Lexical:
+ return "lexical";
+ case ScopeKind::SimpleCatch:
+ case ScopeKind::Catch:
+ return "catch";
+ case ScopeKind::NamedLambda:
+ return "named lambda";
+ case ScopeKind::StrictNamedLambda:
+ return "strict named lambda";
+ case ScopeKind::FunctionLexical:
+ return "function lexical";
+ case ScopeKind::ClassBody:
+ return "class body";
+ case ScopeKind::With:
+ return "with";
+ case ScopeKind::Eval:
+ return "eval";
+ case ScopeKind::StrictEval:
+ return "strict eval";
+ case ScopeKind::Global:
+ return "global";
+ case ScopeKind::NonSyntactic:
+ return "non-syntactic";
+ case ScopeKind::Module:
+ return "module";
+ case ScopeKind::WasmInstance:
+ return "wasm instance";
+ case ScopeKind::WasmFunction:
+ return "wasm function";
+ }
+ MOZ_CRASH("Bad ScopeKind");
+}
+
+SharedShape* js::EmptyEnvironmentShape(JSContext* cx, const JSClass* cls,
+ uint32_t numSlots,
+ ObjectFlags objectFlags) {
+ // Put as many slots into the object header as possible.
+ uint32_t numFixed = gc::GetGCKindSlots(gc::GetGCObjectKind(numSlots));
+ return SharedShape::getInitialShape(
+ cx, cls, cx->realm(), TaggedProto(nullptr), numFixed, objectFlags);
+}
+
+static bool AddToEnvironmentMap(JSContext* cx, const JSClass* clasp,
+ HandleId id, BindingKind bindKind,
+ uint32_t slot,
+ MutableHandle<SharedPropMap*> map,
+ uint32_t* mapLength, ObjectFlags* objectFlags) {
+ PropertyFlags propFlags = {PropertyFlag::Enumerable};
+ switch (bindKind) {
+ case BindingKind::Const:
+ case BindingKind::NamedLambdaCallee:
+ // Non-writable.
+ break;
+ default:
+ propFlags.setFlag(PropertyFlag::Writable);
+ break;
+ }
+
+ return SharedPropMap::addPropertyWithKnownSlot(cx, clasp, map, mapLength, id,
+ propFlags, slot, objectFlags);
+}
+
+SharedShape* js::CreateEnvironmentShape(JSContext* cx, BindingIter& bi,
+ const JSClass* cls, uint32_t numSlots,
+ ObjectFlags objectFlags) {
+ Rooted<SharedPropMap*> map(cx);
+ uint32_t mapLength = 0;
+
+ RootedId id(cx);
+ for (; bi; bi++) {
+ BindingLocation loc = bi.location();
+ if (loc.kind() == BindingLocation::Kind::Environment) {
+ JSAtom* name = bi.name();
+ MOZ_ASSERT(AtomIsMarked(cx->zone(), name));
+ id = NameToId(name->asPropertyName());
+ if (!AddToEnvironmentMap(cx, cls, id, bi.kind(), loc.slot(), &map,
+ &mapLength, &objectFlags)) {
+ return nullptr;
+ }
+ }
+ }
+
+ uint32_t numFixed = gc::GetGCKindSlots(gc::GetGCObjectKind(numSlots));
+ return SharedShape::getInitialOrPropMapShape(cx, cls, cx->realm(),
+ TaggedProto(nullptr), numFixed,
+ map, mapLength, objectFlags);
+}
+
+template <class DataT>
+inline size_t SizeOfAllocatedData(DataT* data) {
+ return SizeOfScopeData<DataT>(data->length);
+}
+
+template <typename ConcreteScope>
+static void MarkParserScopeData(typename ConcreteScope::ParserData* data,
+ frontend::CompilationState& compilationState) {
+ auto names = GetScopeDataTrailingNames(data);
+ for (auto& binding : names) {
+ auto index = binding.name();
+ if (!index) {
+ continue;
+ }
+ compilationState.parserAtoms.markUsedByStencil(
+ index, frontend::ParserAtom::Atomize::Yes);
+ }
+}
+
+template <typename ConcreteScope, typename EnvironmentT>
+static void PrepareScopeData(ParserBindingIter& bi,
+ typename ConcreteScope::ParserData* data,
+ uint32_t firstFrameSlot,
+ mozilla::Maybe<uint32_t>* envShape) {
+ const JSClass* cls = &EnvironmentT::class_;
+
+ // Iterate through all bindings. This counts the number of environment
+ // slots needed and computes the maximum frame slot.
+ while (bi) {
+ bi++;
+ }
+ data->slotInfo.nextFrameSlot =
+ bi.canHaveFrameSlots() ? bi.nextFrameSlot() : LOCALNO_LIMIT;
+
+ // Make a new environment shape if any environment slots were used.
+ if (bi.nextEnvironmentSlot() != JSSLOT_FREE(cls)) {
+ envShape->emplace(bi.nextEnvironmentSlot());
+ }
+}
+
+template <typename ConcreteScope>
+static typename ConcreteScope::ParserData* NewEmptyParserScopeData(
+ FrontendContext* fc, LifoAlloc& alloc, uint32_t length = 0) {
+ using Data = typename ConcreteScope::ParserData;
+
+ size_t dataSize = SizeOfScopeData<Data>(length);
+ void* raw = alloc.alloc(dataSize);
+ if (!raw) {
+ js::ReportOutOfMemory(fc);
+ return nullptr;
+ }
+
+ return new (raw) Data(length);
+}
+
+template <typename ConcreteScope, typename AtomT>
+static UniquePtr<AbstractScopeData<ConcreteScope, AtomT>> NewEmptyScopeData(
+ JSContext* cx, uint32_t length = 0) {
+ using Data = AbstractScopeData<ConcreteScope, AtomT>;
+
+ size_t dataSize = SizeOfScopeData<Data>(length);
+ uint8_t* bytes = cx->pod_malloc<uint8_t>(dataSize);
+ auto data = reinterpret_cast<Data*>(bytes);
+ if (data) {
+ new (data) Data(length);
+ }
+ return UniquePtr<Data>(data);
+}
+
+template <typename ConcreteScope>
+static UniquePtr<typename ConcreteScope::RuntimeData> LiftParserScopeData(
+ JSContext* cx, frontend::CompilationAtomCache& atomCache,
+ BaseParserScopeData* baseData) {
+ using ConcreteData = typename ConcreteScope::RuntimeData;
+
+ auto* data = static_cast<typename ConcreteScope::ParserData*>(baseData);
+
+ // Convert all scope ParserAtoms to rooted JSAtoms.
+ // Rooting is necessary as conversion can gc.
+ JS::RootedVector<JSAtom*> jsatoms(cx);
+ if (!jsatoms.reserve(data->length)) {
+ return nullptr;
+ }
+ auto names = GetScopeDataTrailingNames(data);
+ for (size_t i = 0; i < names.size(); i++) {
+ JSAtom* jsatom = nullptr;
+ if (names[i].name()) {
+ jsatom = atomCache.getExistingAtomAt(cx, names[i].name());
+ MOZ_ASSERT(jsatom);
+ }
+ jsatoms.infallibleAppend(jsatom);
+ }
+
+ // Allocate a new scope-data of the right kind.
+ UniquePtr<ConcreteData> scopeData(
+ NewEmptyScopeData<ConcreteScope, JSAtom>(cx, data->length));
+ if (!scopeData) {
+ return nullptr;
+ }
+
+ // NOTE: There shouldn't be any fallible operation or GC between setting
+ // `length` and filling `trailingNames`.
+ scopeData.get()->length = data->length;
+
+ memcpy(&scopeData.get()->slotInfo, &data->slotInfo,
+ sizeof(typename ConcreteScope::SlotInfo));
+
+ // Initialize new scoped names.
+ auto namesOut = GetScopeDataTrailingNames(scopeData.get());
+ MOZ_ASSERT(data->length == namesOut.size());
+ for (size_t i = 0; i < namesOut.size(); i++) {
+ namesOut[i] = names[i].copyWithNewAtom(jsatoms[i].get());
+ }
+
+ return scopeData;
+}
+
+/* static */
+Scope* Scope::create(JSContext* cx, ScopeKind kind, Handle<Scope*> enclosing,
+ Handle<SharedShape*> envShape) {
+ return cx->newCell<Scope>(kind, enclosing, envShape);
+}
+
+template <typename ConcreteScope>
+/* static */
+ConcreteScope* Scope::create(
+ JSContext* cx, ScopeKind kind, Handle<Scope*> enclosing,
+ Handle<SharedShape*> envShape,
+ MutableHandle<UniquePtr<typename ConcreteScope::RuntimeData>> data) {
+ Scope* scope = create(cx, kind, enclosing, envShape);
+ if (!scope) {
+ return nullptr;
+ }
+
+ // It is an invariant that all Scopes that have data (currently, all
+ // ScopeKinds except With) must have non-null data.
+ MOZ_ASSERT(data);
+ scope->initData<ConcreteScope>(data);
+
+ return &scope->as<ConcreteScope>();
+}
+
+template <typename ConcreteScope>
+inline void Scope::initData(
+ MutableHandle<UniquePtr<typename ConcreteScope::RuntimeData>> data) {
+ MOZ_ASSERT(!rawData());
+
+ AddCellMemory(this, SizeOfAllocatedData(data.get().get()),
+ MemoryUse::ScopeData);
+
+ setHeaderPtr(data.get().release());
+}
+
+void Scope::updateEnvShapeIfRequired(mozilla::Maybe<uint32_t>* envShape,
+ bool needsEnvironment) {
+ if (envShape->isNothing() && needsEnvironment) {
+ uint32_t numSlots = 0;
+ envShape->emplace(numSlots);
+ }
+}
+
+uint32_t Scope::firstFrameSlot() const {
+ switch (kind()) {
+ case ScopeKind::Lexical:
+ case ScopeKind::SimpleCatch:
+ case ScopeKind::Catch:
+ case ScopeKind::FunctionLexical:
+ // For intra-frame scopes, find the enclosing scope's next frame slot.
+ MOZ_ASSERT(is<LexicalScope>());
+ return LexicalScope::nextFrameSlot(enclosing());
+
+ case ScopeKind::NamedLambda:
+ case ScopeKind::StrictNamedLambda:
+ // Named lambda scopes cannot have frame slots.
+ return LOCALNO_LIMIT;
+
+ case ScopeKind::ClassBody:
+ MOZ_ASSERT(is<ClassBodyScope>());
+ return ClassBodyScope::nextFrameSlot(enclosing());
+
+ case ScopeKind::FunctionBodyVar:
+ if (enclosing()->is<FunctionScope>()) {
+ return enclosing()->as<FunctionScope>().nextFrameSlot();
+ }
+ break;
+
+ default:
+ break;
+ }
+ return 0;
+}
+
+uint32_t Scope::chainLength() const {
+ uint32_t length = 0;
+ for (ScopeIter si(const_cast<Scope*>(this)); si; si++) {
+ length++;
+ }
+ return length;
+}
+
+uint32_t Scope::environmentChainLength() const {
+ uint32_t length = 0;
+ for (ScopeIter si(const_cast<Scope*>(this)); si; si++) {
+ if (si.hasSyntacticEnvironment()) {
+ length++;
+ }
+ }
+ return length;
+}
+
+void Scope::finalize(JS::GCContext* gcx) {
+ MOZ_ASSERT(CurrentThreadIsGCFinalizing());
+ applyScopeDataTyped([this, gcx](auto data) {
+ gcx->delete_(this, data, SizeOfAllocatedData(data), MemoryUse::ScopeData);
+ });
+ setHeaderPtr(nullptr);
+}
+
+size_t Scope::sizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf) const {
+ if (rawData()) {
+ return mallocSizeOf(rawData());
+ }
+ return 0;
+}
+
+void Scope::dump() {
+ JSContext* cx = TlsContext.get();
+ if (!cx) {
+ fprintf(stderr, "*** can't get JSContext for current thread\n");
+ return;
+ }
+ for (Rooted<ScopeIter> si(cx, ScopeIter(this)); si; si++) {
+ fprintf(stderr, "- %s [%p]\n", ScopeKindString(si.kind()), si.scope());
+ DumpBindings(cx, si.scope());
+ fprintf(stderr, "\n");
+ }
+ fprintf(stderr, "\n");
+}
+
+#if defined(DEBUG) || defined(JS_JITSPEW)
+
+/* static */
+bool Scope::dumpForDisassemble(JSContext* cx, JS::Handle<Scope*> scope,
+ GenericPrinter& out, const char* indent) {
+ out.put(ScopeKindString(scope->kind()));
+ out.put(" {");
+
+ size_t i = 0;
+ for (Rooted<BindingIter> bi(cx, BindingIter(scope)); bi; bi++, i++) {
+ if (i == 0) {
+ out.put("\n");
+ }
+ UniqueChars bytes = AtomToPrintableString(cx, bi.name());
+ if (!bytes) {
+ return false;
+ }
+ out.put(indent);
+ out.printf(" %2zu: %s %s ", i, BindingKindString(bi.kind()), bytes.get());
+ switch (bi.location().kind()) {
+ case BindingLocation::Kind::Global:
+ if (bi.isTopLevelFunction()) {
+ out.put("(global function)\n");
+ } else {
+ out.put("(global)\n");
+ }
+ break;
+ case BindingLocation::Kind::Argument:
+ out.printf("(arg slot %u)\n", bi.location().argumentSlot());
+ break;
+ case BindingLocation::Kind::Frame:
+ out.printf("(frame slot %u)\n", bi.location().slot());
+ break;
+ case BindingLocation::Kind::Environment:
+ out.printf("(env slot %u)\n", bi.location().slot());
+ break;
+ case BindingLocation::Kind::NamedLambdaCallee:
+ out.put("(named lambda callee)\n");
+ break;
+ case BindingLocation::Kind::Import:
+ out.put("(import)\n");
+ break;
+ }
+ }
+ if (i > 0) {
+ out.put(indent);
+ }
+ out.put("}");
+
+ ScopeIter si(scope);
+ si++;
+ for (; si; si++) {
+ out.put(" -> ");
+ out.put(ScopeKindString(si.kind()));
+ }
+ return true;
+}
+
+#endif /* defined(DEBUG) || defined(JS_JITSPEW) */
+
+static uint32_t NextFrameSlot(Scope* scope) {
+ for (ScopeIter si(scope); si; si++) {
+ switch (si.kind()) {
+ case ScopeKind::With:
+ continue;
+
+ case ScopeKind::Function:
+ return si.scope()->as<FunctionScope>().nextFrameSlot();
+
+ case ScopeKind::FunctionBodyVar:
+ return si.scope()->as<VarScope>().nextFrameSlot();
+
+ case ScopeKind::Lexical:
+ case ScopeKind::SimpleCatch:
+ case ScopeKind::Catch:
+ case ScopeKind::FunctionLexical:
+ return si.scope()->as<LexicalScope>().nextFrameSlot();
+
+ case ScopeKind::ClassBody:
+ return si.scope()->as<ClassBodyScope>().nextFrameSlot();
+
+ case ScopeKind::NamedLambda:
+ case ScopeKind::StrictNamedLambda:
+ // Named lambda scopes cannot have frame slots.
+ return 0;
+
+ case ScopeKind::Eval:
+ case ScopeKind::StrictEval:
+ return si.scope()->as<EvalScope>().nextFrameSlot();
+
+ case ScopeKind::Global:
+ case ScopeKind::NonSyntactic:
+ return 0;
+
+ case ScopeKind::Module:
+ return si.scope()->as<ModuleScope>().nextFrameSlot();
+
+ case ScopeKind::WasmInstance:
+ case ScopeKind::WasmFunction:
+ // Invalid; MOZ_CRASH below.
+ break;
+ }
+ }
+ MOZ_CRASH("Not an enclosing intra-frame Scope");
+}
+
+/* static */
+uint32_t LexicalScope::nextFrameSlot(Scope* scope) {
+ return NextFrameSlot(scope);
+}
+
+/* static */
+uint32_t ClassBodyScope::nextFrameSlot(Scope* scope) {
+ return NextFrameSlot(scope);
+}
+
+/* static */
+void LexicalScope::prepareForScopeCreation(ScopeKind kind,
+ uint32_t firstFrameSlot,
+ LexicalScope::ParserData* data,
+ mozilla::Maybe<uint32_t>* envShape) {
+ bool isNamedLambda =
+ kind == ScopeKind::NamedLambda || kind == ScopeKind::StrictNamedLambda;
+
+ MOZ_ASSERT_IF(isNamedLambda, firstFrameSlot == LOCALNO_LIMIT);
+
+ ParserBindingIter bi(*data, firstFrameSlot, isNamedLambda);
+ PrepareScopeData<LexicalScope, BlockLexicalEnvironmentObject>(
+ bi, data, firstFrameSlot, envShape);
+}
+
+/* static */
+SharedShape* LexicalScope::getEmptyExtensibleEnvironmentShape(JSContext* cx) {
+ const JSClass* cls = &LexicalEnvironmentObject::class_;
+ return EmptyEnvironmentShape(cx, cls, JSSLOT_FREE(cls), ObjectFlags());
+}
+
+/* static */
+void ClassBodyScope::prepareForScopeCreation(
+ ScopeKind kind, uint32_t firstFrameSlot, ClassBodyScope::ParserData* data,
+ mozilla::Maybe<uint32_t>* envShape) {
+ MOZ_ASSERT(kind == ScopeKind::ClassBody);
+
+ ParserBindingIter bi(*data, firstFrameSlot);
+ PrepareScopeData<ClassBodyScope, BlockLexicalEnvironmentObject>(
+ bi, data, firstFrameSlot, envShape);
+}
+
+/* static */
+void FunctionScope::prepareForScopeCreation(
+ FunctionScope::ParserData* data, bool hasParameterExprs,
+ bool needsEnvironment, mozilla::Maybe<uint32_t>* envShape) {
+ uint32_t firstFrameSlot = 0;
+ ParserBindingIter bi(*data, hasParameterExprs);
+ PrepareScopeData<FunctionScope, CallObject>(bi, data, firstFrameSlot,
+ envShape);
+
+ if (hasParameterExprs) {
+ data->slotInfo.setHasParameterExprs();
+ }
+
+ // An environment may be needed regardless of existence of any closed over
+ // bindings:
+ // - Extensible scopes (i.e., due to direct eval)
+ // - Needing a home object
+ // - Being a derived class constructor
+ // - Being a generator or async function
+ // Also see |FunctionBox::needsExtraBodyVarEnvironmentRegardlessOfBindings()|.
+ updateEnvShapeIfRequired(envShape, needsEnvironment);
+}
+
+JSScript* FunctionScope::script() const {
+ return canonicalFunction()->nonLazyScript();
+}
+
+/* static */
+bool FunctionScope::isSpecialName(frontend::TaggedParserAtomIndex name) {
+ return name == frontend::TaggedParserAtomIndex::WellKnown::arguments() ||
+ name == frontend::TaggedParserAtomIndex::WellKnown::dot_this_() ||
+ name == frontend::TaggedParserAtomIndex::WellKnown::dot_newTarget_() ||
+ name == frontend::TaggedParserAtomIndex::WellKnown::dot_generator_();
+}
+
+/* static */
+void VarScope::prepareForScopeCreation(ScopeKind kind,
+ VarScope::ParserData* data,
+ uint32_t firstFrameSlot,
+ bool needsEnvironment,
+ mozilla::Maybe<uint32_t>* envShape) {
+ ParserBindingIter bi(*data, firstFrameSlot);
+ PrepareScopeData<VarScope, VarEnvironmentObject>(bi, data, firstFrameSlot,
+ envShape);
+
+ // An environment may be needed regardless of existence of any closed over
+ // bindings:
+ // - Extensible scopes (i.e., due to direct eval)
+ // - Being a generator
+ updateEnvShapeIfRequired(envShape, needsEnvironment);
+}
+
+GlobalScope* GlobalScope::createEmpty(JSContext* cx, ScopeKind kind) {
+ Rooted<UniquePtr<RuntimeData>> data(
+ cx, NewEmptyScopeData<GlobalScope, JSAtom>(cx));
+ if (!data) {
+ return nullptr;
+ }
+
+ return createWithData(cx, kind, &data);
+}
+
+/* static */
+GlobalScope* GlobalScope::createWithData(
+ JSContext* cx, ScopeKind kind, MutableHandle<UniquePtr<RuntimeData>> data) {
+ MOZ_ASSERT(data);
+
+ // The global scope has no environment shape. Its environment is the
+ // global lexical scope and the global object or non-syntactic objects
+ // created by embedding, all of which are not only extensible but may
+ // have names on them deleted.
+ return Scope::create<GlobalScope>(cx, kind, nullptr, nullptr, data);
+}
+
+/* static */
+WithScope* WithScope::create(JSContext* cx, Handle<Scope*> enclosing) {
+ Scope* scope = Scope::create(cx, ScopeKind::With, enclosing, nullptr);
+ return static_cast<WithScope*>(scope);
+}
+
+/* static */
+void EvalScope::prepareForScopeCreation(ScopeKind scopeKind,
+ EvalScope::ParserData* data,
+ mozilla::Maybe<uint32_t>* envShape) {
+ if (scopeKind == ScopeKind::StrictEval) {
+ uint32_t firstFrameSlot = 0;
+ ParserBindingIter bi(*data, true);
+ PrepareScopeData<EvalScope, VarEnvironmentObject>(bi, data, firstFrameSlot,
+ envShape);
+ }
+}
+
+/* static */
+Scope* EvalScope::nearestVarScopeForDirectEval(Scope* scope) {
+ for (ScopeIter si(scope); si; si++) {
+ switch (si.kind()) {
+ case ScopeKind::Function:
+ case ScopeKind::FunctionBodyVar:
+ case ScopeKind::Global:
+ case ScopeKind::NonSyntactic:
+ return scope;
+ default:
+ break;
+ }
+ }
+ return nullptr;
+}
+
+ModuleScope::RuntimeData::RuntimeData(size_t length) {
+ PoisonNames(this, length);
+}
+
+/* static */
+void ModuleScope::prepareForScopeCreation(ModuleScope::ParserData* data,
+ mozilla::Maybe<uint32_t>* envShape) {
+ uint32_t firstFrameSlot = 0;
+ ParserBindingIter bi(*data);
+ PrepareScopeData<ModuleScope, ModuleEnvironmentObject>(
+ bi, data, firstFrameSlot, envShape);
+
+ // Modules always need an environment object for now.
+ bool needsEnvironment = true;
+ updateEnvShapeIfRequired(envShape, needsEnvironment);
+}
+
+template <size_t ArrayLength>
+static JSAtom* GenerateWasmName(JSContext* cx,
+ const char (&prefix)[ArrayLength],
+ uint32_t index) {
+ StringBuffer sb(cx);
+ if (!sb.append(prefix)) {
+ return nullptr;
+ }
+ if (!NumberValueToStringBuffer(NumberValue(index), sb)) {
+ return nullptr;
+ }
+
+ return sb.finishAtom();
+}
+
+static void InitializeTrailingName(AbstractBindingName<JSAtom>* trailingNames,
+ size_t i, JSAtom* name) {
+ void* trailingName = &trailingNames[i];
+ new (trailingName) BindingName(name, false);
+}
+
+template <class DataT>
+static void InitializeNextTrailingName(const Rooted<UniquePtr<DataT>>& data,
+ JSAtom* name) {
+ InitializeTrailingName(GetScopeDataTrailingNamesPointer(data.get().get()),
+ data->length, name);
+ data->length++;
+}
+
+WasmInstanceScope::RuntimeData::RuntimeData(size_t length) {
+ PoisonNames(this, length);
+}
+
+/* static */
+WasmInstanceScope* WasmInstanceScope::create(JSContext* cx,
+ WasmInstanceObject* instance) {
+ size_t namesCount = 0;
+
+ size_t memoriesStart = namesCount;
+ size_t memoriesCount = instance->instance().metadata().memories.length();
+ namesCount += memoriesCount;
+
+ size_t globalsStart = namesCount;
+ size_t globalsCount = instance->instance().metadata().globals.length();
+ namesCount += globalsCount;
+
+ Rooted<UniquePtr<RuntimeData>> data(
+ cx, NewEmptyScopeData<WasmInstanceScope, JSAtom>(cx, namesCount));
+ if (!data) {
+ return nullptr;
+ }
+
+ Rooted<WasmInstanceObject*> rootedInstance(cx, instance);
+ for (size_t i = 0; i < memoriesCount; i++) {
+ JSAtom* wasmName = GenerateWasmName(cx, "memory", i);
+ if (!wasmName) {
+ return nullptr;
+ }
+
+ InitializeNextTrailingName(data, wasmName);
+ }
+
+ for (size_t i = 0; i < globalsCount; i++) {
+ JSAtom* wasmName = GenerateWasmName(cx, "global", i);
+ if (!wasmName) {
+ return nullptr;
+ }
+
+ InitializeNextTrailingName(data, wasmName);
+ }
+
+ MOZ_ASSERT(data->length == namesCount);
+
+ data->instance.init(rootedInstance);
+ data->slotInfo.memoriesStart = memoriesStart;
+ data->slotInfo.globalsStart = globalsStart;
+
+ Rooted<Scope*> enclosing(cx, &cx->global()->emptyGlobalScope());
+ return Scope::create<WasmInstanceScope>(cx, ScopeKind::WasmInstance,
+ enclosing,
+ /* envShape = */ nullptr, &data);
+}
+
+/* static */
+WasmFunctionScope* WasmFunctionScope::create(JSContext* cx,
+ Handle<Scope*> enclosing,
+ uint32_t funcIndex) {
+ MOZ_ASSERT(enclosing->is<WasmInstanceScope>());
+
+ Rooted<WasmFunctionScope*> wasmFunctionScope(cx);
+
+ Rooted<WasmInstanceObject*> instance(
+ cx, enclosing->as<WasmInstanceScope>().instance());
+
+ // TODO pull the local variable names from the wasm function definition.
+ wasm::ValTypeVector locals;
+ size_t argsLength;
+ wasm::StackResults unusedStackResults;
+ if (!instance->instance().debug().debugGetLocalTypes(
+ funcIndex, &locals, &argsLength, &unusedStackResults)) {
+ return nullptr;
+ }
+ uint32_t namesCount = locals.length();
+
+ Rooted<UniquePtr<RuntimeData>> data(
+ cx, NewEmptyScopeData<WasmFunctionScope, JSAtom>(cx, namesCount));
+ if (!data) {
+ return nullptr;
+ }
+
+ for (size_t i = 0; i < namesCount; i++) {
+ JSAtom* wasmName = GenerateWasmName(cx, "var", i);
+ if (!wasmName) {
+ return nullptr;
+ }
+
+ InitializeNextTrailingName(data, wasmName);
+ }
+ MOZ_ASSERT(data->length == namesCount);
+
+ return Scope::create<WasmFunctionScope>(cx, ScopeKind::WasmFunction,
+ enclosing,
+ /* envShape = */ nullptr, &data);
+}
+
+ScopeIter::ScopeIter(JSScript* script) : scope_(script->bodyScope()) {}
+
+bool ScopeIter::hasSyntacticEnvironment() const {
+ return scope()->hasEnvironment() &&
+ scope()->kind() != ScopeKind::NonSyntactic;
+}
+
+AbstractBindingIter<JSAtom>::AbstractBindingIter(ScopeKind kind,
+ BaseScopeData* data,
+ uint32_t firstFrameSlot)
+ : BaseAbstractBindingIter<JSAtom>() {
+ switch (kind) {
+ case ScopeKind::Lexical:
+ case ScopeKind::SimpleCatch:
+ case ScopeKind::Catch:
+ case ScopeKind::FunctionLexical:
+ init(*static_cast<LexicalScope::RuntimeData*>(data), firstFrameSlot, 0);
+ break;
+ case ScopeKind::NamedLambda:
+ case ScopeKind::StrictNamedLambda:
+ init(*static_cast<LexicalScope::RuntimeData*>(data), LOCALNO_LIMIT,
+ IsNamedLambda);
+ break;
+ case ScopeKind::ClassBody:
+ init(*static_cast<ClassBodyScope::RuntimeData*>(data), firstFrameSlot);
+ break;
+ case ScopeKind::With:
+ // With scopes do not have bindings.
+ index_ = length_ = 0;
+ MOZ_ASSERT(done());
+ break;
+ case ScopeKind::Function: {
+ uint8_t flags = IgnoreDestructuredFormalParameters;
+ if (static_cast<FunctionScope::RuntimeData*>(data)
+ ->slotInfo.hasParameterExprs()) {
+ flags |= HasFormalParameterExprs;
+ }
+ init(*static_cast<FunctionScope::RuntimeData*>(data), flags);
+ break;
+ }
+ case ScopeKind::FunctionBodyVar:
+ init(*static_cast<VarScope::RuntimeData*>(data), firstFrameSlot);
+ break;
+ case ScopeKind::Eval:
+ case ScopeKind::StrictEval:
+ init(*static_cast<EvalScope::RuntimeData*>(data),
+ kind == ScopeKind::StrictEval);
+ break;
+ case ScopeKind::Global:
+ case ScopeKind::NonSyntactic:
+ init(*static_cast<GlobalScope::RuntimeData*>(data));
+ break;
+ case ScopeKind::Module:
+ init(*static_cast<ModuleScope::RuntimeData*>(data));
+ break;
+ case ScopeKind::WasmInstance:
+ init(*static_cast<WasmInstanceScope::RuntimeData*>(data));
+ break;
+ case ScopeKind::WasmFunction:
+ init(*static_cast<WasmFunctionScope::RuntimeData*>(data));
+ break;
+ }
+}
+
+AbstractBindingIter<JSAtom>::AbstractBindingIter(Scope* scope)
+ : AbstractBindingIter<JSAtom>(scope->kind(), scope->rawData(),
+ scope->firstFrameSlot()) {}
+
+AbstractBindingIter<JSAtom>::AbstractBindingIter(JSScript* script)
+ : AbstractBindingIter<JSAtom>(script->bodyScope()) {}
+
+AbstractBindingIter<frontend::TaggedParserAtomIndex>::AbstractBindingIter(
+ const frontend::ScopeStencilRef& ref)
+ : Base() {
+ const ScopeStencil& scope = ref.scope();
+ BaseParserScopeData* data = ref.context_.scopeNames[ref.scopeIndex_];
+ switch (scope.kind()) {
+ case ScopeKind::Lexical:
+ case ScopeKind::SimpleCatch:
+ case ScopeKind::Catch:
+ case ScopeKind::FunctionLexical:
+ init(*static_cast<LexicalScope::ParserData*>(data),
+ scope.firstFrameSlot(), 0);
+ break;
+ case ScopeKind::NamedLambda:
+ case ScopeKind::StrictNamedLambda:
+ init(*static_cast<LexicalScope::ParserData*>(data), LOCALNO_LIMIT,
+ IsNamedLambda);
+ break;
+ case ScopeKind::ClassBody:
+ init(*static_cast<ClassBodyScope::ParserData*>(data),
+ scope.firstFrameSlot());
+ break;
+ case ScopeKind::With:
+ // With scopes do not have bindings.
+ index_ = length_ = 0;
+ MOZ_ASSERT(done());
+ break;
+ case ScopeKind::Function: {
+ uint8_t flags = IgnoreDestructuredFormalParameters;
+ if (static_cast<FunctionScope::ParserData*>(data)
+ ->slotInfo.hasParameterExprs()) {
+ flags |= HasFormalParameterExprs;
+ }
+ init(*static_cast<FunctionScope::ParserData*>(data), flags);
+ break;
+ }
+ case ScopeKind::FunctionBodyVar:
+ init(*static_cast<VarScope::ParserData*>(data), scope.firstFrameSlot());
+ break;
+ case ScopeKind::Eval:
+ case ScopeKind::StrictEval:
+ init(*static_cast<EvalScope::ParserData*>(data),
+ scope.kind() == ScopeKind::StrictEval);
+ break;
+ case ScopeKind::Global:
+ case ScopeKind::NonSyntactic:
+ init(*static_cast<GlobalScope::ParserData*>(data));
+ break;
+ case ScopeKind::Module:
+ init(*static_cast<ModuleScope::ParserData*>(data));
+ break;
+ case ScopeKind::WasmInstance:
+ init(*static_cast<WasmInstanceScope::ParserData*>(data));
+ break;
+ case ScopeKind::WasmFunction:
+ init(*static_cast<WasmFunctionScope::ParserData*>(data));
+ break;
+ }
+}
+
+template <typename NameT>
+void BaseAbstractBindingIter<NameT>::init(
+ LexicalScope::AbstractData<NameT>& data, uint32_t firstFrameSlot,
+ uint8_t flags) {
+ auto& slotInfo = data.slotInfo;
+
+ // Named lambda scopes can only have environment slots. If the callee
+ // isn't closed over, it is accessed via JSOp::Callee.
+ if (flags & IsNamedLambda) {
+ // Named lambda binding is weird. Normal BindingKind ordering rules
+ // don't apply.
+ init(/* positionalFormalStart= */ 0,
+ /* nonPositionalFormalStart= */ 0,
+ /* varStart= */ 0,
+ /* letStart= */ 0,
+ /* constStart= */ 0,
+ /* syntheticStart= */ data.length,
+ /* privageMethodStart= */ data.length,
+ /* flags= */ CanHaveEnvironmentSlots | flags,
+ /* firstFrameSlot= */ firstFrameSlot,
+ /* firstEnvironmentSlot= */
+ JSSLOT_FREE(&LexicalEnvironmentObject::class_),
+ /* names= */ GetScopeDataTrailingNames(&data));
+ } else {
+ // imports - [0, 0)
+ // positional formals - [0, 0)
+ // other formals - [0, 0)
+ // vars - [0, 0)
+ // lets - [0, slotInfo.constStart)
+ // consts - [slotInfo.constStart, data.length)
+ // synthetic - [data.length, data.length)
+ // private methods - [data.length, data.length)
+ init(/* positionalFormalStart= */ 0,
+ /* nonPositionalFormalStart= */ 0,
+ /* varStart= */ 0,
+ /* letStart= */ 0,
+ /* constStart= */ slotInfo.constStart,
+ /* syntheticStart= */ data.length,
+ /* privateMethodStart= */ data.length,
+ /* flags= */ CanHaveFrameSlots | CanHaveEnvironmentSlots | flags,
+ /* firstFrameSlot= */ firstFrameSlot,
+ /* firstEnvironmentSlot= */
+ JSSLOT_FREE(&LexicalEnvironmentObject::class_),
+ /* names= */ GetScopeDataTrailingNames(&data));
+ }
+}
+
+template void BaseAbstractBindingIter<JSAtom>::init(
+ LexicalScope::AbstractData<JSAtom>&, uint32_t, uint8_t);
+template void BaseAbstractBindingIter<frontend::TaggedParserAtomIndex>::init(
+ LexicalScope::AbstractData<frontend::TaggedParserAtomIndex>&, uint32_t,
+ uint8_t);
+
+template <typename NameT>
+void BaseAbstractBindingIter<NameT>::init(
+ ClassBodyScope::AbstractData<NameT>& data, uint32_t firstFrameSlot) {
+ auto& slotInfo = data.slotInfo;
+
+ // imports - [0, 0)
+ // positional formals - [0, 0)
+ // other formals - [0, 0)
+ // vars - [0, 0)
+ // lets - [0, 0)
+ // consts - [0, 0)
+ // synthetic - [0, slotInfo.privateMethodStart)
+ // private methods - [slotInfo.privateMethodStart, data.length)
+ init(/* positionalFormalStart= */ 0,
+ /* nonPositionalFormalStart= */ 0,
+ /* varStart= */ 0,
+ /* letStart= */ 0,
+ /* constStart= */ 0,
+ /* syntheticStart= */ 0,
+ /* privateMethodStart= */ slotInfo.privateMethodStart,
+ /* flags= */ CanHaveFrameSlots | CanHaveEnvironmentSlots,
+ /* firstFrameSlot= */ firstFrameSlot,
+ /* firstEnvironmentSlot= */
+ JSSLOT_FREE(&ClassBodyLexicalEnvironmentObject::class_),
+ /* names= */ GetScopeDataTrailingNames(&data));
+}
+
+template void BaseAbstractBindingIter<JSAtom>::init(
+ ClassBodyScope::AbstractData<JSAtom>&, uint32_t);
+template void BaseAbstractBindingIter<frontend::TaggedParserAtomIndex>::init(
+ ClassBodyScope::AbstractData<frontend::TaggedParserAtomIndex>&, uint32_t);
+
+template <typename NameT>
+void BaseAbstractBindingIter<NameT>::init(
+ FunctionScope::AbstractData<NameT>& data, uint8_t flags) {
+ flags = CanHaveFrameSlots | CanHaveEnvironmentSlots | flags;
+ if (!(flags & HasFormalParameterExprs)) {
+ flags |= CanHaveArgumentSlots;
+ }
+
+ auto length = data.length;
+ auto& slotInfo = data.slotInfo;
+
+ // imports - [0, 0)
+ // positional formals - [0, slotInfo.nonPositionalFormalStart)
+ // other formals - [slotInfo.nonPositionalParamStart, slotInfo.varStart)
+ // vars - [slotInfo.varStart, length)
+ // lets - [length, length)
+ // consts - [length, length)
+ // synthetic - [length, length)
+ // private methods - [length, length)
+ init(/* positionalFormalStart= */ 0,
+ /* nonPositionalFormalStart= */ slotInfo.nonPositionalFormalStart,
+ /* varStart= */ slotInfo.varStart,
+ /* letStart= */ length,
+ /* constStart= */ length,
+ /* syntheticStart= */ length,
+ /* privateMethodStart= */ length,
+ /* flags= */ flags,
+ /* firstFrameSlot= */ 0,
+ /* firstEnvironmentSlot= */ JSSLOT_FREE(&CallObject::class_),
+ /* names= */ GetScopeDataTrailingNames(&data));
+}
+template void BaseAbstractBindingIter<JSAtom>::init(
+ FunctionScope::AbstractData<JSAtom>&, uint8_t);
+template void BaseAbstractBindingIter<frontend::TaggedParserAtomIndex>::init(
+ FunctionScope::AbstractData<frontend::TaggedParserAtomIndex>&, uint8_t);
+
+template <typename NameT>
+void BaseAbstractBindingIter<NameT>::init(VarScope::AbstractData<NameT>& data,
+ uint32_t firstFrameSlot) {
+ auto length = data.length;
+
+ // imports - [0, 0)
+ // positional formals - [0, 0)
+ // other formals - [0, 0)
+ // vars - [0, length)
+ // lets - [length, length)
+ // consts - [length, length)
+ // synthetic - [length, length)
+ // private methods - [length, length)
+ init(/* positionalFormalStart= */ 0,
+ /* nonPositionalFormalStart= */ 0,
+ /* varStart= */ 0,
+ /* letStart= */ length,
+ /* constStart= */ length,
+ /* syntheticStart= */ length,
+ /* privateMethodStart= */ length,
+ /* flags= */ CanHaveFrameSlots | CanHaveEnvironmentSlots,
+ /* firstFrameSlot= */ firstFrameSlot,
+ /* firstEnvironmentSlot= */ JSSLOT_FREE(&VarEnvironmentObject::class_),
+ /* names= */ GetScopeDataTrailingNames(&data));
+}
+template void BaseAbstractBindingIter<JSAtom>::init(
+ VarScope::AbstractData<JSAtom>&, uint32_t);
+template void BaseAbstractBindingIter<frontend::TaggedParserAtomIndex>::init(
+ VarScope::AbstractData<frontend::TaggedParserAtomIndex>&, uint32_t);
+
+template <typename NameT>
+void BaseAbstractBindingIter<NameT>::init(
+ GlobalScope::AbstractData<NameT>& data) {
+ auto& slotInfo = data.slotInfo;
+
+ // imports - [0, 0)
+ // positional formals - [0, 0)
+ // other formals - [0, 0)
+ // vars - [0, slotInfo.letStart)
+ // lets - [slotInfo.letStart, slotInfo.constStart)
+ // consts - [slotInfo.constStart, data.length)
+ // synthetic - [data.length, data.length)
+ // private methods - [data.length, data.length)
+ init(/* positionalFormalStart= */ 0,
+ /* nonPositionalFormalStart= */ 0,
+ /* varStart= */ 0,
+ /* letStart= */ slotInfo.letStart,
+ /* constStart= */ slotInfo.constStart,
+ /* syntheticStart= */ data.length,
+ /* privateMethoodStart= */ data.length,
+ /* flags= */ CannotHaveSlots,
+ /* firstFrameSlot= */ UINT32_MAX,
+ /* firstEnvironmentSlot= */ UINT32_MAX,
+ /* names= */ GetScopeDataTrailingNames(&data));
+}
+template void BaseAbstractBindingIter<JSAtom>::init(
+ GlobalScope::AbstractData<JSAtom>&);
+template void BaseAbstractBindingIter<frontend::TaggedParserAtomIndex>::init(
+ GlobalScope::AbstractData<frontend::TaggedParserAtomIndex>&);
+
+template <typename NameT>
+void BaseAbstractBindingIter<NameT>::init(EvalScope::AbstractData<NameT>& data,
+ bool strict) {
+ uint32_t flags;
+ uint32_t firstFrameSlot;
+ uint32_t firstEnvironmentSlot;
+ if (strict) {
+ flags = CanHaveFrameSlots | CanHaveEnvironmentSlots;
+ firstFrameSlot = 0;
+ firstEnvironmentSlot = JSSLOT_FREE(&VarEnvironmentObject::class_);
+ } else {
+ flags = CannotHaveSlots;
+ firstFrameSlot = UINT32_MAX;
+ firstEnvironmentSlot = UINT32_MAX;
+ }
+
+ auto length = data.length;
+
+ // imports - [0, 0)
+ // positional formals - [0, 0)
+ // other formals - [0, 0)
+ // vars - [0, length)
+ // lets - [length, length)
+ // consts - [length, length)
+ // synthetic - [length, length)
+ // private methods - [length, length)
+ init(/* positionalFormalStart= */ 0,
+ /* nonPositionalFormalStart= */ 0,
+ /* varStart= */ 0,
+ /* letStart= */ length,
+ /* constStart= */ length,
+ /* syntheticStart= */ length,
+ /* privateMethodStart= */ length,
+ /* flags= */ flags,
+ /* firstFrameSlot= */ firstFrameSlot,
+ /* firstEnvironmentSlot= */ firstEnvironmentSlot,
+ /* names= */ GetScopeDataTrailingNames(&data));
+}
+template void BaseAbstractBindingIter<JSAtom>::init(
+ EvalScope::AbstractData<JSAtom>&, bool);
+template void BaseAbstractBindingIter<frontend::TaggedParserAtomIndex>::init(
+ EvalScope::AbstractData<frontend::TaggedParserAtomIndex>&, bool);
+
+template <typename NameT>
+void BaseAbstractBindingIter<NameT>::init(
+ ModuleScope::AbstractData<NameT>& data) {
+ auto& slotInfo = data.slotInfo;
+
+ // imports - [0, slotInfo.varStart)
+ // positional formals - [slotInfo.varStart, slotInfo.varStart)
+ // other formals - [slotInfo.varStart, slotInfo.varStart)
+ // vars - [slotInfo.varStart, slotInfo.letStart)
+ // lets - [slotInfo.letStart, slotInfo.constStart)
+ // consts - [slotInfo.constStart, data.length)
+ // synthetic - [data.length, data.length)
+ // private methods - [data.length, data.length)
+ init(
+ /* positionalFormalStart= */ slotInfo.varStart,
+ /* nonPositionalFormalStart= */ slotInfo.varStart,
+ /* varStart= */ slotInfo.varStart,
+ /* letStart= */ slotInfo.letStart,
+ /* constStart= */ slotInfo.constStart,
+ /* syntheticStart= */ data.length,
+ /* privateMethodStart= */ data.length,
+ /* flags= */ CanHaveFrameSlots | CanHaveEnvironmentSlots,
+ /* firstFrameSlot= */ 0,
+ /* firstEnvironmentSlot= */ JSSLOT_FREE(&ModuleEnvironmentObject::class_),
+ /* names= */ GetScopeDataTrailingNames(&data));
+}
+template void BaseAbstractBindingIter<JSAtom>::init(
+ ModuleScope::AbstractData<JSAtom>&);
+template void BaseAbstractBindingIter<frontend::TaggedParserAtomIndex>::init(
+ ModuleScope::AbstractData<frontend::TaggedParserAtomIndex>&);
+
+template <typename NameT>
+void BaseAbstractBindingIter<NameT>::init(
+ WasmInstanceScope::AbstractData<NameT>& data) {
+ auto length = data.length;
+
+ // imports - [0, 0)
+ // positional formals - [0, 0)
+ // other formals - [0, 0)
+ // vars - [0, length)
+ // lets - [length, length)
+ // consts - [length, length)
+ // synthetic - [length, length)
+ // private methods - [length, length)
+ init(/* positionalFormalStart= */ 0,
+ /* nonPositionalFormalStart= */ 0,
+ /* varStart= */ 0,
+ /* letStart= */ length,
+ /* constStart= */ length,
+ /* syntheticStart= */ length,
+ /* privateMethodStart= */ length,
+ /* flags= */ CanHaveFrameSlots | CanHaveEnvironmentSlots,
+ /* firstFrameSlot= */ UINT32_MAX,
+ /* firstEnvironmentSlot= */ UINT32_MAX,
+ /* names= */ GetScopeDataTrailingNames(&data));
+}
+template void BaseAbstractBindingIter<JSAtom>::init(
+ WasmInstanceScope::AbstractData<JSAtom>&);
+template void BaseAbstractBindingIter<frontend::TaggedParserAtomIndex>::init(
+ WasmInstanceScope::AbstractData<frontend::TaggedParserAtomIndex>&);
+
+template <typename NameT>
+void BaseAbstractBindingIter<NameT>::init(
+ WasmFunctionScope::AbstractData<NameT>& data) {
+ auto length = data.length;
+
+ // imports - [0, 0)
+ // positional formals - [0, 0)
+ // other formals - [0, 0)
+ // vars - [0, length)
+ // lets - [length, length)
+ // consts - [length, length)
+ // synthetic - [length, length)
+ // private methods - [length, length)
+ init(/* positionalFormalStart = */ 0,
+ /* nonPositionalFormalStart = */ 0,
+ /* varStart= */ 0,
+ /* letStart= */ length,
+ /* constStart= */ length,
+ /* syntheticStart= */ length,
+ /* privateMethodStart= */ length,
+ /* flags= */ CanHaveFrameSlots | CanHaveEnvironmentSlots,
+ /* firstFrameSlot= */ UINT32_MAX,
+ /* firstEnvironmentSlot= */ UINT32_MAX,
+ /* names= */ GetScopeDataTrailingNames(&data));
+}
+template void BaseAbstractBindingIter<JSAtom>::init(
+ WasmFunctionScope::AbstractData<JSAtom>&);
+template void BaseAbstractBindingIter<frontend::TaggedParserAtomIndex>::init(
+ WasmFunctionScope::AbstractData<frontend::TaggedParserAtomIndex>&);
+
+AbstractPositionalFormalParameterIter<
+ JSAtom>::AbstractPositionalFormalParameterIter(Scope* scope)
+ : Base(scope) {
+ // Reinit with flags = 0, i.e., iterate over all positional parameters.
+ if (scope->is<FunctionScope>()) {
+ init(scope->as<FunctionScope>().data(), /* flags = */ 0);
+ }
+ settle();
+}
+
+AbstractPositionalFormalParameterIter<
+ JSAtom>::AbstractPositionalFormalParameterIter(JSScript* script)
+ : AbstractPositionalFormalParameterIter(script->bodyScope()) {}
+
+void js::DumpBindings(JSContext* cx, Scope* scopeArg) {
+ Rooted<Scope*> scope(cx, scopeArg);
+ for (Rooted<BindingIter> bi(cx, BindingIter(scope)); bi; bi++) {
+ UniqueChars bytes = AtomToPrintableString(cx, bi.name());
+ if (!bytes) {
+ MaybePrintAndClearPendingException(cx);
+ return;
+ }
+ fprintf(stderr, " %s %s ", BindingKindString(bi.kind()), bytes.get());
+ switch (bi.location().kind()) {
+ case BindingLocation::Kind::Global:
+ if (bi.isTopLevelFunction()) {
+ fprintf(stderr, "global function\n");
+ } else {
+ fprintf(stderr, "global\n");
+ }
+ break;
+ case BindingLocation::Kind::Argument:
+ fprintf(stderr, "arg slot %u\n", bi.location().argumentSlot());
+ break;
+ case BindingLocation::Kind::Frame:
+ fprintf(stderr, "frame slot %u\n", bi.location().slot());
+ break;
+ case BindingLocation::Kind::Environment:
+ fprintf(stderr, "env slot %u\n", bi.location().slot());
+ break;
+ case BindingLocation::Kind::NamedLambdaCallee:
+ fprintf(stderr, "named lambda callee\n");
+ break;
+ case BindingLocation::Kind::Import:
+ fprintf(stderr, "import\n");
+ break;
+ }
+ }
+}
+
+static JSAtom* GetFrameSlotNameInScope(Scope* scope, uint32_t slot) {
+ for (BindingIter bi(scope); bi; bi++) {
+ BindingLocation loc = bi.location();
+ if (loc.kind() == BindingLocation::Kind::Frame && loc.slot() == slot) {
+ return bi.name();
+ }
+ }
+ return nullptr;
+}
+
+JSAtom* js::FrameSlotName(JSScript* script, jsbytecode* pc) {
+ MOZ_ASSERT(IsLocalOp(JSOp(*pc)));
+ uint32_t slot = GET_LOCALNO(pc);
+ MOZ_ASSERT(slot < script->nfixed());
+
+ // Look for it in the body scope first.
+ if (JSAtom* name = GetFrameSlotNameInScope(script->bodyScope(), slot)) {
+ return name;
+ }
+
+ // If this is a function script and there is an extra var scope, look for
+ // it there.
+ if (script->functionHasExtraBodyVarScope()) {
+ if (JSAtom* name = GetFrameSlotNameInScope(
+ script->functionExtraBodyVarScope(), slot)) {
+ return name;
+ }
+ }
+ // If not found, look for it in a lexical scope.
+ for (ScopeIter si(script->innermostScope(pc)); si; si++) {
+ if (!si.scope()->is<LexicalScope>() && !si.scope()->is<ClassBodyScope>()) {
+ continue;
+ }
+
+ // Is the slot within bounds of the current lexical scope?
+ if (slot < si.scope()->firstFrameSlot()) {
+ continue;
+ }
+ if (slot >= LexicalScope::nextFrameSlot(si.scope())) {
+ break;
+ }
+
+ // If so, get the name.
+ if (JSAtom* name = GetFrameSlotNameInScope(si.scope(), slot)) {
+ return name;
+ }
+ }
+
+ MOZ_CRASH("Frame slot not found");
+}
+
+JS::ubi::Node::Size JS::ubi::Concrete<Scope>::size(
+ mozilla::MallocSizeOf mallocSizeOf) const {
+ return js::gc::Arena::thingSize(get().asTenured().getAllocKind()) +
+ get().sizeOfExcludingThis(mallocSizeOf);
+}
+
+template <typename... Args>
+/* static */ bool ScopeStencil::appendScopeStencilAndData(
+ FrontendContext* fc, CompilationState& compilationState,
+ BaseParserScopeData* data, ScopeIndex* indexOut, Args&&... args) {
+ *indexOut = ScopeIndex(compilationState.scopeData.length());
+ if (uint32_t(*indexOut) >= TaggedScriptThingIndex::IndexLimit) {
+ ReportAllocationOverflow(fc);
+ return false;
+ }
+
+ if (!compilationState.scopeData.emplaceBack(std::forward<Args>(args)...)) {
+ js::ReportOutOfMemory(fc);
+ return false;
+ }
+ if (!compilationState.scopeNames.append(data)) {
+ compilationState.scopeData.popBack();
+ MOZ_ASSERT(compilationState.scopeData.length() ==
+ compilationState.scopeNames.length());
+
+ js::ReportOutOfMemory(fc);
+ return false;
+ }
+
+ return true;
+}
+
+/* static */
+bool ScopeStencil::createForFunctionScope(
+ FrontendContext* fc, frontend::CompilationState& compilationState,
+ FunctionScope::ParserData* data, bool hasParameterExprs,
+ bool needsEnvironment, ScriptIndex functionIndex, bool isArrow,
+ mozilla::Maybe<ScopeIndex> enclosing, ScopeIndex* index) {
+ auto kind = ScopeKind::Function;
+ using ScopeType = FunctionScope;
+ MOZ_ASSERT(matchScopeKind<ScopeType>(kind));
+
+ if (data) {
+ MarkParserScopeData<ScopeType>(data, compilationState);
+ } else {
+ data = NewEmptyParserScopeData<ScopeType>(fc, compilationState.alloc);
+ if (!data) {
+ return false;
+ }
+ }
+
+ uint32_t firstFrameSlot = 0;
+ mozilla::Maybe<uint32_t> envShape;
+ FunctionScope::prepareForScopeCreation(data, hasParameterExprs,
+ needsEnvironment, &envShape);
+
+ return appendScopeStencilAndData(fc, compilationState, data, index, kind,
+ enclosing, firstFrameSlot, envShape,
+ mozilla::Some(functionIndex), isArrow);
+}
+
+/* static */
+bool ScopeStencil::createForLexicalScope(
+ FrontendContext* fc, frontend::CompilationState& compilationState,
+ ScopeKind kind, LexicalScope::ParserData* data, uint32_t firstFrameSlot,
+ mozilla::Maybe<ScopeIndex> enclosing, ScopeIndex* index) {
+ using ScopeType = LexicalScope;
+ MOZ_ASSERT(matchScopeKind<ScopeType>(kind));
+
+ if (data) {
+ MarkParserScopeData<ScopeType>(data, compilationState);
+ } else {
+ data = NewEmptyParserScopeData<ScopeType>(fc, compilationState.alloc);
+ if (!data) {
+ return false;
+ }
+ }
+
+ mozilla::Maybe<uint32_t> envShape;
+ ScopeType::prepareForScopeCreation(kind, firstFrameSlot, data, &envShape);
+
+ return appendScopeStencilAndData(fc, compilationState, data, index, kind,
+ enclosing, firstFrameSlot, envShape);
+}
+
+/* static */
+bool ScopeStencil::createForClassBodyScope(
+ FrontendContext* fc, frontend::CompilationState& compilationState,
+ ScopeKind kind, ClassBodyScope::ParserData* data, uint32_t firstFrameSlot,
+ mozilla::Maybe<ScopeIndex> enclosing, ScopeIndex* index) {
+ using ScopeType = ClassBodyScope;
+ MOZ_ASSERT(matchScopeKind<ScopeType>(kind));
+
+ if (data) {
+ MarkParserScopeData<ScopeType>(data, compilationState);
+ } else {
+ data = NewEmptyParserScopeData<ScopeType>(fc, compilationState.alloc);
+ if (!data) {
+ return false;
+ }
+ }
+
+ mozilla::Maybe<uint32_t> envShape;
+ ScopeType::prepareForScopeCreation(kind, firstFrameSlot, data, &envShape);
+
+ return appendScopeStencilAndData(fc, compilationState, data, index, kind,
+ enclosing, firstFrameSlot, envShape);
+}
+
+bool ScopeStencil::createForVarScope(
+ FrontendContext* fc, frontend::CompilationState& compilationState,
+ ScopeKind kind, VarScope::ParserData* data, uint32_t firstFrameSlot,
+ bool needsEnvironment, mozilla::Maybe<ScopeIndex> enclosing,
+ ScopeIndex* index) {
+ using ScopeType = VarScope;
+ MOZ_ASSERT(matchScopeKind<ScopeType>(kind));
+
+ if (data) {
+ MarkParserScopeData<ScopeType>(data, compilationState);
+ } else {
+ data = NewEmptyParserScopeData<ScopeType>(fc, compilationState.alloc);
+ if (!data) {
+ return false;
+ }
+ }
+
+ mozilla::Maybe<uint32_t> envShape;
+ VarScope::prepareForScopeCreation(kind, data, firstFrameSlot,
+ needsEnvironment, &envShape);
+
+ return appendScopeStencilAndData(fc, compilationState, data, index, kind,
+ enclosing, firstFrameSlot, envShape);
+}
+
+/* static */
+bool ScopeStencil::createForGlobalScope(
+ FrontendContext* fc, frontend::CompilationState& compilationState,
+ ScopeKind kind, GlobalScope::ParserData* data, ScopeIndex* index) {
+ using ScopeType = GlobalScope;
+ MOZ_ASSERT(matchScopeKind<ScopeType>(kind));
+
+ if (data) {
+ MarkParserScopeData<ScopeType>(data, compilationState);
+ } else {
+ data = NewEmptyParserScopeData<ScopeType>(fc, compilationState.alloc);
+ if (!data) {
+ return false;
+ }
+ }
+
+ // The global scope has no environment shape. Its environment is the
+ // global lexical scope and the global object or non-syntactic objects
+ // created by embedding, all of which are not only extensible but may
+ // have names on them deleted.
+ uint32_t firstFrameSlot = 0;
+ mozilla::Maybe<uint32_t> envShape;
+
+ mozilla::Maybe<ScopeIndex> enclosing;
+
+ return appendScopeStencilAndData(fc, compilationState, data, index, kind,
+ enclosing, firstFrameSlot, envShape);
+}
+
+/* static */
+bool ScopeStencil::createForEvalScope(
+ FrontendContext* fc, frontend::CompilationState& compilationState,
+ ScopeKind kind, EvalScope::ParserData* data,
+ mozilla::Maybe<ScopeIndex> enclosing, ScopeIndex* index) {
+ using ScopeType = EvalScope;
+ MOZ_ASSERT(matchScopeKind<ScopeType>(kind));
+
+ if (data) {
+ MarkParserScopeData<ScopeType>(data, compilationState);
+ } else {
+ data = NewEmptyParserScopeData<ScopeType>(fc, compilationState.alloc);
+ if (!data) {
+ return false;
+ }
+ }
+
+ uint32_t firstFrameSlot = 0;
+ mozilla::Maybe<uint32_t> envShape;
+ EvalScope::prepareForScopeCreation(kind, data, &envShape);
+
+ return appendScopeStencilAndData(fc, compilationState, data, index, kind,
+ enclosing, firstFrameSlot, envShape);
+}
+
+/* static */
+bool ScopeStencil::createForModuleScope(
+ FrontendContext* fc, frontend::CompilationState& compilationState,
+ ModuleScope::ParserData* data, mozilla::Maybe<ScopeIndex> enclosing,
+ ScopeIndex* index) {
+ auto kind = ScopeKind::Module;
+ using ScopeType = ModuleScope;
+ MOZ_ASSERT(matchScopeKind<ScopeType>(kind));
+
+ if (data) {
+ MarkParserScopeData<ScopeType>(data, compilationState);
+ } else {
+ data = NewEmptyParserScopeData<ScopeType>(fc, compilationState.alloc);
+ if (!data) {
+ return false;
+ }
+ }
+
+ MOZ_ASSERT(enclosing.isNothing());
+
+ // The data that's passed in is from the frontend and is LifoAlloc'd.
+ // Copy it now that we're creating a permanent VM scope.
+ uint32_t firstFrameSlot = 0;
+ mozilla::Maybe<uint32_t> envShape;
+ ModuleScope::prepareForScopeCreation(data, &envShape);
+
+ return appendScopeStencilAndData(fc, compilationState, data, index, kind,
+ enclosing, firstFrameSlot, envShape);
+}
+
+template <typename SpecificEnvironmentT>
+bool ScopeStencil::createSpecificShape(
+ JSContext* cx, ScopeKind kind, BaseScopeData* scopeData,
+ MutableHandle<SharedShape*> shape) const {
+ const JSClass* cls = &SpecificEnvironmentT::class_;
+ constexpr ObjectFlags objectFlags = SpecificEnvironmentT::OBJECT_FLAGS;
+
+ if (hasEnvironmentShape()) {
+ if (numEnvironmentSlots() > 0) {
+ BindingIter bi(kind, scopeData, firstFrameSlot_);
+ shape.set(CreateEnvironmentShape(cx, bi, cls, numEnvironmentSlots(),
+ objectFlags));
+ return shape;
+ }
+
+ shape.set(EmptyEnvironmentShape(cx, cls, JSSLOT_FREE(cls), objectFlags));
+ return shape;
+ }
+
+ return true;
+}
+
+/* static */
+bool ScopeStencil::createForWithScope(FrontendContext* fc,
+ CompilationState& compilationState,
+ mozilla::Maybe<ScopeIndex> enclosing,
+ ScopeIndex* index) {
+ auto kind = ScopeKind::With;
+ MOZ_ASSERT(matchScopeKind<WithScope>(kind));
+
+ uint32_t firstFrameSlot = 0;
+ mozilla::Maybe<uint32_t> envShape;
+
+ return appendScopeStencilAndData(fc, compilationState, nullptr, index, kind,
+ enclosing, firstFrameSlot, envShape);
+}
+
+template <typename SpecificScopeT>
+UniquePtr<typename SpecificScopeT::RuntimeData>
+ScopeStencil::createSpecificScopeData(JSContext* cx,
+ CompilationAtomCache& atomCache,
+ BaseParserScopeData* baseData) const {
+ return LiftParserScopeData<SpecificScopeT>(cx, atomCache, baseData);
+}
+
+template <>
+UniquePtr<FunctionScope::RuntimeData>
+ScopeStencil::createSpecificScopeData<FunctionScope>(
+ JSContext* cx, CompilationAtomCache& atomCache,
+ BaseParserScopeData* baseData) const {
+ // Allocate a new vm function-scope.
+ UniquePtr<FunctionScope::RuntimeData> data =
+ LiftParserScopeData<FunctionScope>(cx, atomCache, baseData);
+ if (!data) {
+ return nullptr;
+ }
+
+ return data;
+}
+
+template <>
+UniquePtr<ModuleScope::RuntimeData>
+ScopeStencil::createSpecificScopeData<ModuleScope>(
+ JSContext* cx, CompilationAtomCache& atomCache,
+ BaseParserScopeData* baseData) const {
+ // Allocate a new vm module-scope.
+ UniquePtr<ModuleScope::RuntimeData> data =
+ LiftParserScopeData<ModuleScope>(cx, atomCache, baseData);
+ if (!data) {
+ return nullptr;
+ }
+
+ return data;
+}
+
+// WithScope does not use binding data.
+template <>
+Scope* ScopeStencil::createSpecificScope<WithScope, std::nullptr_t>(
+ JSContext* cx, CompilationAtomCache& atomCache,
+ Handle<Scope*> enclosingScope, BaseParserScopeData* baseData) const {
+ return Scope::create(cx, ScopeKind::With, enclosingScope, nullptr);
+}
+
+// GlobalScope has bindings but no environment shape.
+template <>
+Scope* ScopeStencil::createSpecificScope<GlobalScope, std::nullptr_t>(
+ JSContext* cx, CompilationAtomCache& atomCache,
+ Handle<Scope*> enclosingScope, BaseParserScopeData* baseData) const {
+ Rooted<UniquePtr<GlobalScope::RuntimeData>> rootedData(
+ cx, createSpecificScopeData<GlobalScope>(cx, atomCache, baseData));
+ if (!rootedData) {
+ return nullptr;
+ }
+
+ MOZ_ASSERT(!hasEnclosing());
+ MOZ_ASSERT(!enclosingScope);
+
+ // Because we already baked the data here, we needn't do it again.
+ return Scope::create<GlobalScope>(cx, kind(), nullptr, nullptr, &rootedData);
+}
+
+template <typename SpecificScopeT, typename SpecificEnvironmentT>
+Scope* ScopeStencil::createSpecificScope(JSContext* cx,
+ CompilationAtomCache& atomCache,
+ Handle<Scope*> enclosingScope,
+ BaseParserScopeData* baseData) const {
+ Rooted<UniquePtr<typename SpecificScopeT::RuntimeData>> rootedData(
+ cx, createSpecificScopeData<SpecificScopeT>(cx, atomCache, baseData));
+ if (!rootedData) {
+ return nullptr;
+ }
+
+ Rooted<SharedShape*> shape(cx);
+ if (!createSpecificShape<SpecificEnvironmentT>(
+ cx, kind(), rootedData.get().get(), &shape)) {
+ return nullptr;
+ }
+
+ // Because we already baked the data here, we needn't do it again.
+ return Scope::create<SpecificScopeT>(cx, kind(), enclosingScope, shape,
+ &rootedData);
+}
+
+template Scope* ScopeStencil::createSpecificScope<FunctionScope, CallObject>(
+ JSContext* cx, CompilationAtomCache& atomCache,
+ Handle<Scope*> enclosingScope, BaseParserScopeData* baseData) const;
+template Scope*
+ScopeStencil::createSpecificScope<LexicalScope, BlockLexicalEnvironmentObject>(
+ JSContext* cx, CompilationAtomCache& atomCache,
+ Handle<Scope*> enclosingScope, BaseParserScopeData* baseData) const;
+template Scope* ScopeStencil::createSpecificScope<
+ ClassBodyScope, BlockLexicalEnvironmentObject>(
+ JSContext* cx, CompilationAtomCache& atomCache,
+ Handle<Scope*> enclosingScope, BaseParserScopeData* baseData) const;
+template Scope*
+ScopeStencil::createSpecificScope<EvalScope, VarEnvironmentObject>(
+ JSContext* cx, CompilationAtomCache& atomCache,
+ Handle<Scope*> enclosingScope, BaseParserScopeData* baseData) const;
+template Scope*
+ScopeStencil::createSpecificScope<VarScope, VarEnvironmentObject>(
+ JSContext* cx, CompilationAtomCache& atomCache,
+ Handle<Scope*> enclosingScope, BaseParserScopeData* baseData) const;
+template Scope*
+ScopeStencil::createSpecificScope<ModuleScope, ModuleEnvironmentObject>(
+ JSContext* cx, CompilationAtomCache& atomCache,
+ Handle<Scope*> enclosingScope, BaseParserScopeData* baseData) const;