Adding upstream version 86.0.1.upstream/86.0.1upstream

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

1 files changed, 581 insertions, 0 deletions

diff --git a/js/src/vm/CompilationAndEvaluation.cpp b/js/src/vm/CompilationAndEvaluation.cpp
new file mode 100644
index 0000000000..0490014a26
--- /dev/null
+++ b/js/src/vm/CompilationAndEvaluation.cpp
@@ -0,0 +1,581 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ * vim: set ts=8 sts=2 et sw=2 tw=80:
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/* Same-thread compilation and evaluation APIs. */
+
+#include "js/CompilationAndEvaluation.h"
+
+#include "mozilla/Maybe.h"      // mozilla::None, mozilla::Some
+#include "mozilla/TextUtils.h"  // mozilla::IsAscii
+#include "mozilla/Utf8.h"       // mozilla::Utf8Unit
+
+#include <utility>  // std::move
+
+#include "jstypes.h"  // JS_PUBLIC_API
+
+#include "frontend/BytecodeCompilation.h"  // frontend::CompileGlobalScript
+#include "frontend/CompilationInfo.h"  // for frontened::CompilationStencil, frontened::CompilationGCOutput
+#include "frontend/FullParseHandler.h"  // frontend::FullParseHandler
+#include "frontend/ParseContext.h"      // frontend::UsedNameTracker
+#include "frontend/Parser.h"            // frontend::Parser, frontend::ParseGoal
+#include "js/CharacterEncoding.h"  // JS::UTF8Chars, JS::UTF8CharsToNewTwoByteCharsZ
+#include "js/friend/ErrorMessages.h"  // js::GetErrorMessage, JSMSG_*
+#include "js/RootingAPI.h"            // JS::Rooted
+#include "js/SourceText.h"            // JS::SourceText
+#include "js/TypeDecls.h"          // JS::HandleObject, JS::MutableHandleScript
+#include "js/Utility.h"            // js::MallocArena, JS::UniqueTwoByteChars
+#include "js/Value.h"              // JS::Value
+#include "util/CompleteFile.h"     // js::FileContents, js::ReadCompleteFile
+#include "util/StringBuffer.h"     // js::StringBuffer
+#include "vm/EnvironmentObject.h"  // js::CreateNonSyntacticEnvironmentChain
+#include "vm/FunctionFlags.h"      // js::FunctionFlags
+#include "vm/Interpreter.h"        // js::Execute
+#include "vm/JSContext.h"          // JSContext
+
+#include "debugger/DebugAPI-inl.h"  // js::DebugAPI
+#include "vm/JSContext-inl.h"       // JSContext::check
+
+using mozilla::Utf8Unit;
+
+using JS::CompileOptions;
+using JS::HandleObject;
+using JS::ReadOnlyCompileOptions;
+using JS::SourceOwnership;
+using JS::SourceText;
+using JS::UniqueTwoByteChars;
+using JS::UTF8Chars;
+using JS::UTF8CharsToNewTwoByteCharsZ;
+
+using namespace js;
+
+JS_PUBLIC_API void JS::detail::ReportSourceTooLong(JSContext* cx) {
+  JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
+                            JSMSG_SOURCE_TOO_LONG);
+}
+
+template <typename Unit>
+static JSScript* CompileSourceBuffer(JSContext* cx,
+                                     const ReadOnlyCompileOptions& options,
+                                     SourceText<Unit>& srcBuf) {
+  ScopeKind scopeKind =
+      options.nonSyntacticScope ? ScopeKind::NonSyntactic : ScopeKind::Global;
+
+  MOZ_ASSERT(!cx->zone()->isAtomsZone());
+  AssertHeapIsIdle();
+  CHECK_THREAD(cx);
+
+  return frontend::CompileGlobalScript(cx, options, srcBuf, scopeKind);
+}
+
+JSScript* JS::Compile(JSContext* cx, const ReadOnlyCompileOptions& options,
+                      SourceText<char16_t>& srcBuf) {
+  return CompileSourceBuffer(cx, options, srcBuf);
+}
+
+JSScript* JS::Compile(JSContext* cx, const ReadOnlyCompileOptions& options,
+                      SourceText<Utf8Unit>& srcBuf) {
+  return CompileSourceBuffer(cx, options, srcBuf);
+}
+
+template <typename Unit>
+static JSScript* CompileSourceBufferAndStartIncrementalEncoding(
+    JSContext* cx, const ReadOnlyCompileOptions& options,
+    SourceText<Unit>& srcBuf) {
+  ScopeKind scopeKind =
+      options.nonSyntacticScope ? ScopeKind::NonSyntactic : ScopeKind::Global;
+
+  MOZ_ASSERT(!cx->zone()->isAtomsZone());
+  AssertHeapIsIdle();
+  CHECK_THREAD(cx);
+
+  Rooted<frontend::CompilationStencil> stencil(
+      cx, frontend::CompilationStencil(cx, options));
+  if (!stencil.get().input.initForGlobal(cx)) {
+    return nullptr;
+  }
+  if (!frontend::CompileGlobalScriptToStencil(cx, stencil.get(), srcBuf,
+                                              scopeKind)) {
+    return nullptr;
+  }
+
+  Rooted<frontend::CompilationGCOutput> gcOutput(cx);
+  if (!frontend::InstantiateStencils(cx, stencil.get(), gcOutput.get())) {
+    return nullptr;
+  }
+
+  RootedScript script(cx, gcOutput.get().script);
+  if (!script) {
+    return nullptr;
+  }
+
+  if (options.useStencilXDR) {
+    UniquePtr<XDRIncrementalEncoderBase> xdrEncoder;
+
+    if (!stencil.get().input.source()->xdrEncodeInitialStencil(
+            cx, stencil.get(), xdrEncoder)) {
+      return nullptr;
+    }
+
+    script->scriptSource()->setIncrementalEncoder(xdrEncoder.release());
+  } else {
+    if (!script->scriptSource()->xdrEncodeTopLevel(cx, script)) {
+      return nullptr;
+    }
+  }
+
+  return script;
+}
+
+JSScript* JS::CompileAndStartIncrementalEncoding(
+    JSContext* cx, const ReadOnlyCompileOptions& options,
+    SourceText<char16_t>& srcBuf) {
+  return CompileSourceBufferAndStartIncrementalEncoding(cx, options, srcBuf);
+}
+
+JSScript* JS::CompileAndStartIncrementalEncoding(
+    JSContext* cx, const ReadOnlyCompileOptions& options,
+    SourceText<Utf8Unit>& srcBuf) {
+  return CompileSourceBufferAndStartIncrementalEncoding(cx, options, srcBuf);
+}
+
+JSScript* JS::CompileUtf8File(JSContext* cx,
+                              const ReadOnlyCompileOptions& options,
+                              FILE* file) {
+  FileContents buffer(cx);
+  if (!ReadCompleteFile(cx, file, buffer)) {
+    return nullptr;
+  }
+
+  SourceText<Utf8Unit> srcBuf;
+  if (!srcBuf.init(cx, reinterpret_cast<const char*>(buffer.begin()),
+                   buffer.length(), SourceOwnership::Borrowed)) {
+    return nullptr;
+  }
+
+  return CompileSourceBuffer(cx, options, srcBuf);
+}
+
+JSScript* JS::CompileUtf8Path(JSContext* cx,
+                              const ReadOnlyCompileOptions& optionsArg,
+                              const char* filename) {
+  AutoFile file;
+  if (!file.open(cx, filename)) {
+    return nullptr;
+  }
+
+  CompileOptions options(cx, optionsArg);
+  options.setFileAndLine(filename, 1);
+  return CompileUtf8File(cx, options, file.fp());
+}
+
+JS_PUBLIC_API bool JS_Utf8BufferIsCompilableUnit(JSContext* cx,
+                                                 HandleObject obj,
+                                                 const char* utf8,
+                                                 size_t length) {
+  AssertHeapIsIdle();
+  CHECK_THREAD(cx);
+  cx->check(obj);
+
+  cx->clearPendingException();
+
+  JS::UniqueTwoByteChars chars{
+      UTF8CharsToNewTwoByteCharsZ(cx, UTF8Chars(utf8, length), &length,
+                                  js::MallocArena)
+          .get()};
+  if (!chars) {
+    return true;
+  }
+
+  // Return true on any out-of-memory error or non-EOF-related syntax error, so
+  // our caller doesn't try to collect more buffered source.
+  bool result = true;
+
+  using frontend::FullParseHandler;
+  using frontend::ParseGoal;
+  using frontend::Parser;
+
+  CompileOptions options(cx);
+  Rooted<frontend::CompilationStencil> stencil(
+      cx, frontend::CompilationStencil(cx, options));
+  if (!stencil.get().input.initForGlobal(cx)) {
+    return false;
+  }
+
+  LifoAllocScope allocScope(&cx->tempLifoAlloc());
+  frontend::CompilationState compilationState(cx, allocScope, options,
+                                              stencil.get());
+
+  JS::AutoSuppressWarningReporter suppressWarnings(cx);
+  Parser<FullParseHandler, char16_t> parser(cx, options, chars.get(), length,
+                                            /* foldConstants = */ true,
+                                            stencil.get(), compilationState,
+                                            nullptr, nullptr);
+  if (!parser.checkOptions() || !parser.parse()) {
+    // We ran into an error. If it was because we ran out of source, we
+    // return false so our caller knows to try to collect more buffered
+    // source.
+    if (parser.isUnexpectedEOF()) {
+      result = false;
+    }
+
+    cx->clearPendingException();
+  }
+
+  return result;
+}
+
+class FunctionCompiler {
+ private:
+  JSContext* const cx_;
+  RootedAtom nameAtom_;
+  StringBuffer funStr_;
+
+  uint32_t parameterListEnd_ = 0;
+  bool nameIsIdentifier_ = true;
+
+ public:
+  explicit FunctionCompiler(JSContext* cx)
+      : cx_(cx), nameAtom_(cx), funStr_(cx) {
+    AssertHeapIsIdle();
+    CHECK_THREAD(cx);
+    MOZ_ASSERT(!cx->zone()->isAtomsZone());
+  }
+
+  MOZ_MUST_USE bool init(const char* name, unsigned nargs,
+                         const char* const* argnames) {
+    if (!funStr_.ensureTwoByteChars()) {
+      return false;
+    }
+    if (!funStr_.append("function ")) {
+      return false;
+    }
+
+    if (name) {
+      size_t nameLen = strlen(name);
+
+      nameAtom_ = Atomize(cx_, name, nameLen);
+      if (!nameAtom_) {
+        return false;
+      }
+
+      // If the name is an identifier, we can just add it to source text.
+      // Otherwise we'll have to set it manually later.
+      nameIsIdentifier_ = js::frontend::IsIdentifier(
+          reinterpret_cast<const Latin1Char*>(name), nameLen);
+      if (nameIsIdentifier_) {
+        if (!funStr_.append(nameAtom_)) {
+          return false;
+        }
+      }
+    }
+
+    if (!funStr_.append("(")) {
+      return false;
+    }
+
+    for (unsigned i = 0; i < nargs; i++) {
+      if (i != 0) {
+        if (!funStr_.append(", ")) {
+          return false;
+        }
+      }
+      if (!funStr_.append(argnames[i], strlen(argnames[i]))) {
+        return false;
+      }
+    }
+
+    // Remember the position of ")".
+    parameterListEnd_ = funStr_.length();
+    MOZ_ASSERT(FunctionConstructorMedialSigils[0] == ')');
+
+    return funStr_.append(FunctionConstructorMedialSigils);
+  }
+
+  template <typename Unit>
+  inline MOZ_MUST_USE bool addFunctionBody(const SourceText<Unit>& srcBuf) {
+    return funStr_.append(srcBuf.get(), srcBuf.length());
+  }
+
+  JSFunction* finish(HandleObjectVector envChain,
+                     const ReadOnlyCompileOptions& optionsArg) {
+    using js::frontend::FunctionSyntaxKind;
+
+    if (!funStr_.append(FunctionConstructorFinalBrace)) {
+      return nullptr;
+    }
+
+    size_t newLen = funStr_.length();
+    UniqueTwoByteChars stolen(funStr_.stealChars());
+    if (!stolen) {
+      return nullptr;
+    }
+
+    SourceText<char16_t> newSrcBuf;
+    if (!newSrcBuf.init(cx_, std::move(stolen), newLen)) {
+      return nullptr;
+    }
+
+    RootedObject enclosingEnv(cx_);
+    RootedScope enclosingScope(cx_);
+    if (!CreateNonSyntacticEnvironmentChain(cx_, envChain, &enclosingEnv,
+                                            &enclosingScope)) {
+      return nullptr;
+    }
+
+    cx_->check(enclosingEnv);
+
+    // Make sure the static scope chain matches up when we have a
+    // non-syntactic scope.
+    MOZ_ASSERT_IF(!IsGlobalLexicalEnvironment(enclosingEnv),
+                  enclosingScope->hasOnChain(ScopeKind::NonSyntactic));
+
+    CompileOptions options(cx_, optionsArg);
+    options.setNonSyntacticScope(
+        enclosingScope->hasOnChain(ScopeKind::NonSyntactic));
+
+    FunctionSyntaxKind syntaxKind = FunctionSyntaxKind::Statement;
+    RootedFunction fun(
+        cx_, js::frontend::CompileStandaloneFunction(
+                 cx_, options, newSrcBuf, mozilla::Some(parameterListEnd_),
+                 syntaxKind, enclosingScope));
+    if (!fun) {
+      return nullptr;
+    }
+
+    // When the function name isn't a valid identifier, the generated function
+    // source in srcBuf won't include the name, so name the function manually.
+    if (!nameIsIdentifier_) {
+      fun->setAtom(nameAtom_);
+    }
+
+    if (fun->isInterpreted()) {
+      fun->initEnvironment(enclosingEnv);
+    }
+
+    return fun;
+  }
+};
+
+JS_PUBLIC_API JSFunction* JS::CompileFunction(
+    JSContext* cx, HandleObjectVector envChain,
+    const ReadOnlyCompileOptions& options, const char* name, unsigned nargs,
+    const char* const* argnames, SourceText<char16_t>& srcBuf) {
+  FunctionCompiler compiler(cx);
+  if (!compiler.init(name, nargs, argnames) ||
+      !compiler.addFunctionBody(srcBuf)) {
+    return nullptr;
+  }
+
+  return compiler.finish(envChain, options);
+}
+
+JS_PUBLIC_API JSFunction* JS::CompileFunction(
+    JSContext* cx, HandleObjectVector envChain,
+    const ReadOnlyCompileOptions& options, const char* name, unsigned nargs,
+    const char* const* argnames, SourceText<Utf8Unit>& srcBuf) {
+  FunctionCompiler compiler(cx);
+  if (!compiler.init(name, nargs, argnames) ||
+      !compiler.addFunctionBody(srcBuf)) {
+    return nullptr;
+  }
+
+  return compiler.finish(envChain, options);
+}
+
+JS_PUBLIC_API JSFunction* JS::CompileFunctionUtf8(
+    JSContext* cx, HandleObjectVector envChain,
+    const ReadOnlyCompileOptions& options, const char* name, unsigned nargs,
+    const char* const* argnames, const char* bytes, size_t length) {
+  SourceText<Utf8Unit> srcBuf;
+  if (!srcBuf.init(cx, bytes, length, SourceOwnership::Borrowed)) {
+    return nullptr;
+  }
+
+  return CompileFunction(cx, envChain, options, name, nargs, argnames, srcBuf);
+}
+
+JS_PUBLIC_API void JS::ExposeScriptToDebugger(JSContext* cx,
+                                              HandleScript script) {
+  MOZ_ASSERT(cx);
+  MOZ_ASSERT(CurrentThreadCanAccessRuntime(cx->runtime()));
+
+  DebugAPI::onNewScript(cx, script);
+}
+
+JS_PUBLIC_API void JS::SetGetElementCallback(JSContext* cx,
+                                             JSGetElementCallback callback) {
+  MOZ_ASSERT(cx->runtime());
+  cx->runtime()->setElementCallback(cx->runtime(), callback);
+}
+
+MOZ_NEVER_INLINE static bool ExecuteScript(JSContext* cx, HandleObject envChain,
+                                           HandleScript script,
+                                           MutableHandleValue rval) {
+  MOZ_ASSERT(!cx->zone()->isAtomsZone());
+  AssertHeapIsIdle();
+  CHECK_THREAD(cx);
+  cx->check(envChain, script);
+  MOZ_ASSERT_IF(!IsGlobalLexicalEnvironment(envChain),
+                script->hasNonSyntacticScope());
+  return Execute(cx, script, envChain, rval);
+}
+
+static bool ExecuteScript(JSContext* cx, HandleObjectVector envChain,
+                          HandleScript scriptArg, MutableHandleValue rval) {
+  RootedObject env(cx);
+  RootedScope dummy(cx);
+  if (!CreateNonSyntacticEnvironmentChain(cx, envChain, &env, &dummy)) {
+    return false;
+  }
+
+  RootedScript script(cx, scriptArg);
+  if (!script->hasNonSyntacticScope() && !IsGlobalLexicalEnvironment(env)) {
+    script = CloneGlobalScript(cx, ScopeKind::NonSyntactic, script);
+    if (!script) {
+      return false;
+    }
+  }
+
+  return ExecuteScript(cx, env, script, rval);
+}
+
+MOZ_NEVER_INLINE JS_PUBLIC_API bool JS_ExecuteScript(JSContext* cx,
+                                                     HandleScript scriptArg,
+                                                     MutableHandleValue rval) {
+  RootedObject globalLexical(cx, &cx->global()->lexicalEnvironment());
+  return ExecuteScript(cx, globalLexical, scriptArg, rval);
+}
+
+MOZ_NEVER_INLINE JS_PUBLIC_API bool JS_ExecuteScript(JSContext* cx,
+                                                     HandleScript scriptArg) {
+  RootedObject globalLexical(cx, &cx->global()->lexicalEnvironment());
+  RootedValue rval(cx);
+  return ExecuteScript(cx, globalLexical, scriptArg, &rval);
+}
+
+MOZ_NEVER_INLINE JS_PUBLIC_API bool JS_ExecuteScript(
+    JSContext* cx, HandleObjectVector envChain, HandleScript scriptArg,
+    MutableHandleValue rval) {
+  return ExecuteScript(cx, envChain, scriptArg, rval);
+}
+
+MOZ_NEVER_INLINE JS_PUBLIC_API bool JS_ExecuteScript(
+    JSContext* cx, HandleObjectVector envChain, HandleScript scriptArg) {
+  RootedValue rval(cx);
+  return ExecuteScript(cx, envChain, scriptArg, &rval);
+}
+
+JS_PUBLIC_API bool JS::CloneAndExecuteScript(JSContext* cx,
+                                             HandleScript scriptArg,
+                                             JS::MutableHandleValue rval) {
+  CHECK_THREAD(cx);
+  RootedScript script(cx, scriptArg);
+  RootedObject globalLexical(cx, &cx->global()->lexicalEnvironment());
+  if (script->realm() != cx->realm()) {
+    script = CloneGlobalScript(cx, ScopeKind::Global, script);
+    if (!script) {
+      return false;
+    }
+  }
+  return ExecuteScript(cx, globalLexical, script, rval);
+}
+
+JS_PUBLIC_API bool JS::CloneAndExecuteScript(JSContext* cx,
+                                             JS::HandleObjectVector envChain,
+                                             HandleScript scriptArg,
+                                             JS::MutableHandleValue rval) {
+  CHECK_THREAD(cx);
+  RootedScript script(cx, scriptArg);
+  if (script->realm() != cx->realm()) {
+    script = CloneGlobalScript(cx, ScopeKind::NonSyntactic, script);
+    if (!script) {
+      return false;
+    }
+  }
+  return ExecuteScript(cx, envChain, script, rval);
+}
+
+template <typename Unit>
+static bool EvaluateSourceBuffer(JSContext* cx, ScopeKind scopeKind,
+                                 Handle<JSObject*> env,
+                                 const ReadOnlyCompileOptions& optionsArg,
+                                 SourceText<Unit>& srcBuf,
+                                 MutableHandle<Value> rval) {
+  CompileOptions options(cx, optionsArg);
+  MOZ_ASSERT(!cx->zone()->isAtomsZone());
+  AssertHeapIsIdle();
+  CHECK_THREAD(cx);
+  cx->check(env);
+  MOZ_ASSERT_IF(!IsGlobalLexicalEnvironment(env),
+                scopeKind == ScopeKind::NonSyntactic);
+
+  options.setNonSyntacticScope(scopeKind == ScopeKind::NonSyntactic);
+  options.setIsRunOnce(true);
+
+  RootedScript script(
+      cx, frontend::CompileGlobalScript(cx, options, srcBuf, scopeKind));
+  if (!script) {
+    return false;
+  }
+
+  return Execute(cx, script, env, rval);
+}
+
+JS_PUBLIC_API bool JS::Evaluate(JSContext* cx,
+                                const ReadOnlyCompileOptions& options,
+                                SourceText<Utf8Unit>& srcBuf,
+                                MutableHandle<Value> rval) {
+  RootedObject globalLexical(cx, &cx->global()->lexicalEnvironment());
+  return EvaluateSourceBuffer(cx, ScopeKind::Global, globalLexical, options,
+                              srcBuf, rval);
+}
+
+JS_PUBLIC_API bool JS::Evaluate(JSContext* cx,
+                                const ReadOnlyCompileOptions& optionsArg,
+                                SourceText<char16_t>& srcBuf,
+                                MutableHandleValue rval) {
+  RootedObject globalLexical(cx, &cx->global()->lexicalEnvironment());
+  return EvaluateSourceBuffer(cx, ScopeKind::Global, globalLexical, optionsArg,
+                              srcBuf, rval);
+}
+
+JS_PUBLIC_API bool JS::Evaluate(JSContext* cx, HandleObjectVector envChain,
+                                const ReadOnlyCompileOptions& options,
+                                SourceText<char16_t>& srcBuf,
+                                MutableHandleValue rval) {
+  RootedObject env(cx);
+  RootedScope scope(cx);
+  if (!CreateNonSyntacticEnvironmentChain(cx, envChain, &env, &scope)) {
+    return false;
+  }
+
+  return EvaluateSourceBuffer(cx, scope->kind(), env, options, srcBuf, rval);
+}
+
+JS_PUBLIC_API bool JS::EvaluateUtf8Path(
+    JSContext* cx, const ReadOnlyCompileOptions& optionsArg,
+    const char* filename, MutableHandleValue rval) {
+  FileContents buffer(cx);
+  {
+    AutoFile file;
+    if (!file.open(cx, filename) || !file.readAll(cx, buffer)) {
+      return false;
+    }
+  }
+
+  CompileOptions options(cx, optionsArg);
+  options.setFileAndLine(filename, 1);
+
+  auto contents = reinterpret_cast<const char*>(buffer.begin());
+  size_t length = buffer.length();
+
+  JS::SourceText<Utf8Unit> srcBuf;
+  if (!srcBuf.init(cx, contents, length, JS::SourceOwnership::Borrowed)) {
+    return false;
+  }
+
+  return Evaluate(cx, options, srcBuf, rval);
+}