Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-10-08 02:14:43 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Bug 1649968 - Part 1: Create CompilationInput, CompilationState, CompilationStencil, and CompilationGCOutput. r=tcampbell

Browse Source 
This patch just adds 4 structs to categolize CompilationInfo fields.
Later patches will simplify methods and consumers.

Depends on D88204

Differential Revision: https://phabricator.services.mozilla.com/D88205
This commit is contained in:
Tooru Fujisawa 2020-08-27 22:11:16 +00:00
parent 1f293906ba
commit 20665eb36c
26 changed files with 390 additions and 319 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
js/src/builtin/Eval.cpp
View File

@ -340,8 +340,8 @@ static bool EvalKernel(JSContext* cx, HandleValue v, EvalType evalType,
uint32_t len = srcBuf.length();
SourceExtent extent = SourceExtent::makeGlobalExtent(len);
frontend::EvalSharedContext evalsc(cx, compilationInfo,
compilationInfo.directives, extent);
frontend::EvalSharedContext evalsc(
cx, compilationInfo, compilationInfo.state.directives, extent);
RootedScript compiled(
cx, frontend::CompileEvalScript(compilationInfo, evalsc, srcBuf));
if (!compiled) {
@ -449,8 +449,8 @@ bool js::DirectEvalStringFromIon(JSContext* cx, HandleObject env,
uint32_t len = srcBuf.length();
SourceExtent extent = SourceExtent::makeGlobalExtent(len);
frontend::EvalSharedContext evalsc(cx, compilationInfo,
compilationInfo.directives, extent);
frontend::EvalSharedContext evalsc(
cx, compilationInfo, compilationInfo.state.directives, extent);
JSScript* compiled =
frontend::CompileEvalScript(compilationInfo, evalsc, srcBuf);
if (!compiled) {

7
js/src/debugger/Frame.cpp
View File

@ -962,8 +962,8 @@ static bool EvaluateInEnv(JSContext* cx, Handle<Env*> env,
}
compilationInfo.setEnclosingScope(scope);
frontend::EvalSharedContext evalsc(cx, compilationInfo,
compilationInfo.directives, extent);
frontend::EvalSharedContext evalsc(
cx, compilationInfo, compilationInfo.state.directives, extent);
script = frontend::CompileEvalScript(compilationInfo, evalsc, srcBuf);
if (!script) {
return false;
@ -984,7 +984,8 @@ static bool EvaluateInEnv(JSContext* cx, Handle<Env*> env,
scopeKind == ScopeKind::NonSyntactic);
frontend::GlobalSharedContext globalsc(cx, scopeKind, compilationInfo,
compilationInfo.directives, extent);
compilationInfo.state.directives,
extent);
script = frontend::CompileGlobalScript(compilationInfo, globalsc, srcBuf);
if (!script) {
return false;

4
js/src/frontend/AbstractScopePtr.cpp
View File

@ -18,7 +18,7 @@ using namespace js::frontend;
ScopeStencil& AbstractScopePtr::scopeData() const {
const Deferred& data = scope_.as<Deferred>();
return data.compilationInfo.scopeData[data.index.index];
return data.compilationInfo.stencil.scopeData[data.index.index];
}
CompilationInfo& AbstractScopePtr::compilationInfo() const {
@ -29,7 +29,7 @@ CompilationInfo& AbstractScopePtr::compilationInfo() const {
Scope* AbstractScopePtr::existingScope() const {
if (isScopeStencil()) {
const Deferred& data = scope_.as<Deferred>();
Scope* result = data.compilationInfo.scopes[data.index.index];
Scope* result = data.compilationInfo.gcOutput.scopes[data.index.index];
MOZ_ASSERT(result, "Scope must already exist to use this method");
return result;
}

105
js/src/frontend/BytecodeCompiler.cpp
View File

@ -187,11 +187,11 @@ static JSScript* CreateGlobalScript(CompilationInfo& compilationInfo,
}
tellDebuggerAboutCompiledScript(
compilationInfo.cx, compilationInfo.options.hideScriptFromDebugger,
compilationInfo.script);
compilationInfo.cx, compilationInfo.input.options.hideScriptFromDebugger,
compilationInfo.gcOutput.script);
assertException.reset();
return compilationInfo.script;
return compilationInfo.gcOutput.script;
}
JSScript* frontend::CompileGlobalScript(CompilationInfo& compilationInfo,
@ -248,11 +248,11 @@ static JSScript* CreateEvalScript(CompilationInfo& compilationInfo,
}
tellDebuggerAboutCompiledScript(
compilationInfo.cx, compilationInfo.options.hideScriptFromDebugger,
compilationInfo.script);
compilationInfo.cx, compilationInfo.input.options.hideScriptFromDebugger,
compilationInfo.gcOutput.script);
assertException.reset();
return compilationInfo.script;
return compilationInfo.gcOutput.script;
}
JSScript* frontend::CompileEvalScript(CompilationInfo& compilationInfo,
@ -376,9 +376,9 @@ AutoFrontendTraceLog::AutoFrontendTraceLog(JSContext* cx,
#endif
static bool CanLazilyParse(const CompilationInfo& compilationInfo) {
return !compilationInfo.options.discardSource &&
!compilationInfo.options.sourceIsLazy &&
!compilationInfo.options.forceFullParse();
return !compilationInfo.input.options.discardSource &&
!compilationInfo.input.options.sourceIsLazy &&
!compilationInfo.input.options.forceFullParse();
}
template <typename Unit>
@ -389,7 +389,7 @@ bool frontend::SourceAwareCompiler<Unit>::createSourceAndParser(
}
if (CanLazilyParse(compilationInfo)) {
syntaxParser.emplace(compilationInfo.cx, compilationInfo.options,
syntaxParser.emplace(compilationInfo.cx, compilationInfo.input.options,
sourceBuffer_.units(), sourceBuffer_.length(),
/* foldConstants = */ false, compilationInfo, nullptr,
nullptr);
@ -398,7 +398,7 @@ bool frontend::SourceAwareCompiler<Unit>::createSourceAndParser(
}
}
parser.emplace(compilationInfo.cx, compilationInfo.options,
parser.emplace(compilationInfo.cx, compilationInfo.input.options,
sourceBuffer_.units(), sourceBuffer_.length(),
/* foldConstants = */ true, compilationInfo,
syntaxParser.ptrOr(nullptr), nullptr);
@ -428,7 +428,7 @@ bool frontend::SourceAwareCompiler<Unit>::canHandleParseFailure(
// are present. We reparse in this case to display the error at the correct
// source location. See |Parser::hasValidSimpleStrictParameterNames()|.
return !parser->anyChars.hadError() &&
compilationInfo.directives != newDirectives;
compilationInfo.state.directives != newDirectives;
}
template <typename Unit>
@ -443,9 +443,11 @@ void frontend::SourceAwareCompiler<Unit>::handleParseFailure(
compilationInfo.rewind(startObj);
// Assignment must be monotonic to prevent reparsing iloops
MOZ_ASSERT_IF(compilationInfo.directives.strict(), newDirectives.strict());
MOZ_ASSERT_IF(compilationInfo.directives.asmJS(), newDirectives.asmJS());
compilationInfo.directives = newDirectives;
MOZ_ASSERT_IF(compilationInfo.state.directives.strict(),
newDirectives.strict());
MOZ_ASSERT_IF(compilationInfo.state.directives.asmJS(),
newDirectives.asmJS());
compilationInfo.state.directives = newDirectives;
}
template <typename Unit>
@ -453,15 +455,15 @@ JSScript* frontend::ScriptCompiler<Unit>::compileScript(
CompilationInfo& compilationInfo, SharedContext* sc) {
assertSourceParserAndScriptCreated(compilationInfo);
TokenStreamPosition startPosition(compilationInfo.keepAtoms,
TokenStreamPosition startPosition(compilationInfo.state.keepAtoms,
parser->tokenStream);
JSContext* cx = compilationInfo.cx;
// Emplace the topLevel stencil
MOZ_ASSERT(compilationInfo.scriptData.length() ==
MOZ_ASSERT(compilationInfo.stencil.scriptData.length() ==
CompilationInfo::TopLevelIndex);
if (!compilationInfo.scriptData.emplaceBack(cx)) {
if (!compilationInfo.stencil.scriptData.emplaceBack(cx)) {
return nullptr;
}
@ -481,8 +483,8 @@ JSScript* frontend::ScriptCompiler<Unit>::compileScript(
// encountered:
// - "use strict" doesn't require any special error reporting for scripts.
// - "use asm" directives don't have an effect in global/eval contexts.
MOZ_ASSERT(
!canHandleParseFailure(compilationInfo, compilationInfo.directives));
MOZ_ASSERT(!canHandleParseFailure(compilationInfo,
compilationInfo.state.directives));
return nullptr;
}
@ -504,7 +506,7 @@ JSScript* frontend::ScriptCompiler<Unit>::compileScript(
return nullptr;
}
MOZ_ASSERT(compilationInfo.script);
MOZ_ASSERT(compilationInfo.gcOutput.script);
}
// Enqueue an off-thread source compression task after finishing parsing.
@ -516,30 +518,33 @@ JSScript* frontend::ScriptCompiler<Unit>::compileScript(
MOZ_ASSERT_IF(!cx->isHelperThreadContext(), !cx->isExceptionPending());
return compilationInfo.script;
return compilationInfo.gcOutput.script;
}
template <typename Unit>
ModuleObject* frontend::ModuleCompiler<Unit>::compile(
CompilationInfo& compilationInfo) {
if (!createSourceAndParser(compilationInfo.allocScope, compilationInfo)) {
if (!createSourceAndParser(compilationInfo.state.allocScope,
compilationInfo)) {
return nullptr;
}
JSContext* cx = compilationInfo.cx;
// Emplace the topLevel stencil
MOZ_ASSERT(compilationInfo.scriptData.length() ==
MOZ_ASSERT(compilationInfo.stencil.scriptData.length() ==
CompilationInfo::TopLevelIndex);
if (!compilationInfo.scriptData.emplaceBack(cx)) {
if (!compilationInfo.stencil.scriptData.emplaceBack(cx)) {
return nullptr;
}
ModuleBuilder builder(cx, parser.ptr());
StencilModuleMetadata& moduleMetadata = compilationInfo.moduleMetadata;
StencilModuleMetadata& moduleMetadata =
compilationInfo.stencil.moduleMetadata;
uint32_t len = this->sourceBuffer_.length();
SourceExtent extent = SourceExtent::makeGlobalExtent(
len, compilationInfo.options.lineno, compilationInfo.options.column);
SourceExtent extent =
SourceExtent::makeGlobalExtent(len, compilationInfo.input.options.lineno,
compilationInfo.input.options.column);
ModuleSharedContext modulesc(cx, compilationInfo, builder, extent);
ParseNode* pn = parser->moduleBody(&modulesc);
@ -562,8 +567,8 @@ ModuleObject* frontend::ModuleCompiler<Unit>::compile(
return nullptr;
}
MOZ_ASSERT(compilationInfo.script);
MOZ_ASSERT(compilationInfo.module);
MOZ_ASSERT(compilationInfo.gcOutput.script);
MOZ_ASSERT(compilationInfo.gcOutput.module);
// Enqueue an off-thread source compression task after finishing parsing.
if (!cx->isHelperThreadContext()) {
@ -573,7 +578,7 @@ ModuleObject* frontend::ModuleCompiler<Unit>::compile(
}
MOZ_ASSERT_IF(!cx->isHelperThreadContext(), !cx->isExceptionPending());
return compilationInfo.module;
return compilationInfo.gcOutput.module;
}
// Parse a standalone JS function, which might appear as the value of an
@ -586,7 +591,7 @@ FunctionNode* frontend::StandaloneFunctionCompiler<Unit>::parse(
const Maybe<uint32_t>& parameterListEnd) {
assertSourceAndParserCreated(compilationInfo);
TokenStreamPosition startPosition(compilationInfo.keepAtoms,
TokenStreamPosition startPosition(compilationInfo.state.keepAtoms,
parser->tokenStream);
CompilationInfo::RewindToken startObj = compilationInfo.getRewindToken();
@ -597,9 +602,9 @@ FunctionNode* frontend::StandaloneFunctionCompiler<Unit>::parse(
FunctionNode* fn;
for (;;) {
Directives newDirectives = compilationInfo.directives;
Directives newDirectives = compilationInfo.state.directives;
fn = parser->standaloneFunction(parameterListEnd, syntaxKind, generatorKind,
asyncKind, compilationInfo.directives,
asyncKind, compilationInfo.state.directives,
&newDirectives);
if (fn) {
break;
@ -636,27 +641,29 @@ JSFunction* frontend::StandaloneFunctionCompiler<Unit>::compile(
// we want the SourceExtent used in the final standalone script to
// start from the beginning of the buffer, and use the provided
// line and column.
compilationInfo.scriptData[CompilationInfo::TopLevelIndex].extent =
compilationInfo.stencil.scriptData[CompilationInfo::TopLevelIndex].extent =
SourceExtent{/* sourceStart = */ 0,
sourceBuffer_.length(),
funbox->extent().toStringStart,
funbox->extent().toStringEnd,
compilationInfo.options.lineno,
compilationInfo.options.column};
compilationInfo.input.options.lineno,
compilationInfo.input.options.column};
} else {
// The asm.js module was created by parser. Instantiation below will
// allocate the JSFunction that wraps it.
MOZ_ASSERT(funbox->isAsmJSModule());
MOZ_ASSERT(compilationInfo.asmJS.has(funbox->index()));
MOZ_ASSERT(compilationInfo.scriptData[CompilationInfo::TopLevelIndex]
.functionFlags.isAsmJSNative());
MOZ_ASSERT(compilationInfo.stencil.asmJS.has(funbox->index()));
MOZ_ASSERT(
compilationInfo.stencil.scriptData[CompilationInfo::TopLevelIndex]
.functionFlags.isAsmJSNative());
}
if (!compilationInfo.instantiateStencils()) {
return nullptr;
}
JSFunction* fun = compilationInfo.functions[CompilationInfo::TopLevelIndex];
JSFunction* fun =
compilationInfo.gcOutput.functions[CompilationInfo::TopLevelIndex];
MOZ_ASSERT(fun->hasBytecode() || IsAsmJSModule(fun));
// Enqueue an off-thread source compression task after finishing parsing.
@ -697,7 +704,7 @@ static ModuleObject* InternalParseModule(
// Even if compile fails, we may have generated some of the scripts so expose
// the ScriptSourceObject to the caller.
if (sourceObjectOut) {
*sourceObjectOut = compilationInfo.sourceObject;
*sourceObjectOut = compilationInfo.gcOutput.sourceObject;
}
if (!module) {
@ -705,7 +712,7 @@ static ModuleObject* InternalParseModule(
}
tellDebuggerAboutCompiledScript(cx, options.hideScriptFromDebugger,
compilationInfo.script);
compilationInfo.gcOutput.script);
assertException.reset();
return module;
@ -822,10 +829,10 @@ static bool CompileLazyFunctionImpl(JSContext* cx, Handle<BaseScript*> lazy,
return false;
}
MOZ_ASSERT(lazyFlags == compilationInfo.script->immutableFlags());
MOZ_ASSERT(compilationInfo.script->outermostScope()->hasOnChain(
MOZ_ASSERT(lazyFlags == compilationInfo.gcOutput.script->immutableFlags());
MOZ_ASSERT(compilationInfo.gcOutput.script->outermostScope()->hasOnChain(
ScopeKind::NonSyntactic) ==
compilationInfo.script->immutableFlags().hasFlag(
compilationInfo.gcOutput.script->immutableFlags().hasFlag(
JSScript::ImmutableFlags::HasNonSyntacticScope));
assertException.reset();
@ -879,12 +886,12 @@ static JSFunction* CompileStandaloneFunction(
// Note: If AsmJS successfully compiles, the into.script will still be
// nullptr. In this case we have compiled to a native function instead of an
// interpreted script.
if (compilationInfo.script) {
if (compilationInfo.gcOutput.script) {
if (parameterListEnd) {
compilationInfo.source()->setParameterListEnd(*parameterListEnd);
}
tellDebuggerAboutCompiledScript(cx, options.hideScriptFromDebugger,
compilationInfo.script);
compilationInfo.gcOutput.script);
}
assertException.reset();
@ -935,5 +942,5 @@ bool frontend::CompilationInfo::init(JSContext* cx) {
}
setSource(ss);
return ss->initFromOptions(cx, options);
return ss->initFromOptions(cx, input.options);
}

36
js/src/frontend/BytecodeEmitter.cpp
View File

@ -1649,11 +1649,11 @@ bool BytecodeEmitter::iteratorResultShape(GCThingIndex* shape) {
// with |NewObject|.
ObjLiteralFlags flags{ObjLiteralFlag::NoValues};
ObjLiteralIndex objIndex(compilationInfo.objLiteralData.length());
if (!compilationInfo.objLiteralData.emplaceBack(cx)) {
ObjLiteralIndex objIndex(compilationInfo.stencil.objLiteralData.length());
if (!compilationInfo.stencil.objLiteralData.emplaceBack(cx)) {
return false;
}
ObjLiteralStencil& data = compilationInfo.objLiteralData.back();
ObjLiteralStencil& data = compilationInfo.stencil.objLiteralData.back();
data.writer().beginObject(flags);
@ -2479,7 +2479,7 @@ bool BytecodeEmitter::emitScript(ParseNode* body) {
// Create a Stencil and convert it into a JSScript.
return intoScriptStencil(
&compilationInfo.scriptData[CompilationInfo::TopLevelIndex]);
&compilationInfo.stencil.scriptData[CompilationInfo::TopLevelIndex]);
}
js::UniquePtr<ImmutableScriptData> BytecodeEmitter::createImmutableScriptData(
@ -4614,11 +4614,11 @@ bool BytecodeEmitter::emitCallSiteObjectArray(ListNode* cookedOrRaw,
MOZ_ASSERT(cookedOrRaw->isKind(ParseNodeKind::ArrayExpr));
}
ObjLiteralIndex objIndex(compilationInfo.objLiteralData.length());
if (!compilationInfo.objLiteralData.emplaceBack(cx)) {
ObjLiteralIndex objIndex(compilationInfo.stencil.objLiteralData.length());
if (!compilationInfo.stencil.objLiteralData.emplaceBack(cx)) {
return false;
}
ObjLiteralStencil& data = compilationInfo.objLiteralData.back();
ObjLiteralStencil& data = compilationInfo.stencil.objLiteralData.back();
ObjLiteralFlags flags(ObjLiteralFlag::Array);
data.writer().beginObject(flags);
@ -8825,11 +8825,11 @@ bool BytecodeEmitter::emitPropertyList(ListNode* obj, PropertyEmitter& pe,
bool BytecodeEmitter::emitPropertyListObjLiteral(ListNode* obj,
ObjLiteralFlags flags) {
ObjLiteralIndex objIndex(compilationInfo.objLiteralData.length());
if (!compilationInfo.objLiteralData.emplaceBack(cx)) {
ObjLiteralIndex objIndex(compilationInfo.stencil.objLiteralData.length());
if (!compilationInfo.stencil.objLiteralData.emplaceBack(cx)) {
return false;
}
ObjLiteralStencil& data = compilationInfo.objLiteralData.back();
ObjLiteralStencil& data = compilationInfo.stencil.objLiteralData.back();
data.writer().beginObject(flags);
bool noValues = flags.contains(ObjLiteralFlag::NoValues);
@ -8893,11 +8893,11 @@ bool BytecodeEmitter::emitDestructuringRestExclusionSetObjLiteral(
// with |NewObject|.
ObjLiteralFlags flags{ObjLiteralFlag::NoValues};
ObjLiteralIndex objIndex(compilationInfo.objLiteralData.length());
if (!compilationInfo.objLiteralData.emplaceBack(cx)) {
ObjLiteralIndex objIndex(compilationInfo.stencil.objLiteralData.length());
if (!compilationInfo.stencil.objLiteralData.emplaceBack(cx)) {
return false;
}
ObjLiteralStencil& data = compilationInfo.objLiteralData.back();
ObjLiteralStencil& data = compilationInfo.stencil.objLiteralData.back();
data.writer().beginObject(flags);
@ -8945,11 +8945,11 @@ bool BytecodeEmitter::emitDestructuringRestExclusionSetObjLiteral(
}
bool BytecodeEmitter::emitObjLiteralArray(ParseNode* arrayHead, bool isCow) {
ObjLiteralIndex objIndex(compilationInfo.objLiteralData.length());
if (!compilationInfo.objLiteralData.emplaceBack(cx)) {
ObjLiteralIndex objIndex(compilationInfo.stencil.objLiteralData.length());
if (!compilationInfo.stencil.objLiteralData.emplaceBack(cx)) {
return false;
}
ObjLiteralStencil& data = compilationInfo.objLiteralData.back();
ObjLiteralStencil& data = compilationInfo.stencil.objLiteralData.back();
ObjLiteralFlags flags(ObjLiteralFlag::Array);
if (isCow) {
@ -9433,8 +9433,8 @@ const MemberInitializers& BytecodeEmitter::findMemberInitializersForCall() {
}
}
MOZ_RELEASE_ASSERT(compilationInfo.scopeContext.memberInitializers);
return *compilationInfo.scopeContext.memberInitializers;
MOZ_RELEASE_ASSERT(compilationInfo.state.scopeContext.memberInitializers);
return *compilationInfo.state.scopeContext.memberInitializers;
}
bool BytecodeEmitter::emitInitializeInstanceMembers() {

12
js/src/frontend/BytecodeSection.cpp
View File

@ -30,7 +30,7 @@ bool GCThingList::append(FunctionBox* funbox, GCThingIndex* index) {
AbstractScopePtr GCThingList::getScope(size_t index) const {
const ScriptThingVariant& elem = vector[index];
if (elem.is<EmptyGlobalScopeType>()) {
MOZ_ASSERT(compilationInfo.enclosingScope == nullptr);
MOZ_ASSERT(compilationInfo.input.enclosingScope == nullptr);
return AbstractScopePtr(&compilationInfo.cx->global()->emptyGlobalScope());
}
return AbstractScopePtr(compilationInfo, elem.as<ScopeIndex>());
@ -73,7 +73,7 @@ bool js::frontend::EmitScriptThingsVector(JSContext* cx,
}
bool operator()(const BigIntIndex& index) {
BigIntStencil& data = compilationInfo.bigIntData[index];
BigIntStencil& data = compilationInfo.stencil.bigIntData[index];
BigInt* bi = data.createBigInt(cx);
if (!bi) {
return false;
@ -83,7 +83,7 @@ bool js::frontend::EmitScriptThingsVector(JSContext* cx,
}
bool operator()(const RegExpIndex& rindex) {
RegExpStencil& data = compilationInfo.regExpData[rindex];
RegExpStencil& data = compilationInfo.stencil.regExpData[rindex];
RegExpObject* regexp = data.createRegExp(cx);
if (!regexp) {
return false;
@ -93,7 +93,7 @@ bool js::frontend::EmitScriptThingsVector(JSContext* cx,
}
bool operator()(const ObjLiteralIndex& index) {
ObjLiteralStencil& data = compilationInfo.objLiteralData[index];
ObjLiteralStencil& data = compilationInfo.stencil.objLiteralData[index];
JSObject* obj = data.create(cx, compilationInfo);
if (!obj) {
return false;
@ -103,12 +103,12 @@ bool js::frontend::EmitScriptThingsVector(JSContext* cx,
}
bool operator()(const ScopeIndex& index) {
output[i] = JS::GCCellPtr(compilationInfo.scopes[index].get());
output[i] = JS::GCCellPtr(compilationInfo.gcOutput.scopes[index].get());
return true;
}
bool operator()(const FunctionIndex& index) {
output[i] = JS::GCCellPtr(compilationInfo.functions[index]);
output[i] = JS::GCCellPtr(compilationInfo.gcOutput.functions[index]);
return true;
}

179
js/src/frontend/CompilationInfo.h
View File

@ -149,55 +149,69 @@ class ScriptStencilIterable {
Iterator end() const { return Iterator::end(compilationInfo_); }
};
// CompilationInfo owns a number of pieces of information about script
// compilation as well as controls the lifetime of parse nodes and other data by
// controling the mark and reset of the LifoAlloc.
struct MOZ_RAII CompilationInfo {
static constexpr FunctionIndex TopLevelIndex = FunctionIndex(0);
JSContext* cx;
// Input of the compilation, including source and enclosing context.
struct MOZ_RAII CompilationInput {
const JS::ReadOnlyCompileOptions& options;
// Atoms lowered into or converted from CompilationStencil.parserAtoms.
//
// This field is here instead of in CompilationGCOutput because atoms lowered
// from JSAtom is part of input (enclosing scope bindings, lazy function name,
// etc), and having 2 vectors in both input/output is error prone.
JS::RootedVector<JSAtom*> atoms;
JS::Rooted<BaseScript*> lazy;
JS::Rooted<ScriptSourceHolder> source_;
// The enclosing scope of the function if we're compiling standalone function.
// The enclosing scope of the `eval` if we're compiling eval.
// Null otherwise.
JS::Rooted<Scope*> enclosingScope;
CompilationInput(JSContext* cx, const JS::ReadOnlyCompileOptions& options)
: options(options),
atoms(cx),
lazy(cx),
source_(cx),
enclosingScope(cx) {}
};
struct MOZ_RAII CompilationState {
// Until we have dealt with Atoms in the front end, we need to hold
// onto them.
AutoKeepAtoms keepAtoms;
// Table of parser atoms for this compilation.
ParserAtomsTable parserAtoms;
JS::RootedVector<JSAtom*> atoms;
Directives directives;
ScopeContext scopeContext;
// The resulting outermost script for the compilation powered
// by this CompilationInfo.
JS::Rooted<JSScript*> script;
JS::Rooted<BaseScript*> lazy;
// The resulting module object if there is one.
JS::Rooted<ModuleObject*> module;
UsedNameTracker usedNames;
LifoAllocScope& allocScope;
CompilationState(JSContext* cx, LifoAllocScope& alloc,
const JS::ReadOnlyCompileOptions& options,
Scope* enclosingScope, JSObject* enclosingEnv)
: keepAtoms(cx),
directives(options.forceStrictMode()),
scopeContext(cx, enclosingScope, enclosingEnv),
usedNames(cx),
allocScope(alloc) {}
};
// The top level struct of stencil.
struct MOZ_RAII CompilationStencil {
// Hold onto the RegExpStencil, BigIntStencil, and ObjLiteralStencil that are
// allocated during parse to ensure correct destruction.
Vector<RegExpStencil> regExpData;
Vector<BigIntStencil> bigIntData;
Vector<ObjLiteralStencil> objLiteralData;
// A Rooted vector to handle tracing of JSFunction*
// and Atoms within.
JS::RootedVector<JSFunction*> functions;
// Stencil for all function and non-function scripts. The TopLevelIndex is
// reserved for the top-level script. This top-level may or may not be a
// function.
Vector<ScriptStencil> scriptData;
// The enclosing scope of the function if we're compiling standalone function.
// The enclosing scope of the `eval` if we're compiling eval.
// Null otherwise.
JS::Rooted<Scope*> enclosingScope;
// A rooted list of scopes created during this parse.
//
// To ensure that ScopeStencil's destructors fire, and thus our HeapPtr
@ -207,7 +221,6 @@ struct MOZ_RAII CompilationInfo {
//
// References to scopes are controlled via AbstractScopePtr, which holds onto
// an index (and CompilationInfo reference).
JS::RootedVector<js::Scope*> scopes;
Vector<ScopeStencil> scopeData;
// Module metadata if this is a module compile.
@ -216,10 +229,59 @@ struct MOZ_RAII CompilationInfo {
// AsmJS modules generated by parsing.
HashMap<FunctionIndex, RefPtr<const JS::WasmModule>> asmJS;
// Table of parser atoms for this compilation.
ParserAtomsTable parserAtoms;
explicit CompilationStencil(JSContext* cx)
: regExpData(cx),
bigIntData(cx),
objLiteralData(cx),
scriptData(cx),
scopeData(cx),
moduleMetadata(cx),
asmJS(cx),
parserAtoms(cx) {}
};
// The output of GC allocation from stencil.
struct MOZ_RAII CompilationGCOutput {
// The resulting outermost script for the compilation powered
// by this CompilationInfo.
JS::Rooted<JSScript*> script;
// The resulting module object if there is one.
JS::Rooted<ModuleObject*> module;
// A Rooted vector to handle tracing of JSFunction* and Atoms within.
//
// If the top level script isn't a function, the item at TopLevelIndex is
// nullptr.
JS::RootedVector<JSFunction*> functions;
// References to scopes are controlled via AbstractScopePtr, which holds onto
// an index (and CompilationInfo reference).
JS::RootedVector<js::Scope*> scopes;
// The result ScriptSourceObject. This is unused in delazifying parses.
JS::Rooted<ScriptSourceHolder> source_;
JS::Rooted<ScriptSourceObject*> sourceObject;
explicit CompilationGCOutput(JSContext* cx)
: script(cx), module(cx), functions(cx), scopes(cx), sourceObject(cx) {}
};
// CompilationInfo owns a number of pieces of information about script
// compilation as well as controls the lifetime of parse nodes and other data by
// controling the mark and reset of the LifoAlloc.
struct MOZ_RAII CompilationInfo {
static constexpr FunctionIndex TopLevelIndex = FunctionIndex(0);
JSContext* cx;
CompilationInput input;
CompilationState state;
CompilationStencil stencil;
CompilationGCOutput gcOutput;
// Track the state of key allocations and roll them back as parts of parsing
// get retried. This ensures iteration during stencil instantiation does not
// encounter discarded frontend state.
@ -237,29 +299,10 @@ struct MOZ_RAII CompilationInfo {
Scope* enclosingScope = nullptr,
JSObject* enclosingEnv = nullptr)
: cx(cx),
options(options),
keepAtoms(cx),
parserAtoms(cx),
atoms(cx),
directives(options.forceStrictMode()),
scopeContext(cx, enclosingScope, enclosingEnv),
script(cx),
lazy(cx),
module(cx),
usedNames(cx),
allocScope(alloc),
regExpData(cx),
bigIntData(cx),
objLiteralData(cx),
functions(cx),
scriptData(cx),
enclosingScope(cx),
scopes(cx),
scopeData(cx),
moduleMetadata(cx),
asmJS(cx),
source_(cx),
sourceObject(cx) {}
input(cx, options),
state(cx, alloc, options, enclosingScope, enclosingEnv),
stencil(cx),
gcOutput(cx) {}
bool init(JSContext* cx);
@ -267,23 +310,23 @@ struct MOZ_RAII CompilationInfo {
if (!init(cx)) {
return false;
}
this->enclosingScope = enclosingScope;
input.enclosingScope = enclosingScope;
return true;
}
void initFromLazy(BaseScript* lazy) {
this->lazy = lazy;
this->enclosingScope = lazy->function()->enclosingScope();
input.lazy = lazy;
input.enclosingScope = lazy->function()->enclosingScope();
}
void setEnclosingScope(Scope* scope) { enclosingScope = scope; }
void setEnclosingScope(Scope* scope) { input.enclosingScope = scope; }
ScriptSource* source() { return source_.get().get(); }
void setSource(ScriptSource* ss) { return source_.get().reset(ss); }
ScriptSource* source() { return input.source_.get().get(); }
void setSource(ScriptSource* ss) { return input.source_.get().reset(ss); }
template <typename Unit>
MOZ_MUST_USE bool assignSource(JS::SourceText<Unit>& sourceBuffer) {
return source()->assignSource(cx, options, sourceBuffer);
return source()->assignSource(cx, input.options, sourceBuffer);
}
MOZ_MUST_USE bool instantiateStencils();
@ -292,7 +335,7 @@ struct MOZ_RAII CompilationInfo {
return parserAtom->toJSAtom(cx, *this).unwrapOr(nullptr);
}
const ParserAtom* lowerJSAtomToParserAtom(JSAtom* atom) {
auto result = parserAtoms.internJSAtom(cx, *this, atom);
auto result = stencil.parserAtoms.internJSAtom(cx, *this, atom);
return result.unwrapOr(nullptr);
}
@ -314,14 +357,14 @@ struct MOZ_RAII CompilationInfo {
};
inline void ScriptStencilIterable::Iterator::next() {
MOZ_ASSERT(index_ < compilationInfo_->scriptData.length());
MOZ_ASSERT(index_ < compilationInfo_->stencil.scriptData.length());
index_++;
}
inline void ScriptStencilIterable::Iterator::skipNonFunctions() {
size_t length = compilationInfo_->scriptData.length();
size_t length = compilationInfo_->stencil.scriptData.length();
while (index_ < length) {
if (compilationInfo_->scriptData[index_].isFunction()) {
if (compilationInfo_->stencil.scriptData[index_].isFunction()) {
return;
}
@ -331,16 +374,18 @@ inline void ScriptStencilIterable::Iterator::skipNonFunctions() {
inline ScriptStencilIterable::ScriptAndFunction
ScriptStencilIterable::Iterator::operator*() {
ScriptStencil& script = compilationInfo_->scriptData[index_];
ScriptStencil& script = compilationInfo_->stencil.scriptData[index_];
FunctionIndex functionIndex = FunctionIndex(index_);
return ScriptAndFunction(script, compilationInfo_->functions[functionIndex],
return ScriptAndFunction(script,
compilationInfo_->gcOutput.functions[functionIndex],
functionIndex);
}
/* static */ inline ScriptStencilIterable::Iterator
ScriptStencilIterable::Iterator::end(CompilationInfo* compilationInfo) {
return Iterator(compilationInfo, compilationInfo->scriptData.length());
return Iterator(compilationInfo,
compilationInfo->stencil.scriptData.length());
}
} // namespace frontend

6
js/src/frontend/EmitterScope.cpp
View File

@ -48,7 +48,7 @@ bool EmitterScope::checkEnvironmentChainLength(BytecodeEmitter* bce) {
if (EmitterScope* emitterScope = enclosing(&bce)) {
hops = emitterScope->environmentChainLength_;
} else {
hops = bce->compilationInfo.enclosingScope->environmentChainLength();
hops = bce->compilationInfo.input.enclosingScope->environmentChainLength();
}
if (hops >= ENVCOORD_HOPS_LIMIT - 1) {
@ -335,7 +335,7 @@ NameLocation EmitterScope::searchAndCache(BytecodeEmitter* bce,
inCurrentScript = false;
loc = Some(searchInEnclosingScope(
jsname, bce->compilationInfo.enclosingScope, hops));
jsname, bce->compilationInfo.input.enclosingScope, hops));
}
// Each script has its own frame. A free name that is accessed
@ -374,7 +374,7 @@ bool EmitterScope::internScopeCreationData(BytecodeEmitter* bce,
if (!createScope(bce->cx, enclosingScopeIndex(bce), &index)) {
return false;
}
ScopeStencil& scope = bce->compilationInfo.scopeData[index.index];
ScopeStencil& scope = bce->compilationInfo.stencil.scopeData[index.index];
hasEnvironment_ = scope.hasEnvironment();
return bce->perScriptData().gcThingList().append(index, &scopeIndex_);
}

2
js/src/frontend/FoldConstants.cpp
View File

@ -1241,7 +1241,7 @@ static bool FoldAdd(FoldInfo info, ParseNode** nodePtr) {
// Construct the concatenated atom.
const ParserAtom* combination =
info.compilationInfo.parserAtoms
info.compilationInfo.stencil.parserAtoms
.concatAtoms(info.cx(),
mozilla::Range(accum.begin(), accum.length()))
.unwrapOr(nullptr);

36
js/src/frontend/Frontend2.cpp
View File

@ -66,7 +66,8 @@ bool ConvertAtoms(JSContext* cx, const SmooshResult& result,
smoosh_get_atom_at(result, i));
auto len = smoosh_get_atom_len_at(result, i);
const ParserAtom* atom =
compilationInfo.parserAtoms.internUtf8(cx, s, len).unwrapOr(nullptr);
compilationInfo.stencil.parserAtoms.internUtf8(cx, s, len)
.unwrapOr(nullptr);
if (!atom) {
return false;
}
@ -115,7 +116,7 @@ void CopyBindingNames(JSContext* cx, CVec<COption<SmooshBindingName>>& from,
bool ConvertScopeStencil(JSContext* cx, const SmooshResult& result,
Vector<const ParserAtom*>& allAtoms,
CompilationInfo& compilationInfo) {
auto& alloc = compilationInfo.allocScope.alloc();
auto& alloc = compilationInfo.state.allocScope.alloc();
for (size_t i = 0; i < result.scopes.len; i++) {
SmooshScopeData& scopeData = result.scopes.data[i];
@ -287,7 +288,8 @@ bool ConvertRegExpData(JSContext* cx, const SmooshResult& result,
mozilla::Range<const char16_t> range(pattern.get(), length);
TokenStreamAnyChars ts(cx, compilationInfo.options, /* smg = */ nullptr);
TokenStreamAnyChars ts(cx, compilationInfo.input.options,
/* smg = */ nullptr);
// See Parser<FullParseHandler, Unit>::newRegExp.
@ -296,13 +298,13 @@ bool ConvertRegExpData(JSContext* cx, const SmooshResult& result,
return false;
}
RegExpIndex index(compilationInfo.regExpData.length());
if (!compilationInfo.regExpData.emplaceBack()) {
RegExpIndex index(compilationInfo.stencil.regExpData.length());
if (!compilationInfo.stencil.regExpData.emplaceBack()) {
return false;
}
if (!compilationInfo.regExpData[index].init(cx, range,
JS::RegExpFlags(flags))) {
if (!compilationInfo.stencil.regExpData[index].init(
cx, range, JS::RegExpFlags(flags))) {
return false;
}
@ -398,7 +400,7 @@ bool ConvertScriptStencil(JSContext* cx, const SmooshResult& result,
ScriptStencil& script) {
using ImmutableFlags = js::ImmutableScriptFlagsEnum;
const JS::ReadOnlyCompileOptions& options = compilationInfo.options;
const JS::ReadOnlyCompileOptions& options = compilationInfo.input.options;
script.immutableFlags = smooshScript.immutable_flags;
@ -512,7 +514,7 @@ bool Smoosh::compileGlobalScriptToStencil(CompilationInfo& compilationInfo,
JSContext* cx = compilationInfo.cx;
const auto& options = compilationInfo.options;
const auto& options = compilationInfo.input.options;
SmooshCompileOptions compileOptions;
compileOptions.no_script_rval = options.noScriptRval;
@ -552,24 +554,24 @@ bool Smoosh::compileGlobalScriptToStencil(CompilationInfo& compilationInfo,
return false;
}
if (!compilationInfo.scriptData.reserve(result.functions.len + 1)) {
if (!compilationInfo.stencil.scriptData.reserve(result.functions.len + 1)) {
return false;
}
compilationInfo.scriptData.infallibleEmplaceBack(cx);
compilationInfo.stencil.scriptData.infallibleEmplaceBack(cx);
if (!ConvertScriptStencil(
cx, result, result.top_level_script, allAtoms, compilationInfo,
compilationInfo.scriptData[CompilationInfo::TopLevelIndex])) {
compilationInfo.stencil.scriptData[CompilationInfo::TopLevelIndex])) {
return false;
}
for (size_t i = 0; i < result.functions.len; i++) {
compilationInfo.scriptData.infallibleEmplaceBack(cx);
compilationInfo.stencil.scriptData.infallibleEmplaceBack(cx);
if (!ConvertScriptStencil(cx, result, result.functions.data[i], allAtoms,
compilationInfo,
compilationInfo.scriptData[i + 1])) {
compilationInfo.stencil.scriptData[i + 1])) {
return false;
}
}
@ -595,19 +597,19 @@ JSScript* Smoosh::compileGlobalScript(CompilationInfo& compilationInfo,
if (!sprinter.init()) {
return nullptr;
}
if (!Disassemble(cx, compilationInfo.script, true, &sprinter,
if (!Disassemble(cx, compilationInfo.gcOutput.script, true, &sprinter,
DisassembleSkeptically::Yes)) {
return nullptr;
}
printf("%s\n", sprinter.string());
if (!Disassemble(cx, compilationInfo.script, true, &sprinter,
if (!Disassemble(cx, compilationInfo.gcOutput.script, true, &sprinter,
DisassembleSkeptically::No)) {
return nullptr;
}
// (don't bother printing it)
#endif
return compilationInfo.script;
return compilationInfo.gcOutput.script;
}
bool SmooshParseScript(JSContext* cx, const uint8_t* bytes, size_t length) {

8
js/src/frontend/ParseContext.cpp
View File

@ -305,13 +305,13 @@ ParseContext::ParseContext(JSContext* cx, ParseContext*& parent,
newDirectives(newDirectives),
lastYieldOffset(NoYieldOffset),
lastAwaitOffset(NoAwaitOffset),
scriptId_(compilationInfo.usedNames.nextScriptId()),
scriptId_(compilationInfo.state.usedNames.nextScriptId()),
superScopeNeedsHomeObject_(false) {
if (isFunctionBox()) {
if (functionBox()->isNamedLambda()) {
namedLambdaScope_.emplace(cx, parent, compilationInfo.usedNames);
namedLambdaScope_.emplace(cx, parent, compilationInfo.state.usedNames);
}
functionScope_.emplace(cx, parent, compilationInfo.usedNames);
functionScope_.emplace(cx, parent, compilationInfo.state.usedNames);
}
}
@ -415,7 +415,7 @@ bool ParseContext::isVarRedeclaredInEval(const ParserName* name,
// In the case of eval, we also need to check enclosing VM scopes to see
// if the var declaration is allowed in the context.
js::Scope* enclosingScope = sc()->compilationInfo().enclosingScope;
js::Scope* enclosingScope = sc()->compilationInfo().input.enclosingScope;
js::Scope* varScope = EvalScope::nearestVarScopeForDirectEval(enclosingScope);
MOZ_ASSERT(varScope);
for (ScopeIter si(enclosingScope); si; si++) {

6
js/src/frontend/ParseNode.cpp
View File

@ -387,11 +387,11 @@ void LexicalScopeNode::dumpImpl(GenericPrinter& out, int indent) {
#endif
BigInt* BigIntLiteral::create(JSContext* cx) {
return compilationInfo_.bigIntData[index_].createBigInt(cx);
return compilationInfo_.stencil.bigIntData[index_].createBigInt(cx);
}
bool BigIntLiteral::isZero() {
return compilationInfo_.bigIntData[index_].isZero();
return compilationInfo_.stencil.bigIntData[index_].isZero();
}
const ParserAtom* NumericLiteral::toAtom(
@ -407,7 +407,7 @@ RegExpObject* RegExpStencil::createRegExp(JSContext* cx) const {
RegExpObject* RegExpLiteral::create(JSContext* cx,
CompilationInfo& compilationInfo) const {
return compilationInfo.regExpData[index_].createRegExp(cx);
return compilationInfo.stencil.regExpData[index_].createRegExp(cx);
}
bool js::frontend::IsAnonymousFunctionDefinition(ParseNode* pn) {

78
js/src/frontend/Parser.cpp
View File

@ -149,10 +149,10 @@ ParserSharedBase::ParserSharedBase(JSContext* cx,
CompilationInfo& compilationInfo, Kind kind)
: JS::CustomAutoRooter(cx),
cx_(cx),
alloc_(compilationInfo.allocScope.alloc()),
alloc_(compilationInfo.state.allocScope.alloc()),
compilationInfo_(compilationInfo),
pc_(nullptr),
usedNames_(compilationInfo.usedNames) {
usedNames_(compilationInfo.state.usedNames) {
cx->frontendCollectionPool().addActiveCompilation();
}
@ -190,7 +190,7 @@ PerHandlerParser<ParseHandler>::PerHandlerParser(
CompilationInfo& compilationInfo, BaseScript* lazyOuterFunction,
void* internalSyntaxParser)
: ParserBase(cx, options, foldConstants, compilationInfo),
handler_(cx, compilationInfo.allocScope.alloc(), lazyOuterFunction),
handler_(cx, compilationInfo.state.allocScope.alloc(), lazyOuterFunction),
internalSyntaxParser_(internalSyntaxParser) {}
template <class ParseHandler, typename Unit>
@ -252,11 +252,12 @@ FunctionBox* PerHandlerParser<ParseHandler>::newFunctionBox(
TopLevelFunction isTopLevel) {
MOZ_ASSERT(funNode);
FunctionIndex index = FunctionIndex(compilationInfo_.scriptData.length());
FunctionIndex index =
FunctionIndex(compilationInfo_.stencil.scriptData.length());
MOZ_ASSERT_IF(isTopLevel == TopLevelFunction::Yes,
index == CompilationInfo::TopLevelIndex);
if (!compilationInfo_.scriptData.emplaceBack(cx_)) {
if (!compilationInfo_.stencil.scriptData.emplaceBack(cx_)) {
return nullptr;
}
@ -832,7 +833,7 @@ bool PerHandlerParser<ParseHandler>::
// TODO-Stencil
// After closed-over-bindings are snapshotted in the handler,
// remove this.
auto mbNameId = compilationInfo_.parserAtoms.internJSAtom(
auto mbNameId = compilationInfo_.stencil.parserAtoms.internJSAtom(
cx_, this->getCompilationInfo(), name);
if (mbNameId.isErr()) {
return false;
@ -1432,7 +1433,7 @@ bool PerHandlerParser<ParseHandler>::checkForUndefinedPrivateFields(
}
Vector<UnboundPrivateName, 8> unboundPrivateNames(cx_);
if (!this->getCompilationInfo().usedNames.getUnboundPrivateNames(
if (!this->getCompilationInfo().state.usedNames.getUnboundPrivateNames(
unboundPrivateNames)) {
return false;
}
@ -1496,7 +1497,8 @@ bool PerHandlerParser<ParseHandler>::checkForUndefinedPrivateFields(
// names, we must use the effective scope that was determined when creating
// the scopeContext.
if (!verifyPrivateName(
cx_, this, this->getCompilationInfo().scopeContext.effectiveScope,
cx_, this,
this->getCompilationInfo().state.scopeContext.effectiveScope,
unboundName)) {
return false;
}
@ -1548,12 +1550,12 @@ LexicalScopeNode* Parser<FullParseHandler, Unit>::evalBody(
#ifdef DEBUG
if (evalpc.superScopeNeedsHomeObject() &&
this->getCompilationInfo().enclosingScope) {
this->getCompilationInfo().input.enclosingScope) {
// If superScopeNeedsHomeObject_ is set and we are an entry-point
// ParseContext, then we must be emitting an eval script, and the
// outer function must already be marked as needing a home object
// since it contains an eval.
ScopeIter si(this->getCompilationInfo().enclosingScope);
ScopeIter si(this->getCompilationInfo().input.enclosingScope);
for (; si; si++) {
if (si.kind() == ScopeKind::Function) {
JSFunction* fun = si.scope()->as<FunctionScope>().canonicalFunction();
@ -1705,12 +1707,14 @@ ModuleNode* Parser<FullParseHandler, Unit>::moduleBody(
}
// Generate the Import/Export tables and store in CompilationInfo.
if (!modulesc->builder.buildTables(this->compilationInfo_.moduleMetadata)) {
if (!modulesc->builder.buildTables(
this->compilationInfo_.stencil.moduleMetadata)) {
return null();
}
// Check exported local bindings exist and mark them as closed over.
StencilModuleMetadata& moduleMetadata = this->compilationInfo_.moduleMetadata;
StencilModuleMetadata& moduleMetadata =
this->compilationInfo_.stencil.moduleMetadata;
for (auto entry : moduleMetadata.localExportEntries) {
const ParserAtom* nameId = entry.localName;
MOZ_ASSERT(nameId);
@ -2104,7 +2108,7 @@ FunctionNode* Parser<FullParseHandler, Unit>::standaloneFunction(
// Function is not syntactically part of another script.
funbox->setIsStandalone(true);
funbox->initStandalone(this->compilationInfo_.scopeContext, flags,
funbox->initStandalone(this->compilationInfo_.state.scopeContext, flags,
syntaxKind);
SourceParseContext funpc(this, funbox, newDirectives);
@ -2342,7 +2346,7 @@ const ParserAtom* ParserBase::prefixAccessorName(PropertyType propType,
const ParserAtom* atoms[2] = {prefix, propAtom};
auto atomsRange = mozilla::Range(atoms, 2);
return compilationInfo_.parserAtoms.concatAtoms(cx_, atomsRange)
return compilationInfo_.stencil.parserAtoms.concatAtoms(cx_, atomsRange)
.unwrapOr(nullptr);
}
@ -2860,7 +2864,7 @@ GeneralParser<ParseHandler, Unit>::functionDefinition(
Directives directives(pc_);
Directives newDirectives = directives;
Position start(this->compilationInfo_.keepAtoms, tokenStream);
Position start(this->compilationInfo_.state.keepAtoms, tokenStream);
CompilationInfo::RewindToken startObj =
this->compilationInfo_.getRewindToken();
@ -2904,7 +2908,7 @@ bool Parser<FullParseHandler, Unit>::advancePastSyntaxParsedFunction(
MOZ_ASSERT(getSyntaxParser() == syntaxParser);
// Advance this parser over tokens processed by the syntax parser.
Position currentSyntaxPosition(this->compilationInfo_.keepAtoms,
Position currentSyntaxPosition(this->compilationInfo_.state.keepAtoms,
syntaxParser->tokenStream);
if (!tokenStream.fastForward(currentSyntaxPosition, syntaxParser->anyChars)) {
return false;
@ -2952,7 +2956,8 @@ bool Parser<FullParseHandler, Unit>::trySyntaxParseInnerFunction(
// var x = (y = z => 2) => q;
// // ^ we first seek to here to syntax-parse this function
// // ^ then we seek back to here to syntax-parse the outer function
Position currentPosition(this->compilationInfo_.keepAtoms, tokenStream);
Position currentPosition(this->compilationInfo_.state.keepAtoms,
tokenStream);
if (!syntaxParser->tokenStream.seekTo(currentPosition, anyChars)) {
return false;
}
@ -2987,7 +2992,7 @@ bool Parser<FullParseHandler, Unit>::trySyntaxParseInnerFunction(
return false;
}
if (!advancePastSyntaxParsedFunction(this->compilationInfo_.keepAtoms,
if (!advancePastSyntaxParsedFunction(this->compilationInfo_.state.keepAtoms,
syntaxParser)) {
return false;
}
@ -3189,8 +3194,8 @@ FunctionNode* Parser<FullParseHandler, Unit>::standaloneLazyFunction(
return null();
}
funbox->initFromLazyFunction(fun);
funbox->initStandalone(this->getCompilationInfo().scopeContext, fun->flags(),
syntaxKind);
funbox->initStandalone(this->getCompilationInfo().state.scopeContext,
fun->flags(), syntaxKind);
if (fun->isClassConstructor()) {
funbox->setMemberInitializers(fun->baseScript()->getMemberInitializers());
}
@ -7598,7 +7603,7 @@ GeneralParser<ParseHandler, Unit>::classDefinition(
// We're leaving a class definition that was not itself nested within a class
if (!isInClass) {
mozilla::Maybe<UnboundPrivateName> maybeUnboundName;
if (!this->getCompilationInfo().usedNames.hasUnboundPrivateNames(
if (!this->getCompilationInfo().state.usedNames.hasUnboundPrivateNames(
cx_, maybeUnboundName)) {
return null();
}
@ -8984,7 +8989,7 @@ typename ParseHandler::Node GeneralParser<ParseHandler, Unit>::assignExpr(
// Save the tokenizer state in case we find an arrow function and have to
// rewind.
Position start(this->compilationInfo_.keepAtoms, tokenStream);
Position start(this->compilationInfo_.state.keepAtoms, tokenStream);
PossibleError possibleErrorInner(*this);
Node lhs;
@ -10236,12 +10241,13 @@ RegExpLiteral* Parser<FullParseHandler, Unit>::newRegExp() {
}
}
RegExpIndex index(this->getCompilationInfo().regExpData.length());
if (!this->getCompilationInfo().regExpData.emplaceBack()) {
RegExpIndex index(this->getCompilationInfo().stencil.regExpData.length());
if (!this->getCompilationInfo().stencil.regExpData.emplaceBack()) {
return nullptr;
}
if (!this->getCompilationInfo().regExpData[index].init(cx_, range, flags)) {
if (!this->getCompilationInfo().stencil.regExpData[index].init(cx_, range,
flags)) {
return nullptr;
}
@ -10287,12 +10293,13 @@ BigIntLiteral* Parser<FullParseHandler, Unit>::newBigInt() {
// productions start with 0[bBoOxX], indicating binary/octal/hex.
const auto& chars = tokenStream.getCharBuffer();
BigIntIndex index(this->getCompilationInfo().bigIntData.length());
if (!this->getCompilationInfo().bigIntData.emplaceBack()) {
BigIntIndex index(this->getCompilationInfo().stencil.bigIntData.length());
if (!this->getCompilationInfo().stencil.bigIntData.emplaceBack()) {
return null();
}
if (!this->getCompilationInfo().bigIntData[index].init(this->cx_, chars)) {
if (!this->getCompilationInfo().stencil.bigIntData[index].init(this->cx_,
chars)) {
return null();
}
@ -11478,18 +11485,19 @@ template class Parser<FullParseHandler, char16_t>;
template class Parser<SyntaxParseHandler, char16_t>;
CompilationInfo::RewindToken CompilationInfo::getRewindToken() {
MOZ_ASSERT(functions.empty());
return RewindToken{scriptData.length(), asmJS.count()};
MOZ_ASSERT(gcOutput.functions.empty());
return RewindToken{stencil.scriptData.length(), stencil.asmJS.count()};
}
void CompilationInfo::rewind(const CompilationInfo::RewindToken& pos) {
if (asmJS.count() != pos.asmJSCount) {
for (size_t i = pos.scriptDataLength; i < scriptData.length(); i++) {
asmJS.remove(FunctionIndex(i));
if (stencil.asmJS.count() != pos.asmJSCount) {
for (size_t i = pos.scriptDataLength; i < stencil.scriptData.length();
i++) {
stencil.asmJS.remove(FunctionIndex(i));
}
MOZ_ASSERT(asmJS.count() == pos.asmJSCount);
MOZ_ASSERT(stencil.asmJS.count() == pos.asmJSCount);
}
scriptData.shrinkTo(pos.scriptDataLength);
stencil.scriptData.shrinkTo(pos.scriptDataLength);
}
} // namespace js::frontend

12
js/src/frontend/ParserAtom.cpp
View File

@ -146,7 +146,7 @@ bool ParserAtomEntry::isIndex(uint32_t* indexp) const {
JS::Result<JSAtom*, OOM&> ParserAtomEntry::toJSAtom(
JSContext* cx, CompilationInfo& compilationInfo) const {
if (atomIndex_.constructed<AtomIndex>()) {
return compilationInfo.atoms[atomIndex_.ref<AtomIndex>()].get();
return compilationInfo.input.atoms[atomIndex_.ref<AtomIndex>()].get();
}
if (atomIndex_.constructed<WellKnownAtomId>()) {
return GetWellKnownAtom(cx, atomIndex_.ref<WellKnownAtomId>());
@ -161,8 +161,8 @@ JS::Result<JSAtom*, OOM&> ParserAtomEntry::toJSAtom(
if (!atom) {
return RaiseParserAtomsOOMError(cx);
}
auto index = compilationInfo.atoms.length();
if (!compilationInfo.atoms.append(atom)) {
auto index = compilationInfo.input.atoms.length();
if (!compilationInfo.input.atoms.append(atom)) {
return mozilla::Err(PARSER_ATOMS_OOM);
}
atomIndex_.construct<AtomIndex>(index);
@ -346,15 +346,15 @@ JS::Result<const ParserAtom*, OOM&> ParserAtomsTable::internJSAtom(
if (id->atomIndex_.empty()) {
MOZ_ASSERT(id->equalsJSAtom(atom));
auto index = AtomIndex(compilationInfo.atoms.length());
if (!compilationInfo.atoms.append(atom)) {
auto index = AtomIndex(compilationInfo.input.atoms.length());
if (!compilationInfo.input.atoms.append(atom)) {
return mozilla::Err(PARSER_ATOMS_OOM);
}
id->setAtomIndex(index);
} else {
#ifdef DEBUG
if (id->atomIndex_.constructed<AtomIndex>()) {
MOZ_ASSERT(compilationInfo.atoms[id->atomIndex_.ref<AtomIndex>()] ==
MOZ_ASSERT(compilationInfo.input.atoms[id->atomIndex_.ref<AtomIndex>()] ==
atom);
} else {
MOZ_ASSERT(GetWellKnownAtom(cx, id->atomIndex_.ref<WellKnownAtomId>()) ==

20
js/src/frontend/SharedContext.cpp
View File

@ -42,7 +42,7 @@ SharedContext::SharedContext(JSContext* cx, Kind kind,
if (kind == Kind::FunctionBox) {
setFlag(ImmutableFlags::IsFunction);
} else if (kind == Kind::Module) {
MOZ_ASSERT(!compilationInfo.options.nonSyntacticScope);
MOZ_ASSERT(!compilationInfo.input.options.nonSyntacticScope);
setFlag(ImmutableFlags::IsModule);
} else if (kind == Kind::Eval) {
setFlag(ImmutableFlags::IsForEval);
@ -51,7 +51,7 @@ SharedContext::SharedContext(JSContext* cx, Kind kind,
}
// Note: This is a mix of transitive and non-transitive options.
const JS::ReadOnlyCompileOptions& options = compilationInfo.options;
const JS::ReadOnlyCompileOptions& options = compilationInfo.input.options;
// Initialize the transitive "input" flags. These are applied to all
// SharedContext in this compilation and generally cannot be determined from
@ -203,12 +203,12 @@ EvalSharedContext::EvalSharedContext(JSContext* cx,
: SharedContext(cx, Kind::Eval, compilationInfo, directives, extent),
bindings(nullptr) {
// Eval inherits syntax and binding rules from enclosing environment.
allowNewTarget_ = compilationInfo.scopeContext.allowNewTarget;
allowSuperProperty_ = compilationInfo.scopeContext.allowSuperProperty;
allowSuperCall_ = compilationInfo.scopeContext.allowSuperCall;
allowArguments_ = compilationInfo.scopeContext.allowArguments;
thisBinding_ = compilationInfo.scopeContext.thisBinding;
inWith_ = compilationInfo.scopeContext.inWith;
allowNewTarget_ = compilationInfo.state.scopeContext.allowNewTarget;
allowSuperProperty_ = compilationInfo.state.scopeContext.allowSuperProperty;
allowSuperCall_ = compilationInfo.state.scopeContext.allowSuperCall;
allowArguments_ = compilationInfo.state.scopeContext.allowArguments;
thisBinding_ = compilationInfo.state.scopeContext.thisBinding;
inWith_ = compilationInfo.state.scopeContext.inWith;
}
#ifdef DEBUG
@ -366,7 +366,7 @@ bool FunctionBox::setAsmJSModule(const JS::WasmModule* module) {
flags_.setIsExtended();
flags_.setKind(FunctionFlags::AsmJS);
return compilationInfo_.asmJS.putNew(index(), module);
return compilationInfo_.stencil.asmJS.putNew(index(), module);
}
ModuleSharedContext::ModuleSharedContext(JSContext* cx,
@ -382,7 +382,7 @@ ModuleSharedContext::ModuleSharedContext(JSContext* cx,
}
ScriptStencil& FunctionBox::functionStencil() const {
return compilationInfo_.scriptData[funcDataIndex_];
return compilationInfo_.stencil.scriptData[funcDataIndex_];
}
void SharedContext::copyScriptFields(ScriptStencil& script) {

101
js/src/frontend/Stencil.cpp
View File

@ -43,12 +43,12 @@ AbstractScopePtr ScopeStencil::enclosing(CompilationInfo& compilationInfo) {
// HACK: The self-hosting script uses the EmptyGlobalScopeType placeholder
// which does not correspond to a ScopeStencil. This means that the inner
// scopes may store Nothing as an enclosing ScopeIndex.
if (compilationInfo.options.selfHostingMode) {
MOZ_ASSERT(compilationInfo.enclosingScope == nullptr);
if (compilationInfo.input.options.selfHostingMode) {
MOZ_ASSERT(compilationInfo.input.enclosingScope == nullptr);
return AbstractScopePtr(&compilationInfo.cx->global()->emptyGlobalScope());
}
return AbstractScopePtr(compilationInfo.enclosingScope);
return AbstractScopePtr(compilationInfo.input.enclosingScope);
}
Scope* ScopeStencil::createScope(JSContext* cx,
@ -147,8 +147,8 @@ static bool CreateLazyScript(JSContext* cx, CompilationInfo& compilationInfo,
Rooted<BaseScript*> lazy(
cx, BaseScript::CreateRawLazy(cx, gcthings.length(), function,
compilationInfo.sourceObject, script.extent,
script.immutableFlags));
compilationInfo.gcOutput.sourceObject,
script.extent, script.immutableFlags));
if (!lazy) {
return false;
}
@ -208,7 +208,7 @@ static JSFunction* CreateFunction(JSContext* cx,
if (isAsmJS) {
RefPtr<const JS::WasmModule> asmJS =
compilationInfo.asmJS.lookup(functionIndex)->value();
compilationInfo.stencil.asmJS.lookup(functionIndex)->value();
JSObject* moduleObj = asmJS->createObjectForAsmJS(cx);
if (!moduleObj) {
@ -226,9 +226,9 @@ static bool InstantiateScriptSourceObject(JSContext* cx,
CompilationInfo& compilationInfo) {
MOZ_ASSERT(compilationInfo.source());
compilationInfo.sourceObject =
compilationInfo.gcOutput.sourceObject =
ScriptSourceObject::create(cx, compilationInfo.source());
if (!compilationInfo.sourceObject) {
if (!compilationInfo.gcOutput.sourceObject) {
return false;
}
@ -242,8 +242,9 @@ static bool InstantiateScriptSourceObject(JSContext* cx,
// Instead, we put off populating those SSO slots in off-thread compilations
// until after we've merged compartments.
if (!cx->isHelperThreadContext()) {
if (!ScriptSourceObject::initFromOptions(cx, compilationInfo.sourceObject,
compilationInfo.options)) {
if (!ScriptSourceObject::initFromOptions(
cx, compilationInfo.gcOutput.sourceObject,
compilationInfo.input.options)) {
return false;
}
}
@ -254,14 +255,15 @@ static bool InstantiateScriptSourceObject(JSContext* cx,
// Instantiate ModuleObject if this is a module compile.
static bool MaybeInstantiateModule(JSContext* cx,
CompilationInfo& compilationInfo) {
if (compilationInfo.scriptData[CompilationInfo::TopLevelIndex].isModule()) {
compilationInfo.module = ModuleObject::create(cx);
if (!compilationInfo.module) {
if (compilationInfo.stencil.scriptData[CompilationInfo::TopLevelIndex]
.isModule()) {
compilationInfo.gcOutput.module = ModuleObject::create(cx);
if (!compilationInfo.gcOutput.module) {
return false;
}
if (!compilationInfo.moduleMetadata.initModule(cx, compilationInfo,
compilationInfo.module)) {
if (!compilationInfo.stencil.moduleMetadata.initModule(
cx, compilationInfo, compilationInfo.gcOutput.module)) {
return false;
}
}
@ -283,7 +285,7 @@ static bool InstantiateFunctions(JSContext* cx,
if (!fun) {
return false;
}
compilationInfo.functions[functionIndex].set(fun);
compilationInfo.gcOutput.functions[functionIndex].set(fun);
}
return true;
@ -305,16 +307,17 @@ static bool InstantiateScopes(JSContext* cx, CompilationInfo& compilationInfo) {
// element in compilationInfo.scopeData, because AbstractScopePtr holds index
// into it, and newly created ScopeStencil is pushed back to the vector.
if (!compilationInfo.scopes.reserve(compilationInfo.scopeData.length())) {
if (!compilationInfo.gcOutput.scopes.reserve(
compilationInfo.stencil.scopeData.length())) {
return false;
}
for (auto& scd : compilationInfo.scopeData) {
for (auto& scd : compilationInfo.stencil.scopeData) {
Scope* scope = scd.createScope(cx, compilationInfo);
if (!scope) {
return false;
}
compilationInfo.scopes.infallibleAppend(scope);
compilationInfo.gcOutput.scopes.infallibleAppend(scope);
}
return true;
@ -398,7 +401,7 @@ static bool InstantiateScriptStencils(JSContext* cx,
MOZ_ASSERT(fun->isAsmJSNative());
} else if (fun->isIncomplete()) {
// Lazy functions are generally only allocated in the initial parse.
MOZ_ASSERT(compilationInfo.lazy == nullptr);
MOZ_ASSERT(compilationInfo.input.lazy == nullptr);
if (!CreateLazyScript(cx, compilationInfo, scriptStencil, fun)) {
return false;
@ -414,10 +417,10 @@ static bool InstantiateScriptStencils(JSContext* cx,
static bool InstantiateTopLevel(JSContext* cx,
CompilationInfo& compilationInfo) {
ScriptStencil& script =
compilationInfo.scriptData[CompilationInfo::TopLevelIndex];
compilationInfo.stencil.scriptData[CompilationInfo::TopLevelIndex];
RootedFunction fun(cx);
if (script.isFunction()) {
fun = compilationInfo.functions[CompilationInfo::TopLevelIndex];
fun = compilationInfo.gcOutput.functions[CompilationInfo::TopLevelIndex];
}
// Top-level asm.js does not generate a JSScript.
@ -427,24 +430,26 @@ static bool InstantiateTopLevel(JSContext* cx,
MOZ_ASSERT(script.immutableScriptData);
if (compilationInfo.lazy) {
compilationInfo.script = JSScript::CastFromLazy(compilationInfo.lazy);
return JSScript::fullyInitFromStencil(cx, compilationInfo,
compilationInfo.script, script, fun);
if (compilationInfo.input.lazy) {
compilationInfo.gcOutput.script =
JSScript::CastFromLazy(compilationInfo.input.lazy);
return JSScript::fullyInitFromStencil(
cx, compilationInfo, compilationInfo.gcOutput.script, script, fun);
}
compilationInfo.script =
compilationInfo.gcOutput.script =
JSScript::fromStencil(cx, compilationInfo, script, fun);
if (!compilationInfo.script) {
if (!compilationInfo.gcOutput.script) {
return false;
}
// Finish initializing the ModuleObject if needed.
if (script.isModule()) {
compilationInfo.module->initScriptSlots(compilationInfo.script);
compilationInfo.module->initStatusSlot();
compilationInfo.gcOutput.module->initScriptSlots(
compilationInfo.gcOutput.script);
compilationInfo.gcOutput.module->initStatusSlot();
if (!ModuleObject::createEnvironment(cx, compilationInfo.module)) {
if (!ModuleObject::createEnvironment(cx, compilationInfo.gcOutput.module)) {
return false;
}
}
@ -473,7 +478,7 @@ static void UpdateEmittedInnerFunctions(CompilationInfo& compilationInfo) {
BaseScript* script = fun->baseScript();
ScopeIndex index = *scriptStencil.lazyFunctionEnclosingScopeIndex_;
Scope* scope = compilationInfo.scopes[index].get();
Scope* scope = compilationInfo.gcOutput.scopes[index].get();
script->setEnclosingScope(scope);
script->initTreatAsRunOnce(scriptStencil.immutableFlags.hasFlag(
ImmutableScriptFlagsEnum::TreatAsRunOnce));
@ -515,27 +520,29 @@ static void LinkEnclosingLazyScript(CompilationInfo& compilationInfo) {
// parse are required to generate the same sequence of functions for lazy
// parsing to work at all.
static void FunctionsFromExistingLazy(CompilationInfo& compilationInfo) {
MOZ_ASSERT(compilationInfo.lazy);
MOZ_ASSERT(compilationInfo.input.lazy);
size_t idx = 0;
compilationInfo.functions[idx++].set(compilationInfo.lazy->function());
compilationInfo.gcOutput.functions[idx++].set(
compilationInfo.input.lazy->function());
for (JS::GCCellPtr elem : compilationInfo.lazy->gcthings()) {
for (JS::GCCellPtr elem : compilationInfo.input.lazy->gcthings()) {
if (!elem.is<JSObject>()) {
continue;
}
compilationInfo.functions[idx++].set(&elem.as<JSObject>().as<JSFunction>());
compilationInfo.gcOutput.functions[idx++].set(
&elem.as<JSObject>().as<JSFunction>());
}
MOZ_ASSERT(idx == compilationInfo.functions.length());
MOZ_ASSERT(idx == compilationInfo.gcOutput.functions.length());
}
bool CompilationInfo::instantiateStencils() {
if (!functions.resize(scriptData.length())) {
if (!gcOutput.functions.resize(stencil.scriptData.length())) {
return false;
}
if (lazy) {
if (input.lazy) {
FunctionsFromExistingLazy(*this);
} else {
if (!InstantiateScriptSourceObject(cx, *this)) {
@ -571,7 +578,7 @@ bool CompilationInfo::instantiateStencils() {
UpdateEmittedInnerFunctions(*this);
if (lazy == nullptr) {
if (input.lazy == nullptr) {
LinkEnclosingLazyScript(*this);
}
@ -1202,38 +1209,38 @@ void CompilationInfo::dumpStencil(js::JSONPrinter& json) {
// FIXME: dump asmJS
json.beginListProperty("scriptData");
for (auto& data : scriptData) {
for (auto& data : stencil.scriptData) {
data.dump(json);
}
json.endList();
json.beginListProperty("regExpData");
for (auto& data : regExpData) {
for (auto& data : stencil.regExpData) {
data.dump(json);
}
json.endList();
json.beginListProperty("bigIntData");
for (auto& data : bigIntData) {
for (auto& data : stencil.bigIntData) {
data.dump(json);
}
json.endList();
json.beginListProperty("objLiteralData");
for (auto& data : objLiteralData) {
for (auto& data : stencil.objLiteralData) {
data.dump(json);
}
json.endList();
json.beginListProperty("scopeData");
for (auto& data : scopeData) {
for (auto& data : stencil.scopeData) {
data.dump(json);
}
json.endList();
if (scriptData[CompilationInfo::TopLevelIndex].isModule()) {
if (stencil.scriptData[CompilationInfo::TopLevelIndex].isModule()) {
json.beginObjectProperty("moduleMetadata");
moduleMetadata.dumpFields(json);
stencil.moduleMetadata.dumpFields(json);
json.endObject();
}

6
js/src/frontend/TokenStream.h
View File

@ -1541,7 +1541,7 @@ class TokenStreamCharsShared {
const ParserAtom* drainCharBufferIntoAtom() {
// Add to parser atoms table.
auto maybeId = this->compilationInfo->parserAtoms.internChar16(
auto maybeId = this->compilationInfo->stencil.parserAtoms.internChar16(
this->compilationInfo->cx, charBuffer.begin(), charBuffer.length());
if (maybeId.isErr()) {
return nullptr;
@ -1699,7 +1699,7 @@ template <>
MOZ_ALWAYS_INLINE const ParserAtom*
TokenStreamCharsBase<char16_t>::atomizeSourceChars(
mozilla::Span<const char16_t> units) {
return this->compilationInfo->parserAtoms
return this->compilationInfo->stencil.parserAtoms
.internChar16(this->compilationInfo->cx, units.data(), units.size())
.unwrapOr(nullptr);
}
@ -1708,7 +1708,7 @@ template <>
/* static */ MOZ_ALWAYS_INLINE const ParserAtom*
TokenStreamCharsBase<mozilla::Utf8Unit>::atomizeSourceChars(
mozilla::Span<const mozilla::Utf8Unit> units) {
return this->compilationInfo->parserAtoms
return this->compilationInfo->stencil.parserAtoms
.internUtf8(this->compilationInfo->cx, units.data(), units.size())
.unwrapOr(nullptr);
}

4
js/src/jsnum.cpp
View File

@ -859,7 +859,7 @@ const frontend::ParserAtom* js::Int32ToParserAtom(
indexValue.emplace(si);
}
return compilationInfo.parserAtoms
return compilationInfo.stencil.parserAtoms
.internAscii(compilationInfo.cx, start, length)
.unwrapOr(nullptr);
}
@ -1667,7 +1667,7 @@ const frontend::ParserAtom* js::NumberToParserAtom(
numStr < cbuf.sbuf + cbuf.sbufSize);
size_t length = strlen(numStr);
return compilationInfo.parserAtoms
return compilationInfo.stencil.parserAtoms
.internAscii(compilationInfo.cx, numStr, length)
.unwrapOr(nullptr);
}

2
js/src/shell/js.cpp
View File

@ -5223,7 +5223,7 @@ static bool FrontendTest(JSContext* cx,
return false;
}
builder.finishFunctionDecls(compilationInfo.moduleMetadata);
builder.finishFunctionDecls(compilationInfo.stencil.moduleMetadata);
#if defined(DEBUG) || defined(JS_JITSPEW)
compilationInfo.dumpStencil();

4
js/src/util/StringBuffer.cpp
View File

@ -162,7 +162,7 @@ const frontend::ParserAtom* StringBuffer::finishParserAtom(
}
if (isLatin1()) {
auto result = compilationInfo.parserAtoms.internLatin1(
auto result = compilationInfo.stencil.parserAtoms.internLatin1(
cx_, latin1Chars().begin(), len);
if (result.isErr()) {
return nullptr;
@ -171,7 +171,7 @@ const frontend::ParserAtom* StringBuffer::finishParserAtom(
return result.unwrap();
}
auto result = compilationInfo.parserAtoms.internChar16(
auto result = compilationInfo.stencil.parserAtoms.internChar16(
cx_, twoByteChars().begin(), len);
if (result.isErr()) {
return nullptr;

7
js/src/vm/CompilationAndEvaluation.cpp
View File

@ -75,8 +75,8 @@ static JSScript* CompileSourceBuffer(JSContext* cx,
SourceExtent extent = SourceExtent::makeGlobalExtent(
srcBuf.length(), options.lineno, options.column);
frontend::GlobalSharedContext globalsc(cx, scopeKind, compilationInfo,
compilationInfo.directives, extent);
frontend::GlobalSharedContext globalsc(
cx, scopeKind, compilationInfo, compilationInfo.state.directives, extent);
return frontend::CompileGlobalScript(compilationInfo, globalsc, srcBuf);
}
@ -487,7 +487,8 @@ static bool EvaluateSourceBuffer(JSContext* cx, ScopeKind scopeKind,
SourceExtent extent = SourceExtent::makeGlobalExtent(
srcBuf.length(), options.lineno, options.column);
frontend::GlobalSharedContext globalsc(cx, scopeKind, compilationInfo,
compilationInfo.directives, extent);
compilationInfo.state.directives,
extent);
script = frontend::CompileGlobalScript(compilationInfo, globalsc, srcBuf);
if (!script) {
return false;

8
js/src/vm/HelperThreads.cpp
View File

@ -613,8 +613,8 @@ void ScriptParseTask<Unit>::parse(JSContext* cx) {
uint32_t len = data.length();
SourceExtent extent =
SourceExtent::makeGlobalExtent(len, options.lineno, options.column);
frontend::GlobalSharedContext globalsc(cx, scopeKind, compilationInfo,
compilationInfo.directives, extent);
frontend::GlobalSharedContext globalsc(
cx, scopeKind, compilationInfo, compilationInfo.state.directives, extent);
JSScript* script =
frontend::CompileGlobalScript(compilationInfo, globalsc, data);
@ -622,8 +622,8 @@ void ScriptParseTask<Unit>::parse(JSContext* cx) {
// we must finish initializing the SSO. This is because there may be valid
// inner scripts observable by the debugger which reference the partially-
// initialized SSO.
if (compilationInfo.sourceObject) {
sourceObjects.infallibleAppend(compilationInfo.sourceObject);
if (compilationInfo.gcOutput.sourceObject) {
sourceObjects.infallibleAppend(compilationInfo.gcOutput.sourceObject);
}
if (script) {

2
js/src/vm/Instrumentation.cpp
View File

@ -97,7 +97,7 @@ const frontend::ParserAtom* RealmInstrumentation::getInstrumentationKindName(
frontend::CompilationInfo& compilationInfo, InstrumentationKind kind) {
for (size_t i = 0; i < mozilla::ArrayLength(instrumentationNames); i++) {
if (kind == (InstrumentationKind)(1 << i)) {
return compilationInfo.parserAtoms
return compilationInfo.stencil.parserAtoms
.internAscii(compilationInfo.cx, instrumentationNames[i],
strlen(instrumentationNames[i]))
.unwrapOr(nullptr);

2
js/src/vm/JSScript.cpp
View File

@ -3736,7 +3736,7 @@ JSScript* JSScript::fromStencil(JSContext* cx,
}
RootedScript script(
cx, Create(cx, functionOrGlobal, compilationInfo.sourceObject,
cx, Create(cx, functionOrGlobal, compilationInfo.gcOutput.sourceObject,
scriptStencil.extent, scriptStencil.immutableFlags));
if (!script) {
return nullptr;

46
js/src/vm/Scope.cpp
View File

@ -1950,8 +1950,8 @@ bool ScopeStencil::createForFunctionScope(
}
}
*index = compilationInfo.scopeData.length();
return compilationInfo.scopeData.emplaceBack(
*index = compilationInfo.stencil.scopeData.length();
return compilationInfo.stencil.scopeData.emplaceBack(
ScopeKind::Function, enclosing, firstFrameSlot, envShape,
ownedData.release(), mozilla::Some(functionIndex), isArrow);
}
@ -1984,9 +1984,9 @@ bool ScopeStencil::createForLexicalScope(
}
}
*index = compilationInfo.scopeData.length();
return compilationInfo.scopeData.emplaceBack(kind, enclosing, firstFrameSlot,
envShape, ownedData.release());
*index = compilationInfo.stencil.scopeData.length();
return compilationInfo.stencil.scopeData.emplaceBack(
kind, enclosing, firstFrameSlot, envShape, ownedData.release());
}
bool ScopeStencil::createForVarScope(
@ -2016,9 +2016,9 @@ bool ScopeStencil::createForVarScope(
}
}
*index = compilationInfo.scopeData.length();
return compilationInfo.scopeData.emplaceBack(kind, enclosing, firstFrameSlot,
envShape, ownedData.release());
*index = compilationInfo.stencil.scopeData.length();
return compilationInfo.stencil.scopeData.emplaceBack(
kind, enclosing, firstFrameSlot, envShape, ownedData.release());
}
/* static */
@ -2051,9 +2051,9 @@ bool ScopeStencil::createForGlobalScope(
}
}
*index = compilationInfo.scopeData.length();
return compilationInfo.scopeData.emplaceBack(kind, enclosing, firstFrameSlot,
envShape, ownedData.release());
*index = compilationInfo.stencil.scopeData.length();
return compilationInfo.stencil.scopeData.emplaceBack(
kind, enclosing, firstFrameSlot, envShape, ownedData.release());
}
/* static */
@ -2085,9 +2085,9 @@ bool ScopeStencil::createForEvalScope(
}
}
*index = compilationInfo.scopeData.length();
return compilationInfo.scopeData.emplaceBack(kind, enclosing, firstFrameSlot,
envShape, ownedData.release());
*index = compilationInfo.stencil.scopeData.length();
return compilationInfo.stencil.scopeData.emplaceBack(
kind, enclosing, firstFrameSlot, envShape, ownedData.release());
}
/* static */
@ -2127,10 +2127,10 @@ bool ScopeStencil::createForModuleScope(
}
}
*index = compilationInfo.scopeData.length();
return compilationInfo.scopeData.emplaceBack(ScopeKind::Module, enclosing,
firstFrameSlot, envShape,
ownedData.release());
*index = compilationInfo.stencil.scopeData.length();
return compilationInfo.stencil.scopeData.emplaceBack(
ScopeKind::Module, enclosing, firstFrameSlot, envShape,
ownedData.release());
}
template <typename SpecificEnvironmentT>
@ -2162,9 +2162,9 @@ bool ScopeStencil::createForWithScope(
uint32_t firstFrameSlot = 0;
mozilla::Maybe<uint32_t> envShape;
*index = compilationInfo.scopeData.length();
return compilationInfo.scopeData.emplaceBack(ScopeKind::With, enclosing,
firstFrameSlot, envShape);
*index = compilationInfo.stencil.scopeData.length();
return compilationInfo.stencil.scopeData.emplaceBack(
ScopeKind::With, enclosing, firstFrameSlot, envShape);
}
template <typename SpecificScopeT>
@ -2186,7 +2186,7 @@ ScopeStencil::createSpecificScopeData<FunctionScope>(
}
// Initialize the GCPtrs in the FunctionScope::Data.
data->canonicalFunction = compilationInfo.functions[*functionIndex_];
data->canonicalFunction = compilationInfo.gcOutput.functions[*functionIndex_];
return data;
}
@ -2202,7 +2202,7 @@ UniquePtr<ModuleScope::Data> ScopeStencil::createSpecificScopeData<ModuleScope>(
}
// Initialize the GCPtrs in the ModuleScope::Data.
data->module = compilationInfo.module;
data->module = compilationInfo.gcOutput.module;
return data;
}

8
js/src/wasm/AsmJS.cpp
View File

@ -1386,8 +1386,8 @@ class MOZ_STACK_CLASS JS_HAZ_ROOTED ModuleValidatorShared {
auto AddMathFunction = [this](const char* name,
AsmJSMathBuiltinFunction func) {
auto mbAtom =
compilationInfo_.parserAtoms.internAscii(cx_, name, strlen(name));
auto mbAtom = compilationInfo_.stencil.parserAtoms.internAscii(
cx_, name, strlen(name));
if (mbAtom.isErr()) {
return false;
}
@ -1417,8 +1417,8 @@ class MOZ_STACK_CLASS JS_HAZ_ROOTED ModuleValidatorShared {
};
auto AddMathConstant = [this](const char* name, double cst) {
auto mbAtom =
compilationInfo_.parserAtoms.internAscii(cx_, name, strlen(name));
auto mbAtom = compilationInfo_.stencil.parserAtoms.internAscii(
cx_, name, strlen(name));
if (mbAtom.isErr()) {
return false;
}