diff options
Diffstat (limited to 'js/src/jsapi.cpp')
| -rw-r--r-- | js/src/jsapi.cpp | 4806 |
1 files changed, 4806 insertions, 0 deletions
diff --git a/js/src/jsapi.cpp b/js/src/jsapi.cpp new file mode 100644 index 0000000000..90ba9bcf08 --- /dev/null +++ b/js/src/jsapi.cpp @@ -0,0 +1,4806 @@ +/* -*- 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/. */ + +/* + * JavaScript API. + */ + +#include "jsapi.h" + +#include "mozilla/FloatingPoint.h" +#include "mozilla/Maybe.h" +#include "mozilla/PodOperations.h" +#include "mozilla/Sprintf.h" + +#include <algorithm> +#include <cstdarg> +#ifdef __linux__ +# include <dlfcn.h> +#endif +#include <iterator> +#include <stdarg.h> +#include <string.h> + +#include "jsexn.h" +#include "jsfriendapi.h" +#include "jsmath.h" +#include "jstypes.h" + +#include "builtin/AtomicsObject.h" +#include "builtin/Eval.h" +#include "builtin/JSON.h" +#include "builtin/Promise.h" +#include "builtin/Symbol.h" +#include "frontend/BytecodeCompiler.h" +#include "frontend/FrontendContext.h" // AutoReportFrontendContext +#include "gc/GC.h" +#include "gc/GCContext.h" +#include "gc/Marking.h" +#include "gc/PublicIterators.h" +#include "jit/JitSpewer.h" +#include "js/CallAndConstruct.h" // JS::IsCallable +#include "js/CharacterEncoding.h" +#include "js/CompileOptions.h" +#include "js/ContextOptions.h" // JS::ContextOptions{,Ref} +#include "js/Conversions.h" +#include "js/ErrorInterceptor.h" +#include "js/friend/ErrorMessages.h" // js::GetErrorMessage, JSMSG_* +#include "js/friend/StackLimits.h" // js::AutoCheckRecursionLimit +#include "js/GlobalObject.h" +#include "js/Initialization.h" +#include "js/Interrupt.h" +#include "js/JSON.h" +#include "js/LocaleSensitive.h" +#include "js/MemoryCallbacks.h" +#include "js/MemoryFunctions.h" +#include "js/PropertySpec.h" +#include "js/Proxy.h" +#include "js/ScriptPrivate.h" +#include "js/StableStringChars.h" +#include "js/Stack.h" // JS::NativeStackSize, JS::NativeStackLimitMax, JS::GetNativeStackLimit +#include "js/StreamConsumer.h" +#include "js/String.h" // JS::MaxStringLength +#include "js/Symbol.h" +#include "js/TelemetryTimers.h" +#include "js/Utility.h" +#include "js/WaitCallbacks.h" +#include "js/WasmModule.h" +#include "js/Wrapper.h" +#include "js/WrapperCallbacks.h" +#include "proxy/DOMProxy.h" +#include "util/StringBuffer.h" +#include "util/Text.h" +#include "vm/BoundFunctionObject.h" +#include "vm/EnvironmentObject.h" +#include "vm/ErrorObject.h" +#include "vm/ErrorReporting.h" +#include "vm/FunctionPrefixKind.h" +#include "vm/Interpreter.h" +#include "vm/JSAtom.h" +#include "vm/JSAtomState.h" +#include "vm/JSContext.h" +#include "vm/JSFunction.h" +#include "vm/JSObject.h" +#include "vm/JSScript.h" +#include "vm/PlainObject.h" // js::PlainObject +#include "vm/PromiseObject.h" // js::PromiseObject +#include "vm/Runtime.h" +#include "vm/SavedStacks.h" +#include "vm/StringType.h" +#include "vm/Time.h" +#include "vm/ToSource.h" +#include "vm/WrapperObject.h" +#include "wasm/WasmModule.h" +#include "wasm/WasmProcess.h" + +#include "builtin/Promise-inl.h" +#include "debugger/DebugAPI-inl.h" +#include "vm/Compartment-inl.h" +#include "vm/Interpreter-inl.h" +#include "vm/IsGivenTypeObject-inl.h" // js::IsGivenTypeObject +#include "vm/JSAtom-inl.h" +#include "vm/JSFunction-inl.h" +#include "vm/JSScript-inl.h" +#include "vm/NativeObject-inl.h" +#include "vm/SavedStacks-inl.h" +#include "vm/StringType-inl.h" + +using namespace js; + +using mozilla::Maybe; +using mozilla::PodCopy; +using mozilla::Some; + +using JS::AutoStableStringChars; +using JS::CompileOptions; +using JS::ReadOnlyCompileOptions; +using JS::SourceText; + +// See preprocessor definition of JS_BITS_PER_WORD in jstypes.h; make sure +// JS_64BIT (used internally) agrees with it +#ifdef JS_64BIT +static_assert(JS_BITS_PER_WORD == 64, "values must be in sync"); +#else +static_assert(JS_BITS_PER_WORD == 32, "values must be in sync"); +#endif + +JS_PUBLIC_API void JS::CallArgs::reportMoreArgsNeeded(JSContext* cx, + const char* fnname, + unsigned required, + unsigned actual) { + char requiredArgsStr[40]; + SprintfLiteral(requiredArgsStr, "%u", required); + char actualArgsStr[40]; + SprintfLiteral(actualArgsStr, "%u", actual); + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, + JSMSG_MORE_ARGS_NEEDED, fnname, requiredArgsStr, + required == 1 ? "" : "s", actualArgsStr); +} + +static bool ErrorTakesArguments(unsigned msg) { + MOZ_ASSERT(msg < JSErr_Limit); + unsigned argCount = js_ErrorFormatString[msg].argCount; + MOZ_ASSERT(argCount <= 2); + return argCount == 1 || argCount == 2; +} + +static bool ErrorTakesObjectArgument(unsigned msg) { + MOZ_ASSERT(msg < JSErr_Limit); + unsigned argCount = js_ErrorFormatString[msg].argCount; + MOZ_ASSERT(argCount <= 2); + return argCount == 2; +} + +bool JS::ObjectOpResult::reportError(JSContext* cx, HandleObject obj, + HandleId id) { + static_assert(unsigned(OkCode) == unsigned(JSMSG_NOT_AN_ERROR), + "unsigned value of OkCode must not be an error code"); + MOZ_ASSERT(code_ != Uninitialized); + MOZ_ASSERT(!ok()); + cx->check(obj); + + if (code_ == JSMSG_OBJECT_NOT_EXTENSIBLE) { + RootedValue val(cx, ObjectValue(*obj)); + return ReportValueError(cx, code_, JSDVG_IGNORE_STACK, val, nullptr); + } + + if (ErrorTakesArguments(code_)) { + UniqueChars propName = + IdToPrintableUTF8(cx, id, IdToPrintableBehavior::IdIsPropertyKey); + if (!propName) { + return false; + } + + if (code_ == JSMSG_SET_NON_OBJECT_RECEIVER) { + // We know that the original receiver was a primitive, so unbox it. + RootedValue val(cx, ObjectValue(*obj)); + if (!obj->is<ProxyObject>()) { + if (!Unbox(cx, obj, &val)) { + return false; + } + } + return ReportValueError(cx, code_, JSDVG_IGNORE_STACK, val, nullptr, + propName.get()); + } + + if (ErrorTakesObjectArgument(code_)) { + JSObject* unwrapped = js::CheckedUnwrapStatic(obj); + const char* name = unwrapped ? unwrapped->getClass()->name : "Object"; + JS_ReportErrorNumberUTF8(cx, GetErrorMessage, nullptr, code_, name, + propName.get()); + return false; + } + + JS_ReportErrorNumberUTF8(cx, GetErrorMessage, nullptr, code_, + propName.get()); + return false; + } + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, code_); + return false; +} + +bool JS::ObjectOpResult::reportError(JSContext* cx, HandleObject obj) { + MOZ_ASSERT(code_ != Uninitialized); + MOZ_ASSERT(!ok()); + MOZ_ASSERT(!ErrorTakesArguments(code_)); + cx->check(obj); + + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, code_); + return false; +} + +JS_PUBLIC_API bool JS::ObjectOpResult::failCantRedefineProp() { + return fail(JSMSG_CANT_REDEFINE_PROP); +} + +JS_PUBLIC_API bool JS::ObjectOpResult::failReadOnly() { + return fail(JSMSG_READ_ONLY); +} + +JS_PUBLIC_API bool JS::ObjectOpResult::failGetterOnly() { + return fail(JSMSG_GETTER_ONLY); +} + +JS_PUBLIC_API bool JS::ObjectOpResult::failCantDelete() { + return fail(JSMSG_CANT_DELETE); +} + +JS_PUBLIC_API bool JS::ObjectOpResult::failCantSetInterposed() { + return fail(JSMSG_CANT_SET_INTERPOSED); +} + +JS_PUBLIC_API bool JS::ObjectOpResult::failCantDefineWindowElement() { + return fail(JSMSG_CANT_DEFINE_WINDOW_ELEMENT); +} + +JS_PUBLIC_API bool JS::ObjectOpResult::failCantDeleteWindowElement() { + return fail(JSMSG_CANT_DELETE_WINDOW_ELEMENT); +} + +JS_PUBLIC_API bool JS::ObjectOpResult::failCantDefineWindowNamedProperty() { + return fail(JSMSG_CANT_DEFINE_WINDOW_NAMED_PROPERTY); +} + +JS_PUBLIC_API bool JS::ObjectOpResult::failCantDeleteWindowNamedProperty() { + return fail(JSMSG_CANT_DELETE_WINDOW_NAMED_PROPERTY); +} + +JS_PUBLIC_API bool JS::ObjectOpResult::failCantDefineWindowNonConfigurable() { + return fail(JSMSG_CANT_DEFINE_WINDOW_NC); +} + +JS_PUBLIC_API bool JS::ObjectOpResult::failCantPreventExtensions() { + return fail(JSMSG_CANT_PREVENT_EXTENSIONS); +} + +JS_PUBLIC_API bool JS::ObjectOpResult::failCantSetProto() { + return fail(JSMSG_CANT_SET_PROTO); +} + +JS_PUBLIC_API bool JS::ObjectOpResult::failNoNamedSetter() { + return fail(JSMSG_NO_NAMED_SETTER); +} + +JS_PUBLIC_API bool JS::ObjectOpResult::failNoIndexedSetter() { + return fail(JSMSG_NO_INDEXED_SETTER); +} + +JS_PUBLIC_API bool JS::ObjectOpResult::failNotDataDescriptor() { + return fail(JSMSG_NOT_DATA_DESCRIPTOR); +} + +JS_PUBLIC_API bool JS::ObjectOpResult::failInvalidDescriptor() { + return fail(JSMSG_INVALID_DESCRIPTOR); +} + +JS_PUBLIC_API bool JS::ObjectOpResult::failBadArrayLength() { + return fail(JSMSG_BAD_ARRAY_LENGTH); +} + +JS_PUBLIC_API bool JS::ObjectOpResult::failBadIndex() { + return fail(JSMSG_BAD_INDEX); +} + +JS_PUBLIC_API int64_t JS_Now() { return PRMJ_Now(); } + +JS_PUBLIC_API Value JS_GetEmptyStringValue(JSContext* cx) { + return StringValue(cx->runtime()->emptyString); +} + +JS_PUBLIC_API JSString* JS_GetEmptyString(JSContext* cx) { + MOZ_ASSERT(cx->emptyString()); + return cx->emptyString(); +} + +namespace js { + +void AssertHeapIsIdle() { MOZ_ASSERT(!JS::RuntimeHeapIsBusy()); } + +} // namespace js + +static void AssertHeapIsIdleOrIterating() { + MOZ_ASSERT(!JS::RuntimeHeapIsCollecting()); +} + +JS_PUBLIC_API bool JS_ValueToObject(JSContext* cx, HandleValue value, + MutableHandleObject objp) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + cx->check(value); + if (value.isNullOrUndefined()) { + objp.set(nullptr); + return true; + } + JSObject* obj = ToObject(cx, value); + if (!obj) { + return false; + } + objp.set(obj); + return true; +} + +JS_PUBLIC_API JSFunction* JS_ValueToFunction(JSContext* cx, HandleValue value) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + cx->check(value); + return ReportIfNotFunction(cx, value); +} + +JS_PUBLIC_API JSFunction* JS_ValueToConstructor(JSContext* cx, + HandleValue value) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + cx->check(value); + return ReportIfNotFunction(cx, value); +} + +JS_PUBLIC_API JSString* JS_ValueToSource(JSContext* cx, HandleValue value) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + cx->check(value); + return ValueToSource(cx, value); +} + +JS_PUBLIC_API bool JS_DoubleIsInt32(double d, int32_t* ip) { + return mozilla::NumberIsInt32(d, ip); +} + +JS_PUBLIC_API JSType JS_TypeOfValue(JSContext* cx, HandleValue value) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + cx->check(value); + return TypeOfValue(value); +} + +JS_PUBLIC_API bool JS_IsBuiltinEvalFunction(JSFunction* fun) { + return IsAnyBuiltinEval(fun); +} + +JS_PUBLIC_API bool JS_IsBuiltinFunctionConstructor(JSFunction* fun) { + return fun->isBuiltinFunctionConstructor(); +} + +JS_PUBLIC_API bool JS_ObjectIsBoundFunction(JSObject* obj) { + return obj->is<BoundFunctionObject>(); +} + +JS_PUBLIC_API JSObject* JS_GetBoundFunctionTarget(JSObject* obj) { + return obj->is<BoundFunctionObject>() + ? obj->as<BoundFunctionObject>().getTarget() + : nullptr; +} + +/************************************************************************/ + +// Prevent functions from being discarded by linker, so that they are callable +// when debugging. +static void PreventDiscardingFunctions() { + if (reinterpret_cast<uintptr_t>(&PreventDiscardingFunctions) == 1) { + // Never executed. + memset((void*)&js::debug::GetMarkInfo, 0, 1); + memset((void*)&js::debug::GetMarkWordAddress, 0, 1); + memset((void*)&js::debug::GetMarkMask, 0, 1); + } +} + +JS_PUBLIC_API JSContext* JS_NewContext(uint32_t maxbytes, + JSRuntime* parentRuntime) { + MOZ_ASSERT(JS::detail::libraryInitState == JS::detail::InitState::Running, + "must call JS_Init prior to creating any JSContexts"); + + // Prevent linker from discarding unused debug functions. + PreventDiscardingFunctions(); + + // Make sure that all parent runtimes are the topmost parent. + while (parentRuntime && parentRuntime->parentRuntime) { + parentRuntime = parentRuntime->parentRuntime; + } + + return NewContext(maxbytes, parentRuntime); +} + +JS_PUBLIC_API void JS_DestroyContext(JSContext* cx) { DestroyContext(cx); } + +JS_PUBLIC_API void* JS_GetContextPrivate(JSContext* cx) { return cx->data; } + +JS_PUBLIC_API void JS_SetContextPrivate(JSContext* cx, void* data) { + cx->data = data; +} + +JS_PUBLIC_API void JS_SetFutexCanWait(JSContext* cx) { + cx->fx.setCanWait(true); +} + +JS_PUBLIC_API JSRuntime* JS_GetParentRuntime(JSContext* cx) { + return cx->runtime()->parentRuntime ? cx->runtime()->parentRuntime + : cx->runtime(); +} + +JS_PUBLIC_API JSRuntime* JS_GetRuntime(JSContext* cx) { return cx->runtime(); } + +JS_PUBLIC_API JS::ContextOptions& JS::ContextOptionsRef(JSContext* cx) { + return cx->options(); +} + +JS::ContextOptions& JS::ContextOptions::setFuzzing(bool flag) { +#ifdef FUZZING + fuzzing_ = flag; +#endif + return *this; +} + +JS_PUBLIC_API const char* JS_GetImplementationVersion(void) { + return "JavaScript-C" MOZILLA_VERSION; +} + +JS_PUBLIC_API void JS_SetDestroyZoneCallback(JSContext* cx, + JSDestroyZoneCallback callback) { + cx->runtime()->destroyZoneCallback = callback; +} + +JS_PUBLIC_API void JS_SetDestroyCompartmentCallback( + JSContext* cx, JSDestroyCompartmentCallback callback) { + cx->runtime()->destroyCompartmentCallback = callback; +} + +JS_PUBLIC_API void JS_SetSizeOfIncludingThisCompartmentCallback( + JSContext* cx, JSSizeOfIncludingThisCompartmentCallback callback) { + cx->runtime()->sizeOfIncludingThisCompartmentCallback = callback; +} + +JS_PUBLIC_API void JS_SetErrorInterceptorCallback( + JSRuntime* rt, JSErrorInterceptor* callback) { +#if defined(NIGHTLY_BUILD) + rt->errorInterception.interceptor = callback; +#endif // defined(NIGHTLY_BUILD) +} + +JS_PUBLIC_API JSErrorInterceptor* JS_GetErrorInterceptorCallback( + JSRuntime* rt) { +#if defined(NIGHTLY_BUILD) + return rt->errorInterception.interceptor; +#else // !NIGHTLY_BUILD + return nullptr; +#endif // defined(NIGHTLY_BUILD) +} + +JS_PUBLIC_API Maybe<JSExnType> JS_GetErrorType(const JS::Value& val) { + // All errors are objects. + if (!val.isObject()) { + return mozilla::Nothing(); + } + + const JSObject& obj = val.toObject(); + + // All errors are `ErrorObject`. + if (!obj.is<js::ErrorObject>()) { + // Not one of the primitive errors. + return mozilla::Nothing(); + } + + const js::ErrorObject& err = obj.as<js::ErrorObject>(); + return mozilla::Some(err.type()); +} + +JS_PUBLIC_API void JS_SetWrapObjectCallbacks( + JSContext* cx, const JSWrapObjectCallbacks* callbacks) { + cx->runtime()->wrapObjectCallbacks = callbacks; +} + +JS_PUBLIC_API Realm* JS::EnterRealm(JSContext* cx, JSObject* target) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + + MOZ_DIAGNOSTIC_ASSERT(!js::IsCrossCompartmentWrapper(target)); + + Realm* oldRealm = cx->realm(); + cx->enterRealmOf(target); + return oldRealm; +} + +JS_PUBLIC_API void JS::LeaveRealm(JSContext* cx, JS::Realm* oldRealm) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + cx->leaveRealm(oldRealm); +} + +JSAutoRealm::JSAutoRealm(JSContext* cx, JSObject* target) + : cx_(cx), oldRealm_(cx->realm()) { + MOZ_DIAGNOSTIC_ASSERT(!js::IsCrossCompartmentWrapper(target)); + AssertHeapIsIdleOrIterating(); + cx_->enterRealmOf(target); +} + +JSAutoRealm::JSAutoRealm(JSContext* cx, JSScript* target) + : cx_(cx), oldRealm_(cx->realm()) { + AssertHeapIsIdleOrIterating(); + cx_->enterRealmOf(target); +} + +JSAutoRealm::~JSAutoRealm() { cx_->leaveRealm(oldRealm_); } + +JSAutoNullableRealm::JSAutoNullableRealm(JSContext* cx, JSObject* targetOrNull) + : cx_(cx), oldRealm_(cx->realm()) { + AssertHeapIsIdleOrIterating(); + if (targetOrNull) { + MOZ_DIAGNOSTIC_ASSERT(!js::IsCrossCompartmentWrapper(targetOrNull)); + cx_->enterRealmOf(targetOrNull); + } else { + cx_->enterNullRealm(); + } +} + +JSAutoNullableRealm::~JSAutoNullableRealm() { cx_->leaveRealm(oldRealm_); } + +JS_PUBLIC_API void JS_SetCompartmentPrivate(JS::Compartment* compartment, + void* data) { + compartment->data = data; +} + +JS_PUBLIC_API void* JS_GetCompartmentPrivate(JS::Compartment* compartment) { + return compartment->data; +} + +JS_PUBLIC_API void JS_MarkCrossZoneId(JSContext* cx, jsid id) { + cx->markId(id); +} + +JS_PUBLIC_API void JS_MarkCrossZoneIdValue(JSContext* cx, const Value& value) { + cx->markAtomValue(value); +} + +JS_PUBLIC_API void JS_SetZoneUserData(JS::Zone* zone, void* data) { + zone->data = data; +} + +JS_PUBLIC_API void* JS_GetZoneUserData(JS::Zone* zone) { return zone->data; } + +JS_PUBLIC_API bool JS_WrapObject(JSContext* cx, MutableHandleObject objp) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + if (objp) { + JS::ExposeObjectToActiveJS(objp); + } + return cx->compartment()->wrap(cx, objp); +} + +JS_PUBLIC_API bool JS_WrapValue(JSContext* cx, MutableHandleValue vp) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + JS::ExposeValueToActiveJS(vp); + return cx->compartment()->wrap(cx, vp); +} + +static void ReleaseAssertObjectHasNoWrappers(JSContext* cx, + HandleObject target) { + for (CompartmentsIter c(cx->runtime()); !c.done(); c.next()) { + if (c->lookupWrapper(target)) { + MOZ_CRASH("wrapper found for target object"); + } + } +} + +/* + * [SMDOC] Brain transplants. + * + * Not for beginners or the squeamish. + * + * Sometimes a web spec requires us to transplant an object from one + * compartment to another, like when a DOM node is inserted into a document in + * another window and thus gets "adopted". We cannot literally change the + * `.compartment()` of a `JSObject`; that would break the compartment + * invariants. However, as usual, we have a workaround using wrappers. + * + * Of all the wrapper-based workarounds we do, it's safe to say this is the + * most spectacular and questionable. + * + * `JS_TransplantObject(cx, origobj, target)` changes `origobj` into a + * simulacrum of `target`, using highly esoteric means. To JS code, the effect + * is as if `origobj` magically "became" `target`, but most often what actually + * happens is that `origobj` gets turned into a cross-compartment wrapper for + * `target`. The old behavior and contents of `origobj` are overwritten or + * discarded. + * + * Thus, to "transplant" an object from one compartment to another: + * + * 1. Let `origobj` be the object that you want to move. First, create a + * clone of it, `target`, in the destination compartment. + * + * In our DOM adoption example, `target` will be a Node of the same type as + * `origobj`, same content, but in the adopting document. We're not done + * yet: the spec for DOM adoption requires that `origobj.ownerDocument` + * actually change. All we've done so far is make a copy. + * + * 2. Call `JS_TransplantObject(cx, origobj, target)`. This typically turns + * `origobj` into a wrapper for `target`, so that any JS code that has a + * reference to `origobj` will observe it to have the behavior of `target` + * going forward. In addition, all existing wrappers for `origobj` are + * changed into wrappers for `target`, extending the illusion to those + * compartments as well. + * + * During navigation, we use the above technique to transplant the WindowProxy + * into the new Window's compartment. + * + * A few rules: + * + * - `origobj` and `target` must be two distinct objects of the same + * `JSClass`. Some classes may not support transplantation; WindowProxy + * objects and DOM nodes are OK. + * + * - `target` should be created specifically to be passed to this function. + * There must be no existing cross-compartment wrappers for it; ideally + * there shouldn't be any pointers to it at all, except the one passed in. + * + * - `target` shouldn't be used afterwards. Instead, `JS_TransplantObject` + * returns a pointer to the transplanted object, which might be `target` + * but might be some other object in the same compartment. Use that. + * + * The reason for this last rule is that JS_TransplantObject does very strange + * things in some cases, like swapping `target`'s brain with that of another + * object. Leaving `target` behaving like its former self is not a goal. + * + * We don't have a good way to recover from failure in this function, so + * we intentionally crash instead. + */ + +static void CheckTransplantObject(JSObject* obj) { +#ifdef DEBUG + MOZ_ASSERT(!obj->is<CrossCompartmentWrapperObject>()); + JS::AssertCellIsNotGray(obj); +#endif +} + +JS_PUBLIC_API JSObject* JS_TransplantObject(JSContext* cx, HandleObject origobj, + HandleObject target) { + AssertHeapIsIdle(); + MOZ_ASSERT(origobj != target); + CheckTransplantObject(origobj); + CheckTransplantObject(target); + ReleaseAssertObjectHasNoWrappers(cx, target); + + RootedObject newIdentity(cx); + + // Don't allow a compacting GC to observe any intermediate state. + AutoDisableCompactingGC nocgc(cx); + + AutoDisableProxyCheck adpc; + + AutoEnterOOMUnsafeRegion oomUnsafe; + + JS::Compartment* destination = target->compartment(); + + if (origobj->compartment() == destination) { + // If the original object is in the same compartment as the + // destination, then we know that we won't find a wrapper in the + // destination's cross compartment map and that the same + // object will continue to work. + AutoRealm ar(cx, origobj); + JSObject::swap(cx, origobj, target, oomUnsafe); + newIdentity = origobj; + } else if (ObjectWrapperMap::Ptr p = destination->lookupWrapper(origobj)) { + // There might already be a wrapper for the original object in + // the new compartment. If there is, we use its identity and swap + // in the contents of |target|. + newIdentity = p->value().get(); + + // When we remove origv from the wrapper map, its wrapper, newIdentity, + // must immediately cease to be a cross-compartment wrapper. Nuke it. + destination->removeWrapper(p); + NukeCrossCompartmentWrapper(cx, newIdentity); + + AutoRealm ar(cx, newIdentity); + JSObject::swap(cx, newIdentity, target, oomUnsafe); + } else { + // Otherwise, we use |target| for the new identity object. + newIdentity = target; + } + + // Now, iterate through other scopes looking for references to the old + // object, and update the relevant cross-compartment wrappers. We do this + // even if origobj is in the same compartment as target and thus + // `newIdentity == origobj`, because this process also clears out any + // cached wrapper state. + if (!RemapAllWrappersForObject(cx, origobj, newIdentity)) { + oomUnsafe.crash("JS_TransplantObject"); + } + + // Lastly, update the original object to point to the new one. + if (origobj->compartment() != destination) { + RootedObject newIdentityWrapper(cx, newIdentity); + AutoRealm ar(cx, origobj); + if (!JS_WrapObject(cx, &newIdentityWrapper)) { + MOZ_RELEASE_ASSERT(cx->isThrowingOutOfMemory() || + cx->isThrowingOverRecursed()); + oomUnsafe.crash("JS_TransplantObject"); + } + MOZ_ASSERT(Wrapper::wrappedObject(newIdentityWrapper) == newIdentity); + JSObject::swap(cx, origobj, newIdentityWrapper, oomUnsafe); + if (origobj->compartment()->lookupWrapper(newIdentity)) { + MOZ_ASSERT(origobj->is<CrossCompartmentWrapperObject>()); + if (!origobj->compartment()->putWrapper(cx, newIdentity, origobj)) { + oomUnsafe.crash("JS_TransplantObject"); + } + } + } + + // The new identity object might be one of several things. Return it to avoid + // ambiguity. + JS::AssertCellIsNotGray(newIdentity); + return newIdentity; +} + +JS_PUBLIC_API void js::RemapRemoteWindowProxies( + JSContext* cx, CompartmentTransplantCallback* callback, + MutableHandleObject target) { + AssertHeapIsIdle(); + CheckTransplantObject(target); + ReleaseAssertObjectHasNoWrappers(cx, target); + + // |target| can't be a remote proxy, because we expect it to get a CCW when + // wrapped across compartments. + MOZ_ASSERT(!js::IsDOMRemoteProxyObject(target)); + + // Don't allow a compacting GC to observe any intermediate state. + AutoDisableCompactingGC nocgc(cx); + + AutoDisableProxyCheck adpc; + + AutoEnterOOMUnsafeRegion oomUnsafe; + + AutoCheckRecursionLimit recursion(cx); + if (!recursion.checkSystem(cx)) { + oomUnsafe.crash("js::RemapRemoteWindowProxies"); + } + + RootedObject targetCompartmentProxy(cx); + JS::RootedVector<JSObject*> otherProxies(cx); + + // Use the callback to find remote proxies in all compartments that match + // whatever criteria callback uses. + for (CompartmentsIter c(cx->runtime()); !c.done(); c.next()) { + RootedObject remoteProxy(cx, callback->getObjectToTransplant(c)); + if (!remoteProxy) { + continue; + } + // The object the callback returns should be a DOM remote proxy object in + // the compartment c. We rely on it being a DOM remote proxy because that + // means that it won't have any cross-compartment wrappers. + MOZ_ASSERT(js::IsDOMRemoteProxyObject(remoteProxy)); + MOZ_ASSERT(remoteProxy->compartment() == c); + CheckTransplantObject(remoteProxy); + + // Immediately turn the DOM remote proxy object into a dead proxy object + // so we don't have to worry about anything weird going on with it. + js::NukeNonCCWProxy(cx, remoteProxy); + + if (remoteProxy->compartment() == target->compartment()) { + targetCompartmentProxy = remoteProxy; + } else if (!otherProxies.append(remoteProxy)) { + oomUnsafe.crash("js::RemapRemoteWindowProxies"); + } + } + + // If there was a remote proxy in |target|'s compartment, we need to use it + // instead of |target|, in case it had any references, so swap it. Do this + // before any other compartment so that the target object will be set up + // correctly before we start wrapping it into other compartments. + if (targetCompartmentProxy) { + AutoRealm ar(cx, targetCompartmentProxy); + JSObject::swap(cx, targetCompartmentProxy, target, oomUnsafe); + target.set(targetCompartmentProxy); + } + + for (JSObject*& obj : otherProxies) { + RootedObject deadWrapper(cx, obj); + js::RemapDeadWrapper(cx, deadWrapper, target); + } +} + +/* + * Recompute all cross-compartment wrappers for an object, resetting state. + * Gecko uses this to clear Xray wrappers when doing a navigation that reuses + * the inner window and global object. + */ +JS_PUBLIC_API bool JS_RefreshCrossCompartmentWrappers(JSContext* cx, + HandleObject obj) { + return RemapAllWrappersForObject(cx, obj, obj); +} + +typedef struct JSStdName { + size_t atomOffset; /* offset of atom pointer in JSAtomState */ + JSProtoKey key; + bool isDummy() const { return key == JSProto_Null; } + bool isSentinel() const { return key == JSProto_LIMIT; } +} JSStdName; + +static const JSStdName* LookupStdName(const JSAtomState& names, JSAtom* name, + const JSStdName* table) { + for (unsigned i = 0; !table[i].isSentinel(); i++) { + if (table[i].isDummy()) { + continue; + } + JSAtom* atom = AtomStateOffsetToName(names, table[i].atomOffset); + MOZ_ASSERT(atom); + if (name == atom) { + return &table[i]; + } + } + + return nullptr; +} + +/* + * Table of standard classes, indexed by JSProtoKey. For entries where the + * JSProtoKey does not correspond to a class with a meaningful constructor, we + * insert a null entry into the table. + */ +#define STD_NAME_ENTRY(name, clasp) {NAME_OFFSET(name), JSProto_##name}, +#define STD_DUMMY_ENTRY(name, dummy) {0, JSProto_Null}, +static const JSStdName standard_class_names[] = { + JS_FOR_PROTOTYPES(STD_NAME_ENTRY, STD_DUMMY_ENTRY){0, JSProto_LIMIT}}; + +/* + * Table of top-level function and constant names and the JSProtoKey of the + * standard class that initializes them. + */ +static const JSStdName builtin_property_names[] = { + {NAME_OFFSET(eval), JSProto_Object}, + + /* Global properties and functions defined by the Number class. */ + {NAME_OFFSET(NaN), JSProto_Number}, + {NAME_OFFSET(Infinity), JSProto_Number}, + {NAME_OFFSET(isNaN), JSProto_Number}, + {NAME_OFFSET(isFinite), JSProto_Number}, + {NAME_OFFSET(parseFloat), JSProto_Number}, + {NAME_OFFSET(parseInt), JSProto_Number}, + + /* String global functions. */ + {NAME_OFFSET(escape), JSProto_String}, + {NAME_OFFSET(unescape), JSProto_String}, + {NAME_OFFSET(decodeURI), JSProto_String}, + {NAME_OFFSET(encodeURI), JSProto_String}, + {NAME_OFFSET(decodeURIComponent), JSProto_String}, + {NAME_OFFSET(encodeURIComponent), JSProto_String}, + {NAME_OFFSET(uneval), JSProto_String}, + + {0, JSProto_LIMIT}}; + +static bool SkipUneval(jsid id, JSContext* cx) { + return !cx->realm()->creationOptions().getToSourceEnabled() && + id == NameToId(cx->names().uneval); +} + +static bool SkipSharedArrayBufferConstructor(JSProtoKey key, + GlobalObject* global) { + if (key != JSProto_SharedArrayBuffer) { + return false; + } + + const JS::RealmCreationOptions& options = global->realm()->creationOptions(); + MOZ_ASSERT(options.getSharedMemoryAndAtomicsEnabled(), + "shouldn't contemplate defining SharedArrayBuffer if shared " + "memory is disabled"); + + // On the web, it isn't presently possible to expose the global + // "SharedArrayBuffer" property unless the page is cross-site-isolated. Only + // define this constructor if an option on the realm indicates that it should + // be defined. + return !options.defineSharedArrayBufferConstructor(); +} + +JS_PUBLIC_API bool JS_ResolveStandardClass(JSContext* cx, HandleObject obj, + HandleId id, bool* resolved) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + cx->check(obj, id); + + Handle<GlobalObject*> global = obj.as<GlobalObject>(); + *resolved = false; + + if (!id.isAtom()) { + return true; + } + + /* Check whether we're resolving 'undefined', and define it if so. */ + JSAtom* idAtom = id.toAtom(); + if (idAtom == cx->names().undefined) { + *resolved = true; + return js::DefineDataProperty( + cx, global, id, UndefinedHandleValue, + JSPROP_PERMANENT | JSPROP_READONLY | JSPROP_RESOLVING); + } + + // Resolve a "globalThis" self-referential property if necessary. + if (idAtom == cx->names().globalThis) { + return GlobalObject::maybeResolveGlobalThis(cx, global, resolved); + } + + // Try for class constructors/prototypes named by well-known atoms. + const JSStdName* stdnm = + LookupStdName(cx->names(), idAtom, standard_class_names); + if (!stdnm) { + // Try less frequently used top-level functions and constants. + stdnm = LookupStdName(cx->names(), idAtom, builtin_property_names); + if (!stdnm) { + return true; + } + } + + JSProtoKey key = stdnm->key; + if (key == JSProto_Null || GlobalObject::skipDeselectedConstructor(cx, key) || + SkipUneval(id, cx)) { + return true; + } + + // If this class is anonymous (or it's "SharedArrayBuffer" but that global + // constructor isn't supposed to be defined), then it doesn't exist as a + // global property, so we won't resolve anything. + const JSClass* clasp = ProtoKeyToClass(key); + if (clasp && !clasp->specShouldDefineConstructor()) { + return true; + } + if (SkipSharedArrayBufferConstructor(key, global)) { + return true; + } + + if (!GlobalObject::ensureConstructor(cx, global, key)) { + return false; + } + *resolved = true; + return true; +} + +JS_PUBLIC_API bool JS_MayResolveStandardClass(const JSAtomState& names, jsid id, + JSObject* maybeObj) { + MOZ_ASSERT_IF(maybeObj, maybeObj->is<GlobalObject>()); + + // The global object's resolve hook is special: JS_ResolveStandardClass + // initializes the prototype chain lazily. Only attempt to optimize here + // if we know the prototype chain has been initialized. + if (!maybeObj || !maybeObj->staticPrototype()) { + return true; + } + + if (!id.isAtom()) { + return false; + } + + JSAtom* atom = id.toAtom(); + + // This will return true even for deselected constructors. (To do + // better, we need a JSContext here; it's fine as it is.) + + return atom == names.undefined || atom == names.globalThis || + LookupStdName(names, atom, standard_class_names) || + LookupStdName(names, atom, builtin_property_names); +} + +JS_PUBLIC_API bool JS_EnumerateStandardClasses(JSContext* cx, + HandleObject obj) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + cx->check(obj); + Handle<GlobalObject*> global = obj.as<GlobalObject>(); + return GlobalObject::initStandardClasses(cx, global); +} + +static bool EnumerateStandardClassesInTable(JSContext* cx, + Handle<GlobalObject*> global, + MutableHandleIdVector properties, + const JSStdName* table, + bool includeResolved) { + for (unsigned i = 0; !table[i].isSentinel(); i++) { + if (table[i].isDummy()) { + continue; + } + + JSProtoKey key = table[i].key; + + // If the standard class has been resolved, the properties have been + // defined on the global so we don't need to add them here. + if (!includeResolved && global->isStandardClassResolved(key)) { + continue; + } + + if (GlobalObject::skipDeselectedConstructor(cx, key)) { + continue; + } + + if (const JSClass* clasp = ProtoKeyToClass(key)) { + if (!clasp->specShouldDefineConstructor() || + SkipSharedArrayBufferConstructor(key, global)) { + continue; + } + } + + jsid id = NameToId(AtomStateOffsetToName(cx->names(), table[i].atomOffset)); + + if (SkipUneval(id, cx)) { + continue; + } + + if (!properties.append(id)) { + return false; + } + } + + return true; +} + +static bool EnumerateStandardClasses(JSContext* cx, JS::HandleObject obj, + JS::MutableHandleIdVector properties, + bool enumerableOnly, + bool includeResolved) { + if (enumerableOnly) { + // There are no enumerable standard classes and "undefined" is + // not enumerable. + return true; + } + + Handle<GlobalObject*> global = obj.as<GlobalObject>(); + + // It's fine to always append |undefined| here, it's non-configurable and + // the enumeration code filters duplicates. + if (!properties.append(NameToId(cx->names().undefined))) { + return false; + } + + bool resolved = false; + if (!GlobalObject::maybeResolveGlobalThis(cx, global, &resolved)) { + return false; + } + if (resolved || includeResolved) { + if (!properties.append(NameToId(cx->names().globalThis))) { + return false; + } + } + + if (!EnumerateStandardClassesInTable(cx, global, properties, + standard_class_names, includeResolved)) { + return false; + } + if (!EnumerateStandardClassesInTable( + cx, global, properties, builtin_property_names, includeResolved)) { + return false; + } + + return true; +} + +JS_PUBLIC_API bool JS_NewEnumerateStandardClasses( + JSContext* cx, JS::HandleObject obj, JS::MutableHandleIdVector properties, + bool enumerableOnly) { + return EnumerateStandardClasses(cx, obj, properties, enumerableOnly, false); +} + +JS_PUBLIC_API bool JS_NewEnumerateStandardClassesIncludingResolved( + JSContext* cx, JS::HandleObject obj, JS::MutableHandleIdVector properties, + bool enumerableOnly) { + return EnumerateStandardClasses(cx, obj, properties, enumerableOnly, true); +} + +JS_PUBLIC_API bool JS_GetClassObject(JSContext* cx, JSProtoKey key, + MutableHandleObject objp) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + JSObject* obj = GlobalObject::getOrCreateConstructor(cx, key); + if (!obj) { + return false; + } + objp.set(obj); + return true; +} + +JS_PUBLIC_API bool JS_GetClassPrototype(JSContext* cx, JSProtoKey key, + MutableHandleObject objp) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + + // Bound functions don't have their own prototype object: they reuse the + // prototype of the target object. This is typically Function.prototype so we + // use that here. + if (key == JSProto_BoundFunction) { + key = JSProto_Function; + } + + JSObject* proto = GlobalObject::getOrCreatePrototype(cx, key); + if (!proto) { + return false; + } + objp.set(proto); + return true; +} + +namespace JS { + +JS_PUBLIC_API void ProtoKeyToId(JSContext* cx, JSProtoKey key, + MutableHandleId idp) { + idp.set(NameToId(ClassName(key, cx))); +} + +} /* namespace JS */ + +JS_PUBLIC_API JSProtoKey JS_IdToProtoKey(JSContext* cx, HandleId id) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + cx->check(id); + + if (!id.isAtom()) { + return JSProto_Null; + } + + JSAtom* atom = id.toAtom(); + const JSStdName* stdnm = + LookupStdName(cx->names(), atom, standard_class_names); + if (!stdnm) { + return JSProto_Null; + } + + if (GlobalObject::skipDeselectedConstructor(cx, stdnm->key)) { + return JSProto_Null; + } + + if (SkipSharedArrayBufferConstructor(stdnm->key, cx->global())) { + MOZ_ASSERT(id == NameToId(cx->names().SharedArrayBuffer)); + return JSProto_Null; + } + + if (SkipUneval(id, cx)) { + return JSProto_Null; + } + + static_assert(std::size(standard_class_names) == JSProto_LIMIT + 1); + return static_cast<JSProtoKey>(stdnm - standard_class_names); +} + +extern JS_PUBLIC_API bool JS_IsGlobalObject(JSObject* obj) { + return obj->is<GlobalObject>(); +} + +extern JS_PUBLIC_API JSObject* JS_GlobalLexicalEnvironment(JSObject* obj) { + return &obj->as<GlobalObject>().lexicalEnvironment(); +} + +extern JS_PUBLIC_API bool JS_HasExtensibleLexicalEnvironment(JSObject* obj) { + return obj->is<GlobalObject>() || + ObjectRealm::get(obj).getNonSyntacticLexicalEnvironment(obj); +} + +extern JS_PUBLIC_API JSObject* JS_ExtensibleLexicalEnvironment(JSObject* obj) { + return ExtensibleLexicalEnvironmentObject::forVarEnvironment(obj); +} + +JS_PUBLIC_API JSObject* JS::CurrentGlobalOrNull(JSContext* cx) { + AssertHeapIsIdleOrIterating(); + CHECK_THREAD(cx); + if (!cx->realm()) { + return nullptr; + } + return cx->global(); +} + +JS_PUBLIC_API JSObject* JS::GetNonCCWObjectGlobal(JSObject* obj) { + AssertHeapIsIdleOrIterating(); + MOZ_DIAGNOSTIC_ASSERT(!IsCrossCompartmentWrapper(obj)); + return &obj->nonCCWGlobal(); +} + +JS_PUBLIC_API bool JS::detail::ComputeThis(JSContext* cx, Value* vp, + MutableHandleObject thisObject) { + AssertHeapIsIdle(); + cx->check(vp[0], vp[1]); + + MutableHandleValue thisv = MutableHandleValue::fromMarkedLocation(&vp[1]); + JSObject* obj = BoxNonStrictThis(cx, thisv); + if (!obj) { + return false; + } + + thisObject.set(obj); + return true; +} + +static bool gProfileTimelineRecordingEnabled = false; + +JS_PUBLIC_API void JS::SetProfileTimelineRecordingEnabled(bool enabled) { + gProfileTimelineRecordingEnabled = enabled; +} + +JS_PUBLIC_API bool JS::IsProfileTimelineRecordingEnabled() { + return gProfileTimelineRecordingEnabled; +} + +JS_PUBLIC_API void* JS_malloc(JSContext* cx, size_t nbytes) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + return static_cast<void*>(cx->maybe_pod_malloc<uint8_t>(nbytes)); +} + +JS_PUBLIC_API void* JS_realloc(JSContext* cx, void* p, size_t oldBytes, + size_t newBytes) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + return static_cast<void*>(cx->maybe_pod_realloc<uint8_t>( + static_cast<uint8_t*>(p), oldBytes, newBytes)); +} + +JS_PUBLIC_API void JS_free(JSContext* cx, void* p) { return js_free(p); } + +JS_PUBLIC_API void* JS_string_malloc(JSContext* cx, size_t nbytes) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + return static_cast<void*>( + cx->maybe_pod_arena_malloc<uint8_t>(js::StringBufferArena, nbytes)); +} + +JS_PUBLIC_API void* JS_string_realloc(JSContext* cx, void* p, size_t oldBytes, + size_t newBytes) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + return static_cast<void*>(cx->maybe_pod_arena_realloc<uint8_t>( + js::StringBufferArena, static_cast<uint8_t*>(p), oldBytes, newBytes)); +} + +JS_PUBLIC_API void JS_string_free(JSContext* cx, void* p) { return js_free(p); } + +JS_PUBLIC_API void JS::AddAssociatedMemory(JSObject* obj, size_t nbytes, + JS::MemoryUse use) { + MOZ_ASSERT(obj); + if (!nbytes) { + return; + } + + Zone* zone = obj->zone(); + MOZ_ASSERT(!IsInsideNursery(obj)); + zone->addCellMemory(obj, nbytes, js::MemoryUse(use)); + zone->maybeTriggerGCOnMalloc(); +} + +JS_PUBLIC_API void JS::RemoveAssociatedMemory(JSObject* obj, size_t nbytes, + JS::MemoryUse use) { + MOZ_ASSERT(obj); + if (!nbytes) { + return; + } + + GCContext* gcx = obj->runtimeFromMainThread()->gcContext(); + gcx->removeCellMemory(obj, nbytes, js::MemoryUse(use)); +} + +#undef JS_AddRoot + +JS_PUBLIC_API bool JS_AddExtraGCRootsTracer(JSContext* cx, + JSTraceDataOp traceOp, void* data) { + return cx->runtime()->gc.addBlackRootsTracer(traceOp, data); +} + +JS_PUBLIC_API void JS_RemoveExtraGCRootsTracer(JSContext* cx, + JSTraceDataOp traceOp, + void* data) { + return cx->runtime()->gc.removeBlackRootsTracer(traceOp, data); +} + +JS_PUBLIC_API JS::GCReason JS::WantEagerMinorGC(JSRuntime* rt) { + if (rt->gc.nursery().shouldCollect()) { + return JS::GCReason::EAGER_NURSERY_COLLECTION; + } + return JS::GCReason::NO_REASON; +} + +JS_PUBLIC_API JS::GCReason JS::WantEagerMajorGC(JSRuntime* rt) { + return rt->gc.wantMajorGC(true); +} + +JS_PUBLIC_API void JS::MaybeRunNurseryCollection(JSRuntime* rt, + JS::GCReason reason) { + gc::GCRuntime& gc = rt->gc; + if (gc.nursery().shouldCollect()) { + gc.minorGC(reason); + } +} + +JS_PUBLIC_API void JS_GC(JSContext* cx, JS::GCReason reason) { + AssertHeapIsIdle(); + JS::PrepareForFullGC(cx); + cx->runtime()->gc.gc(JS::GCOptions::Normal, reason); +} + +JS_PUBLIC_API void JS_MaybeGC(JSContext* cx) { + AssertHeapIsIdle(); + cx->runtime()->gc.maybeGC(); +} + +JS_PUBLIC_API void JS_SetGCCallback(JSContext* cx, JSGCCallback cb, + void* data) { + AssertHeapIsIdle(); + cx->runtime()->gc.setGCCallback(cb, data); +} + +JS_PUBLIC_API void JS_SetObjectsTenuredCallback(JSContext* cx, + JSObjectsTenuredCallback cb, + void* data) { + AssertHeapIsIdle(); + cx->runtime()->gc.setObjectsTenuredCallback(cb, data); +} + +JS_PUBLIC_API bool JS_AddFinalizeCallback(JSContext* cx, JSFinalizeCallback cb, + void* data) { + AssertHeapIsIdle(); + return cx->runtime()->gc.addFinalizeCallback(cb, data); +} + +JS_PUBLIC_API void JS_RemoveFinalizeCallback(JSContext* cx, + JSFinalizeCallback cb) { + cx->runtime()->gc.removeFinalizeCallback(cb); +} + +JS_PUBLIC_API void JS::SetHostCleanupFinalizationRegistryCallback( + JSContext* cx, JSHostCleanupFinalizationRegistryCallback cb, void* data) { + AssertHeapIsIdle(); + cx->runtime()->gc.setHostCleanupFinalizationRegistryCallback(cb, data); +} + +JS_PUBLIC_API void JS::ClearKeptObjects(JSContext* cx) { + gc::GCRuntime* gc = &cx->runtime()->gc; + + for (ZonesIter zone(gc, ZoneSelector::WithAtoms); !zone.done(); zone.next()) { + zone->clearKeptObjects(); + } +} + +JS_PUBLIC_API bool JS::AtomsZoneIsCollecting(JSRuntime* runtime) { + return runtime->activeGCInAtomsZone(); +} + +JS_PUBLIC_API bool JS::IsAtomsZone(JS::Zone* zone) { + return zone->isAtomsZone(); +} + +JS_PUBLIC_API bool JS_AddWeakPointerZonesCallback(JSContext* cx, + JSWeakPointerZonesCallback cb, + void* data) { + AssertHeapIsIdle(); + return cx->runtime()->gc.addWeakPointerZonesCallback(cb, data); +} + +JS_PUBLIC_API void JS_RemoveWeakPointerZonesCallback( + JSContext* cx, JSWeakPointerZonesCallback cb) { + cx->runtime()->gc.removeWeakPointerZonesCallback(cb); +} + +JS_PUBLIC_API bool JS_AddWeakPointerCompartmentCallback( + JSContext* cx, JSWeakPointerCompartmentCallback cb, void* data) { + AssertHeapIsIdle(); + return cx->runtime()->gc.addWeakPointerCompartmentCallback(cb, data); +} + +JS_PUBLIC_API void JS_RemoveWeakPointerCompartmentCallback( + JSContext* cx, JSWeakPointerCompartmentCallback cb) { + cx->runtime()->gc.removeWeakPointerCompartmentCallback(cb); +} + +JS_PUBLIC_API bool JS_UpdateWeakPointerAfterGC(JSTracer* trc, + JS::Heap<JSObject*>* objp) { + return TraceWeakEdge(trc, objp); +} + +JS_PUBLIC_API bool JS_UpdateWeakPointerAfterGCUnbarriered(JSTracer* trc, + JSObject** objp) { + return TraceManuallyBarrieredWeakEdge(trc, objp, "External weak pointer"); +} + +JS_PUBLIC_API void JS_SetGCParameter(JSContext* cx, JSGCParamKey key, + uint32_t value) { + MOZ_ALWAYS_TRUE(cx->runtime()->gc.setParameter(cx, key, value)); +} + +JS_PUBLIC_API void JS_ResetGCParameter(JSContext* cx, JSGCParamKey key) { + cx->runtime()->gc.resetParameter(cx, key); +} + +JS_PUBLIC_API uint32_t JS_GetGCParameter(JSContext* cx, JSGCParamKey key) { + return cx->runtime()->gc.getParameter(key); +} + +JS_PUBLIC_API void JS_SetGCParametersBasedOnAvailableMemory( + JSContext* cx, uint32_t availMemMB) { + struct JSGCConfig { + JSGCParamKey key; + uint32_t value; + }; + + static const JSGCConfig minimal[] = { + {JSGC_SLICE_TIME_BUDGET_MS, 5}, + {JSGC_HIGH_FREQUENCY_TIME_LIMIT, 1500}, + {JSGC_LARGE_HEAP_SIZE_MIN, 250}, + {JSGC_SMALL_HEAP_SIZE_MAX, 50}, + {JSGC_HIGH_FREQUENCY_SMALL_HEAP_GROWTH, 300}, + {JSGC_HIGH_FREQUENCY_LARGE_HEAP_GROWTH, 120}, + {JSGC_LOW_FREQUENCY_HEAP_GROWTH, 120}, + {JSGC_ALLOCATION_THRESHOLD, 15}, + {JSGC_MALLOC_THRESHOLD_BASE, 20}, + {JSGC_SMALL_HEAP_INCREMENTAL_LIMIT, 200}, + {JSGC_LARGE_HEAP_INCREMENTAL_LIMIT, 110}, + {JSGC_URGENT_THRESHOLD_MB, 8}}; + + static const JSGCConfig nominal[] = { + {JSGC_SLICE_TIME_BUDGET_MS, 5}, + {JSGC_HIGH_FREQUENCY_TIME_LIMIT, 1000}, + {JSGC_LARGE_HEAP_SIZE_MIN, 500}, + {JSGC_SMALL_HEAP_SIZE_MAX, 100}, + {JSGC_HIGH_FREQUENCY_SMALL_HEAP_GROWTH, 300}, + {JSGC_HIGH_FREQUENCY_LARGE_HEAP_GROWTH, 150}, + {JSGC_LOW_FREQUENCY_HEAP_GROWTH, 150}, + {JSGC_ALLOCATION_THRESHOLD, 27}, + {JSGC_MALLOC_THRESHOLD_BASE, 38}, + {JSGC_SMALL_HEAP_INCREMENTAL_LIMIT, 150}, + {JSGC_LARGE_HEAP_INCREMENTAL_LIMIT, 110}, + {JSGC_URGENT_THRESHOLD_MB, 16}}; + + const auto& configSet = availMemMB > 512 ? nominal : minimal; + for (const auto& config : configSet) { + JS_SetGCParameter(cx, config.key, config.value); + } +} + +JS_PUBLIC_API JSString* JS_NewExternalString( + JSContext* cx, const char16_t* chars, size_t length, + const JSExternalStringCallbacks* callbacks) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + return JSExternalString::new_(cx, chars, length, callbacks); +} + +JS_PUBLIC_API JSString* JS_NewMaybeExternalString( + JSContext* cx, const char16_t* chars, size_t length, + const JSExternalStringCallbacks* callbacks, bool* allocatedExternal) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + return NewMaybeExternalString(cx, chars, length, callbacks, + allocatedExternal); +} + +extern JS_PUBLIC_API const JSExternalStringCallbacks* +JS_GetExternalStringCallbacks(JSString* str) { + return str->asExternal().callbacks(); +} + +static void SetNativeStackSize(JSContext* cx, JS::StackKind kind, + JS::NativeStackSize stackSize) { +#ifdef __wasi__ + cx->nativeStackLimit[kind] = JS::WASINativeStackLimit; +#else // __wasi__ + if (stackSize == 0) { + cx->nativeStackLimit[kind] = JS::NativeStackLimitMax; + } else { + cx->nativeStackLimit[kind] = + JS::GetNativeStackLimit(cx->nativeStackBase(), stackSize - 1); + } +#endif // !__wasi__ +} + +JS_PUBLIC_API void JS_SetNativeStackQuota( + JSContext* cx, JS::NativeStackSize systemCodeStackSize, + JS::NativeStackSize trustedScriptStackSize, + JS::NativeStackSize untrustedScriptStackSize) { + MOZ_ASSERT(!cx->activation()); + MOZ_ASSERT(cx->isMainThreadContext()); + + if (!trustedScriptStackSize) { + trustedScriptStackSize = systemCodeStackSize; + } else { + MOZ_ASSERT(trustedScriptStackSize < systemCodeStackSize); + } + + if (!untrustedScriptStackSize) { + untrustedScriptStackSize = trustedScriptStackSize; + } else { + MOZ_ASSERT(untrustedScriptStackSize < trustedScriptStackSize); + } + + SetNativeStackSize(cx, JS::StackForSystemCode, systemCodeStackSize); + SetNativeStackSize(cx, JS::StackForTrustedScript, trustedScriptStackSize); + SetNativeStackSize(cx, JS::StackForUntrustedScript, untrustedScriptStackSize); + + cx->initJitStackLimit(); +} + +/************************************************************************/ + +JS_PUBLIC_API bool JS_ValueToId(JSContext* cx, HandleValue value, + MutableHandleId idp) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + cx->check(value); + return ToPropertyKey(cx, value, idp); +} + +JS_PUBLIC_API bool JS_StringToId(JSContext* cx, HandleString string, + MutableHandleId idp) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + cx->check(string); + RootedValue value(cx, StringValue(string)); + return PrimitiveValueToId<CanGC>(cx, value, idp); +} + +JS_PUBLIC_API bool JS_IdToValue(JSContext* cx, jsid id, MutableHandleValue vp) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + cx->check(id); + vp.set(IdToValue(id)); + cx->check(vp); + return true; +} + +JS_PUBLIC_API bool JS::ToPrimitive(JSContext* cx, HandleObject obj, JSType hint, + MutableHandleValue vp) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + cx->check(obj); + MOZ_ASSERT(obj != nullptr); + MOZ_ASSERT(hint == JSTYPE_UNDEFINED || hint == JSTYPE_STRING || + hint == JSTYPE_NUMBER); + vp.setObject(*obj); + return ToPrimitiveSlow(cx, hint, vp); +} + +JS_PUBLIC_API bool JS::GetFirstArgumentAsTypeHint(JSContext* cx, CallArgs args, + JSType* result) { + if (!args.get(0).isString()) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, + JSMSG_NOT_EXPECTED_TYPE, "Symbol.toPrimitive", + "\"string\", \"number\", or \"default\"", + InformalValueTypeName(args.get(0))); + return false; + } + + RootedString str(cx, args.get(0).toString()); + bool match; + + if (!EqualStrings(cx, str, cx->names().default_, &match)) { + return false; + } + if (match) { + *result = JSTYPE_UNDEFINED; + return true; + } + + if (!EqualStrings(cx, str, cx->names().string, &match)) { + return false; + } + if (match) { + *result = JSTYPE_STRING; + return true; + } + + if (!EqualStrings(cx, str, cx->names().number, &match)) { + return false; + } + if (match) { + *result = JSTYPE_NUMBER; + return true; + } + + UniqueChars bytes; + const char* source = ValueToSourceForError(cx, args.get(0), bytes); + if (!source) { + ReportOutOfMemory(cx); + return false; + } + + JS_ReportErrorNumberUTF8(cx, GetErrorMessage, nullptr, + JSMSG_NOT_EXPECTED_TYPE, "Symbol.toPrimitive", + "\"string\", \"number\", or \"default\"", source); + return false; +} + +JS_PUBLIC_API JSObject* JS_InitClass( + JSContext* cx, HandleObject obj, const JSClass* protoClass, + HandleObject protoProto, const char* name, JSNative constructor, + unsigned nargs, const JSPropertySpec* ps, const JSFunctionSpec* fs, + const JSPropertySpec* static_ps, const JSFunctionSpec* static_fs) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + cx->check(obj, protoProto); + return InitClass(cx, obj, protoClass, protoProto, name, constructor, nargs, + ps, fs, static_ps, static_fs); +} + +JS_PUBLIC_API bool JS_LinkConstructorAndPrototype(JSContext* cx, + HandleObject ctor, + HandleObject proto) { + return LinkConstructorAndPrototype(cx, ctor, proto); +} + +JS_PUBLIC_API bool JS_InstanceOf(JSContext* cx, HandleObject obj, + const JSClass* clasp, CallArgs* args) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); +#ifdef DEBUG + if (args) { + cx->check(obj); + cx->check(args->thisv(), args->calleev()); + } +#endif + if (!obj || obj->getClass() != clasp) { + if (args) { + ReportIncompatibleMethod(cx, *args, clasp); + } + return false; + } + return true; +} + +JS_PUBLIC_API bool JS_HasInstance(JSContext* cx, HandleObject obj, + HandleValue value, bool* bp) { + AssertHeapIsIdle(); + cx->check(obj, value); + return InstanceofOperator(cx, obj, value, bp); +} + +JS_PUBLIC_API JSObject* JS_GetConstructor(JSContext* cx, HandleObject proto) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + cx->check(proto); + + RootedValue cval(cx); + if (!GetProperty(cx, proto, proto, cx->names().constructor, &cval)) { + return nullptr; + } + if (!IsFunctionObject(cval)) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, + JSMSG_NO_CONSTRUCTOR, proto->getClass()->name); + return nullptr; + } + return &cval.toObject(); +} + +JS::RealmCreationOptions& +JS::RealmCreationOptions::setNewCompartmentInSystemZone() { + compSpec_ = CompartmentSpecifier::NewCompartmentInSystemZone; + comp_ = nullptr; + return *this; +} + +JS::RealmCreationOptions& +JS::RealmCreationOptions::setNewCompartmentInExistingZone(JSObject* obj) { + compSpec_ = CompartmentSpecifier::NewCompartmentInExistingZone; + zone_ = obj->zone(); + return *this; +} + +JS::RealmCreationOptions& JS::RealmCreationOptions::setExistingCompartment( + JSObject* obj) { + compSpec_ = CompartmentSpecifier::ExistingCompartment; + comp_ = obj->compartment(); + return *this; +} + +JS::RealmCreationOptions& JS::RealmCreationOptions::setExistingCompartment( + JS::Compartment* compartment) { + compSpec_ = CompartmentSpecifier::ExistingCompartment; + comp_ = compartment; + return *this; +} + +JS::RealmCreationOptions& JS::RealmCreationOptions::setNewCompartmentAndZone() { + compSpec_ = CompartmentSpecifier::NewCompartmentAndZone; + comp_ = nullptr; + return *this; +} + +const JS::RealmCreationOptions& JS::RealmCreationOptionsRef(Realm* realm) { + return realm->creationOptions(); +} + +const JS::RealmCreationOptions& JS::RealmCreationOptionsRef(JSContext* cx) { + return cx->realm()->creationOptions(); +} + +bool JS::RealmCreationOptions::getSharedMemoryAndAtomicsEnabled() const { + return sharedMemoryAndAtomics_; +} + +JS::RealmCreationOptions& +JS::RealmCreationOptions::setSharedMemoryAndAtomicsEnabled(bool flag) { + sharedMemoryAndAtomics_ = flag; + return *this; +} + +bool JS::RealmCreationOptions::getCoopAndCoepEnabled() const { + return coopAndCoep_; +} + +JS::RealmCreationOptions& JS::RealmCreationOptions::setCoopAndCoepEnabled( + bool flag) { + coopAndCoep_ = flag; + return *this; +} + +const JS::RealmBehaviors& JS::RealmBehaviorsRef(JS::Realm* realm) { + return realm->behaviors(); +} + +const JS::RealmBehaviors& JS::RealmBehaviorsRef(JSContext* cx) { + return cx->realm()->behaviors(); +} + +void JS::SetRealmNonLive(Realm* realm) { realm->setNonLive(); } + +JS_PUBLIC_API JSObject* JS_NewGlobalObject(JSContext* cx, const JSClass* clasp, + JSPrincipals* principals, + JS::OnNewGlobalHookOption hookOption, + const JS::RealmOptions& options) { + MOZ_RELEASE_ASSERT( + cx->runtime()->hasInitializedSelfHosting(), + "Must call JS::InitSelfHostedCode() before creating a global"); + + AssertHeapIsIdle(); + CHECK_THREAD(cx); + + return GlobalObject::new_(cx, clasp, principals, hookOption, options); +} + +JS_PUBLIC_API void JS_GlobalObjectTraceHook(JSTracer* trc, JSObject* global) { + GlobalObject* globalObj = &global->as<GlobalObject>(); + Realm* globalRealm = globalObj->realm(); + + // If we GC when creating the global, we may not have set that global's + // realm's global pointer yet. In this case, the realm will not yet contain + // anything that needs to be traced. + if (globalRealm->unsafeUnbarrieredMaybeGlobal() != globalObj) { + return; + } + + // Trace the realm for any GC things that should only stick around if we + // know the global is live. + globalRealm->traceGlobalData(trc); + + globalObj->traceData(trc, globalObj); + + if (JSTraceOp trace = globalRealm->creationOptions().getTrace()) { + trace(trc, global); + } +} + +const JSClassOps JS::DefaultGlobalClassOps = { + nullptr, // addProperty + nullptr, // delProperty + nullptr, // enumerate + JS_NewEnumerateStandardClasses, // newEnumerate + JS_ResolveStandardClass, // resolve + JS_MayResolveStandardClass, // mayResolve + nullptr, // finalize + nullptr, // call + nullptr, // construct + JS_GlobalObjectTraceHook, // trace +}; + +JS_PUBLIC_API void JS_FireOnNewGlobalObject(JSContext* cx, + JS::HandleObject global) { + // This hook is infallible, because we don't really want arbitrary script + // to be able to throw errors during delicate global creation routines. + // This infallibility will eat OOM and slow script, but if that happens + // we'll likely run up into them again soon in a fallible context. + cx->check(global); + Rooted<js::GlobalObject*> globalObject(cx, &global->as<GlobalObject>()); + DebugAPI::onNewGlobalObject(cx, globalObject); + cx->runtime()->ensureRealmIsRecordingAllocations(globalObject); +} + +JS_PUBLIC_API JSObject* JS_NewObject(JSContext* cx, const JSClass* clasp) { + MOZ_ASSERT(!cx->zone()->isAtomsZone()); + AssertHeapIsIdle(); + CHECK_THREAD(cx); + + if (!clasp) { + // Default class is Object. + return NewPlainObject(cx); + } + + MOZ_ASSERT(!clasp->isJSFunction()); + MOZ_ASSERT(clasp != &PlainObject::class_); + MOZ_ASSERT(clasp != &ArrayObject::class_); + MOZ_ASSERT(!(clasp->flags & JSCLASS_IS_GLOBAL)); + + return NewBuiltinClassInstance(cx, clasp); +} + +JS_PUBLIC_API JSObject* JS_NewObjectWithGivenProto(JSContext* cx, + const JSClass* clasp, + HandleObject proto) { + MOZ_ASSERT(!cx->zone()->isAtomsZone()); + AssertHeapIsIdle(); + CHECK_THREAD(cx); + cx->check(proto); + + if (!clasp) { + // Default class is Object. + return NewPlainObjectWithProto(cx, proto); + } + + MOZ_ASSERT(!clasp->isJSFunction()); + MOZ_ASSERT(clasp != &PlainObject::class_); + MOZ_ASSERT(clasp != &ArrayObject::class_); + MOZ_ASSERT(!(clasp->flags & JSCLASS_IS_GLOBAL)); + + return NewObjectWithGivenProto(cx, clasp, proto); +} + +JS_PUBLIC_API JSObject* JS_NewPlainObject(JSContext* cx) { + MOZ_ASSERT(!cx->zone()->isAtomsZone()); + AssertHeapIsIdle(); + CHECK_THREAD(cx); + + return NewPlainObject(cx); +} + +JS_PUBLIC_API JSObject* JS_NewObjectForConstructor(JSContext* cx, + const JSClass* clasp, + const CallArgs& args) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + + MOZ_ASSERT(!clasp->isJSFunction()); + MOZ_ASSERT(clasp != &PlainObject::class_); + MOZ_ASSERT(clasp != &ArrayObject::class_); + MOZ_ASSERT(!(clasp->flags & JSCLASS_IS_GLOBAL)); + + if (!ThrowIfNotConstructing(cx, args, clasp->name)) { + return nullptr; + } + + RootedObject newTarget(cx, &args.newTarget().toObject()); + cx->check(newTarget); + + RootedObject proto(cx); + if (!GetPrototypeFromConstructor(cx, newTarget, + JSCLASS_CACHED_PROTO_KEY(clasp), &proto)) { + return nullptr; + } + + return NewObjectWithClassProto(cx, clasp, proto); +} + +JS_PUBLIC_API bool JS_IsNative(JSObject* obj) { + return obj->is<NativeObject>(); +} + +JS_PUBLIC_API void JS::AssertObjectBelongsToCurrentThread(JSObject* obj) { + JSRuntime* rt = obj->compartment()->runtimeFromAnyThread(); + MOZ_RELEASE_ASSERT(CurrentThreadCanAccessRuntime(rt)); +} + +JS_PUBLIC_API void JS::SetFilenameValidationCallback( + JS::FilenameValidationCallback cb) { + js::gFilenameValidationCallback = cb; +} + +JS_PUBLIC_API void JS::SetHostEnsureCanAddPrivateElementHook( + JSContext* cx, JS::EnsureCanAddPrivateElementOp op) { + cx->runtime()->canAddPrivateElement = op; +} + +/*** Standard internal methods **********************************************/ + +JS_PUBLIC_API bool JS_GetPrototype(JSContext* cx, HandleObject obj, + MutableHandleObject result) { + cx->check(obj); + return GetPrototype(cx, obj, result); +} + +JS_PUBLIC_API bool JS_SetPrototype(JSContext* cx, HandleObject obj, + HandleObject proto) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + cx->check(obj, proto); + + return SetPrototype(cx, obj, proto); +} + +JS_PUBLIC_API bool JS_GetPrototypeIfOrdinary(JSContext* cx, HandleObject obj, + bool* isOrdinary, + MutableHandleObject result) { + cx->check(obj); + return GetPrototypeIfOrdinary(cx, obj, isOrdinary, result); +} + +JS_PUBLIC_API bool JS_IsExtensible(JSContext* cx, HandleObject obj, + bool* extensible) { + cx->check(obj); + return IsExtensible(cx, obj, extensible); +} + +JS_PUBLIC_API bool JS_PreventExtensions(JSContext* cx, JS::HandleObject obj, + ObjectOpResult& result) { + cx->check(obj); + return PreventExtensions(cx, obj, result); +} + +JS_PUBLIC_API bool JS_SetImmutablePrototype(JSContext* cx, JS::HandleObject obj, + bool* succeeded) { + cx->check(obj); + return SetImmutablePrototype(cx, obj, succeeded); +} + +/* * */ + +JS_PUBLIC_API bool JS_FreezeObject(JSContext* cx, HandleObject obj) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + cx->check(obj); + return FreezeObject(cx, obj); +} + +static bool DeepFreezeSlot(JSContext* cx, const Value& v) { + if (v.isPrimitive()) { + return true; + } + RootedObject obj(cx, &v.toObject()); + return JS_DeepFreezeObject(cx, obj); +} + +JS_PUBLIC_API bool JS_DeepFreezeObject(JSContext* cx, HandleObject obj) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + cx->check(obj); + + // Assume that non-extensible objects are already deep-frozen, to avoid + // divergence. + bool extensible; + if (!IsExtensible(cx, obj, &extensible)) { + return false; + } + if (!extensible) { + return true; + } + + if (!FreezeObject(cx, obj)) { + return false; + } + + // Walk slots in obj and if any value is a non-null object, seal it. + if (obj->is<NativeObject>()) { + Rooted<NativeObject*> nobj(cx, &obj->as<NativeObject>()); + for (uint32_t i = 0, n = nobj->slotSpan(); i < n; ++i) { + if (!DeepFreezeSlot(cx, nobj->getSlot(i))) { + return false; + } + } + for (uint32_t i = 0, n = nobj->getDenseInitializedLength(); i < n; ++i) { + if (!DeepFreezeSlot(cx, nobj->getDenseElement(i))) { + return false; + } + } + } + + return true; +} + +JS_PUBLIC_API bool JSPropertySpec::getValue(JSContext* cx, + MutableHandleValue vp) const { + MOZ_ASSERT(!isAccessor()); + + switch (u.value.type) { + case ValueWrapper::Type::String: { + Rooted<JSAtom*> atom(cx, + Atomize(cx, u.value.string, strlen(u.value.string))); + if (!atom) { + return false; + } + vp.setString(atom); + return true; + } + + case ValueWrapper::Type::Int32: + vp.setInt32(u.value.int32); + return true; + + case ValueWrapper::Type::Double: + vp.setDouble(u.value.double_); + return true; + } + + MOZ_CRASH("Unexpected type"); +} + +bool PropertySpecNameToId(JSContext* cx, JSPropertySpec::Name name, + MutableHandleId id) { + if (name.isSymbol()) { + id.set(PropertyKey::Symbol(cx->wellKnownSymbols().get(name.symbol()))); + } else { + JSAtom* atom = Atomize(cx, name.string(), strlen(name.string())); + if (!atom) { + return false; + } + id.set(AtomToId(atom)); + } + return true; +} + +JS_PUBLIC_API bool JS::PropertySpecNameToPermanentId(JSContext* cx, + JSPropertySpec::Name name, + jsid* idp) { + // We are calling fromMarkedLocation(idp) even though idp points to a + // location that will never be marked. This is OK because the whole point + // of this API is to populate *idp with a jsid that does not need to be + // marked. + MutableHandleId id = MutableHandleId::fromMarkedLocation(idp); + if (!PropertySpecNameToId(cx, name, id)) { + return false; + } + + if (id.isString() && !PinAtom(cx, &id.toString()->asAtom())) { + return false; + } + + return true; +} + +JS_PUBLIC_API bool JS::ObjectToCompletePropertyDescriptor( + JSContext* cx, HandleObject obj, HandleValue descObj, + MutableHandle<PropertyDescriptor> desc) { + // |obj| can be in a different compartment here. The caller is responsible + // for wrapping it (see JS_WrapPropertyDescriptor). + cx->check(descObj); + if (!ToPropertyDescriptor(cx, descObj, true, desc)) { + return false; + } + CompletePropertyDescriptor(desc); + return true; +} + +JS_PUBLIC_API void JS_SetAllNonReservedSlotsToUndefined(JS::HandleObject obj) { + if (!obj->is<NativeObject>()) { + return; + } + + const JSClass* clasp = obj->getClass(); + unsigned numReserved = JSCLASS_RESERVED_SLOTS(clasp); + unsigned numSlots = obj->as<NativeObject>().slotSpan(); + for (unsigned i = numReserved; i < numSlots; i++) { + obj->as<NativeObject>().setSlot(i, UndefinedValue()); + } +} + +JS_PUBLIC_API void JS_SetReservedSlot(JSObject* obj, uint32_t index, + const Value& value) { + // Note: we don't use setReservedSlot so that this also works on swappable DOM + // objects. See NativeObject::getReservedSlotRef comment. + MOZ_ASSERT(index < JSCLASS_RESERVED_SLOTS(obj->getClass())); + obj->as<NativeObject>().setSlot(index, value); +} + +JS_PUBLIC_API void JS_InitReservedSlot(JSObject* obj, uint32_t index, void* ptr, + size_t nbytes, JS::MemoryUse use) { + // Note: we don't use InitReservedSlot so that this also works on swappable + // DOM objects. See NativeObject::getReservedSlotRef comment. + MOZ_ASSERT(index < JSCLASS_RESERVED_SLOTS(obj->getClass())); + AddCellMemory(obj, nbytes, js::MemoryUse(use)); + obj->as<NativeObject>().initSlot(index, PrivateValue(ptr)); +} + +JS_PUBLIC_API bool JS::IsMapObject(JSContext* cx, JS::HandleObject obj, + bool* isMap) { + return IsGivenTypeObject(cx, obj, ESClass::Map, isMap); +} + +JS_PUBLIC_API bool JS::IsSetObject(JSContext* cx, JS::HandleObject obj, + bool* isSet) { + return IsGivenTypeObject(cx, obj, ESClass::Set, isSet); +} + +JS_PUBLIC_API void JS_HoldPrincipals(JSPrincipals* principals) { + ++principals->refcount; +} + +JS_PUBLIC_API void JS_DropPrincipals(JSContext* cx, JSPrincipals* principals) { + int rc = --principals->refcount; + if (rc == 0) { + JS::AutoSuppressGCAnalysis nogc; + cx->runtime()->destroyPrincipals(principals); + } +} + +JS_PUBLIC_API void JS_SetSecurityCallbacks(JSContext* cx, + const JSSecurityCallbacks* scb) { + MOZ_ASSERT(scb != &NullSecurityCallbacks); + cx->runtime()->securityCallbacks = scb ? scb : &NullSecurityCallbacks; +} + +JS_PUBLIC_API const JSSecurityCallbacks* JS_GetSecurityCallbacks( + JSContext* cx) { + return (cx->runtime()->securityCallbacks != &NullSecurityCallbacks) + ? cx->runtime()->securityCallbacks.ref() + : nullptr; +} + +JS_PUBLIC_API void JS_SetTrustedPrincipals(JSContext* cx, JSPrincipals* prin) { + cx->runtime()->setTrustedPrincipals(prin); +} + +extern JS_PUBLIC_API void JS_InitDestroyPrincipalsCallback( + JSContext* cx, JSDestroyPrincipalsOp destroyPrincipals) { + MOZ_ASSERT(destroyPrincipals); + MOZ_ASSERT(!cx->runtime()->destroyPrincipals); + cx->runtime()->destroyPrincipals = destroyPrincipals; +} + +extern JS_PUBLIC_API void JS_InitReadPrincipalsCallback( + JSContext* cx, JSReadPrincipalsOp read) { + MOZ_ASSERT(read); + MOZ_ASSERT(!cx->runtime()->readPrincipals); + cx->runtime()->readPrincipals = read; +} + +JS_PUBLIC_API JSFunction* JS_NewFunction(JSContext* cx, JSNative native, + unsigned nargs, unsigned flags, + const char* name) { + MOZ_ASSERT(!cx->zone()->isAtomsZone()); + + AssertHeapIsIdle(); + CHECK_THREAD(cx); + + Rooted<JSAtom*> atom(cx); + if (name) { + atom = Atomize(cx, name, strlen(name)); + if (!atom) { + return nullptr; + } + } + + return (flags & JSFUN_CONSTRUCTOR) + ? NewNativeConstructor(cx, native, nargs, atom) + : NewNativeFunction(cx, native, nargs, atom); +} + +JS_PUBLIC_API JSFunction* JS::GetSelfHostedFunction(JSContext* cx, + const char* selfHostedName, + HandleId id, + unsigned nargs) { + MOZ_ASSERT(!cx->zone()->isAtomsZone()); + AssertHeapIsIdle(); + CHECK_THREAD(cx); + cx->check(id); + + Rooted<JSAtom*> name(cx, IdToFunctionName(cx, id)); + if (!name) { + return nullptr; + } + + JSAtom* shAtom = Atomize(cx, selfHostedName, strlen(selfHostedName)); + if (!shAtom) { + return nullptr; + } + Rooted<PropertyName*> shName(cx, shAtom->asPropertyName()); + RootedValue funVal(cx); + if (!GlobalObject::getSelfHostedFunction(cx, cx->global(), shName, name, + nargs, &funVal)) { + return nullptr; + } + return &funVal.toObject().as<JSFunction>(); +} + +JS_PUBLIC_API JSFunction* JS::NewFunctionFromSpec(JSContext* cx, + const JSFunctionSpec* fs, + HandleId id) { + cx->check(id); + +#ifdef DEBUG + if (fs->name.isSymbol()) { + JS::Symbol* sym = cx->wellKnownSymbols().get(fs->name.symbol()); + MOZ_ASSERT(PropertyKey::Symbol(sym) == id); + } else { + MOZ_ASSERT(id.isString() && + StringEqualsAscii(id.toLinearString(), fs->name.string())); + } +#endif + + // Delay cloning self-hosted functions until they are called. This is + // achieved by passing DefineFunction a nullptr JSNative which produces an + // interpreted JSFunction where !hasScript. Interpreted call paths then + // call InitializeLazyFunctionScript if !hasScript. + if (fs->selfHostedName) { + MOZ_ASSERT(!fs->call.op); + MOZ_ASSERT(!fs->call.info); + + JSAtom* shAtom = + Atomize(cx, fs->selfHostedName, strlen(fs->selfHostedName)); + if (!shAtom) { + return nullptr; + } + Rooted<PropertyName*> shName(cx, shAtom->asPropertyName()); + Rooted<JSAtom*> name(cx, IdToFunctionName(cx, id)); + if (!name) { + return nullptr; + } + RootedValue funVal(cx); + if (!GlobalObject::getSelfHostedFunction(cx, cx->global(), shName, name, + fs->nargs, &funVal)) { + return nullptr; + } + return &funVal.toObject().as<JSFunction>(); + } + + Rooted<JSAtom*> atom(cx, IdToFunctionName(cx, id)); + if (!atom) { + return nullptr; + } + + MOZ_ASSERT(fs->call.op); + + JSFunction* fun; + if (fs->flags & JSFUN_CONSTRUCTOR) { + fun = NewNativeConstructor(cx, fs->call.op, fs->nargs, atom); + } else { + fun = NewNativeFunction(cx, fs->call.op, fs->nargs, atom); + } + if (!fun) { + return nullptr; + } + + if (fs->call.info) { + fun->setJitInfo(fs->call.info); + } + return fun; +} + +JS_PUBLIC_API JSFunction* JS::NewFunctionFromSpec(JSContext* cx, + const JSFunctionSpec* fs) { + RootedId id(cx); + if (!PropertySpecNameToId(cx, fs->name, &id)) { + return nullptr; + } + + return NewFunctionFromSpec(cx, fs, id); +} + +JS_PUBLIC_API JSObject* JS_GetFunctionObject(JSFunction* fun) { return fun; } + +JS_PUBLIC_API JSString* JS_GetFunctionId(JSFunction* fun) { + return fun->explicitName(); +} + +JS_PUBLIC_API JSString* JS_GetFunctionDisplayId(JSFunction* fun) { + return fun->displayAtom(); +} + +JS_PUBLIC_API uint16_t JS_GetFunctionArity(JSFunction* fun) { + return fun->nargs(); +} + +JS_PUBLIC_API bool JS_GetFunctionLength(JSContext* cx, HandleFunction fun, + uint16_t* length) { + cx->check(fun); + return JSFunction::getLength(cx, fun, length); +} + +JS_PUBLIC_API bool JS_ObjectIsFunction(JSObject* obj) { + return obj->is<JSFunction>(); +} + +JS_PUBLIC_API bool JS_IsNativeFunction(JSObject* funobj, JSNative call) { + if (!funobj->is<JSFunction>()) { + return false; + } + JSFunction* fun = &funobj->as<JSFunction>(); + return fun->isNativeFun() && fun->native() == call; +} + +extern JS_PUBLIC_API bool JS_IsConstructor(JSFunction* fun) { + return fun->isConstructor(); +} + +void JS::TransitiveCompileOptions::copyPODTransitiveOptions( + const TransitiveCompileOptions& rhs) { + // filename_, introducerFilename_, sourceMapURL_ should be handled in caller. + + mutedErrors_ = rhs.mutedErrors_; + forceStrictMode_ = rhs.forceStrictMode_; + shouldResistFingerprinting_ = rhs.shouldResistFingerprinting_; + sourcePragmas_ = rhs.sourcePragmas_; + skipFilenameValidation_ = rhs.skipFilenameValidation_; + hideScriptFromDebugger_ = rhs.hideScriptFromDebugger_; + deferDebugMetadata_ = rhs.deferDebugMetadata_; + eagerDelazificationStrategy_ = rhs.eagerDelazificationStrategy_; + + selfHostingMode = rhs.selfHostingMode; + asmJSOption = rhs.asmJSOption; + throwOnAsmJSValidationFailureOption = rhs.throwOnAsmJSValidationFailureOption; + forceAsync = rhs.forceAsync; + discardSource = rhs.discardSource; + sourceIsLazy = rhs.sourceIsLazy; + allowHTMLComments = rhs.allowHTMLComments; + nonSyntacticScope = rhs.nonSyntacticScope; + + topLevelAwait = rhs.topLevelAwait; + importAssertions = rhs.importAssertions; + + borrowBuffer = rhs.borrowBuffer; + usePinnedBytecode = rhs.usePinnedBytecode; + allocateInstantiationStorage = rhs.allocateInstantiationStorage; + deoptimizeModuleGlobalVars = rhs.deoptimizeModuleGlobalVars; + + introductionType = rhs.introductionType; + introductionLineno = rhs.introductionLineno; + introductionOffset = rhs.introductionOffset; + hasIntroductionInfo = rhs.hasIntroductionInfo; +}; + +void JS::ReadOnlyCompileOptions::copyPODNonTransitiveOptions( + const ReadOnlyCompileOptions& rhs) { + lineno = rhs.lineno; + column = rhs.column; + scriptSourceOffset = rhs.scriptSourceOffset; + isRunOnce = rhs.isRunOnce; + noScriptRval = rhs.noScriptRval; +} + +JS::OwningCompileOptions::OwningCompileOptions(JSContext* cx) + : ReadOnlyCompileOptions() {} + +void JS::OwningCompileOptions::release() { + // OwningCompileOptions always owns these, so these casts are okay. + js_free(const_cast<char*>(filename_)); + js_free(const_cast<char16_t*>(sourceMapURL_)); + js_free(const_cast<char*>(introducerFilename_)); + + filename_ = nullptr; + sourceMapURL_ = nullptr; + introducerFilename_ = nullptr; +} + +JS::OwningCompileOptions::~OwningCompileOptions() { release(); } + +size_t JS::OwningCompileOptions::sizeOfExcludingThis( + mozilla::MallocSizeOf mallocSizeOf) const { + return mallocSizeOf(filename_) + mallocSizeOf(sourceMapURL_) + + mallocSizeOf(introducerFilename_); +} + +bool JS::OwningCompileOptions::copy(JSContext* cx, + const ReadOnlyCompileOptions& rhs) { + // Release existing string allocations. + release(); + + copyPODNonTransitiveOptions(rhs); + copyPODTransitiveOptions(rhs); + + if (rhs.filename()) { + filename_ = DuplicateString(cx, rhs.filename()).release(); + if (!filename_) { + return false; + } + } + + if (rhs.sourceMapURL()) { + sourceMapURL_ = DuplicateString(cx, rhs.sourceMapURL()).release(); + if (!sourceMapURL_) { + return false; + } + } + + if (rhs.introducerFilename()) { + introducerFilename_ = + DuplicateString(cx, rhs.introducerFilename()).release(); + if (!introducerFilename_) { + return false; + } + } + + return true; +} + +JS::CompileOptions::CompileOptions(JSContext* cx) : ReadOnlyCompileOptions() { + if (!js::IsAsmJSCompilationAvailable(cx)) { + // Distinguishing the cases is just for error reporting. + asmJSOption = !cx->options().asmJS() + ? AsmJSOption::DisabledByAsmJSPref + : AsmJSOption::DisabledByNoWasmCompiler; + } else if (cx->realm() && (cx->realm()->debuggerObservesWasm() || + cx->realm()->debuggerObservesAsmJS())) { + asmJSOption = AsmJSOption::DisabledByDebugger; + } else { + asmJSOption = AsmJSOption::Enabled; + } + throwOnAsmJSValidationFailureOption = + cx->options().throwOnAsmJSValidationFailure(); + + importAssertions = cx->options().importAssertions(); + + sourcePragmas_ = cx->options().sourcePragmas(); + + // Certain modes of operation force strict-mode in general. + forceStrictMode_ = cx->options().strictMode(); + + // Certain modes of operation disallow syntax parsing in general. + if (coverage::IsLCovEnabled()) { + eagerDelazificationStrategy_ = DelazificationOption::ParseEverythingEagerly; + } + + // Note: If we parse outside of a specific realm, we do not inherit any realm + // behaviours. These can still be set manually on the options though. + if (Realm* realm = cx->realm()) { + shouldResistFingerprinting_ = + realm->behaviors().shouldResistFingerprinting(); + discardSource = realm->behaviors().discardSource(); + } +} + +CompileOptions& CompileOptions::setIntroductionInfoToCaller( + JSContext* cx, const char* introductionType, + MutableHandle<JSScript*> introductionScript) { + RootedScript maybeScript(cx); + const char* filename; + unsigned lineno; + uint32_t pcOffset; + bool mutedErrors; + DescribeScriptedCallerForCompilation(cx, &maybeScript, &filename, &lineno, + &pcOffset, &mutedErrors); + if (filename) { + introductionScript.set(maybeScript); + return setIntroductionInfo(filename, introductionType, lineno, pcOffset); + } + return setIntroductionType(introductionType); +} + +JS_PUBLIC_API JSObject* JS_GetGlobalFromScript(JSScript* script) { + return &script->global(); +} + +JS_PUBLIC_API const char* JS_GetScriptFilename(JSScript* script) { + // This is called from ThreadStackHelper which can be called from another + // thread or inside a signal hander, so we need to be careful in case a + // copmacting GC is currently moving things around. + return script->maybeForwardedFilename(); +} + +JS_PUBLIC_API unsigned JS_GetScriptBaseLineNumber(JSContext* cx, + JSScript* script) { + return script->lineno(); +} + +JS_PUBLIC_API JSScript* JS_GetFunctionScript(JSContext* cx, + HandleFunction fun) { + if (fun->isNativeFun()) { + return nullptr; + } + + if (fun->hasBytecode()) { + return fun->nonLazyScript(); + } + + AutoRealm ar(cx, fun); + JSScript* script = JSFunction::getOrCreateScript(cx, fun); + if (!script) { + MOZ_CRASH(); + } + return script; +} + +JS_PUBLIC_API JSString* JS_DecompileScript(JSContext* cx, HandleScript script) { + MOZ_ASSERT(!cx->zone()->isAtomsZone()); + + AssertHeapIsIdle(); + CHECK_THREAD(cx); + RootedFunction fun(cx, script->function()); + if (fun) { + return JS_DecompileFunction(cx, fun); + } + bool haveSource; + if (!ScriptSource::loadSource(cx, script->scriptSource(), &haveSource)) { + return nullptr; + } + return haveSource ? JSScript::sourceData(cx, script) + : NewStringCopyZ<CanGC>(cx, "[no source]"); +} + +JS_PUBLIC_API JSString* JS_DecompileFunction(JSContext* cx, + HandleFunction fun) { + MOZ_ASSERT(!cx->zone()->isAtomsZone()); + AssertHeapIsIdle(); + CHECK_THREAD(cx); + cx->check(fun); + return FunctionToString(cx, fun, /* isToSource = */ false); +} + +JS_PUBLIC_API void JS::SetScriptPrivate(JSScript* script, + const JS::Value& value) { + JSRuntime* rt = script->zone()->runtimeFromMainThread(); + script->sourceObject()->setPrivate(rt, value); +} + +JS_PUBLIC_API JS::Value JS::GetScriptPrivate(JSScript* script) { + return script->sourceObject()->getPrivate(); +} + +JS_PUBLIC_API JS::Value JS::GetScriptedCallerPrivate(JSContext* cx) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + + NonBuiltinFrameIter iter(cx, cx->realm()->principals()); + if (iter.done() || !iter.hasScript()) { + return UndefinedValue(); + } + + return iter.script()->sourceObject()->getPrivate(); +} + +JS_PUBLIC_API void JS::SetScriptPrivateReferenceHooks( + JSRuntime* rt, JS::ScriptPrivateReferenceHook addRefHook, + JS::ScriptPrivateReferenceHook releaseHook) { + AssertHeapIsIdle(); + rt->scriptPrivateAddRefHook = addRefHook; + rt->scriptPrivateReleaseHook = releaseHook; +} + +JS_PUBLIC_API void JS::SetWaitCallback(JSRuntime* rt, + BeforeWaitCallback beforeWait, + AfterWaitCallback afterWait, + size_t requiredMemory) { + MOZ_RELEASE_ASSERT(requiredMemory <= WAIT_CALLBACK_CLIENT_MAXMEM); + MOZ_RELEASE_ASSERT((beforeWait == nullptr) == (afterWait == nullptr)); + rt->beforeWaitCallback = beforeWait; + rt->afterWaitCallback = afterWait; +} + +JS_PUBLIC_API bool JS_CheckForInterrupt(JSContext* cx) { + return js::CheckForInterrupt(cx); +} + +JS_PUBLIC_API bool JS_AddInterruptCallback(JSContext* cx, + JSInterruptCallback callback) { + return cx->interruptCallbacks().append(callback); +} + +JS_PUBLIC_API bool JS_DisableInterruptCallback(JSContext* cx) { + bool result = cx->interruptCallbackDisabled; + cx->interruptCallbackDisabled = true; + return result; +} + +JS_PUBLIC_API void JS_ResetInterruptCallback(JSContext* cx, bool enable) { + cx->interruptCallbackDisabled = enable; +} + +/************************************************************************/ + +/* + * Promises. + */ +JS_PUBLIC_API void JS::SetJobQueue(JSContext* cx, JobQueue* queue) { + cx->jobQueue = queue; +} + +extern JS_PUBLIC_API void JS::SetPromiseRejectionTrackerCallback( + JSContext* cx, PromiseRejectionTrackerCallback callback, + void* data /* = nullptr */) { + cx->promiseRejectionTrackerCallback = callback; + cx->promiseRejectionTrackerCallbackData = data; +} + +extern JS_PUBLIC_API void JS::JobQueueIsEmpty(JSContext* cx) { + cx->canSkipEnqueuingJobs = true; +} + +extern JS_PUBLIC_API void JS::JobQueueMayNotBeEmpty(JSContext* cx) { + cx->canSkipEnqueuingJobs = false; +} + +JS_PUBLIC_API JSObject* JS::NewPromiseObject(JSContext* cx, + HandleObject executor) { + MOZ_ASSERT(!cx->zone()->isAtomsZone()); + AssertHeapIsIdle(); + CHECK_THREAD(cx); + cx->check(executor); + + if (!executor) { + return PromiseObject::createSkippingExecutor(cx); + } + + MOZ_ASSERT(IsCallable(executor)); + return PromiseObject::create(cx, executor); +} + +JS_PUBLIC_API bool JS::IsPromiseObject(JS::HandleObject obj) { + return obj->is<PromiseObject>(); +} + +JS_PUBLIC_API JSObject* JS::GetPromiseConstructor(JSContext* cx) { + CHECK_THREAD(cx); + Rooted<GlobalObject*> global(cx, cx->global()); + return GlobalObject::getOrCreatePromiseConstructor(cx, global); +} + +JS_PUBLIC_API JSObject* JS::GetPromisePrototype(JSContext* cx) { + CHECK_THREAD(cx); + Rooted<GlobalObject*> global(cx, cx->global()); + return GlobalObject::getOrCreatePromisePrototype(cx, global); +} + +JS_PUBLIC_API JS::PromiseState JS::GetPromiseState(JS::HandleObject promise) { + PromiseObject* promiseObj = promise->maybeUnwrapIf<PromiseObject>(); + if (!promiseObj) { + return JS::PromiseState::Pending; + } + + return promiseObj->state(); +} + +JS_PUBLIC_API uint64_t JS::GetPromiseID(JS::HandleObject promise) { + return promise->as<PromiseObject>().getID(); +} + +JS_PUBLIC_API JS::Value JS::GetPromiseResult(JS::HandleObject promiseObj) { + PromiseObject* promise = &promiseObj->as<PromiseObject>(); + MOZ_ASSERT(promise->state() != JS::PromiseState::Pending); + return promise->state() == JS::PromiseState::Fulfilled ? promise->value() + : promise->reason(); +} + +JS_PUBLIC_API bool JS::GetPromiseIsHandled(JS::HandleObject promise) { + PromiseObject* promiseObj = &promise->as<PromiseObject>(); + return !promiseObj->isUnhandled(); +} + +static PromiseObject* UnwrapPromise(JSContext* cx, JS::HandleObject promise, + mozilla::Maybe<AutoRealm>& ar) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + cx->check(promise); + + PromiseObject* promiseObj; + if (IsWrapper(promise)) { + promiseObj = promise->maybeUnwrapAs<PromiseObject>(); + if (!promiseObj) { + ReportAccessDenied(cx); + return nullptr; + } + ar.emplace(cx, promiseObj); + } else { + promiseObj = promise.as<PromiseObject>(); + } + return promiseObj; +} + +JS_PUBLIC_API bool JS::SetSettledPromiseIsHandled(JSContext* cx, + JS::HandleObject promise) { + mozilla::Maybe<AutoRealm> ar; + Rooted<PromiseObject*> promiseObj(cx, UnwrapPromise(cx, promise, ar)); + if (!promiseObj) { + return false; + } + js::SetSettledPromiseIsHandled(cx, promiseObj); + return true; +} + +JS_PUBLIC_API bool JS::SetAnyPromiseIsHandled(JSContext* cx, + JS::HandleObject promise) { + mozilla::Maybe<AutoRealm> ar; + Rooted<PromiseObject*> promiseObj(cx, UnwrapPromise(cx, promise, ar)); + if (!promiseObj) { + return false; + } + js::SetAnyPromiseIsHandled(cx, promiseObj); + return true; +} + +JS_PUBLIC_API JSObject* JS::GetPromiseAllocationSite(JS::HandleObject promise) { + return promise->as<PromiseObject>().allocationSite(); +} + +JS_PUBLIC_API JSObject* JS::GetPromiseResolutionSite(JS::HandleObject promise) { + return promise->as<PromiseObject>().resolutionSite(); +} + +#ifdef DEBUG +JS_PUBLIC_API void JS::DumpPromiseAllocationSite(JSContext* cx, + JS::HandleObject promise) { + RootedObject stack(cx, promise->as<PromiseObject>().allocationSite()); + JSPrincipals* principals = cx->realm()->principals(); + UniqueChars stackStr = BuildUTF8StackString(cx, principals, stack); + if (stackStr) { + fputs(stackStr.get(), stderr); + } +} + +JS_PUBLIC_API void JS::DumpPromiseResolutionSite(JSContext* cx, + JS::HandleObject promise) { + RootedObject stack(cx, promise->as<PromiseObject>().resolutionSite()); + JSPrincipals* principals = cx->realm()->principals(); + UniqueChars stackStr = BuildUTF8StackString(cx, principals, stack); + if (stackStr) { + fputs(stackStr.get(), stderr); + } +} +#endif + +JS_PUBLIC_API JSObject* JS::CallOriginalPromiseResolve( + JSContext* cx, JS::HandleValue resolutionValue) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + cx->check(resolutionValue); + + RootedObject promise(cx, + PromiseObject::unforgeableResolve(cx, resolutionValue)); + MOZ_ASSERT_IF(promise, promise->canUnwrapAs<PromiseObject>()); + return promise; +} + +JS_PUBLIC_API JSObject* JS::CallOriginalPromiseReject( + JSContext* cx, JS::HandleValue rejectionValue) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + cx->check(rejectionValue); + + RootedObject promise(cx, + PromiseObject::unforgeableReject(cx, rejectionValue)); + MOZ_ASSERT_IF(promise, promise->canUnwrapAs<PromiseObject>()); + return promise; +} + +static bool ResolveOrRejectPromise(JSContext* cx, JS::HandleObject promiseObj, + JS::HandleValue resultOrReason_, + bool reject) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + cx->check(promiseObj, resultOrReason_); + + mozilla::Maybe<AutoRealm> ar; + Rooted<PromiseObject*> promise(cx); + RootedValue resultOrReason(cx, resultOrReason_); + if (IsWrapper(promiseObj)) { + promise = promiseObj->maybeUnwrapAs<PromiseObject>(); + if (!promise) { + ReportAccessDenied(cx); + return false; + } + ar.emplace(cx, promise); + if (!cx->compartment()->wrap(cx, &resultOrReason)) { + return false; + } + } else { + promise = promiseObj.as<PromiseObject>(); + } + + return reject ? PromiseObject::reject(cx, promise, resultOrReason) + : PromiseObject::resolve(cx, promise, resultOrReason); +} + +JS_PUBLIC_API bool JS::ResolvePromise(JSContext* cx, + JS::HandleObject promiseObj, + JS::HandleValue resolutionValue) { + return ResolveOrRejectPromise(cx, promiseObj, resolutionValue, false); +} + +JS_PUBLIC_API bool JS::RejectPromise(JSContext* cx, JS::HandleObject promiseObj, + JS::HandleValue rejectionValue) { + return ResolveOrRejectPromise(cx, promiseObj, rejectionValue, true); +} + +JS_PUBLIC_API JSObject* JS::CallOriginalPromiseThen( + JSContext* cx, JS::HandleObject promiseObj, JS::HandleObject onFulfilled, + JS::HandleObject onRejected) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + cx->check(promiseObj, onFulfilled, onRejected); + + MOZ_ASSERT_IF(onFulfilled, IsCallable(onFulfilled)); + MOZ_ASSERT_IF(onRejected, IsCallable(onRejected)); + + return OriginalPromiseThen(cx, promiseObj, onFulfilled, onRejected); +} + +[[nodiscard]] static bool ReactToPromise(JSContext* cx, + JS::Handle<JSObject*> promiseObj, + JS::Handle<JSObject*> onFulfilled, + JS::Handle<JSObject*> onRejected, + UnhandledRejectionBehavior behavior) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + cx->check(promiseObj, onFulfilled, onRejected); + + MOZ_ASSERT_IF(onFulfilled, IsCallable(onFulfilled)); + MOZ_ASSERT_IF(onRejected, IsCallable(onRejected)); + + Rooted<PromiseObject*> unwrappedPromise(cx); + { + RootedValue promiseVal(cx, ObjectValue(*promiseObj)); + unwrappedPromise = UnwrapAndTypeCheckValue<PromiseObject>( + cx, promiseVal, [cx, promiseObj] { + JS_ReportErrorNumberLatin1(cx, GetErrorMessage, nullptr, + JSMSG_INCOMPATIBLE_PROTO, "Promise", + "then", promiseObj->getClass()->name); + }); + if (!unwrappedPromise) { + return false; + } + } + + return ReactToUnwrappedPromise(cx, unwrappedPromise, onFulfilled, onRejected, + behavior); +} + +JS_PUBLIC_API bool JS::AddPromiseReactions(JSContext* cx, + JS::HandleObject promiseObj, + JS::HandleObject onFulfilled, + JS::HandleObject onRejected) { + return ReactToPromise(cx, promiseObj, onFulfilled, onRejected, + UnhandledRejectionBehavior::Report); +} + +JS_PUBLIC_API bool JS::AddPromiseReactionsIgnoringUnhandledRejection( + JSContext* cx, JS::HandleObject promiseObj, JS::HandleObject onFulfilled, + JS::HandleObject onRejected) { + return ReactToPromise(cx, promiseObj, onFulfilled, onRejected, + UnhandledRejectionBehavior::Ignore); +} + +JS_PUBLIC_API JS::PromiseUserInputEventHandlingState +JS::GetPromiseUserInputEventHandlingState(JS::HandleObject promiseObj_) { + PromiseObject* promise = promiseObj_->maybeUnwrapIf<PromiseObject>(); + if (!promise) { + return JS::PromiseUserInputEventHandlingState::DontCare; + } + + if (!promise->requiresUserInteractionHandling()) { + return JS::PromiseUserInputEventHandlingState::DontCare; + } + if (promise->hadUserInteractionUponCreation()) { + return JS::PromiseUserInputEventHandlingState::HadUserInteractionAtCreation; + } + return JS::PromiseUserInputEventHandlingState:: + DidntHaveUserInteractionAtCreation; +} + +JS_PUBLIC_API bool JS::SetPromiseUserInputEventHandlingState( + JS::HandleObject promiseObj_, + JS::PromiseUserInputEventHandlingState state) { + PromiseObject* promise = promiseObj_->maybeUnwrapIf<PromiseObject>(); + if (!promise) { + return false; + } + + switch (state) { + case JS::PromiseUserInputEventHandlingState::DontCare: + promise->setRequiresUserInteractionHandling(false); + break; + case JS::PromiseUserInputEventHandlingState::HadUserInteractionAtCreation: + promise->setRequiresUserInteractionHandling(true); + promise->setHadUserInteractionUponCreation(true); + break; + case JS::PromiseUserInputEventHandlingState:: + DidntHaveUserInteractionAtCreation: + promise->setRequiresUserInteractionHandling(true); + promise->setHadUserInteractionUponCreation(false); + break; + default: + MOZ_ASSERT_UNREACHABLE( + "Invalid PromiseUserInputEventHandlingState enum value"); + return false; + } + return true; +} + +/** + * Unforgeable version of Promise.all for internal use. + * + * Takes a dense array of Promise objects and returns a promise that's + * resolved with an array of resolution values when all those promises ahve + * been resolved, or rejected with the rejection value of the first rejected + * promise. + * + * Asserts that the array is dense and all entries are Promise objects. + */ +JS_PUBLIC_API JSObject* JS::GetWaitForAllPromise( + JSContext* cx, JS::HandleObjectVector promises) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + + return js::GetWaitForAllPromise(cx, promises); +} + +JS_PUBLIC_API void JS::InitDispatchToEventLoop( + JSContext* cx, JS::DispatchToEventLoopCallback callback, void* closure) { + cx->runtime()->offThreadPromiseState.ref().init(callback, closure); +} + +JS_PUBLIC_API void JS::ShutdownAsyncTasks(JSContext* cx) { + cx->runtime()->offThreadPromiseState.ref().shutdown(cx); +} + +JS_PUBLIC_API void JS::InitConsumeStreamCallback( + JSContext* cx, ConsumeStreamCallback consume, + ReportStreamErrorCallback report) { + cx->runtime()->consumeStreamCallback = consume; + cx->runtime()->reportStreamErrorCallback = report; +} + +JS_PUBLIC_API void JS_RequestInterruptCallback(JSContext* cx) { + cx->requestInterrupt(InterruptReason::CallbackUrgent); +} + +JS_PUBLIC_API void JS_RequestInterruptCallbackCanWait(JSContext* cx) { + cx->requestInterrupt(InterruptReason::CallbackCanWait); +} + +JS::AutoSetAsyncStackForNewCalls::AutoSetAsyncStackForNewCalls( + JSContext* cx, HandleObject stack, const char* asyncCause, + JS::AutoSetAsyncStackForNewCalls::AsyncCallKind kind) + : cx(cx), + oldAsyncStack(cx, cx->asyncStackForNewActivations()), + oldAsyncCause(cx->asyncCauseForNewActivations), + oldAsyncCallIsExplicit(cx->asyncCallIsExplicit) { + CHECK_THREAD(cx); + + // The option determines whether we actually use the new values at this + // point. It will not affect restoring the previous values when the object + // is destroyed, so if the option changes it won't cause consistency issues. + if (!cx->options().asyncStack()) { + return; + } + + SavedFrame* asyncStack = &stack->as<SavedFrame>(); + + cx->asyncStackForNewActivations() = asyncStack; + cx->asyncCauseForNewActivations = asyncCause; + cx->asyncCallIsExplicit = kind == AsyncCallKind::EXPLICIT; +} + +JS::AutoSetAsyncStackForNewCalls::~AutoSetAsyncStackForNewCalls() { + cx->asyncCauseForNewActivations = oldAsyncCause; + cx->asyncStackForNewActivations() = + oldAsyncStack ? &oldAsyncStack->as<SavedFrame>() : nullptr; + cx->asyncCallIsExplicit = oldAsyncCallIsExplicit; +} + +/************************************************************************/ +JS_PUBLIC_API JSString* JS_NewStringCopyN(JSContext* cx, const char* s, + size_t n) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + return NewStringCopyN<CanGC>(cx, s, n); +} + +JS_PUBLIC_API JSString* JS_NewStringCopyZ(JSContext* cx, const char* s) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + if (!s) { + return cx->runtime()->emptyString; + } + return NewStringCopyZ<CanGC>(cx, s); +} + +JS_PUBLIC_API JSString* JS_NewStringCopyUTF8Z(JSContext* cx, + const JS::ConstUTF8CharsZ s) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + return NewStringCopyUTF8Z(cx, s); +} + +JS_PUBLIC_API JSString* JS_NewStringCopyUTF8N(JSContext* cx, + const JS::UTF8Chars s) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + return NewStringCopyUTF8N(cx, s); +} + +JS_PUBLIC_API bool JS_StringHasBeenPinned(JSContext* cx, JSString* str) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + + if (!str->isAtom()) { + return false; + } + + return AtomIsPinned(cx, &str->asAtom()); +} + +JS_PUBLIC_API JSString* JS_AtomizeString(JSContext* cx, const char* s) { + return JS_AtomizeStringN(cx, s, strlen(s)); +} + +JS_PUBLIC_API JSString* JS_AtomizeStringN(JSContext* cx, const char* s, + size_t length) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + return Atomize(cx, s, length); +} + +JS_PUBLIC_API JSString* JS_AtomizeAndPinString(JSContext* cx, const char* s) { + return JS_AtomizeAndPinStringN(cx, s, strlen(s)); +} + +JS_PUBLIC_API JSString* JS_AtomizeAndPinStringN(JSContext* cx, const char* s, + size_t length) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + + JSAtom* atom = cx->zone() ? Atomize(cx, s, length) + : AtomizeWithoutActiveZone(cx, s, length); + if (!atom || !PinAtom(cx, atom)) { + return nullptr; + } + + MOZ_ASSERT(JS_StringHasBeenPinned(cx, atom)); + return atom; +} + +JS_PUBLIC_API JSString* JS_NewLatin1String( + JSContext* cx, js::UniquePtr<JS::Latin1Char[], JS::FreePolicy> chars, + size_t length) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + return NewString<CanGC>(cx, std::move(chars), length); +} + +JS_PUBLIC_API JSString* JS_NewUCString(JSContext* cx, + JS::UniqueTwoByteChars chars, + size_t length) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + return NewString<CanGC>(cx, std::move(chars), length); +} + +JS_PUBLIC_API JSString* JS_NewUCStringDontDeflate(JSContext* cx, + JS::UniqueTwoByteChars chars, + size_t length) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + return NewStringDontDeflate<CanGC>(cx, std::move(chars), length); +} + +JS_PUBLIC_API JSString* JS_NewUCStringCopyN(JSContext* cx, const char16_t* s, + size_t n) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + if (!n) { + return cx->names().empty; + } + return NewStringCopyN<CanGC>(cx, s, n); +} + +JS_PUBLIC_API JSString* JS_NewUCStringCopyZ(JSContext* cx, const char16_t* s) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + if (!s) { + return cx->runtime()->emptyString; + } + return NewStringCopyZ<CanGC>(cx, s); +} + +JS_PUBLIC_API JSString* JS_AtomizeUCString(JSContext* cx, const char16_t* s) { + return JS_AtomizeUCStringN(cx, s, js_strlen(s)); +} + +JS_PUBLIC_API JSString* JS_AtomizeUCStringN(JSContext* cx, const char16_t* s, + size_t length) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + return AtomizeChars(cx, s, length); +} + +JS_PUBLIC_API size_t JS_GetStringLength(JSString* str) { return str->length(); } + +JS_PUBLIC_API bool JS_StringIsLinear(JSString* str) { return str->isLinear(); } + +JS_PUBLIC_API bool JS_DeprecatedStringHasLatin1Chars(JSString* str) { + return str->hasLatin1Chars(); +} + +JS_PUBLIC_API const JS::Latin1Char* JS_GetLatin1StringCharsAndLength( + JSContext* cx, const JS::AutoRequireNoGC& nogc, JSString* str, + size_t* plength) { + MOZ_ASSERT(plength); + AssertHeapIsIdle(); + CHECK_THREAD(cx); + cx->check(str); + JSLinearString* linear = str->ensureLinear(cx); + if (!linear) { + return nullptr; + } + *plength = linear->length(); + return linear->latin1Chars(nogc); +} + +JS_PUBLIC_API const char16_t* JS_GetTwoByteStringCharsAndLength( + JSContext* cx, const JS::AutoRequireNoGC& nogc, JSString* str, + size_t* plength) { + MOZ_ASSERT(plength); + AssertHeapIsIdle(); + CHECK_THREAD(cx); + cx->check(str); + JSLinearString* linear = str->ensureLinear(cx); + if (!linear) { + return nullptr; + } + *plength = linear->length(); + return linear->twoByteChars(nogc); +} + +JS_PUBLIC_API const char16_t* JS_GetTwoByteExternalStringChars(JSString* str) { + return str->asExternal().twoByteChars(); +} + +JS_PUBLIC_API bool JS_GetStringCharAt(JSContext* cx, JSString* str, + size_t index, char16_t* res) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + cx->check(str); + + JSLinearString* linear = str->ensureLinear(cx); + if (!linear) { + return false; + } + + *res = linear->latin1OrTwoByteChar(index); + return true; +} + +JS_PUBLIC_API bool JS_CopyStringChars(JSContext* cx, + mozilla::Range<char16_t> dest, + JSString* str) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + cx->check(str); + + JSLinearString* linear = str->ensureLinear(cx); + if (!linear) { + return false; + } + + MOZ_ASSERT(linear->length() <= dest.length()); + CopyChars(dest.begin().get(), *linear); + return true; +} + +extern JS_PUBLIC_API JS::UniqueTwoByteChars JS_CopyStringCharsZ(JSContext* cx, + JSString* str) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + + JSLinearString* linear = str->ensureLinear(cx); + if (!linear) { + return nullptr; + } + + size_t len = linear->length(); + + static_assert(JS::MaxStringLength < UINT32_MAX, + "len + 1 must not overflow on 32-bit platforms"); + + UniqueTwoByteChars chars(cx->pod_malloc<char16_t>(len + 1)); + if (!chars) { + return nullptr; + } + + CopyChars(chars.get(), *linear); + chars[len] = '\0'; + + return chars; +} + +extern JS_PUBLIC_API JSLinearString* JS_EnsureLinearString(JSContext* cx, + JSString* str) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + cx->check(str); + return str->ensureLinear(cx); +} + +JS_PUBLIC_API bool JS_CompareStrings(JSContext* cx, JSString* str1, + JSString* str2, int32_t* result) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + + return CompareStrings(cx, str1, str2, result); +} + +JS_PUBLIC_API bool JS_StringEqualsAscii(JSContext* cx, JSString* str, + const char* asciiBytes, bool* match) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + + JSLinearString* linearStr = str->ensureLinear(cx); + if (!linearStr) { + return false; + } + *match = StringEqualsAscii(linearStr, asciiBytes); + return true; +} + +JS_PUBLIC_API bool JS_StringEqualsAscii(JSContext* cx, JSString* str, + const char* asciiBytes, size_t length, + bool* match) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + + JSLinearString* linearStr = str->ensureLinear(cx); + if (!linearStr) { + return false; + } + *match = StringEqualsAscii(linearStr, asciiBytes, length); + return true; +} + +JS_PUBLIC_API bool JS_LinearStringEqualsAscii(JSLinearString* str, + const char* asciiBytes) { + return StringEqualsAscii(str, asciiBytes); +} + +JS_PUBLIC_API bool JS_LinearStringEqualsAscii(JSLinearString* str, + const char* asciiBytes, + size_t length) { + return StringEqualsAscii(str, asciiBytes, length); +} + +JS_PUBLIC_API size_t JS_PutEscapedLinearString(char* buffer, size_t size, + JSLinearString* str, + char quote) { + return PutEscapedString(buffer, size, str, quote); +} + +JS_PUBLIC_API size_t JS_PutEscapedString(JSContext* cx, char* buffer, + size_t size, JSString* str, + char quote) { + AssertHeapIsIdle(); + JSLinearString* linearStr = str->ensureLinear(cx); + if (!linearStr) { + return size_t(-1); + } + return PutEscapedString(buffer, size, linearStr, quote); +} + +JS_PUBLIC_API JSString* JS_NewDependentString(JSContext* cx, HandleString str, + size_t start, size_t length) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + return NewDependentString(cx, str, start, length); +} + +JS_PUBLIC_API JSString* JS_ConcatStrings(JSContext* cx, HandleString left, + HandleString right) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + return ConcatStrings<CanGC>(cx, left, right); +} + +JS_PUBLIC_API bool JS_DecodeBytes(JSContext* cx, const char* src, size_t srclen, + char16_t* dst, size_t* dstlenp) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + + if (!dst) { + *dstlenp = srclen; + return true; + } + + size_t dstlen = *dstlenp; + + if (srclen > dstlen) { + CopyAndInflateChars(dst, src, dstlen); + + gc::AutoSuppressGC suppress(cx); + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, + JSMSG_BUFFER_TOO_SMALL); + return false; + } + + CopyAndInflateChars(dst, src, srclen); + *dstlenp = srclen; + return true; +} + +JS_PUBLIC_API JS::UniqueChars JS_EncodeStringToASCII(JSContext* cx, + JSString* str) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + + return js::EncodeAscii(cx, str); +} + +JS_PUBLIC_API JS::UniqueChars JS_EncodeStringToLatin1(JSContext* cx, + JSString* str) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + + return js::EncodeLatin1(cx, str); +} + +JS_PUBLIC_API JS::UniqueChars JS_EncodeStringToUTF8(JSContext* cx, + HandleString str) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + + return StringToNewUTF8CharsZ(cx, *str); +} + +JS_PUBLIC_API size_t JS_GetStringEncodingLength(JSContext* cx, JSString* str) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + + if (!str->ensureLinear(cx)) { + return size_t(-1); + } + return str->length(); +} + +JS_PUBLIC_API bool JS_EncodeStringToBuffer(JSContext* cx, JSString* str, + char* buffer, size_t length) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + + JSLinearString* linear = str->ensureLinear(cx); + if (!linear) { + return false; + } + + JS::AutoCheckCannotGC nogc; + size_t writeLength = std::min(linear->length(), length); + if (linear->hasLatin1Chars()) { + mozilla::PodCopy(reinterpret_cast<Latin1Char*>(buffer), + linear->latin1Chars(nogc), writeLength); + } else { + const char16_t* src = linear->twoByteChars(nogc); + for (size_t i = 0; i < writeLength; i++) { + buffer[i] = char(src[i]); + } + } + return true; +} + +JS_PUBLIC_API mozilla::Maybe<std::tuple<size_t, size_t>> +JS_EncodeStringToUTF8BufferPartial(JSContext* cx, JSString* str, + mozilla::Span<char> buffer) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + JS::AutoCheckCannotGC nogc; + return str->encodeUTF8Partial(nogc, buffer); +} + +JS_PUBLIC_API JS::Symbol* JS::NewSymbol(JSContext* cx, + HandleString description) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + if (description) { + cx->check(description); + } + + return Symbol::new_(cx, SymbolCode::UniqueSymbol, description); +} + +JS_PUBLIC_API JS::Symbol* JS::GetSymbolFor(JSContext* cx, HandleString key) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + cx->check(key); + + return Symbol::for_(cx, key); +} + +JS_PUBLIC_API JSString* JS::GetSymbolDescription(HandleSymbol symbol) { + return symbol->description(); +} + +JS_PUBLIC_API JS::SymbolCode JS::GetSymbolCode(Handle<Symbol*> symbol) { + return symbol->code(); +} + +JS_PUBLIC_API JS::Symbol* JS::GetWellKnownSymbol(JSContext* cx, + JS::SymbolCode which) { + return cx->wellKnownSymbols().get(which); +} + +JS_PUBLIC_API JS::PropertyKey JS::GetWellKnownSymbolKey(JSContext* cx, + JS::SymbolCode which) { + return PropertyKey::Symbol(cx->wellKnownSymbols().get(which)); +} + +static bool AddPrefix(JSContext* cx, JS::Handle<JS::PropertyKey> id, + FunctionPrefixKind prefixKind, + JS::MutableHandle<JS::PropertyKey> out) { + JS::Rooted<JSAtom*> atom(cx, js::IdToFunctionName(cx, id, prefixKind)); + if (!atom) { + return false; + } + + out.set(JS::PropertyKey::NonIntAtom(atom)); + return true; +} + +JS_PUBLIC_API bool JS::ToGetterId(JSContext* cx, JS::Handle<JS::PropertyKey> id, + JS::MutableHandle<JS::PropertyKey> getterId) { + return AddPrefix(cx, id, FunctionPrefixKind::Get, getterId); +} + +JS_PUBLIC_API bool JS::ToSetterId(JSContext* cx, JS::Handle<JS::PropertyKey> id, + JS::MutableHandle<JS::PropertyKey> setterId) { + return AddPrefix(cx, id, FunctionPrefixKind::Set, setterId); +} + +#ifdef DEBUG +static bool PropertySpecNameIsDigits(JSPropertySpec::Name name) { + if (name.isSymbol()) { + return false; + } + const char* s = name.string(); + if (!*s) { + return false; + } + for (; *s; s++) { + if (*s < '0' || *s > '9') { + return false; + } + } + return true; +} +#endif // DEBUG + +JS_PUBLIC_API bool JS::PropertySpecNameEqualsId(JSPropertySpec::Name name, + HandleId id) { + if (name.isSymbol()) { + return id.isWellKnownSymbol(name.symbol()); + } + + MOZ_ASSERT(!PropertySpecNameIsDigits(name)); + return id.isAtom() && JS_LinearStringEqualsAscii(id.toAtom(), name.string()); +} + +JS_PUBLIC_API bool JS_Stringify(JSContext* cx, MutableHandleValue vp, + HandleObject replacer, HandleValue space, + JSONWriteCallback callback, void* data) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + cx->check(replacer, space); + StringBuffer sb(cx); + if (!sb.ensureTwoByteChars()) { + return false; + } + if (!Stringify(cx, vp, replacer, space, sb, StringifyBehavior::Normal)) { + return false; + } + if (sb.empty() && !sb.append(cx->names().null)) { + return false; + } + return callback(sb.rawTwoByteBegin(), sb.length(), data); +} + +JS_PUBLIC_API bool JS::ToJSON(JSContext* cx, HandleValue value, + HandleObject replacer, HandleValue space, + JSONWriteCallback callback, void* data) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + cx->check(replacer, space); + StringBuffer sb(cx); + if (!sb.ensureTwoByteChars()) { + return false; + } + RootedValue v(cx, value); + if (!Stringify(cx, &v, replacer, space, sb, StringifyBehavior::Normal)) { + return false; + } + if (sb.empty()) { + return true; + } + return callback(sb.rawTwoByteBegin(), sb.length(), data); +} + +JS_PUBLIC_API bool JS::ToJSONMaybeSafely(JSContext* cx, JS::HandleObject input, + JSONWriteCallback callback, + void* data) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + cx->check(input); + + StringBuffer sb(cx); + if (!sb.ensureTwoByteChars()) { + return false; + } + + RootedValue inputValue(cx, ObjectValue(*input)); + if (!Stringify(cx, &inputValue, nullptr, NullHandleValue, sb, + StringifyBehavior::RestrictedSafe)) + return false; + + if (sb.empty() && !sb.append(cx->names().null)) { + return false; + } + + return callback(sb.rawTwoByteBegin(), sb.length(), data); +} + +JS_PUBLIC_API bool JS_ParseJSON(JSContext* cx, const char16_t* chars, + uint32_t len, MutableHandleValue vp) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + return ParseJSONWithReviver(cx, mozilla::Range<const char16_t>(chars, len), + NullHandleValue, vp); +} + +JS_PUBLIC_API bool JS_ParseJSON(JSContext* cx, HandleString str, + MutableHandleValue vp) { + return JS_ParseJSONWithReviver(cx, str, NullHandleValue, vp); +} + +JS_PUBLIC_API bool JS_ParseJSON(JSContext* cx, const Latin1Char* chars, + uint32_t len, MutableHandleValue vp) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + return ParseJSONWithReviver(cx, mozilla::Range<const Latin1Char>(chars, len), + NullHandleValue, vp); +} + +JS_PUBLIC_API bool JS_ParseJSONWithReviver(JSContext* cx, const char16_t* chars, + uint32_t len, HandleValue reviver, + MutableHandleValue vp) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + return ParseJSONWithReviver(cx, mozilla::Range<const char16_t>(chars, len), + reviver, vp); +} + +JS_PUBLIC_API bool JS_ParseJSONWithReviver(JSContext* cx, HandleString str, + HandleValue reviver, + MutableHandleValue vp) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + cx->check(str); + + AutoStableStringChars stableChars(cx); + if (!stableChars.init(cx, str)) { + return false; + } + + return stableChars.isLatin1() + ? ParseJSONWithReviver(cx, stableChars.latin1Range(), reviver, vp) + : ParseJSONWithReviver(cx, stableChars.twoByteRange(), reviver, + vp); +} + +/************************************************************************/ + +JS_PUBLIC_API void JS_ReportErrorASCII(JSContext* cx, const char* format, ...) { + va_list ap; + + AssertHeapIsIdle(); + va_start(ap, format); + ReportErrorVA(cx, IsWarning::No, format, ArgumentsAreASCII, ap); + va_end(ap); +} + +JS_PUBLIC_API void JS_ReportErrorLatin1(JSContext* cx, const char* format, + ...) { + va_list ap; + + AssertHeapIsIdle(); + va_start(ap, format); + ReportErrorVA(cx, IsWarning::No, format, ArgumentsAreLatin1, ap); + va_end(ap); +} + +JS_PUBLIC_API void JS_ReportErrorUTF8(JSContext* cx, const char* format, ...) { + va_list ap; + + AssertHeapIsIdle(); + va_start(ap, format); + ReportErrorVA(cx, IsWarning::No, format, ArgumentsAreUTF8, ap); + va_end(ap); +} + +JS_PUBLIC_API void JS_ReportErrorNumberASCII(JSContext* cx, + JSErrorCallback errorCallback, + void* userRef, + const unsigned errorNumber, ...) { + va_list ap; + va_start(ap, errorNumber); + JS_ReportErrorNumberASCIIVA(cx, errorCallback, userRef, errorNumber, ap); + va_end(ap); +} + +JS_PUBLIC_API void JS_ReportErrorNumberASCIIVA(JSContext* cx, + JSErrorCallback errorCallback, + void* userRef, + const unsigned errorNumber, + va_list ap) { + AssertHeapIsIdle(); + ReportErrorNumberVA(cx, IsWarning::No, errorCallback, userRef, errorNumber, + ArgumentsAreASCII, ap); +} + +JS_PUBLIC_API void JS_ReportErrorNumberLatin1(JSContext* cx, + JSErrorCallback errorCallback, + void* userRef, + const unsigned errorNumber, ...) { + va_list ap; + va_start(ap, errorNumber); + JS_ReportErrorNumberLatin1VA(cx, errorCallback, userRef, errorNumber, ap); + va_end(ap); +} + +JS_PUBLIC_API void JS_ReportErrorNumberLatin1VA(JSContext* cx, + JSErrorCallback errorCallback, + void* userRef, + const unsigned errorNumber, + va_list ap) { + AssertHeapIsIdle(); + ReportErrorNumberVA(cx, IsWarning::No, errorCallback, userRef, errorNumber, + ArgumentsAreLatin1, ap); +} + +JS_PUBLIC_API void JS_ReportErrorNumberUTF8(JSContext* cx, + JSErrorCallback errorCallback, + void* userRef, + const unsigned errorNumber, ...) { + va_list ap; + va_start(ap, errorNumber); + JS_ReportErrorNumberUTF8VA(cx, errorCallback, userRef, errorNumber, ap); + va_end(ap); +} + +JS_PUBLIC_API void JS_ReportErrorNumberUTF8VA(JSContext* cx, + JSErrorCallback errorCallback, + void* userRef, + const unsigned errorNumber, + va_list ap) { + AssertHeapIsIdle(); + ReportErrorNumberVA(cx, IsWarning::No, errorCallback, userRef, errorNumber, + ArgumentsAreUTF8, ap); +} + +JS_PUBLIC_API void JS_ReportErrorNumberUTF8Array(JSContext* cx, + JSErrorCallback errorCallback, + void* userRef, + const unsigned errorNumber, + const char** args) { + AssertHeapIsIdle(); + ReportErrorNumberUTF8Array(cx, IsWarning::No, errorCallback, userRef, + errorNumber, args); +} + +JS_PUBLIC_API void JS_ReportErrorNumberUC(JSContext* cx, + JSErrorCallback errorCallback, + void* userRef, + const unsigned errorNumber, ...) { + va_list ap; + + AssertHeapIsIdle(); + va_start(ap, errorNumber); + ReportErrorNumberVA(cx, IsWarning::No, errorCallback, userRef, errorNumber, + ArgumentsAreUnicode, ap); + va_end(ap); +} + +JS_PUBLIC_API void JS_ReportErrorNumberUCArray(JSContext* cx, + JSErrorCallback errorCallback, + void* userRef, + const unsigned errorNumber, + const char16_t** args) { + AssertHeapIsIdle(); + ReportErrorNumberUCArray(cx, IsWarning::No, errorCallback, userRef, + errorNumber, args); +} + +JS_PUBLIC_API void JS_ReportOutOfMemory(JSContext* cx) { + ReportOutOfMemory(cx); +} + +JS_PUBLIC_API void JS_ReportAllocationOverflow(JSContext* cx) { + ReportAllocationOverflow(cx); +} + +JS_PUBLIC_API bool JS_ExpandErrorArgumentsASCII(JSContext* cx, + JSErrorCallback errorCallback, + const unsigned errorNumber, + JSErrorReport* reportp, ...) { + va_list ap; + bool ok; + + AssertHeapIsIdle(); + va_start(ap, reportp); + AutoReportFrontendContext fc(cx); + ok = ExpandErrorArgumentsVA(&fc, errorCallback, nullptr, errorNumber, + ArgumentsAreASCII, reportp, ap); + va_end(ap); + return ok; +} +/************************************************************************/ + +JS_PUBLIC_API bool JS_SetDefaultLocale(JSRuntime* rt, const char* locale) { + AssertHeapIsIdle(); + return rt->setDefaultLocale(locale); +} + +JS_PUBLIC_API UniqueChars JS_GetDefaultLocale(JSContext* cx) { + AssertHeapIsIdle(); + if (const char* locale = cx->runtime()->getDefaultLocale()) { + return DuplicateString(cx, locale); + } + + return nullptr; +} + +JS_PUBLIC_API void JS_ResetDefaultLocale(JSRuntime* rt) { + AssertHeapIsIdle(); + rt->resetDefaultLocale(); +} + +JS_PUBLIC_API void JS_SetLocaleCallbacks(JSRuntime* rt, + const JSLocaleCallbacks* callbacks) { + AssertHeapIsIdle(); + rt->localeCallbacks = callbacks; +} + +JS_PUBLIC_API const JSLocaleCallbacks* JS_GetLocaleCallbacks(JSRuntime* rt) { + /* This function can be called by a finalizer. */ + return rt->localeCallbacks; +} + +/************************************************************************/ + +JS_PUBLIC_API bool JS_IsExceptionPending(JSContext* cx) { + /* This function can be called by a finalizer. */ + return (bool)cx->isExceptionPending(); +} + +JS_PUBLIC_API bool JS_IsThrowingOutOfMemory(JSContext* cx) { + return cx->isThrowingOutOfMemory(); +} + +JS_PUBLIC_API bool JS_GetPendingException(JSContext* cx, + MutableHandleValue vp) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + if (!cx->isExceptionPending()) { + return false; + } + return cx->getPendingException(vp); +} + +JS_PUBLIC_API void JS_SetPendingException(JSContext* cx, HandleValue value, + JS::ExceptionStackBehavior behavior) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + // We don't check the compartment of `value` here, because we're not + // doing anything with it other than storing it, and stored + // exception values can be in an abitrary compartment. + + if (behavior == JS::ExceptionStackBehavior::Capture) { + cx->setPendingException(value, ShouldCaptureStack::Always); + } else { + cx->setPendingException(value, nullptr); + } +} + +JS_PUBLIC_API void JS_ClearPendingException(JSContext* cx) { + AssertHeapIsIdle(); + cx->clearPendingException(); +} + +JS::AutoSaveExceptionState::AutoSaveExceptionState(JSContext* cx) + : context(cx), status(cx->status), exceptionValue(cx), exceptionStack(cx) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + if (IsCatchableExceptionStatus(status)) { + exceptionValue = cx->unwrappedException(); + exceptionStack = cx->unwrappedExceptionStack(); + } + cx->clearPendingException(); +} + +void JS::AutoSaveExceptionState::drop() { + status = JS::ExceptionStatus::None; + exceptionValue.setUndefined(); + exceptionStack = nullptr; +} + +void JS::AutoSaveExceptionState::restore() { + context->status = status; + context->unwrappedException() = exceptionValue; + if (exceptionStack) { + context->unwrappedExceptionStack() = &exceptionStack->as<SavedFrame>(); + } + drop(); +} + +JS::AutoSaveExceptionState::~AutoSaveExceptionState() { + // NOTE: An interrupt/uncatchable exception or a debugger-forced-return may be + // clobbered here by the saved exception. If that is not desired, this + // state should be dropped before the destructor fires. + if (!context->isExceptionPending()) { + if (status != JS::ExceptionStatus::None) { + context->status = status; + } + if (IsCatchableExceptionStatus(status)) { + context->unwrappedException() = exceptionValue; + if (exceptionStack) { + context->unwrappedExceptionStack() = &exceptionStack->as<SavedFrame>(); + } + } + } +} + +JS_PUBLIC_API JSErrorReport* JS_ErrorFromException(JSContext* cx, + HandleObject obj) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + cx->check(obj); + return ErrorFromException(cx, obj); +} + +void JSErrorReport::initBorrowedLinebuf(const char16_t* linebufArg, + size_t linebufLengthArg, + size_t tokenOffsetArg) { + MOZ_ASSERT(linebufArg); + MOZ_ASSERT(tokenOffsetArg <= linebufLengthArg); + MOZ_ASSERT(linebufArg[linebufLengthArg] == '\0'); + + linebuf_ = linebufArg; + linebufLength_ = linebufLengthArg; + tokenOffset_ = tokenOffsetArg; +} + +void JSErrorReport::freeLinebuf() { + if (ownsLinebuf_ && linebuf_) { + js_free((void*)linebuf_); + ownsLinebuf_ = false; + } + linebuf_ = nullptr; +} + +JSString* JSErrorBase::newMessageString(JSContext* cx) { + if (!message_) { + return cx->runtime()->emptyString; + } + + return JS_NewStringCopyUTF8Z(cx, message_); +} + +void JSErrorBase::freeMessage() { + if (ownsMessage_) { + js_free((void*)message_.get()); + ownsMessage_ = false; + } + message_ = JS::ConstUTF8CharsZ(); +} + +JSErrorNotes::JSErrorNotes() : notes_() {} + +JSErrorNotes::~JSErrorNotes() = default; + +static UniquePtr<JSErrorNotes::Note> CreateErrorNoteVA( + FrontendContext* fc, const char* filename, unsigned sourceId, + unsigned lineno, unsigned column, JSErrorCallback errorCallback, + void* userRef, const unsigned errorNumber, ErrorArgumentsType argumentsType, + va_list ap) { + auto note = MakeUnique<JSErrorNotes::Note>(); + if (!note) { + ReportOutOfMemory(fc); + return nullptr; + } + + note->errorNumber = errorNumber; + note->filename = filename; + note->sourceId = sourceId; + note->lineno = lineno; + note->column = column; + + if (!ExpandErrorArgumentsVA(fc, errorCallback, userRef, errorNumber, nullptr, + argumentsType, note.get(), ap)) { + return nullptr; + } + + return note; +} + +bool JSErrorNotes::addNoteVA(FrontendContext* fc, const char* filename, + unsigned sourceId, unsigned lineno, + unsigned column, JSErrorCallback errorCallback, + void* userRef, const unsigned errorNumber, + ErrorArgumentsType argumentsType, va_list ap) { + auto note = + CreateErrorNoteVA(fc, filename, sourceId, lineno, column, errorCallback, + userRef, errorNumber, argumentsType, ap); + + if (!note) { + return false; + } + if (!notes_.append(std::move(note))) { + ReportOutOfMemory(fc); + return false; + } + return true; +} + +bool JSErrorNotes::addNoteASCII(JSContext* cx, const char* filename, + unsigned sourceId, unsigned lineno, + unsigned column, JSErrorCallback errorCallback, + void* userRef, const unsigned errorNumber, + ...) { + AutoReportFrontendContext fc(cx); + va_list ap; + va_start(ap, errorNumber); + bool ok = addNoteVA(&fc, filename, sourceId, lineno, column, errorCallback, + userRef, errorNumber, ArgumentsAreASCII, ap); + va_end(ap); + return ok; +} + +bool JSErrorNotes::addNoteASCII(FrontendContext* fc, const char* filename, + unsigned sourceId, unsigned lineno, + unsigned column, JSErrorCallback errorCallback, + void* userRef, const unsigned errorNumber, + ...) { + va_list ap; + va_start(ap, errorNumber); + bool ok = addNoteVA(fc, filename, sourceId, lineno, column, errorCallback, + userRef, errorNumber, ArgumentsAreASCII, ap); + va_end(ap); + return ok; +} + +bool JSErrorNotes::addNoteLatin1(JSContext* cx, const char* filename, + unsigned sourceId, unsigned lineno, + unsigned column, JSErrorCallback errorCallback, + void* userRef, const unsigned errorNumber, + ...) { + AutoReportFrontendContext fc(cx); + va_list ap; + va_start(ap, errorNumber); + bool ok = addNoteVA(&fc, filename, sourceId, lineno, column, errorCallback, + userRef, errorNumber, ArgumentsAreLatin1, ap); + va_end(ap); + return ok; +} + +bool JSErrorNotes::addNoteLatin1(FrontendContext* fc, const char* filename, + unsigned sourceId, unsigned lineno, + unsigned column, JSErrorCallback errorCallback, + void* userRef, const unsigned errorNumber, + ...) { + va_list ap; + va_start(ap, errorNumber); + bool ok = addNoteVA(fc, filename, sourceId, lineno, column, errorCallback, + userRef, errorNumber, ArgumentsAreLatin1, ap); + va_end(ap); + return ok; +} + +bool JSErrorNotes::addNoteUTF8(JSContext* cx, const char* filename, + unsigned sourceId, unsigned lineno, + unsigned column, JSErrorCallback errorCallback, + void* userRef, const unsigned errorNumber, ...) { + AutoReportFrontendContext fc(cx); + va_list ap; + va_start(ap, errorNumber); + bool ok = addNoteVA(&fc, filename, sourceId, lineno, column, errorCallback, + userRef, errorNumber, ArgumentsAreUTF8, ap); + va_end(ap); + return ok; +} + +bool JSErrorNotes::addNoteUTF8(FrontendContext* fc, const char* filename, + unsigned sourceId, unsigned lineno, + unsigned column, JSErrorCallback errorCallback, + void* userRef, const unsigned errorNumber, ...) { + va_list ap; + va_start(ap, errorNumber); + bool ok = addNoteVA(fc, filename, sourceId, lineno, column, errorCallback, + userRef, errorNumber, ArgumentsAreUTF8, ap); + va_end(ap); + return ok; +} + +JS_PUBLIC_API size_t JSErrorNotes::length() { return notes_.length(); } + +UniquePtr<JSErrorNotes> JSErrorNotes::copy(JSContext* cx) { + auto copiedNotes = MakeUnique<JSErrorNotes>(); + if (!copiedNotes) { + ReportOutOfMemory(cx); + return nullptr; + } + + for (auto&& note : *this) { + UniquePtr<JSErrorNotes::Note> copied = CopyErrorNote(cx, note.get()); + if (!copied) { + return nullptr; + } + + if (!copiedNotes->notes_.append(std::move(copied))) { + return nullptr; + } + } + + return copiedNotes; +} + +JS_PUBLIC_API JSErrorNotes::iterator JSErrorNotes::begin() { + return iterator(notes_.begin()); +} + +JS_PUBLIC_API JSErrorNotes::iterator JSErrorNotes::end() { + return iterator(notes_.end()); +} + +extern MOZ_NEVER_INLINE JS_PUBLIC_API void JS_AbortIfWrongThread( + JSContext* cx) { + if (!CurrentThreadCanAccessRuntime(cx->runtime())) { + MOZ_CRASH(); + } + if (TlsContext.get() != cx) { + MOZ_CRASH(); + } +} + +#ifdef JS_GC_ZEAL +JS_PUBLIC_API void JS_GetGCZealBits(JSContext* cx, uint32_t* zealBits, + uint32_t* frequency, + uint32_t* nextScheduled) { + cx->runtime()->gc.getZealBits(zealBits, frequency, nextScheduled); +} + +JS_PUBLIC_API void JS_SetGCZeal(JSContext* cx, uint8_t zeal, + uint32_t frequency) { + cx->runtime()->gc.setZeal(zeal, frequency); +} + +JS_PUBLIC_API void JS_UnsetGCZeal(JSContext* cx, uint8_t zeal) { + cx->runtime()->gc.unsetZeal(zeal); +} + +JS_PUBLIC_API void JS_ScheduleGC(JSContext* cx, uint32_t count) { + cx->runtime()->gc.setNextScheduled(count); +} +#endif + +JS_PUBLIC_API void JS_SetParallelParsingEnabled(JSContext* cx, bool enabled) { + cx->runtime()->setParallelParsingEnabled(enabled); +} + +JS_PUBLIC_API void JS_SetOffthreadIonCompilationEnabled(JSContext* cx, + bool enabled) { + cx->runtime()->setOffthreadIonCompilationEnabled(enabled); +} + +JS_PUBLIC_API void JS_SetGlobalJitCompilerOption(JSContext* cx, + JSJitCompilerOption opt, + uint32_t value) { + JSRuntime* rt = cx->runtime(); + switch (opt) { + case JSJITCOMPILER_BASELINE_INTERPRETER_WARMUP_TRIGGER: + if (value == uint32_t(-1)) { + jit::DefaultJitOptions defaultValues; + value = defaultValues.baselineInterpreterWarmUpThreshold; + } + jit::JitOptions.baselineInterpreterWarmUpThreshold = value; + break; + case JSJITCOMPILER_BASELINE_WARMUP_TRIGGER: + if (value == uint32_t(-1)) { + jit::DefaultJitOptions defaultValues; + value = defaultValues.baselineJitWarmUpThreshold; + } + jit::JitOptions.baselineJitWarmUpThreshold = value; + break; + case JSJITCOMPILER_IC_FORCE_MEGAMORPHIC: + jit::JitOptions.forceMegamorphicICs = !!value; + break; + case JSJITCOMPILER_ION_NORMAL_WARMUP_TRIGGER: + if (value == uint32_t(-1)) { + jit::JitOptions.resetNormalIonWarmUpThreshold(); + break; + } + jit::JitOptions.setNormalIonWarmUpThreshold(value); + break; + case JSJITCOMPILER_ION_GVN_ENABLE: + if (value == 0) { + jit::JitOptions.enableGvn(false); + JitSpew(js::jit::JitSpew_IonScripts, "Disable ion's GVN"); + } else { + jit::JitOptions.enableGvn(true); + JitSpew(js::jit::JitSpew_IonScripts, "Enable ion's GVN"); + } + break; + case JSJITCOMPILER_ION_FORCE_IC: + if (value == 0) { + jit::JitOptions.forceInlineCaches = false; + JitSpew(js::jit::JitSpew_IonScripts, + "Ion: Enable non-IC optimizations."); + } else { + jit::JitOptions.forceInlineCaches = true; + JitSpew(js::jit::JitSpew_IonScripts, + "Ion: Disable non-IC optimizations."); + } + break; + case JSJITCOMPILER_ION_CHECK_RANGE_ANALYSIS: + if (value == 0) { + jit::JitOptions.checkRangeAnalysis = false; + JitSpew(js::jit::JitSpew_IonScripts, + "Ion: Enable range analysis checks."); + } else { + jit::JitOptions.checkRangeAnalysis = true; + JitSpew(js::jit::JitSpew_IonScripts, + "Ion: Disable range analysis checks."); + } + break; + case JSJITCOMPILER_ION_ENABLE: + if (value == 1) { + jit::JitOptions.ion = true; + JitSpew(js::jit::JitSpew_IonScripts, "Enable ion"); + } else if (value == 0) { + jit::JitOptions.ion = false; + JitSpew(js::jit::JitSpew_IonScripts, "Disable ion"); + } + break; + case JSJITCOMPILER_JIT_TRUSTEDPRINCIPALS_ENABLE: + if (value == 1) { + jit::JitOptions.jitForTrustedPrincipals = true; + JitSpew(js::jit::JitSpew_IonScripts, + "Enable ion and baselinejit for trusted principals"); + } else if (value == 0) { + jit::JitOptions.jitForTrustedPrincipals = false; + JitSpew(js::jit::JitSpew_IonScripts, + "Disable ion and baselinejit for trusted principals"); + } + break; + case JSJITCOMPILER_ION_FREQUENT_BAILOUT_THRESHOLD: + if (value == uint32_t(-1)) { + jit::DefaultJitOptions defaultValues; + value = defaultValues.frequentBailoutThreshold; + } + jit::JitOptions.frequentBailoutThreshold = value; + break; + case JSJITCOMPILER_BASE_REG_FOR_LOCALS: + if (value == 0) { + jit::JitOptions.baseRegForLocals = jit::BaseRegForAddress::SP; + } else if (value == 1) { + jit::JitOptions.baseRegForLocals = jit::BaseRegForAddress::FP; + } else { + jit::DefaultJitOptions defaultValues; + jit::JitOptions.baseRegForLocals = defaultValues.baseRegForLocals; + } + break; + case JSJITCOMPILER_BASELINE_INTERPRETER_ENABLE: + if (value == 1) { + jit::JitOptions.baselineInterpreter = true; + } else if (value == 0) { + ReleaseAllJITCode(rt->gcContext()); + jit::JitOptions.baselineInterpreter = false; + } + break; + case JSJITCOMPILER_BASELINE_ENABLE: + if (value == 1) { + jit::JitOptions.baselineJit = true; + ReleaseAllJITCode(rt->gcContext()); + JitSpew(js::jit::JitSpew_BaselineScripts, "Enable baseline"); + } else if (value == 0) { + jit::JitOptions.baselineJit = false; + ReleaseAllJITCode(rt->gcContext()); + JitSpew(js::jit::JitSpew_BaselineScripts, "Disable baseline"); + } + break; + case JSJITCOMPILER_NATIVE_REGEXP_ENABLE: + jit::JitOptions.nativeRegExp = !!value; + break; + case JSJITCOMPILER_JIT_HINTS_ENABLE: + jit::JitOptions.disableJitHints = !value; + break; + case JSJITCOMPILER_OFFTHREAD_COMPILATION_ENABLE: + if (value == 1) { + rt->setOffthreadIonCompilationEnabled(true); + JitSpew(js::jit::JitSpew_IonScripts, "Enable offthread compilation"); + } else if (value == 0) { + rt->setOffthreadIonCompilationEnabled(false); + JitSpew(js::jit::JitSpew_IonScripts, "Disable offthread compilation"); + } + break; + case JSJITCOMPILER_INLINING_BYTECODE_MAX_LENGTH: + if (value == uint32_t(-1)) { + jit::DefaultJitOptions defaultValues; + value = defaultValues.smallFunctionMaxBytecodeLength; + } + jit::JitOptions.smallFunctionMaxBytecodeLength = value; + break; + case JSJITCOMPILER_JUMP_THRESHOLD: + if (value == uint32_t(-1)) { + jit::DefaultJitOptions defaultValues; + value = defaultValues.jumpThreshold; + } + jit::JitOptions.jumpThreshold = value; + break; + case JSJITCOMPILER_SPECTRE_INDEX_MASKING: + jit::JitOptions.spectreIndexMasking = !!value; + break; + case JSJITCOMPILER_SPECTRE_OBJECT_MITIGATIONS: + jit::JitOptions.spectreObjectMitigations = !!value; + break; + case JSJITCOMPILER_SPECTRE_STRING_MITIGATIONS: + jit::JitOptions.spectreStringMitigations = !!value; + break; + case JSJITCOMPILER_SPECTRE_VALUE_MASKING: + jit::JitOptions.spectreValueMasking = !!value; + break; + case JSJITCOMPILER_SPECTRE_JIT_TO_CXX_CALLS: + jit::JitOptions.spectreJitToCxxCalls = !!value; + break; + case JSJITCOMPILER_WATCHTOWER_MEGAMORPHIC: + jit::JitOptions.enableWatchtowerMegamorphic = !!value; + break; + case JSJITCOMPILER_WASM_FOLD_OFFSETS: + jit::JitOptions.wasmFoldOffsets = !!value; + break; + case JSJITCOMPILER_WASM_DELAY_TIER2: + jit::JitOptions.wasmDelayTier2 = !!value; + break; + case JSJITCOMPILER_WASM_JIT_BASELINE: + JS::ContextOptionsRef(cx).setWasmBaseline(!!value); + break; + case JSJITCOMPILER_WASM_JIT_OPTIMIZING: + JS::ContextOptionsRef(cx).setWasmIon(!!value); + break; +#ifdef DEBUG + case JSJITCOMPILER_FULL_DEBUG_CHECKS: + jit::JitOptions.fullDebugChecks = !!value; + break; +#endif + default: + break; + } +} + +JS_PUBLIC_API bool JS_GetGlobalJitCompilerOption(JSContext* cx, + JSJitCompilerOption opt, + uint32_t* valueOut) { + MOZ_ASSERT(valueOut); +#ifndef JS_CODEGEN_NONE + JSRuntime* rt = cx->runtime(); + switch (opt) { + case JSJITCOMPILER_BASELINE_INTERPRETER_WARMUP_TRIGGER: + *valueOut = jit::JitOptions.baselineInterpreterWarmUpThreshold; + break; + case JSJITCOMPILER_BASELINE_WARMUP_TRIGGER: + *valueOut = jit::JitOptions.baselineJitWarmUpThreshold; + break; + case JSJITCOMPILER_IC_FORCE_MEGAMORPHIC: + *valueOut = jit::JitOptions.forceMegamorphicICs; + break; + case JSJITCOMPILER_ION_NORMAL_WARMUP_TRIGGER: + *valueOut = jit::JitOptions.normalIonWarmUpThreshold; + break; + case JSJITCOMPILER_ION_FORCE_IC: + *valueOut = jit::JitOptions.forceInlineCaches; + break; + case JSJITCOMPILER_ION_CHECK_RANGE_ANALYSIS: + *valueOut = jit::JitOptions.checkRangeAnalysis; + break; + case JSJITCOMPILER_ION_ENABLE: + *valueOut = jit::JitOptions.ion; + break; + case JSJITCOMPILER_ION_FREQUENT_BAILOUT_THRESHOLD: + *valueOut = jit::JitOptions.frequentBailoutThreshold; + break; + case JSJITCOMPILER_BASE_REG_FOR_LOCALS: + *valueOut = uint32_t(jit::JitOptions.baseRegForLocals); + break; + case JSJITCOMPILER_INLINING_BYTECODE_MAX_LENGTH: + *valueOut = jit::JitOptions.smallFunctionMaxBytecodeLength; + break; + case JSJITCOMPILER_BASELINE_INTERPRETER_ENABLE: + *valueOut = jit::JitOptions.baselineInterpreter; + break; + case JSJITCOMPILER_BASELINE_ENABLE: + *valueOut = jit::JitOptions.baselineJit; + break; + case JSJITCOMPILER_NATIVE_REGEXP_ENABLE: + *valueOut = jit::JitOptions.nativeRegExp; + break; + case JSJITCOMPILER_OFFTHREAD_COMPILATION_ENABLE: + *valueOut = rt->canUseOffthreadIonCompilation(); + break; + case JSJITCOMPILER_SPECTRE_INDEX_MASKING: + *valueOut = jit::JitOptions.spectreIndexMasking ? 1 : 0; + break; + case JSJITCOMPILER_SPECTRE_OBJECT_MITIGATIONS: + *valueOut = jit::JitOptions.spectreObjectMitigations ? 1 : 0; + break; + case JSJITCOMPILER_SPECTRE_STRING_MITIGATIONS: + *valueOut = jit::JitOptions.spectreStringMitigations ? 1 : 0; + break; + case JSJITCOMPILER_SPECTRE_VALUE_MASKING: + *valueOut = jit::JitOptions.spectreValueMasking ? 1 : 0; + break; + case JSJITCOMPILER_SPECTRE_JIT_TO_CXX_CALLS: + *valueOut = jit::JitOptions.spectreJitToCxxCalls ? 1 : 0; + break; + case JSJITCOMPILER_WATCHTOWER_MEGAMORPHIC: + *valueOut = jit::JitOptions.enableWatchtowerMegamorphic ? 1 : 0; + break; + case JSJITCOMPILER_WASM_FOLD_OFFSETS: + *valueOut = jit::JitOptions.wasmFoldOffsets ? 1 : 0; + break; + case JSJITCOMPILER_WASM_JIT_BASELINE: + *valueOut = JS::ContextOptionsRef(cx).wasmBaseline() ? 1 : 0; + break; + case JSJITCOMPILER_WASM_JIT_OPTIMIZING: + *valueOut = JS::ContextOptionsRef(cx).wasmIon() ? 1 : 0; + break; +# ifdef DEBUG + case JSJITCOMPILER_FULL_DEBUG_CHECKS: + *valueOut = jit::JitOptions.fullDebugChecks ? 1 : 0; + break; +# endif + default: + return false; + } +#else + *valueOut = 0; +#endif + return true; +} + +JS_PUBLIC_API void JS::DisableSpectreMitigationsAfterInit() { + // This is used to turn off Spectre mitigations in pre-allocated child + // processes used for isolated web content. Assert there's a single runtime + // and cancel off-thread compilations, to ensure we're not racing with any + // compilations. + JSContext* cx = TlsContext.get(); + MOZ_RELEASE_ASSERT(cx); + MOZ_RELEASE_ASSERT(JSRuntime::hasSingleLiveRuntime()); + MOZ_RELEASE_ASSERT(cx->runtime()->wasmInstances.lock()->empty()); + + CancelOffThreadIonCompile(cx->runtime()); + + jit::JitOptions.spectreIndexMasking = false; + jit::JitOptions.spectreObjectMitigations = false; + jit::JitOptions.spectreStringMitigations = false; + jit::JitOptions.spectreValueMasking = false; + jit::JitOptions.spectreJitToCxxCalls = false; +} + +/************************************************************************/ + +#if !defined(STATIC_EXPORTABLE_JS_API) && !defined(STATIC_JS_API) && \ + defined(XP_WIN) && (defined(MOZ_MEMORY) || !defined(JS_STANDALONE)) + +# include "util/WindowsWrapper.h" + +/* + * Initialization routine for the JS DLL. + */ +BOOL WINAPI DllMain(HINSTANCE hDLL, DWORD dwReason, LPVOID lpReserved) { + return TRUE; +} + +#endif + +JS_PUBLIC_API bool JS_IndexToId(JSContext* cx, uint32_t index, + MutableHandleId id) { + return IndexToId(cx, index, id); +} + +JS_PUBLIC_API bool JS_CharsToId(JSContext* cx, JS::TwoByteChars chars, + MutableHandleId idp) { + Rooted<JSAtom*> atom(cx, + AtomizeChars(cx, chars.begin().get(), chars.length())); + if (!atom) { + return false; + } +#ifdef DEBUG + MOZ_ASSERT(!atom->isIndex(), "API misuse: |chars| must not encode an index"); +#endif + idp.set(AtomToId(atom)); + return true; +} + +JS_PUBLIC_API bool JS_IsIdentifier(JSContext* cx, HandleString str, + bool* isIdentifier) { + cx->check(str); + + JSLinearString* linearStr = str->ensureLinear(cx); + if (!linearStr) { + return false; + } + + *isIdentifier = js::frontend::IsIdentifier(linearStr); + return true; +} + +JS_PUBLIC_API bool JS_IsIdentifier(const char16_t* chars, size_t length) { + return js::frontend::IsIdentifier(chars, length); +} + +namespace JS { + +void AutoFilename::reset() { + if (ss_) { + ss_->Release(); + ss_ = nullptr; + } + if (filename_.is<const char*>()) { + filename_.as<const char*>() = nullptr; + } else { + filename_.as<UniqueChars>().reset(); + } +} + +void AutoFilename::setScriptSource(js::ScriptSource* p) { + MOZ_ASSERT(!ss_); + MOZ_ASSERT(!get()); + ss_ = p; + if (p) { + p->AddRef(); + setUnowned(p->filename()); + } +} + +void AutoFilename::setUnowned(const char* filename) { + MOZ_ASSERT(!get()); + filename_.as<const char*>() = filename ? filename : ""; +} + +void AutoFilename::setOwned(UniqueChars&& filename) { + MOZ_ASSERT(!get()); + filename_ = AsVariant(std::move(filename)); +} + +const char* AutoFilename::get() const { + if (filename_.is<const char*>()) { + return filename_.as<const char*>(); + } + return filename_.as<UniqueChars>().get(); +} + +JS_PUBLIC_API bool DescribeScriptedCaller(JSContext* cx, AutoFilename* filename, + unsigned* lineno, unsigned* column) { + if (filename) { + filename->reset(); + } + if (lineno) { + *lineno = 0; + } + if (column) { + *column = 0; + } + + if (!cx->compartment()) { + return false; + } + + NonBuiltinFrameIter i(cx, cx->realm()->principals()); + if (i.done()) { + return false; + } + + // If the caller is hidden, the embedding wants us to return false here so + // that it can check its own stack (see HideScriptedCaller). + if (i.activation()->scriptedCallerIsHidden()) { + return false; + } + + if (filename) { + if (i.isWasm()) { + // For Wasm, copy out the filename, there is no script source. + UniqueChars copy = DuplicateString(i.filename() ? i.filename() : ""); + if (!copy) { + filename->setUnowned("out of memory"); + } else { + filename->setOwned(std::move(copy)); + } + } else { + // All other frames have a script source to read the filename from. + filename->setScriptSource(i.scriptSource()); + } + } + + if (lineno) { + *lineno = i.computeLine(column); + } else if (column) { + i.computeLine(column); + } + + return true; +} + +// Fast path to get the activation and realm to use for GetScriptedCallerGlobal. +// If this returns false, the fast path didn't work out and the caller has to +// use the (much slower) NonBuiltinFrameIter path. +// +// The optimization here is that we skip Ion-inlined frames and only look at +// 'outer' frames. That's fine because Ion doesn't inline cross-realm calls. +// However, GetScriptedCallerGlobal has to skip self-hosted frames and Ion +// can inline self-hosted scripts, so we have to be careful: +// +// * When we see a non-self-hosted outer script, it's possible we inlined +// self-hosted scripts into it but that doesn't matter because these scripts +// all have the same realm/global anyway. +// +// * When we see a self-hosted outer script, it's possible we inlined +// non-self-hosted scripts into it, so we have to give up because in this +// case, whether or not to skip the self-hosted frame (to the possibly +// different-realm caller) requires the slow path to handle inlining. Baseline +// and the interpreter don't inline so this only affects Ion. +static bool GetScriptedCallerActivationRealmFast(JSContext* cx, + Activation** activation, + Realm** realm) { + ActivationIterator activationIter(cx); + + if (activationIter.done()) { + *activation = nullptr; + *realm = nullptr; + return true; + } + + if (activationIter->isJit()) { + jit::JitActivation* act = activationIter->asJit(); + JitFrameIter iter(act); + while (true) { + iter.skipNonScriptedJSFrames(); + if (iter.done()) { + break; + } + + if (!iter.isSelfHostedIgnoringInlining()) { + *activation = act; + *realm = iter.realm(); + return true; + } + + if (iter.isJSJit() && iter.asJSJit().isIonScripted()) { + // Ion might have inlined non-self-hosted scripts in this + // self-hosted script. + return false; + } + + ++iter; + } + } else if (activationIter->isInterpreter()) { + InterpreterActivation* act = activationIter->asInterpreter(); + for (InterpreterFrameIterator iter(act); !iter.done(); ++iter) { + if (!iter.frame()->script()->selfHosted()) { + *activation = act; + *realm = iter.frame()->script()->realm(); + return true; + } + } + } + + return false; +} + +JS_PUBLIC_API JSObject* GetScriptedCallerGlobal(JSContext* cx) { + Activation* activation; + Realm* realm; + if (GetScriptedCallerActivationRealmFast(cx, &activation, &realm)) { + if (!activation) { + return nullptr; + } + } else { + NonBuiltinFrameIter i(cx); + if (i.done()) { + return nullptr; + } + activation = i.activation(); + realm = i.realm(); + } + + MOZ_ASSERT(realm->compartment() == activation->compartment()); + + // If the caller is hidden, the embedding wants us to return null here so + // that it can check its own stack (see HideScriptedCaller). + if (activation->scriptedCallerIsHidden()) { + return nullptr; + } + + GlobalObject* global = realm->maybeGlobal(); + + // No one should be running code in a realm without any live objects, so + // there should definitely be a live global. + MOZ_ASSERT(global); + + return global; +} + +JS_PUBLIC_API void HideScriptedCaller(JSContext* cx) { + MOZ_ASSERT(cx); + + // If there's no accessible activation on the stack, we'll return null from + // DescribeScriptedCaller anyway, so there's no need to annotate anything. + Activation* act = cx->activation(); + if (!act) { + return; + } + act->hideScriptedCaller(); +} + +JS_PUBLIC_API void UnhideScriptedCaller(JSContext* cx) { + Activation* act = cx->activation(); + if (!act) { + return; + } + act->unhideScriptedCaller(); +} + +} /* namespace JS */ + +#ifdef JS_DEBUG +JS_PUBLIC_API void JS::detail::AssertArgumentsAreSane(JSContext* cx, + HandleValue value) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + cx->check(value); +} +#endif /* JS_DEBUG */ + +JS_PUBLIC_API bool JS::FinishIncrementalEncoding(JSContext* cx, + JS::HandleScript script, + TranscodeBuffer& buffer) { + if (!script) { + return false; + } + if (!script->scriptSource()->xdrFinalizeEncoder(cx, buffer)) { + return false; + } + return true; +} + +JS_PUBLIC_API bool JS::FinishIncrementalEncoding(JSContext* cx, + JS::Handle<JSObject*> module, + TranscodeBuffer& buffer) { + if (!module->as<ModuleObject>() + .scriptSourceObject() + ->source() + ->xdrFinalizeEncoder(cx, buffer)) { + return false; + } + return true; +} + +JS_PUBLIC_API void JS::AbortIncrementalEncoding(JS::HandleScript script) { + if (!script) { + return; + } + script->scriptSource()->xdrAbortEncoder(); +} + +JS_PUBLIC_API void JS::AbortIncrementalEncoding(JS::Handle<JSObject*> module) { + module->as<ModuleObject>().scriptSourceObject()->source()->xdrAbortEncoder(); +} + +bool JS::IsWasmModuleObject(HandleObject obj) { + return obj->canUnwrapAs<WasmModuleObject>(); +} + +JS_PUBLIC_API RefPtr<JS::WasmModule> JS::GetWasmModule(HandleObject obj) { + MOZ_ASSERT(JS::IsWasmModuleObject(obj)); + WasmModuleObject& mobj = obj->unwrapAs<WasmModuleObject>(); + return const_cast<wasm::Module*>(&mobj.module()); +} + +bool JS::DisableWasmHugeMemory() { return wasm::DisableHugeMemory(); } + +JS_PUBLIC_API void JS::SetProcessLargeAllocationFailureCallback( + JS::LargeAllocationFailureCallback lafc) { + MOZ_ASSERT(!OnLargeAllocationFailure); + OnLargeAllocationFailure = lafc; +} + +JS_PUBLIC_API void JS::SetOutOfMemoryCallback(JSContext* cx, + OutOfMemoryCallback cb, + void* data) { + cx->runtime()->oomCallback = cb; + cx->runtime()->oomCallbackData = data; +} + +JS_PUBLIC_API void JS::SetShadowRealmInitializeGlobalCallback( + JSContext* cx, JS::GlobalInitializeCallback callback) { + cx->runtime()->shadowRealmInitializeGlobalCallback = callback; +} + +JS_PUBLIC_API void JS::SetShadowRealmGlobalCreationCallback( + JSContext* cx, JS::GlobalCreationCallback callback) { + cx->runtime()->shadowRealmGlobalCreationCallback = callback; +} + +JS::FirstSubsumedFrame::FirstSubsumedFrame( + JSContext* cx, bool ignoreSelfHostedFrames /* = true */) + : JS::FirstSubsumedFrame(cx, cx->realm()->principals(), + ignoreSelfHostedFrames) {} + +JS_PUBLIC_API bool JS::CaptureCurrentStack( + JSContext* cx, JS::MutableHandleObject stackp, + JS::StackCapture&& capture /* = JS::StackCapture(JS::AllFrames()) */) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + MOZ_RELEASE_ASSERT(cx->realm()); + + Realm* realm = cx->realm(); + Rooted<SavedFrame*> frame(cx); + if (!realm->savedStacks().saveCurrentStack(cx, &frame, std::move(capture))) { + return false; + } + stackp.set(frame.get()); + return true; +} + +JS_PUBLIC_API bool JS::IsAsyncStackCaptureEnabledForRealm(JSContext* cx) { + if (!cx->options().asyncStack()) { + return false; + } + + if (!cx->options().asyncStackCaptureDebuggeeOnly() || + cx->realm()->isDebuggee()) { + return true; + } + + return cx->realm()->isAsyncStackCapturingEnabled; +} + +JS_PUBLIC_API bool JS::CopyAsyncStack(JSContext* cx, + JS::HandleObject asyncStack, + JS::HandleString asyncCause, + JS::MutableHandleObject stackp, + const Maybe<size_t>& maxFrameCount) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + MOZ_RELEASE_ASSERT(cx->realm()); + + js::AssertObjectIsSavedFrameOrWrapper(cx, asyncStack); + Realm* realm = cx->realm(); + Rooted<SavedFrame*> frame(cx); + if (!realm->savedStacks().copyAsyncStack(cx, asyncStack, asyncCause, &frame, + maxFrameCount)) { + return false; + } + stackp.set(frame.get()); + return true; +} + +JS_PUBLIC_API Zone* JS::GetObjectZone(JSObject* obj) { return obj->zone(); } + +JS_PUBLIC_API Zone* JS::GetNurseryCellZone(gc::Cell* cell) { + return cell->nurseryZone(); +} + +JS_PUBLIC_API JS::TraceKind JS::GCThingTraceKind(void* thing) { + MOZ_ASSERT(thing); + return static_cast<js::gc::Cell*>(thing)->getTraceKind(); +} + +JS_PUBLIC_API void js::SetStackFormat(JSContext* cx, js::StackFormat format) { + cx->runtime()->setStackFormat(format); +} + +JS_PUBLIC_API js::StackFormat js::GetStackFormat(JSContext* cx) { + return cx->runtime()->stackFormat(); +} + +JS_PUBLIC_API JS::JSTimers JS::GetJSTimers(JSContext* cx) { + return cx->realm()->timers; +} + +namespace js { + +JS_PUBLIC_API void NoteIntentionalCrash() { +#ifdef __linux__ + static bool* addr = + reinterpret_cast<bool*>(dlsym(RTLD_DEFAULT, "gBreakpadInjectorEnabled")); + if (addr) { + *addr = false; + } +#endif +} + +#ifdef DEBUG +bool gSupportDifferentialTesting = false; +#endif // DEBUG + +} // namespace js + +#ifdef DEBUG + +JS_PUBLIC_API void JS::SetSupportDifferentialTesting(bool value) { + js::gSupportDifferentialTesting = value; +} + +#endif // DEBUG |