The Tor Browser: js/src/frontend/BytecodeCompiler.cpp@6474c204b198 (annotated)

js/src/frontend/BytecodeCompiler.cpp@6474c204b198 (annotated)

js/src/frontend/BytecodeCompiler.cpp

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
  * vim: set ts=8 sts=4 et sw=4 tw=99:
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 #include "frontend/BytecodeCompiler.h"
 #include "jscntxt.h"
 #include "jsscript.h"
 #include "frontend/BytecodeEmitter.h"
 #include "frontend/FoldConstants.h"
 #include "frontend/NameFunctions.h"
 #include "frontend/Parser.h"
 #include "jit/AsmJSLink.h"
 #include "vm/GlobalObject.h"
 #include "vm/TraceLogging.h"
 #include "jsobjinlines.h"
 #include "jsscriptinlines.h"
 #include "frontend/Parser-inl.h"
 using namespace js;
 using namespace js::frontend;
 using mozilla::Maybe;
 static bool
 CheckLength(ExclusiveContext *cx, SourceBufferHolder &srcBuf)
 {
     // Note this limit is simply so we can store sourceStart and sourceEnd in
     // JSScript as 32-bits. It could be lifted fairly easily, since the compiler
     // is using size_t internally already.
     if (srcBuf.length() > UINT32_MAX) {
         if (cx->isJSContext())
             JS_ReportErrorNumber(cx->asJSContext(), js_GetErrorMessage, nullptr,
                                  JSMSG_SOURCE_TOO_LONG);
         return false;
     }
     return true;
 }
 static bool
 SetDisplayURL(ExclusiveContext *cx, TokenStream &tokenStream, ScriptSource *ss)
 {
     if (tokenStream.hasDisplayURL()) {
         if (!ss->setDisplayURL(cx, tokenStream.displayURL()))
             return false;
     }
     return true;
 }
 static bool
 SetSourceMap(ExclusiveContext *cx, TokenStream &tokenStream, ScriptSource *ss)
 {
     if (tokenStream.hasSourceMapURL()) {
         if (!ss->setSourceMapURL(cx, tokenStream.sourceMapURL()))
             return false;
     }
     return true;
 }
 static bool
 CheckArgumentsWithinEval(JSContext *cx, Parser<FullParseHandler> &parser, HandleFunction fun)
 {
     if (fun->hasRest()) {
         // It's an error to use |arguments| in a function that has a rest
         // parameter.
         parser.report(ParseError, false, nullptr, JSMSG_ARGUMENTS_AND_REST);
         return false;
     }
     // Force construction of arguments objects for functions that use
     // |arguments| within an eval.
     RootedScript script(cx, fun->getOrCreateScript(cx));
     if (!script)
         return false;
     if (script->argumentsHasVarBinding()) {
         if (!JSScript::argumentsOptimizationFailed(cx, script))
             return false;
     }
     // It's an error to use |arguments| in a legacy generator expression.
     if (script->isGeneratorExp() && script->isLegacyGenerator()) {
         parser.report(ParseError, false, nullptr, JSMSG_BAD_GENEXP_BODY, js_arguments_str);
         return false;
     }
     return true;
 }
 static bool
 MaybeCheckEvalFreeVariables(ExclusiveContext *cxArg, HandleScript evalCaller, HandleObject scopeChain,
                             Parser<FullParseHandler> &parser,
                             ParseContext<FullParseHandler> &pc)
 {
     if (!evalCaller || !evalCaller->functionOrCallerFunction())
         return true;
     // Eval scripts are only compiled on the main thread.
     JSContext *cx = cxArg->asJSContext();
     // Watch for uses of 'arguments' within the evaluated script, both as
     // free variables and as variables redeclared with 'var'.
     RootedFunction fun(cx, evalCaller->functionOrCallerFunction());
     HandlePropertyName arguments = cx->names().arguments;
     for (AtomDefnRange r = pc.lexdeps->all(); !r.empty(); r.popFront()) {
         if (r.front().key() == arguments) {
             if (!CheckArgumentsWithinEval(cx, parser, fun))
                 return false;
         }
     }
     for (AtomDefnListMap::Range r = pc.decls().all(); !r.empty(); r.popFront()) {
         if (r.front().key() == arguments) {
             if (!CheckArgumentsWithinEval(cx, parser, fun))
                 return false;
         }
     }
     // If the eval'ed script contains any debugger statement, force construction
     // of arguments objects for the caller script and any other scripts it is
     // transitively nested inside. The debugger can access any variable on the
     // scope chain.
     if (pc.sc->hasDebuggerStatement()) {
         RootedObject scope(cx, scopeChain);
         while (scope->is<ScopeObject>() || scope->is<DebugScopeObject>()) {
             if (scope->is<CallObject>() && !scope->as<CallObject>().isForEval()) {
                 RootedScript script(cx, scope->as<CallObject>().callee().getOrCreateScript(cx));
                 if (!script)
                     return false;
                 if (script->argumentsHasVarBinding()) {
                     if (!JSScript::argumentsOptimizationFailed(cx, script))
                         return false;
                 }
             }
             scope = scope->enclosingScope();
         }
     }
     return true;
 }
 static inline bool
 CanLazilyParse(ExclusiveContext *cx, const ReadOnlyCompileOptions &options)
 {
     return options.canLazilyParse &&
         options.compileAndGo &&
         !cx->compartment()->options().discardSource() &&
         !options.sourceIsLazy &&
         !(cx->compartment()->debugMode() &&
           cx->compartment()->runtimeFromAnyThread()->debugHooks.newScriptHook);
 }
 static void
 MarkFunctionsWithinEvalScript(JSScript *script)
 {
     // Mark top level functions in an eval script as being within an eval and,
     // if applicable, inside a with statement.
     if (!script->hasObjects())
         return;
     ObjectArray *objects = script->objects();
     size_t start = script->innerObjectsStart();
     for (size_t i = start; i < objects->length; i++) {
         JSObject *obj = objects->vector[i];
         if (obj->is<JSFunction>()) {
             JSFunction *fun = &obj->as<JSFunction>();
             if (fun->hasScript())
                 fun->nonLazyScript()->setDirectlyInsideEval();
             else if (fun->isInterpretedLazy())
                 fun->lazyScript()->setDirectlyInsideEval();
         }
     }
 }
 void
 frontend::MaybeCallSourceHandler(JSContext *cx, const ReadOnlyCompileOptions &options,
                                  SourceBufferHolder &srcBuf)
 {
     JSSourceHandler listener = cx->runtime()->debugHooks.sourceHandler;
     void *listenerData = cx->runtime()->debugHooks.sourceHandlerData;
     if (listener) {
         void *listenerTSData;
         listener(options.filename(), options.lineno, srcBuf.get(), srcBuf.length(),
                  &listenerTSData, listenerData);
     }
 }
 ScriptSourceObject *
 frontend::CreateScriptSourceObject(ExclusiveContext *cx, const ReadOnlyCompileOptions &options)
 {
     ScriptSource *ss = cx->new_<ScriptSource>();
     if (!ss)
         return nullptr;
     ScriptSourceHolder ssHolder(ss);
     if (!ss->initFromOptions(cx, options))
         return nullptr;
     return ScriptSourceObject::create(cx, ss, options);
 }
 JSScript *
 frontend::CompileScript(ExclusiveContext *cx, LifoAlloc *alloc, HandleObject scopeChain,
                         HandleScript evalCaller,
                         const ReadOnlyCompileOptions &options,
                         SourceBufferHolder &srcBuf,
                         JSString *source_ /* = nullptr */,
                         unsigned staticLevel /* = 0 */,
                         SourceCompressionTask *extraSct /* = nullptr */)
 {
     JS_ASSERT(srcBuf.get());
     RootedString source(cx, source_);
     js::TraceLogger *logger = nullptr;
     if (cx->isJSContext())
         logger = TraceLoggerForMainThread(cx->asJSContext()->runtime());
     else
         logger = TraceLoggerForCurrentThread();
     uint32_t logId = js::TraceLogCreateTextId(logger, options);
     js::AutoTraceLog scriptLogger(logger, logId);
     js::AutoTraceLog typeLogger(logger, TraceLogger::ParserCompileScript);
     if (cx->isJSContext())
         MaybeCallSourceHandler(cx->asJSContext(), options, srcBuf);
     /*
      * The scripted callerFrame can only be given for compile-and-go scripts
      * and non-zero static level requires callerFrame.
      */
     JS_ASSERT_IF(evalCaller, options.compileAndGo);
     JS_ASSERT_IF(evalCaller, options.forEval);
     JS_ASSERT_IF(staticLevel != 0, evalCaller);
     if (!CheckLength(cx, srcBuf))
         return nullptr;
     JS_ASSERT_IF(staticLevel != 0, !options.sourceIsLazy);
     RootedScriptSource sourceObject(cx, CreateScriptSourceObject(cx, options));
     if (!sourceObject)
         return nullptr;
     ScriptSource *ss = sourceObject->source();
     SourceCompressionTask mysct(cx);
     SourceCompressionTask *sct = extraSct ? extraSct : &mysct;
     if (!cx->compartment()->options().discardSource()) {
         if (options.sourceIsLazy)
             ss->setSourceRetrievable();
         else if (!ss->setSourceCopy(cx, srcBuf, false, sct))
             return nullptr;
     }
     bool canLazilyParse = CanLazilyParse(cx, options);
     Maybe<Parser<SyntaxParseHandler> > syntaxParser;
     if (canLazilyParse) {
         syntaxParser.construct(cx, alloc, options, srcBuf.get(), srcBuf.length(),
                                /* foldConstants = */ false,
                                (Parser<SyntaxParseHandler> *) nullptr,
                                (LazyScript *) nullptr);
     }
     Parser<FullParseHandler> parser(cx, alloc, options, srcBuf.get(), srcBuf.length(),
                                     /* foldConstants = */ true,
                                     canLazilyParse ? &syntaxParser.ref() : nullptr, nullptr);
     parser.sct = sct;
     parser.ss = ss;
     Directives directives(options.strictOption);
     GlobalSharedContext globalsc(cx, scopeChain, directives, options.extraWarningsOption);
     bool savedCallerFun = options.compileAndGo &&
                           evalCaller && evalCaller->functionOrCallerFunction();
     Rooted<JSScript*> script(cx, JSScript::Create(cx, NullPtr(), savedCallerFun,
                                                   options, staticLevel, sourceObject, 0,
                                                   srcBuf.length()));
     if (!script)
         return nullptr;
     // We can specialize a bit for the given scope chain if that scope chain is the global object.
     JSObject *globalScope =
         scopeChain && scopeChain == &scopeChain->global() ? (JSObject*) scopeChain : nullptr;
     JS_ASSERT_IF(globalScope, globalScope->isNative());
     JS_ASSERT_IF(globalScope, JSCLASS_HAS_GLOBAL_FLAG_AND_SLOTS(globalScope->getClass()));
     BytecodeEmitter::EmitterMode emitterMode =
         options.selfHostingMode ? BytecodeEmitter::SelfHosting : BytecodeEmitter::Normal;
     BytecodeEmitter bce(/* parent = */ nullptr, &parser, &globalsc, script, options.forEval,
                         evalCaller, !!globalScope, options.lineno, emitterMode);
     if (!bce.init())
         return nullptr;
     // Syntax parsing may cause us to restart processing of top level
     // statements in the script. Use Maybe<> so that the parse context can be
     // reset when this occurs.
     Maybe<ParseContext<FullParseHandler> > pc;
     pc.construct(&parser, (GenericParseContext *) nullptr, (ParseNode *) nullptr, &globalsc,
                  (Directives *) nullptr, staticLevel, /* bodyid = */ 0,
                  /* blockScopeDepth = */ 0);
     if (!pc.ref().init(parser.tokenStream))
         return nullptr;
     /* If this is a direct call to eval, inherit the caller's strictness.  */
     if (evalCaller && evalCaller->strict())
         globalsc.strict = true;
     if (options.compileAndGo) {
         if (source) {
             /*
              * Save eval program source in script->atoms[0] for the
              * eval cache (see EvalCacheLookup in jsobj.cpp).
              */
             JSAtom *atom = AtomizeString(cx, source);
             jsatomid _;
             if (!atom || !bce.makeAtomIndex(atom, &_))
                 return nullptr;
         }
         if (evalCaller && evalCaller->functionOrCallerFunction()) {
             /*
              * An eval script in a caller frame needs to have its enclosing
              * function captured in case it refers to an upvar, and someone
              * wishes to decompile it while it's running.
              */
             JSFunction *fun = evalCaller->functionOrCallerFunction();
             Directives directives(/* strict = */ fun->strict());
             ObjectBox *funbox = parser.newFunctionBox(/* fn = */ nullptr, fun, pc.addr(),
                                                       directives, fun->generatorKind());
             if (!funbox)
                 return nullptr;
             bce.objectList.add(funbox);
         }
     }
     bool canHaveDirectives = true;
     for (;;) {
         TokenKind tt = parser.tokenStream.peekToken(TokenStream::Operand);
         if (tt <= TOK_EOF) {
             if (tt == TOK_EOF)
                 break;
             JS_ASSERT(tt == TOK_ERROR);
             return nullptr;
         }
         TokenStream::Position pos(parser.keepAtoms);
         parser.tokenStream.tell(&pos);
         ParseNode *pn = parser.statement(canHaveDirectives);
         if (!pn) {
             if (parser.hadAbortedSyntaxParse()) {
                 // Parsing inner functions lazily may lead the parser into an
                 // unrecoverable state and may require starting over on the top
                 // level statement. Restart the parse; syntax parsing has
                 // already been disabled for the parser and the result will not
                 // be ambiguous.
                 parser.clearAbortedSyntaxParse();
                 parser.tokenStream.seek(pos);
                 // Destroying the parse context will destroy its free
                 // variables, so check if any deoptimization is needed.
                 if (!MaybeCheckEvalFreeVariables(cx, evalCaller, scopeChain, parser, pc.ref()))
                     return nullptr;
                 pc.destroy();
                 pc.construct(&parser, (GenericParseContext *) nullptr, (ParseNode *) nullptr,
                              &globalsc, (Directives *) nullptr, staticLevel, /* bodyid = */ 0,
                              script->bindings.numBlockScoped());
                 if (!pc.ref().init(parser.tokenStream))
                     return nullptr;
                 JS_ASSERT(parser.pc == pc.addr());
                 pn = parser.statement();
             }
             if (!pn) {
                 JS_ASSERT(!parser.hadAbortedSyntaxParse());
                 return nullptr;
             }
         }
         // Accumulate the maximum block scope depth, so that EmitTree can assert
         // when emitting JSOP_GETLOCAL that the local is indeed within the fixed
         // part of the stack frame.
         script->bindings.updateNumBlockScoped(pc.ref().blockScopeDepth);
         if (canHaveDirectives) {
             if (!parser.maybeParseDirective(/* stmtList = */ nullptr, pn, &canHaveDirectives))
                 return nullptr;
         }
         if (!FoldConstants(cx, &pn, &parser))
             return nullptr;
         if (!NameFunctions(cx, pn))
             return nullptr;
         if (!EmitTree(cx, &bce, pn))
             return nullptr;
         parser.handler.freeTree(pn);
     }
     if (!MaybeCheckEvalFreeVariables(cx, evalCaller, scopeChain, parser, pc.ref()))
         return nullptr;
     if (!SetDisplayURL(cx, parser.tokenStream, ss))
         return nullptr;
     if (!SetSourceMap(cx, parser.tokenStream, ss))
         return nullptr;
     /*
      * Source map URLs passed as a compile option (usually via a HTTP source map
      * header) override any source map urls passed as comment pragmas.
      */
     if (options.sourceMapURL()) {
         if (!ss->setSourceMapURL(cx, options.sourceMapURL()))
             return nullptr;
     }
     /*
      * Nowadays the threaded interpreter needs a last return instruction, so we
      * do have to emit that here.
      */
     if (Emit1(cx, &bce, JSOP_RETRVAL) < 0)
         return nullptr;
     // Global/eval script bindings are always empty (all names are added to the
     // scope dynamically via JSOP_DEFFUN/VAR).  They may have block-scoped
     // locals, however, which are allocated to the fixed part of the stack
     // frame.
     InternalHandle<Bindings*> bindings(script, &script->bindings);
     if (!Bindings::initWithTemporaryStorage(cx, bindings, 0, 0, nullptr,
                                             pc.ref().blockScopeDepth))
         return nullptr;
     if (!JSScript::fullyInitFromEmitter(cx, script, &bce))
         return nullptr;
     // Note that this marking must happen before we tell Debugger
     // about the new script, in case Debugger delazifies the script's
     // inner functions.
     if (options.forEval)
         MarkFunctionsWithinEvalScript(script);
     bce.tellDebuggerAboutCompiledScript(cx);
     if (sct && !extraSct && !sct->complete())
         return nullptr;
     return script;
 }
 bool
 frontend::CompileLazyFunction(JSContext *cx, Handle<LazyScript*> lazy, const jschar *chars, size_t length)
 {
     JS_ASSERT(cx->compartment() == lazy->functionNonDelazifying()->compartment());
     CompileOptions options(cx, lazy->version());
     options.setOriginPrincipals(lazy->originPrincipals())
            .setFileAndLine(lazy->source()->filename(), lazy->lineno())
            .setColumn(lazy->column())
            .setCompileAndGo(true)
            .setNoScriptRval(false)
            .setSelfHostingMode(false);
     js::TraceLogger *logger = js::TraceLoggerForMainThread(cx->runtime());
     uint32_t logId = js::TraceLogCreateTextId(logger, options);
     js::AutoTraceLog scriptLogger(logger, logId);
     js::AutoTraceLog typeLogger(logger, TraceLogger::ParserCompileLazy);
     Parser<FullParseHandler> parser(cx, &cx->tempLifoAlloc(), options, chars, length,
                                     /* foldConstants = */ true, nullptr, lazy);
     uint32_t staticLevel = lazy->staticLevel(cx);
     Rooted<JSFunction*> fun(cx, lazy->functionNonDelazifying());
     JS_ASSERT(!lazy->isLegacyGenerator());
     ParseNode *pn = parser.standaloneLazyFunction(fun, staticLevel, lazy->strict(),
                                                   lazy->generatorKind());
     if (!pn)
         return false;
     if (!NameFunctions(cx, pn))
         return false;
     RootedObject enclosingScope(cx, lazy->enclosingScope());
     RootedScriptSource sourceObject(cx, lazy->sourceObject());
     JS_ASSERT(sourceObject);
     Rooted<JSScript*> script(cx, JSScript::Create(cx, enclosingScope, false,
                                                   options, staticLevel,
                                                   sourceObject, lazy->begin(), lazy->end()));
     if (!script)
         return false;
     script->bindings = pn->pn_funbox->bindings;
     if (lazy->directlyInsideEval())
         script->setDirectlyInsideEval();
     if (lazy->usesArgumentsAndApply())
         script->setUsesArgumentsAndApply();
     if (lazy->hasBeenCloned())
         script->setHasBeenCloned();
     BytecodeEmitter bce(/* parent = */ nullptr, &parser, pn->pn_funbox, script, options.forEval,
                         /* evalCaller = */ NullPtr(), /* hasGlobalScope = */ true,
                         options.lineno, BytecodeEmitter::LazyFunction);
     if (!bce.init())
         return false;
     if (lazy->treatAsRunOnce())
         bce.lazyRunOnceLambda = true;
     return EmitFunctionScript(cx, &bce, pn->pn_body);
 }
 // Compile a JS function body, which might appear as the value of an event
 // handler attribute in an HTML <INPUT> tag, or in a Function() constructor.
 static bool
 CompileFunctionBody(JSContext *cx, MutableHandleFunction fun, const ReadOnlyCompileOptions &options,
                     const AutoNameVector &formals, SourceBufferHolder &srcBuf,
                     GeneratorKind generatorKind)
 {
     js::TraceLogger *logger = js::TraceLoggerForMainThread(cx->runtime());
     uint32_t logId = js::TraceLogCreateTextId(logger, options);
     js::AutoTraceLog scriptLogger(logger, logId);
     js::AutoTraceLog typeLogger(logger, TraceLogger::ParserCompileFunction);
     // FIXME: make Function pass in two strings and parse them as arguments and
     // ProgramElements respectively.
     MaybeCallSourceHandler(cx, options, srcBuf);
     if (!CheckLength(cx, srcBuf))
         return false;
     RootedScriptSource sourceObject(cx, CreateScriptSourceObject(cx, options));
     if (!sourceObject)
         return nullptr;
     ScriptSource *ss = sourceObject->source();
     SourceCompressionTask sct(cx);
     JS_ASSERT(!options.sourceIsLazy);
     if (!cx->compartment()->options().discardSource()) {
         if (!ss->setSourceCopy(cx, srcBuf, true, &sct))
             return false;
     }
     bool canLazilyParse = CanLazilyParse(cx, options);
     Maybe<Parser<SyntaxParseHandler> > syntaxParser;
     if (canLazilyParse) {
         syntaxParser.construct(cx, &cx->tempLifoAlloc(),
                                options, srcBuf.get(), srcBuf.length(),
                                /* foldConstants = */ false,
                                (Parser<SyntaxParseHandler> *) nullptr,
                                (LazyScript *) nullptr);
     }
     JS_ASSERT(!options.forEval);
     Parser<FullParseHandler> parser(cx, &cx->tempLifoAlloc(),
                                     options, srcBuf.get(), srcBuf.length(),
                                     /* foldConstants = */ true,
                                     canLazilyParse ? &syntaxParser.ref() : nullptr, nullptr);
     parser.sct = &sct;
     parser.ss = ss;
     JS_ASSERT(fun);
     JS_ASSERT(fun->isTenured());
     fun->setArgCount(formals.length());
     // Speculatively parse using the default directives implied by the context.
     // If a directive is encountered (e.g., "use strict") that changes how the
     // function should have been parsed, we backup and reparse with the new set
     // of directives.
     Directives directives(options.strictOption);
     TokenStream::Position start(parser.keepAtoms);
     parser.tokenStream.tell(&start);
     ParseNode *fn;
     while (true) {
         Directives newDirectives = directives;
         fn = parser.standaloneFunctionBody(fun, formals, generatorKind, directives, &newDirectives);
         if (fn)
             break;
         if (parser.hadAbortedSyntaxParse()) {
             // Hit some unrecoverable ambiguity during an inner syntax parse.
             // Syntax parsing has now been disabled in the parser, so retry
             // the parse.
             parser.clearAbortedSyntaxParse();
         } else {
             if (parser.tokenStream.hadError() || directives == newDirectives)
                 return false;
             // Assignment must be monotonic to prevent reparsing iloops
             JS_ASSERT_IF(directives.strict(), newDirectives.strict());
             JS_ASSERT_IF(directives.asmJS(), newDirectives.asmJS());
             directives = newDirectives;
         }
         parser.tokenStream.seek(start);
     }
     if (!NameFunctions(cx, fn))
         return false;
     if (fn->pn_funbox->function()->isInterpreted()) {
         JS_ASSERT(fun == fn->pn_funbox->function());
         Rooted<JSScript*> script(cx, JSScript::Create(cx, js::NullPtr(), false, options,
                                                       /* staticLevel = */ 0, sourceObject,
                                                       /* sourceStart = */ 0, srcBuf.length()));
         if (!script)
             return false;
         script->bindings = fn->pn_funbox->bindings;
         /*
          * The reason for checking fun->environment() below is that certain
          * consumers of JS::CompileFunction, namely
          * EventListenerManager::CompileEventHandlerInternal, passes in a
          * nullptr environment. This compiled function is never used, but
          * instead is cloned immediately onto the right scope chain.
          */
         BytecodeEmitter funbce(/* parent = */ nullptr, &parser, fn->pn_funbox, script,
                                /* insideEval = */ false, /* evalCaller = */ js::NullPtr(),
                                fun->environment() && fun->environment()->is<GlobalObject>(),
                                options.lineno);
         if (!funbce.init())
             return false;
         if (!EmitFunctionScript(cx, &funbce, fn->pn_body))
             return false;
     } else {
         fun.set(fn->pn_funbox->function());
         JS_ASSERT(IsAsmJSModuleNative(fun->native()));
     }
     if (!SetDisplayURL(cx, parser.tokenStream, ss))
         return false;
     if (!SetSourceMap(cx, parser.tokenStream, ss))
         return false;
     if (!sct.complete())
         return false;
     return true;
 }
 bool
 frontend::CompileFunctionBody(JSContext *cx, MutableHandleFunction fun,
                               const ReadOnlyCompileOptions &options,
                               const AutoNameVector &formals, JS::SourceBufferHolder &srcBuf)
 {
     return CompileFunctionBody(cx, fun, options, formals, srcBuf, NotGenerator);
 }
 bool
 frontend::CompileStarGeneratorBody(JSContext *cx, MutableHandleFunction fun,
                                    const ReadOnlyCompileOptions &options, const AutoNameVector &formals,
                                    JS::SourceBufferHolder &srcBuf)
 {
     return CompileFunctionBody(cx, fun, options, formals, srcBuf, StarGenerator);
 }

The Tor Browser / annotate

js/src/frontend/BytecodeCompiler.cpp@6474c204b198 (annotated)

js/src/frontend/BytecodeCompiler.cpp