summaryrefslogtreecommitdiffstats
path: root/js/src/jsfriendapi.h
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /js/src/jsfriendapi.h
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'js/src/jsfriendapi.h')
-rw-r--r--js/src/jsfriendapi.h3067
1 files changed, 3067 insertions, 0 deletions
diff --git a/js/src/jsfriendapi.h b/js/src/jsfriendapi.h
new file mode 100644
index 000000000..b1c7cb0dc
--- /dev/null
+++ b/js/src/jsfriendapi.h
@@ -0,0 +1,3067 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ * vim: set ts=8 sts=4 et sw=4 tw=99:
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef jsfriendapi_h
+#define jsfriendapi_h
+
+#include "mozilla/Atomics.h"
+#include "mozilla/Casting.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/MemoryReporting.h"
+#include "mozilla/UniquePtr.h"
+
+#include "jsapi.h" // For JSAutoByteString. See bug 1033916.
+#include "jsbytecode.h"
+#include "jspubtd.h"
+
+#include "js/CallArgs.h"
+#include "js/CallNonGenericMethod.h"
+#include "js/Class.h"
+#include "js/Utility.h"
+
+#if JS_STACK_GROWTH_DIRECTION > 0
+# define JS_CHECK_STACK_SIZE(limit, sp) (MOZ_LIKELY((uintptr_t)(sp) < (limit)))
+#else
+# define JS_CHECK_STACK_SIZE(limit, sp) (MOZ_LIKELY((uintptr_t)(sp) > (limit)))
+#endif
+
+class JSAtom;
+struct JSErrorFormatString;
+class JSLinearString;
+struct JSJitInfo;
+class JSErrorReport;
+
+namespace JS {
+template <class T>
+class Heap;
+} /* namespace JS */
+
+namespace js {
+class JS_FRIEND_API(BaseProxyHandler);
+class InterpreterFrame;
+} /* namespace js */
+
+extern JS_FRIEND_API(void)
+JS_SetGrayGCRootsTracer(JSContext* cx, JSTraceDataOp traceOp, void* data);
+
+extern JS_FRIEND_API(JSObject*)
+JS_FindCompilationScope(JSContext* cx, JS::HandleObject obj);
+
+extern JS_FRIEND_API(JSFunction*)
+JS_GetObjectFunction(JSObject* obj);
+
+extern JS_FRIEND_API(bool)
+JS_SplicePrototype(JSContext* cx, JS::HandleObject obj, JS::HandleObject proto);
+
+extern JS_FRIEND_API(JSObject*)
+JS_NewObjectWithUniqueType(JSContext* cx, const JSClass* clasp, JS::HandleObject proto);
+
+/**
+ * Allocate an object in exactly the same way as JS_NewObjectWithGivenProto, but
+ * without invoking the metadata callback on it. This allows creation of
+ * internal bookkeeping objects that are guaranteed to not have metadata
+ * attached to them.
+ */
+extern JS_FRIEND_API(JSObject*)
+JS_NewObjectWithoutMetadata(JSContext* cx, const JSClass* clasp, JS::Handle<JSObject*> proto);
+
+extern JS_FRIEND_API(uint32_t)
+JS_ObjectCountDynamicSlots(JS::HandleObject obj);
+
+extern JS_FRIEND_API(size_t)
+JS_SetProtoCalled(JSContext* cx);
+
+extern JS_FRIEND_API(size_t)
+JS_GetCustomIteratorCount(JSContext* cx);
+
+extern JS_FRIEND_API(bool)
+JS_NondeterministicGetWeakMapKeys(JSContext* cx, JS::HandleObject obj, JS::MutableHandleObject ret);
+
+extern JS_FRIEND_API(bool)
+JS_NondeterministicGetWeakSetKeys(JSContext* cx, JS::HandleObject obj, JS::MutableHandleObject ret);
+
+// Raw JSScript* because this needs to be callable from a signal handler.
+extern JS_FRIEND_API(unsigned)
+JS_PCToLineNumber(JSScript* script, jsbytecode* pc, unsigned* columnp = nullptr);
+
+/**
+ * Determine whether the given object is backed by a DeadObjectProxy.
+ *
+ * Such objects hold no other objects (they have no outgoing reference edges)
+ * and will throw if you touch them (e.g. by reading/writing a property).
+ */
+extern JS_FRIEND_API(bool)
+JS_IsDeadWrapper(JSObject* obj);
+
+/*
+ * Used by the cycle collector to trace through a shape or object group and
+ * all cycle-participating data it reaches, using bounded stack space.
+ */
+extern JS_FRIEND_API(void)
+JS_TraceShapeCycleCollectorChildren(JS::CallbackTracer* trc, JS::GCCellPtr shape);
+extern JS_FRIEND_API(void)
+JS_TraceObjectGroupCycleCollectorChildren(JS::CallbackTracer* trc, JS::GCCellPtr group);
+
+enum {
+ JS_TELEMETRY_GC_REASON,
+ JS_TELEMETRY_GC_IS_ZONE_GC,
+ JS_TELEMETRY_GC_MS,
+ JS_TELEMETRY_GC_BUDGET_MS,
+ JS_TELEMETRY_GC_ANIMATION_MS,
+ JS_TELEMETRY_GC_MAX_PAUSE_MS,
+ JS_TELEMETRY_GC_MARK_MS,
+ JS_TELEMETRY_GC_SWEEP_MS,
+ JS_TELEMETRY_GC_COMPACT_MS,
+ JS_TELEMETRY_GC_MARK_ROOTS_MS,
+ JS_TELEMETRY_GC_MARK_GRAY_MS,
+ JS_TELEMETRY_GC_SLICE_MS,
+ JS_TELEMETRY_GC_SLOW_PHASE,
+ JS_TELEMETRY_GC_MMU_50,
+ JS_TELEMETRY_GC_RESET,
+ JS_TELEMETRY_GC_RESET_REASON,
+ JS_TELEMETRY_GC_INCREMENTAL_DISABLED,
+ JS_TELEMETRY_GC_NON_INCREMENTAL,
+ JS_TELEMETRY_GC_NON_INCREMENTAL_REASON,
+ JS_TELEMETRY_GC_SCC_SWEEP_TOTAL_MS,
+ JS_TELEMETRY_GC_SCC_SWEEP_MAX_PAUSE_MS,
+ JS_TELEMETRY_GC_MINOR_REASON,
+ JS_TELEMETRY_GC_MINOR_REASON_LONG,
+ JS_TELEMETRY_GC_MINOR_US,
+ JS_TELEMETRY_GC_NURSERY_BYTES,
+ JS_TELEMETRY_GC_PRETENURE_COUNT,
+ JS_TELEMETRY_DEPRECATED_LANGUAGE_EXTENSIONS_IN_CONTENT,
+ JS_TELEMETRY_DEPRECATED_LANGUAGE_EXTENSIONS_IN_ADDONS,
+ JS_TELEMETRY_ADDON_EXCEPTIONS,
+ JS_TELEMETRY_AOT_USAGE,
+ JS_TELEMETRY_END
+};
+
+typedef void
+(*JSAccumulateTelemetryDataCallback)(int id, uint32_t sample, const char* key);
+
+extern JS_FRIEND_API(void)
+JS_SetAccumulateTelemetryCallback(JSContext* cx, JSAccumulateTelemetryDataCallback callback);
+
+extern JS_FRIEND_API(bool)
+JS_GetIsSecureContext(JSCompartment* compartment);
+
+extern JS_FRIEND_API(JSPrincipals*)
+JS_GetCompartmentPrincipals(JSCompartment* compartment);
+
+extern JS_FRIEND_API(void)
+JS_SetCompartmentPrincipals(JSCompartment* compartment, JSPrincipals* principals);
+
+extern JS_FRIEND_API(JSPrincipals*)
+JS_GetScriptPrincipals(JSScript* script);
+
+extern JS_FRIEND_API(bool)
+JS_ScriptHasMutedErrors(JSScript* script);
+
+extern JS_FRIEND_API(JSObject*)
+JS_CloneObject(JSContext* cx, JS::HandleObject obj, JS::HandleObject proto);
+
+/**
+ * Copy the own properties of src to dst in a fast way. src and dst must both
+ * be native and must be in the compartment of cx. They must have the same
+ * class, the same parent, and the same prototype. Class reserved slots will
+ * NOT be copied.
+ *
+ * dst must not have any properties on it before this function is called.
+ *
+ * src must have been allocated via JS_NewObjectWithoutMetadata so that we can
+ * be sure it has no metadata that needs copying to dst. This also means that
+ * dst needs to have the compartment global as its parent. This function will
+ * preserve the existing metadata on dst, if any.
+ */
+extern JS_FRIEND_API(bool)
+JS_InitializePropertiesFromCompatibleNativeObject(JSContext* cx,
+ JS::HandleObject dst,
+ JS::HandleObject src);
+
+extern JS_FRIEND_API(JSString*)
+JS_BasicObjectToString(JSContext* cx, JS::HandleObject obj);
+
+namespace js {
+
+JS_FRIEND_API(bool)
+GetBuiltinClass(JSContext* cx, JS::HandleObject obj, ESClass* cls);
+
+JS_FRIEND_API(const char*)
+ObjectClassName(JSContext* cx, JS::HandleObject obj);
+
+JS_FRIEND_API(void)
+ReportOverRecursed(JSContext* maybecx);
+
+JS_FRIEND_API(bool)
+AddRawValueRoot(JSContext* cx, JS::Value* vp, const char* name);
+
+JS_FRIEND_API(void)
+RemoveRawValueRoot(JSContext* cx, JS::Value* vp);
+
+JS_FRIEND_API(JSAtom*)
+GetPropertyNameFromPC(JSScript* script, jsbytecode* pc);
+
+#ifdef JS_DEBUG
+
+/*
+ * Routines to print out values during debugging. These are FRIEND_API to help
+ * the debugger find them and to support temporarily hacking js::Dump* calls
+ * into other code. Note that there are overloads that do not require the FILE*
+ * parameter, which will default to stderr.
+ */
+
+extern JS_FRIEND_API(void)
+DumpString(JSString* str, FILE* fp);
+
+extern JS_FRIEND_API(void)
+DumpAtom(JSAtom* atom, FILE* fp);
+
+extern JS_FRIEND_API(void)
+DumpObject(JSObject* obj, FILE* fp);
+
+extern JS_FRIEND_API(void)
+DumpChars(const char16_t* s, size_t n, FILE* fp);
+
+extern JS_FRIEND_API(void)
+DumpValue(const JS::Value& val, FILE* fp);
+
+extern JS_FRIEND_API(void)
+DumpId(jsid id, FILE* fp);
+
+extern JS_FRIEND_API(void)
+DumpInterpreterFrame(JSContext* cx, FILE* fp, InterpreterFrame* start = nullptr);
+
+extern JS_FRIEND_API(bool)
+DumpPC(JSContext* cx, FILE* fp);
+
+extern JS_FRIEND_API(bool)
+DumpScript(JSContext* cx, JSScript* scriptArg, FILE* fp);
+
+// Versions for use directly in a debugger (default parameters are not handled
+// well in gdb; built-in handles like stderr are not handled well in lldb.)
+extern JS_FRIEND_API(void) DumpString(JSString* str);
+extern JS_FRIEND_API(void) DumpAtom(JSAtom* atom);
+extern JS_FRIEND_API(void) DumpObject(JSObject* obj);
+extern JS_FRIEND_API(void) DumpChars(const char16_t* s, size_t n);
+extern JS_FRIEND_API(void) DumpValue(const JS::Value& val);
+extern JS_FRIEND_API(void) DumpId(jsid id);
+extern JS_FRIEND_API(void) DumpInterpreterFrame(JSContext* cx, InterpreterFrame* start = nullptr);
+extern JS_FRIEND_API(bool) DumpPC(JSContext* cx);
+extern JS_FRIEND_API(bool) DumpScript(JSContext* cx, JSScript* scriptArg);
+
+#endif
+
+extern JS_FRIEND_API(void)
+DumpBacktrace(JSContext* cx, FILE* fp);
+
+extern JS_FRIEND_API(void)
+DumpBacktrace(JSContext* cx);
+
+} // namespace js
+
+namespace JS {
+
+/** Exposed for DumpJSStack */
+extern JS_FRIEND_API(char*)
+FormatStackDump(JSContext* cx, char* buf, bool showArgs, bool showLocals, bool showThisProps);
+
+/**
+ * Set all of the uninitialized lexicals on an object to undefined. Return
+ * true if any lexicals were initialized and false otherwise.
+ * */
+extern JS_FRIEND_API(bool)
+ForceLexicalInitialization(JSContext *cx, HandleObject obj);
+
+} // namespace JS
+
+/**
+ * Copies all own properties from |obj| to |target|. |obj| must be a "native"
+ * object (that is to say, normal-ish - not an Array or a Proxy).
+ *
+ * This function immediately enters a compartment, and does not impose any
+ * restrictions on the compartment of |cx|.
+ */
+extern JS_FRIEND_API(bool)
+JS_CopyPropertiesFrom(JSContext* cx, JS::HandleObject target, JS::HandleObject obj);
+
+/*
+ * Single-property version of the above. This function asserts that an |own|
+ * property of the given name exists on |obj|.
+ *
+ * On entry, |cx| must be same-compartment with |obj|.
+ *
+ * The copyBehavior argument controls what happens with
+ * non-configurable properties.
+ */
+typedef enum {
+ MakeNonConfigurableIntoConfigurable,
+ CopyNonConfigurableAsIs
+} PropertyCopyBehavior;
+
+extern JS_FRIEND_API(bool)
+JS_CopyPropertyFrom(JSContext* cx, JS::HandleId id, JS::HandleObject target,
+ JS::HandleObject obj,
+ PropertyCopyBehavior copyBehavior = CopyNonConfigurableAsIs);
+
+extern JS_FRIEND_API(bool)
+JS_WrapPropertyDescriptor(JSContext* cx, JS::MutableHandle<JS::PropertyDescriptor> desc);
+
+struct JSFunctionSpecWithHelp {
+ const char* name;
+ JSNative call;
+ uint16_t nargs;
+ uint16_t flags;
+ const JSJitInfo* jitInfo;
+ const char* usage;
+ const char* help;
+};
+
+#define JS_FN_HELP(name,call,nargs,flags,usage,help) \
+ {name, call, nargs, (flags) | JSPROP_ENUMERATE | JSFUN_STUB_GSOPS, nullptr, usage, help}
+#define JS_INLINABLE_FN_HELP(name,call,nargs,flags,native,usage,help) \
+ {name, call, nargs, (flags) | JSPROP_ENUMERATE | JSFUN_STUB_GSOPS, &js::jit::JitInfo_##native,\
+ usage, help}
+#define JS_FS_HELP_END \
+ {nullptr, nullptr, 0, 0, nullptr, nullptr}
+
+extern JS_FRIEND_API(bool)
+JS_DefineFunctionsWithHelp(JSContext* cx, JS::HandleObject obj, const JSFunctionSpecWithHelp* fs);
+
+namespace js {
+
+extern JS_FRIEND_DATA(const js::ClassOps) ProxyClassOps;
+extern JS_FRIEND_DATA(const js::ClassExtension) ProxyClassExtension;
+extern JS_FRIEND_DATA(const js::ObjectOps) ProxyObjectOps;
+
+/*
+ * Helper Macros for creating JSClasses that function as proxies.
+ *
+ * NB: The macro invocation must be surrounded by braces, so as to
+ * allow for potential JSClass extensions.
+ */
+#define PROXY_MAKE_EXT(objectMoved) \
+ { \
+ js::proxy_WeakmapKeyDelegate, \
+ objectMoved \
+ }
+
+#define PROXY_CLASS_WITH_EXT(name, flags, extPtr) \
+ { \
+ name, \
+ js::Class::NON_NATIVE | \
+ JSCLASS_IS_PROXY | \
+ JSCLASS_DELAY_METADATA_BUILDER | \
+ flags, \
+ &js::ProxyClassOps, \
+ JS_NULL_CLASS_SPEC, \
+ extPtr, \
+ &js::ProxyObjectOps \
+ }
+
+#define PROXY_CLASS_DEF(name, flags) \
+ PROXY_CLASS_WITH_EXT(name, flags, &js::ProxyClassExtension)
+
+/*
+ * Proxy stubs, similar to JS_*Stub, for embedder proxy class definitions.
+ *
+ * NB: Should not be called directly.
+ */
+
+extern JS_FRIEND_API(bool)
+proxy_LookupProperty(JSContext* cx, JS::HandleObject obj, JS::HandleId id, JS::MutableHandleObject objp,
+ JS::MutableHandle<Shape*> propp);
+extern JS_FRIEND_API(bool)
+proxy_DefineProperty(JSContext* cx, JS::HandleObject obj, JS::HandleId id,
+ JS::Handle<JS::PropertyDescriptor> desc,
+ JS::ObjectOpResult& result);
+extern JS_FRIEND_API(bool)
+proxy_HasProperty(JSContext* cx, JS::HandleObject obj, JS::HandleId id, bool* foundp);
+extern JS_FRIEND_API(bool)
+proxy_GetProperty(JSContext* cx, JS::HandleObject obj, JS::HandleValue receiver, JS::HandleId id,
+ JS::MutableHandleValue vp);
+extern JS_FRIEND_API(bool)
+proxy_SetProperty(JSContext* cx, JS::HandleObject obj, JS::HandleId id, JS::HandleValue bp,
+ JS::HandleValue receiver, JS::ObjectOpResult& result);
+extern JS_FRIEND_API(bool)
+proxy_GetOwnPropertyDescriptor(JSContext* cx, JS::HandleObject obj, JS::HandleId id,
+ JS::MutableHandle<JS::PropertyDescriptor> desc);
+extern JS_FRIEND_API(bool)
+proxy_DeleteProperty(JSContext* cx, JS::HandleObject obj, JS::HandleId id,
+ JS::ObjectOpResult& result);
+
+extern JS_FRIEND_API(void)
+proxy_Trace(JSTracer* trc, JSObject* obj);
+extern JS_FRIEND_API(JSObject*)
+proxy_WeakmapKeyDelegate(JSObject* obj);
+extern JS_FRIEND_API(bool)
+proxy_Convert(JSContext* cx, JS::HandleObject proxy, JSType hint, JS::MutableHandleValue vp);
+extern JS_FRIEND_API(void)
+proxy_Finalize(FreeOp* fop, JSObject* obj);
+extern JS_FRIEND_API(void)
+proxy_ObjectMoved(JSObject* obj, const JSObject* old);
+extern JS_FRIEND_API(bool)
+proxy_HasInstance(JSContext* cx, JS::HandleObject proxy, JS::MutableHandleValue v, bool* bp);
+extern JS_FRIEND_API(bool)
+proxy_Call(JSContext* cx, unsigned argc, JS::Value* vp);
+extern JS_FRIEND_API(bool)
+proxy_Construct(JSContext* cx, unsigned argc, JS::Value* vp);
+extern JS_FRIEND_API(JSObject*)
+proxy_innerObject(JSObject* obj);
+extern JS_FRIEND_API(bool)
+proxy_Watch(JSContext* cx, JS::HandleObject obj, JS::HandleId id, JS::HandleObject callable);
+extern JS_FRIEND_API(bool)
+proxy_Unwatch(JSContext* cx, JS::HandleObject obj, JS::HandleId id);
+extern JS_FRIEND_API(bool)
+proxy_GetElements(JSContext* cx, JS::HandleObject proxy, uint32_t begin, uint32_t end,
+ ElementAdder* adder);
+extern JS_FRIEND_API(JSString*)
+proxy_FunToString(JSContext* cx, JS::HandleObject proxy, unsigned indent);
+
+/**
+ * A class of objects that return source code on demand.
+ *
+ * When code is compiled with setSourceIsLazy(true), SpiderMonkey doesn't
+ * retain the source code (and doesn't do lazy bytecode generation). If we ever
+ * need the source code, say, in response to a call to Function.prototype.
+ * toSource or Debugger.Source.prototype.text, then we call the 'load' member
+ * function of the instance of this class that has hopefully been registered
+ * with the runtime, passing the code's URL, and hope that it will be able to
+ * find the source.
+ */
+class SourceHook {
+ public:
+ virtual ~SourceHook() { }
+
+ /**
+ * Set |*src| and |*length| to refer to the source code for |filename|.
+ * On success, the caller owns the buffer to which |*src| points, and
+ * should use JS_free to free it.
+ */
+ virtual bool load(JSContext* cx, const char* filename, char16_t** src, size_t* length) = 0;
+};
+
+/**
+ * Have |cx| use |hook| to retrieve lazily-retrieved source code. See the
+ * comments for SourceHook. The context takes ownership of the hook, and
+ * will delete it when the context itself is deleted, or when a new hook is
+ * set.
+ */
+extern JS_FRIEND_API(void)
+SetSourceHook(JSContext* cx, mozilla::UniquePtr<SourceHook> hook);
+
+/** Remove |cx|'s source hook, and return it. The caller now owns the hook. */
+extern JS_FRIEND_API(mozilla::UniquePtr<SourceHook>)
+ForgetSourceHook(JSContext* cx);
+
+extern JS_FRIEND_API(JS::Zone*)
+GetCompartmentZone(JSCompartment* comp);
+
+typedef bool
+(* PreserveWrapperCallback)(JSContext* cx, JSObject* obj);
+
+typedef enum {
+ CollectNurseryBeforeDump,
+ IgnoreNurseryObjects
+} DumpHeapNurseryBehaviour;
+
+ /**
+ * Dump the complete object graph of heap-allocated things.
+ * fp is the file for the dump output.
+ */
+extern JS_FRIEND_API(void)
+DumpHeap(JSContext* cx, FILE* fp, DumpHeapNurseryBehaviour nurseryBehaviour);
+
+#ifdef JS_OLD_GETTER_SETTER_METHODS
+JS_FRIEND_API(bool) obj_defineGetter(JSContext* cx, unsigned argc, JS::Value* vp);
+JS_FRIEND_API(bool) obj_defineSetter(JSContext* cx, unsigned argc, JS::Value* vp);
+#endif
+
+extern JS_FRIEND_API(bool)
+IsSystemCompartment(JSCompartment* comp);
+
+extern JS_FRIEND_API(bool)
+IsSystemZone(JS::Zone* zone);
+
+extern JS_FRIEND_API(bool)
+IsAtomsCompartment(JSCompartment* comp);
+
+extern JS_FRIEND_API(bool)
+IsAtomsZone(JS::Zone* zone);
+
+struct WeakMapTracer
+{
+ JSContext* context;
+
+ explicit WeakMapTracer(JSContext* cx) : context(cx) {}
+
+ // Weak map tracer callback, called once for every binding of every
+ // weak map that was live at the time of the last garbage collection.
+ //
+ // m will be nullptr if the weak map is not contained in a JS Object.
+ //
+ // The callback should not GC (and will assert in a debug build if it does so.)
+ virtual void trace(JSObject* m, JS::GCCellPtr key, JS::GCCellPtr value) = 0;
+};
+
+extern JS_FRIEND_API(void)
+TraceWeakMaps(WeakMapTracer* trc);
+
+extern JS_FRIEND_API(bool)
+AreGCGrayBitsValid(JSContext* cx);
+
+extern JS_FRIEND_API(bool)
+ZoneGlobalsAreAllGray(JS::Zone* zone);
+
+typedef void
+(*GCThingCallback)(void* closure, JS::GCCellPtr thing);
+
+extern JS_FRIEND_API(void)
+VisitGrayWrapperTargets(JS::Zone* zone, GCThingCallback callback, void* closure);
+
+extern JS_FRIEND_API(JSObject*)
+GetWeakmapKeyDelegate(JSObject* key);
+
+/**
+ * Invoke cellCallback on every gray JSObject in the given zone.
+ */
+extern JS_FRIEND_API(void)
+IterateGrayObjects(JS::Zone* zone, GCThingCallback cellCallback, void* data);
+
+/**
+ * Invoke cellCallback on every gray JSObject in the given zone while cycle
+ * collection is in progress.
+ */
+extern JS_FRIEND_API(void)
+IterateGrayObjectsUnderCC(JS::Zone* zone, GCThingCallback cellCallback, void* data);
+
+#ifdef JS_HAS_CTYPES
+extern JS_FRIEND_API(size_t)
+SizeOfDataIfCDataObject(mozilla::MallocSizeOf mallocSizeOf, JSObject* obj);
+#endif
+
+extern JS_FRIEND_API(JSCompartment*)
+GetAnyCompartmentInZone(JS::Zone* zone);
+
+/*
+ * Shadow declarations of JS internal structures, for access by inline access
+ * functions below. Do not use these structures in any other way. When adding
+ * new fields for access by inline methods, make sure to add static asserts to
+ * the original header file to ensure that offsets are consistent.
+ */
+namespace shadow {
+
+struct ObjectGroup {
+ const Class* clasp;
+ JSObject* proto;
+ JSCompartment* compartment;
+};
+
+struct BaseShape {
+ const js::Class* clasp_;
+ JSObject* parent;
+};
+
+class Shape {
+public:
+ shadow::BaseShape* base;
+ jsid _1;
+ uint32_t slotInfo;
+
+ static const uint32_t FIXED_SLOTS_SHIFT = 27;
+};
+
+/**
+ * This layout is shared by all native objects. For non-native objects, the
+ * group may always be accessed safely, and other members may be as well,
+ * depending on the object's specific layout.
+ */
+struct Object {
+ shadow::ObjectGroup* group;
+ shadow::Shape* shape;
+ JS::Value* slots;
+ void* _1;
+
+ size_t numFixedSlots() const { return shape->slotInfo >> Shape::FIXED_SLOTS_SHIFT; }
+ JS::Value* fixedSlots() const {
+ return (JS::Value*)(uintptr_t(this) + sizeof(shadow::Object));
+ }
+
+ JS::Value& slotRef(size_t slot) const {
+ size_t nfixed = numFixedSlots();
+ if (slot < nfixed)
+ return fixedSlots()[slot];
+ return slots[slot - nfixed];
+ }
+};
+
+struct Function {
+ Object base;
+ uint16_t nargs;
+ uint16_t flags;
+ /* Used only for natives */
+ JSNative native;
+ const JSJitInfo* jitinfo;
+ void* _1;
+};
+
+struct String
+{
+ static const uint32_t INLINE_CHARS_BIT = JS_BIT(2);
+ static const uint32_t LATIN1_CHARS_BIT = JS_BIT(6);
+ static const uint32_t ROPE_FLAGS = 0;
+ static const uint32_t TYPE_FLAGS_MASK = JS_BIT(6) - 1;
+ uint32_t flags;
+ uint32_t length;
+ union {
+ const JS::Latin1Char* nonInlineCharsLatin1;
+ const char16_t* nonInlineCharsTwoByte;
+ JS::Latin1Char inlineStorageLatin1[1];
+ char16_t inlineStorageTwoByte[1];
+ };
+};
+
+} /* namespace shadow */
+
+// This is equal to |&JSObject::class_|. Use it in places where you don't want
+// to #include jsobj.h.
+extern JS_FRIEND_DATA(const js::Class* const) ObjectClassPtr;
+
+inline const js::Class*
+GetObjectClass(const JSObject* obj)
+{
+ return reinterpret_cast<const shadow::Object*>(obj)->group->clasp;
+}
+
+inline const JSClass*
+GetObjectJSClass(JSObject* obj)
+{
+ return js::Jsvalify(GetObjectClass(obj));
+}
+
+JS_FRIEND_API(const Class*)
+ProtoKeyToClass(JSProtoKey key);
+
+// Returns the key for the class inherited by a given standard class (that
+// is to say, the prototype of this standard class's prototype).
+//
+// You must be sure that this corresponds to a standard class with a cached
+// JSProtoKey before calling this function. In general |key| will match the
+// cached proto key, except in cases where multiple JSProtoKeys share a
+// JSClass.
+inline JSProtoKey
+InheritanceProtoKeyForStandardClass(JSProtoKey key)
+{
+ // [Object] has nothing to inherit from.
+ if (key == JSProto_Object)
+ return JSProto_Null;
+
+ // If we're ClassSpec defined return the proto key from that
+ if (ProtoKeyToClass(key)->specDefined())
+ return ProtoKeyToClass(key)->specInheritanceProtoKey();
+
+ // Otherwise, we inherit [Object].
+ return JSProto_Object;
+}
+
+JS_FRIEND_API(bool)
+IsFunctionObject(JSObject* obj);
+
+static MOZ_ALWAYS_INLINE JSCompartment*
+GetObjectCompartment(JSObject* obj)
+{
+ return reinterpret_cast<shadow::Object*>(obj)->group->compartment;
+}
+
+JS_FRIEND_API(JSObject*)
+GetGlobalForObjectCrossCompartment(JSObject* obj);
+
+JS_FRIEND_API(JSObject*)
+GetPrototypeNoProxy(JSObject* obj);
+
+JS_FRIEND_API(void)
+AssertSameCompartment(JSContext* cx, JSObject* obj);
+
+#ifdef JS_DEBUG
+JS_FRIEND_API(void)
+AssertSameCompartment(JSObject* objA, JSObject* objB);
+#else
+inline void AssertSameCompartment(JSObject* objA, JSObject* objB) {}
+#endif
+
+JS_FRIEND_API(void)
+NotifyAnimationActivity(JSObject* obj);
+
+/**
+ * Return the outermost enclosing function (script) of the scripted caller.
+ * This function returns nullptr in several cases:
+ * - no script is running on the context
+ * - the caller is in global or eval code
+ * In particular, this function will "stop" its outermost search at eval() and
+ * thus it will really return the outermost enclosing function *since the
+ * innermost eval*.
+ */
+JS_FRIEND_API(JSFunction*)
+GetOutermostEnclosingFunctionOfScriptedCaller(JSContext* cx);
+
+JS_FRIEND_API(JSFunction*)
+DefineFunctionWithReserved(JSContext* cx, JSObject* obj, const char* name, JSNative call,
+ unsigned nargs, unsigned attrs);
+
+JS_FRIEND_API(JSFunction*)
+NewFunctionWithReserved(JSContext* cx, JSNative call, unsigned nargs, unsigned flags,
+ const char* name);
+
+JS_FRIEND_API(JSFunction*)
+NewFunctionByIdWithReserved(JSContext* cx, JSNative native, unsigned nargs, unsigned flags,
+ jsid id);
+
+JS_FRIEND_API(const JS::Value&)
+GetFunctionNativeReserved(JSObject* fun, size_t which);
+
+JS_FRIEND_API(void)
+SetFunctionNativeReserved(JSObject* fun, size_t which, const JS::Value& val);
+
+JS_FRIEND_API(bool)
+FunctionHasNativeReserved(JSObject* fun);
+
+JS_FRIEND_API(bool)
+GetObjectProto(JSContext* cx, JS::HandleObject obj, JS::MutableHandleObject proto);
+
+extern JS_FRIEND_API(JSObject*)
+GetStaticPrototype(JSObject* obj);
+
+JS_FRIEND_API(bool)
+GetOriginalEval(JSContext* cx, JS::HandleObject scope,
+ JS::MutableHandleObject eval);
+
+inline void*
+GetObjectPrivate(JSObject* obj)
+{
+ MOZ_ASSERT(GetObjectClass(obj)->flags & JSCLASS_HAS_PRIVATE);
+ const shadow::Object* nobj = reinterpret_cast<const shadow::Object*>(obj);
+ void** addr = reinterpret_cast<void**>(&nobj->fixedSlots()[nobj->numFixedSlots()]);
+ return *addr;
+}
+
+inline const JS::Value&
+GetReservedSlot(JSObject* obj, size_t slot)
+{
+ MOZ_ASSERT(slot < JSCLASS_RESERVED_SLOTS(GetObjectClass(obj)));
+ return reinterpret_cast<const shadow::Object*>(obj)->slotRef(slot);
+}
+
+JS_FRIEND_API(void)
+SetReservedOrProxyPrivateSlotWithBarrier(JSObject* obj, size_t slot, const JS::Value& value);
+
+inline void
+SetReservedSlot(JSObject* obj, size_t slot, const JS::Value& value)
+{
+ MOZ_ASSERT(slot < JSCLASS_RESERVED_SLOTS(GetObjectClass(obj)));
+ shadow::Object* sobj = reinterpret_cast<shadow::Object*>(obj);
+ if (sobj->slotRef(slot).isMarkable() || value.isMarkable())
+ SetReservedOrProxyPrivateSlotWithBarrier(obj, slot, value);
+ else
+ sobj->slotRef(slot) = value;
+}
+
+JS_FRIEND_API(uint32_t)
+GetObjectSlotSpan(JSObject* obj);
+
+inline const JS::Value&
+GetObjectSlot(JSObject* obj, size_t slot)
+{
+ MOZ_ASSERT(slot < GetObjectSlotSpan(obj));
+ return reinterpret_cast<const shadow::Object*>(obj)->slotRef(slot);
+}
+
+MOZ_ALWAYS_INLINE size_t
+GetAtomLength(JSAtom* atom)
+{
+ return reinterpret_cast<shadow::String*>(atom)->length;
+}
+
+static const uint32_t MaxStringLength = (1 << 28) - 1;
+
+MOZ_ALWAYS_INLINE size_t
+GetStringLength(JSString* s)
+{
+ return reinterpret_cast<shadow::String*>(s)->length;
+}
+
+MOZ_ALWAYS_INLINE size_t
+GetFlatStringLength(JSFlatString* s)
+{
+ return reinterpret_cast<shadow::String*>(s)->length;
+}
+
+MOZ_ALWAYS_INLINE size_t
+GetLinearStringLength(JSLinearString* s)
+{
+ return reinterpret_cast<shadow::String*>(s)->length;
+}
+
+MOZ_ALWAYS_INLINE bool
+LinearStringHasLatin1Chars(JSLinearString* s)
+{
+ return reinterpret_cast<shadow::String*>(s)->flags & shadow::String::LATIN1_CHARS_BIT;
+}
+
+MOZ_ALWAYS_INLINE bool
+AtomHasLatin1Chars(JSAtom* atom)
+{
+ return reinterpret_cast<shadow::String*>(atom)->flags & shadow::String::LATIN1_CHARS_BIT;
+}
+
+MOZ_ALWAYS_INLINE bool
+StringHasLatin1Chars(JSString* s)
+{
+ return reinterpret_cast<shadow::String*>(s)->flags & shadow::String::LATIN1_CHARS_BIT;
+}
+
+MOZ_ALWAYS_INLINE const JS::Latin1Char*
+GetLatin1LinearStringChars(const JS::AutoCheckCannotGC& nogc, JSLinearString* linear)
+{
+ MOZ_ASSERT(LinearStringHasLatin1Chars(linear));
+
+ using shadow::String;
+ String* s = reinterpret_cast<String*>(linear);
+ if (s->flags & String::INLINE_CHARS_BIT)
+ return s->inlineStorageLatin1;
+ return s->nonInlineCharsLatin1;
+}
+
+MOZ_ALWAYS_INLINE const char16_t*
+GetTwoByteLinearStringChars(const JS::AutoCheckCannotGC& nogc, JSLinearString* linear)
+{
+ MOZ_ASSERT(!LinearStringHasLatin1Chars(linear));
+
+ using shadow::String;
+ String* s = reinterpret_cast<String*>(linear);
+ if (s->flags & String::INLINE_CHARS_BIT)
+ return s->inlineStorageTwoByte;
+ return s->nonInlineCharsTwoByte;
+}
+
+MOZ_ALWAYS_INLINE JSLinearString*
+AtomToLinearString(JSAtom* atom)
+{
+ return reinterpret_cast<JSLinearString*>(atom);
+}
+
+MOZ_ALWAYS_INLINE JSFlatString*
+AtomToFlatString(JSAtom* atom)
+{
+ return reinterpret_cast<JSFlatString*>(atom);
+}
+
+MOZ_ALWAYS_INLINE JSLinearString*
+FlatStringToLinearString(JSFlatString* s)
+{
+ return reinterpret_cast<JSLinearString*>(s);
+}
+
+MOZ_ALWAYS_INLINE const JS::Latin1Char*
+GetLatin1AtomChars(const JS::AutoCheckCannotGC& nogc, JSAtom* atom)
+{
+ return GetLatin1LinearStringChars(nogc, AtomToLinearString(atom));
+}
+
+MOZ_ALWAYS_INLINE const char16_t*
+GetTwoByteAtomChars(const JS::AutoCheckCannotGC& nogc, JSAtom* atom)
+{
+ return GetTwoByteLinearStringChars(nogc, AtomToLinearString(atom));
+}
+
+JS_FRIEND_API(JSLinearString*)
+StringToLinearStringSlow(JSContext* cx, JSString* str);
+
+MOZ_ALWAYS_INLINE JSLinearString*
+StringToLinearString(JSContext* cx, JSString* str)
+{
+ using shadow::String;
+ String* s = reinterpret_cast<String*>(str);
+ if (MOZ_UNLIKELY((s->flags & String::TYPE_FLAGS_MASK) == String::ROPE_FLAGS))
+ return StringToLinearStringSlow(cx, str);
+ return reinterpret_cast<JSLinearString*>(str);
+}
+
+template<typename CharType>
+MOZ_ALWAYS_INLINE void
+CopyLinearStringChars(CharType* dest, JSLinearString* s, size_t len, size_t start = 0);
+
+MOZ_ALWAYS_INLINE void
+CopyLinearStringChars(char16_t* dest, JSLinearString* s, size_t len, size_t start = 0)
+{
+ MOZ_ASSERT(start + len <= GetLinearStringLength(s));
+ JS::AutoCheckCannotGC nogc;
+ if (LinearStringHasLatin1Chars(s)) {
+ const JS::Latin1Char* src = GetLatin1LinearStringChars(nogc, s);
+ for (size_t i = 0; i < len; i++)
+ dest[i] = src[start + i];
+ } else {
+ const char16_t* src = GetTwoByteLinearStringChars(nogc, s);
+ mozilla::PodCopy(dest, src + start, len);
+ }
+}
+
+MOZ_ALWAYS_INLINE void
+CopyLinearStringChars(char* dest, JSLinearString* s, size_t len, size_t start = 0)
+{
+ MOZ_ASSERT(start + len <= GetLinearStringLength(s));
+ JS::AutoCheckCannotGC nogc;
+ if (LinearStringHasLatin1Chars(s)) {
+ const JS::Latin1Char* src = GetLatin1LinearStringChars(nogc, s);
+ for (size_t i = 0; i < len; i++)
+ dest[i] = char(src[start + i]);
+ } else {
+ const char16_t* src = GetTwoByteLinearStringChars(nogc, s);
+ for (size_t i = 0; i < len; i++)
+ dest[i] = char(src[start + i]);
+ }
+}
+
+template<typename CharType>
+inline bool
+CopyStringChars(JSContext* cx, CharType* dest, JSString* s, size_t len, size_t start = 0)
+{
+ JSLinearString* linear = StringToLinearString(cx, s);
+ if (!linear)
+ return false;
+
+ CopyLinearStringChars(dest, linear, len, start);
+ return true;
+}
+
+inline void
+CopyFlatStringChars(char16_t* dest, JSFlatString* s, size_t len)
+{
+ CopyLinearStringChars(dest, FlatStringToLinearString(s), len);
+}
+
+/**
+ * Add some or all property keys of obj to the id vector *props.
+ *
+ * The flags parameter controls which property keys are added. Pass a
+ * combination of the following bits:
+ *
+ * JSITER_OWNONLY - Don't also search the prototype chain; only consider
+ * obj's own properties.
+ *
+ * JSITER_HIDDEN - Include nonenumerable properties.
+ *
+ * JSITER_SYMBOLS - Include property keys that are symbols. The default
+ * behavior is to filter out symbols.
+ *
+ * JSITER_SYMBOLSONLY - Exclude non-symbol property keys.
+ *
+ * This is the closest C++ API we have to `Reflect.ownKeys(obj)`, or
+ * equivalently, the ES6 [[OwnPropertyKeys]] internal method. Pass
+ * `JSITER_OWNONLY | JSITER_HIDDEN | JSITER_SYMBOLS` as flags to get
+ * results that match the output of Reflect.ownKeys.
+ */
+JS_FRIEND_API(bool)
+GetPropertyKeys(JSContext* cx, JS::HandleObject obj, unsigned flags, JS::AutoIdVector* props);
+
+JS_FRIEND_API(bool)
+AppendUnique(JSContext* cx, JS::AutoIdVector& base, JS::AutoIdVector& others);
+
+JS_FRIEND_API(bool)
+StringIsArrayIndex(JSLinearString* str, uint32_t* indexp);
+
+JS_FRIEND_API(void)
+SetPreserveWrapperCallback(JSContext* cx, PreserveWrapperCallback callback);
+
+JS_FRIEND_API(bool)
+IsObjectInContextCompartment(JSObject* obj, const JSContext* cx);
+
+/*
+ * NB: keep these in sync with the copy in builtin/SelfHostingDefines.h.
+ * The first three are omitted because they shouldn't be used in new code.
+ */
+#define JSITER_ENUMERATE 0x1 /* for-in compatible hidden default iterator */
+#define JSITER_FOREACH 0x2 /* get obj[key] for each property */
+#define JSITER_KEYVALUE 0x4 /* obsolete destructuring for-in wants [key, value] */
+#define JSITER_OWNONLY 0x8 /* iterate over obj's own properties only */
+#define JSITER_HIDDEN 0x10 /* also enumerate non-enumerable properties */
+#define JSITER_SYMBOLS 0x20 /* also include symbol property keys */
+#define JSITER_SYMBOLSONLY 0x40 /* exclude string property keys */
+
+JS_FRIEND_API(bool)
+RunningWithTrustedPrincipals(JSContext* cx);
+
+inline uintptr_t
+GetNativeStackLimit(JSContext* cx, StackKind kind, int extraAllowance = 0)
+{
+ uintptr_t limit = ContextFriendFields::get(cx)->nativeStackLimit[kind];
+#if JS_STACK_GROWTH_DIRECTION > 0
+ limit += extraAllowance;
+#else
+ limit -= extraAllowance;
+#endif
+ return limit;
+}
+
+inline uintptr_t
+GetNativeStackLimit(JSContext* cx, int extraAllowance = 0)
+{
+ StackKind kind = RunningWithTrustedPrincipals(cx) ? StackForTrustedScript
+ : StackForUntrustedScript;
+ return GetNativeStackLimit(cx, kind, extraAllowance);
+}
+
+/*
+ * These macros report a stack overflow and run |onerror| if we are close to
+ * using up the C stack. The JS_CHECK_CHROME_RECURSION variant gives us a
+ * little extra space so that we can ensure that crucial code is able to run.
+ * JS_CHECK_RECURSION_CONSERVATIVE allows less space than any other check,
+ * including a safety buffer (as in, it uses the untrusted limit and subtracts
+ * a little more from it).
+ */
+
+#define JS_CHECK_RECURSION_LIMIT(cx, limit, onerror) \
+ JS_BEGIN_MACRO \
+ int stackDummy_; \
+ if (!JS_CHECK_STACK_SIZE(limit, &stackDummy_)) { \
+ js::ReportOverRecursed(cx); \
+ onerror; \
+ } \
+ JS_END_MACRO
+
+#define JS_CHECK_RECURSION(cx, onerror) \
+ JS_CHECK_RECURSION_LIMIT(cx, js::GetNativeStackLimit(cx), onerror)
+
+#define JS_CHECK_RECURSION_LIMIT_DONT_REPORT(cx, limit, onerror) \
+ JS_BEGIN_MACRO \
+ int stackDummy_; \
+ if (!JS_CHECK_STACK_SIZE(limit, &stackDummy_)) { \
+ onerror; \
+ } \
+ JS_END_MACRO
+
+#define JS_CHECK_RECURSION_DONT_REPORT(cx, onerror) \
+ JS_CHECK_RECURSION_LIMIT_DONT_REPORT(cx, js::GetNativeStackLimit(cx), onerror)
+
+#define JS_CHECK_RECURSION_WITH_SP_DONT_REPORT(cx, sp, onerror) \
+ JS_BEGIN_MACRO \
+ if (!JS_CHECK_STACK_SIZE(js::GetNativeStackLimit(cx), sp)) { \
+ onerror; \
+ } \
+ JS_END_MACRO
+
+#define JS_CHECK_RECURSION_WITH_SP(cx, sp, onerror) \
+ JS_BEGIN_MACRO \
+ if (!JS_CHECK_STACK_SIZE(js::GetNativeStackLimit(cx), sp)) { \
+ js::ReportOverRecursed(cx); \
+ onerror; \
+ } \
+ JS_END_MACRO
+
+#define JS_CHECK_SYSTEM_RECURSION(cx, onerror) \
+ JS_CHECK_RECURSION_LIMIT(cx, js::GetNativeStackLimit(cx, js::StackForSystemCode), onerror)
+
+#define JS_CHECK_RECURSION_CONSERVATIVE(cx, onerror) \
+ JS_CHECK_RECURSION_LIMIT(cx, \
+ js::GetNativeStackLimit(cx, js::StackForUntrustedScript, -1024 * int(sizeof(size_t))), \
+ onerror)
+
+#define JS_CHECK_RECURSION_CONSERVATIVE_DONT_REPORT(cx, onerror) \
+ JS_CHECK_RECURSION_LIMIT_DONT_REPORT(cx, \
+ js::GetNativeStackLimit(cx, js::StackForUntrustedScript, -1024 * int(sizeof(size_t))), \
+ onerror)
+
+JS_FRIEND_API(void)
+StartPCCountProfiling(JSContext* cx);
+
+JS_FRIEND_API(void)
+StopPCCountProfiling(JSContext* cx);
+
+JS_FRIEND_API(void)
+PurgePCCounts(JSContext* cx);
+
+JS_FRIEND_API(size_t)
+GetPCCountScriptCount(JSContext* cx);
+
+JS_FRIEND_API(JSString*)
+GetPCCountScriptSummary(JSContext* cx, size_t script);
+
+JS_FRIEND_API(JSString*)
+GetPCCountScriptContents(JSContext* cx, size_t script);
+
+/**
+ * Generate lcov trace file content for the current compartment, and allocate a
+ * new buffer and return the content in it, the size of the newly allocated
+ * content within the buffer would be set to the length out-param.
+ *
+ * In case of out-of-memory, this function returns nullptr and does not set any
+ * value to the length out-param.
+ */
+JS_FRIEND_API(char*)
+GetCodeCoverageSummary(JSContext* cx, size_t* length);
+
+typedef void
+(* ActivityCallback)(void* arg, bool active);
+
+/**
+ * Sets a callback that is run whenever the runtime goes idle - the
+ * last active request ceases - and begins activity - when it was
+ * idle and a request begins.
+ */
+JS_FRIEND_API(void)
+SetActivityCallback(JSContext* cx, ActivityCallback cb, void* arg);
+
+typedef bool
+(* DOMInstanceClassHasProtoAtDepth)(const Class* instanceClass,
+ uint32_t protoID, uint32_t depth);
+struct JSDOMCallbacks {
+ DOMInstanceClassHasProtoAtDepth instanceClassMatchesProto;
+};
+typedef struct JSDOMCallbacks DOMCallbacks;
+
+extern JS_FRIEND_API(void)
+SetDOMCallbacks(JSContext* cx, const DOMCallbacks* callbacks);
+
+extern JS_FRIEND_API(const DOMCallbacks*)
+GetDOMCallbacks(JSContext* cx);
+
+extern JS_FRIEND_API(JSObject*)
+GetTestingFunctions(JSContext* cx);
+
+/**
+ * Helper to convert FreeOp to JSFreeOp when the definition of FreeOp is not
+ * available and the compiler does not know that FreeOp inherits from
+ * JSFreeOp.
+ */
+inline JSFreeOp*
+CastToJSFreeOp(FreeOp* fop)
+{
+ return reinterpret_cast<JSFreeOp*>(fop);
+}
+
+/* Implemented in jsexn.cpp. */
+
+/**
+ * Get an error type name from a JSExnType constant.
+ * Returns nullptr for invalid arguments and JSEXN_INTERNALERR
+ */
+extern JS_FRIEND_API(JSFlatString*)
+GetErrorTypeName(JSContext* cx, int16_t exnType);
+
+#ifdef JS_DEBUG
+extern JS_FRIEND_API(unsigned)
+GetEnterCompartmentDepth(JSContext* cx);
+#endif
+
+class RegExpGuard;
+extern JS_FRIEND_API(bool)
+RegExpToSharedNonInline(JSContext* cx, JS::HandleObject regexp, RegExpGuard* shared);
+
+/* Implemented in jswrapper.cpp. */
+typedef enum NukeReferencesToWindow {
+ NukeWindowReferences,
+ DontNukeWindowReferences
+} NukeReferencesToWindow;
+
+/*
+ * These filters are designed to be ephemeral stack classes, and thus don't
+ * do any rooting or holding of their members.
+ */
+struct CompartmentFilter {
+ virtual bool match(JSCompartment* c) const = 0;
+};
+
+struct AllCompartments : public CompartmentFilter {
+ virtual bool match(JSCompartment* c) const override { return true; }
+};
+
+struct ContentCompartmentsOnly : public CompartmentFilter {
+ virtual bool match(JSCompartment* c) const override {
+ return !IsSystemCompartment(c);
+ }
+};
+
+struct ChromeCompartmentsOnly : public CompartmentFilter {
+ virtual bool match(JSCompartment* c) const override {
+ return IsSystemCompartment(c);
+ }
+};
+
+struct SingleCompartment : public CompartmentFilter {
+ JSCompartment* ours;
+ explicit SingleCompartment(JSCompartment* c) : ours(c) {}
+ virtual bool match(JSCompartment* c) const override { return c == ours; }
+};
+
+struct CompartmentsWithPrincipals : public CompartmentFilter {
+ JSPrincipals* principals;
+ explicit CompartmentsWithPrincipals(JSPrincipals* p) : principals(p) {}
+ virtual bool match(JSCompartment* c) const override {
+ return JS_GetCompartmentPrincipals(c) == principals;
+ }
+};
+
+extern JS_FRIEND_API(bool)
+NukeCrossCompartmentWrappers(JSContext* cx,
+ const CompartmentFilter& sourceFilter,
+ const CompartmentFilter& targetFilter,
+ NukeReferencesToWindow nukeReferencesToWindow);
+
+/* Specify information about DOMProxy proxies in the DOM, for use by ICs. */
+
+/*
+ * The DOMProxyShadowsCheck function will be called to check if the property for
+ * id should be gotten from the prototype, or if there is an own property that
+ * shadows it.
+ * * If ShadowsViaDirectExpando is returned, then the slot at
+ * listBaseExpandoSlot contains an expando object which has the property in
+ * question.
+ * * If ShadowsViaIndirectExpando is returned, then the slot at
+ * listBaseExpandoSlot contains a private pointer to an ExpandoAndGeneration
+ * and the expando object in the ExpandoAndGeneration has the property in
+ * question.
+ * * If DoesntShadow is returned then the slot at listBaseExpandoSlot should
+ * either be undefined or point to an expando object that would contain the
+ * own property.
+ * * If DoesntShadowUnique is returned then the slot at listBaseExpandoSlot
+ * should contain a private pointer to a ExpandoAndGeneration, which contains
+ * a JS::Value that should either be undefined or point to an expando object,
+ * and a uint64 value. If that value changes then the IC for getting a
+ * property will be invalidated.
+ * * If Shadows is returned, that means the property is an own property of the
+ * proxy but doesn't live on the expando object.
+ */
+
+struct ExpandoAndGeneration {
+ ExpandoAndGeneration()
+ : expando(JS::UndefinedValue()),
+ generation(0)
+ {}
+
+ void OwnerUnlinked()
+ {
+ ++generation;
+ }
+
+ static size_t offsetOfExpando()
+ {
+ return offsetof(ExpandoAndGeneration, expando);
+ }
+
+ static size_t offsetOfGeneration()
+ {
+ return offsetof(ExpandoAndGeneration, generation);
+ }
+
+ JS::Heap<JS::Value> expando;
+ uint64_t generation;
+};
+
+typedef enum DOMProxyShadowsResult {
+ ShadowCheckFailed,
+ Shadows,
+ DoesntShadow,
+ DoesntShadowUnique,
+ ShadowsViaDirectExpando,
+ ShadowsViaIndirectExpando
+} DOMProxyShadowsResult;
+typedef DOMProxyShadowsResult
+(* DOMProxyShadowsCheck)(JSContext* cx, JS::HandleObject object, JS::HandleId id);
+JS_FRIEND_API(void)
+SetDOMProxyInformation(const void* domProxyHandlerFamily, uint32_t domProxyExpandoSlot,
+ DOMProxyShadowsCheck domProxyShadowsCheck);
+
+const void* GetDOMProxyHandlerFamily();
+uint32_t GetDOMProxyExpandoSlot();
+DOMProxyShadowsCheck GetDOMProxyShadowsCheck();
+inline bool DOMProxyIsShadowing(DOMProxyShadowsResult result) {
+ return result == Shadows ||
+ result == ShadowsViaDirectExpando ||
+ result == ShadowsViaIndirectExpando;
+}
+
+/* Implemented in jsdate.cpp. */
+
+/** Detect whether the internal date value is NaN. */
+extern JS_FRIEND_API(bool)
+DateIsValid(JSContext* cx, JS::HandleObject obj, bool* isValid);
+
+extern JS_FRIEND_API(bool)
+DateGetMsecSinceEpoch(JSContext* cx, JS::HandleObject obj, double* msecSinceEpoch);
+
+} /* namespace js */
+
+/* Implemented in jscntxt.cpp. */
+
+/**
+ * Report an exception, which is currently realized as a printf-style format
+ * string and its arguments.
+ */
+typedef enum JSErrNum {
+#define MSG_DEF(name, count, exception, format) \
+ name,
+#include "js.msg"
+#undef MSG_DEF
+ JSErr_Limit
+} JSErrNum;
+
+namespace js {
+
+extern JS_FRIEND_API(const JSErrorFormatString*)
+GetErrorMessage(void* userRef, const unsigned errorNumber);
+
+// AutoStableStringChars is here so we can use it in ErrorReport. It
+// should get moved out of here if we can manage it. See bug 1040316.
+
+/**
+ * This class provides safe access to a string's chars across a GC. Once
+ * we allocate strings and chars in the nursery (bug 903519), this class
+ * will have to make a copy of the string's chars if they are allocated
+ * in the nursery, so it's best to avoid using this class unless you really
+ * need it. It's usually more efficient to use the latin1Chars/twoByteChars
+ * JSString methods and often the code can be rewritten so that only indexes
+ * instead of char pointers are used in parts of the code that can GC.
+ */
+class MOZ_STACK_CLASS JS_FRIEND_API(AutoStableStringChars)
+{
+ /*
+ * When copying string char, use this many bytes of inline storage. This is
+ * chosen to allow the inline string types to be copied without allocating.
+ * This is asserted in AutoStableStringChars::allocOwnChars.
+ */
+ static const size_t InlineCapacity = 24;
+
+ /* Ensure the string is kept alive while we're using its chars. */
+ JS::RootedString s_;
+ union {
+ const char16_t* twoByteChars_;
+ const JS::Latin1Char* latin1Chars_;
+ };
+ mozilla::Maybe<Vector<uint8_t, InlineCapacity>> ownChars_;
+ enum State { Uninitialized, Latin1, TwoByte };
+ State state_;
+
+ public:
+ explicit AutoStableStringChars(JSContext* cx)
+ : s_(cx), state_(Uninitialized)
+ {}
+
+ MOZ_MUST_USE
+ bool init(JSContext* cx, JSString* s);
+
+ /* Like init(), but Latin1 chars are inflated to TwoByte. */
+ MOZ_MUST_USE
+ bool initTwoByte(JSContext* cx, JSString* s);
+
+ bool isLatin1() const { return state_ == Latin1; }
+ bool isTwoByte() const { return state_ == TwoByte; }
+
+ const char16_t* twoByteChars() const {
+ MOZ_ASSERT(state_ == TwoByte);
+ return twoByteChars_;
+ }
+
+ mozilla::Range<const JS::Latin1Char> latin1Range() const {
+ MOZ_ASSERT(state_ == Latin1);
+ return mozilla::Range<const JS::Latin1Char>(latin1Chars_,
+ GetStringLength(s_));
+ }
+
+ mozilla::Range<const char16_t> twoByteRange() const {
+ MOZ_ASSERT(state_ == TwoByte);
+ return mozilla::Range<const char16_t>(twoByteChars_,
+ GetStringLength(s_));
+ }
+
+ /* If we own the chars, transfer ownership to the caller. */
+ bool maybeGiveOwnershipToCaller() {
+ MOZ_ASSERT(state_ != Uninitialized);
+ if (!ownChars_.isSome() || !ownChars_->extractRawBuffer())
+ return false;
+ state_ = Uninitialized;
+ ownChars_.reset();
+ return true;
+ }
+
+ private:
+ AutoStableStringChars(const AutoStableStringChars& other) = delete;
+ void operator=(const AutoStableStringChars& other) = delete;
+
+ bool baseIsInline(JS::Handle<JSLinearString*> linearString);
+ template <typename T> T* allocOwnChars(JSContext* cx, size_t count);
+ bool copyLatin1Chars(JSContext* cx, JS::Handle<JSLinearString*> linearString);
+ bool copyTwoByteChars(JSContext* cx, JS::Handle<JSLinearString*> linearString);
+ bool copyAndInflateLatin1Chars(JSContext*, JS::Handle<JSLinearString*> linearString);
+};
+
+struct MOZ_STACK_CLASS JS_FRIEND_API(ErrorReport)
+{
+ explicit ErrorReport(JSContext* cx);
+ ~ErrorReport();
+
+ enum SniffingBehavior {
+ WithSideEffects,
+ NoSideEffects
+ };
+
+ /**
+ * Generate a JSErrorReport from the provided thrown value.
+ *
+ * If the value is a (possibly wrapped) Error object, the JSErrorReport will
+ * be exactly initialized from the Error object's information, without
+ * observable side effects. (The Error object's JSErrorReport is reused, if
+ * it has one.)
+ *
+ * Otherwise various attempts are made to derive JSErrorReport information
+ * from |exn| and from the current execution state. This process is
+ * *definitely* inconsistent with any standard, and particulars of the
+ * behavior implemented here generally shouldn't be relied upon.
+ *
+ * If the value of |sniffingBehavior| is |WithSideEffects|, some of these
+ * attempts *may* invoke user-configurable behavior when |exn| is an object:
+ * converting |exn| to a string, detecting and getting properties on |exn|,
+ * accessing |exn|'s prototype chain, and others are possible. Users *must*
+ * tolerate |ErrorReport::init| potentially having arbitrary effects. Any
+ * exceptions thrown by these operations will be caught and silently
+ * ignored, and "default" values will be substituted into the JSErrorReport.
+ *
+ * But if the value of |sniffingBehavior| is |NoSideEffects|, these attempts
+ * *will not* invoke any observable side effects. The JSErrorReport will
+ * simply contain fewer, less precise details.
+ *
+ * Unlike some functions involved in error handling, this function adheres
+ * to the usual JSAPI return value error behavior.
+ */
+ bool init(JSContext* cx, JS::HandleValue exn,
+ SniffingBehavior sniffingBehavior);
+
+ JSErrorReport* report()
+ {
+ return reportp;
+ }
+
+ const JS::ConstUTF8CharsZ toStringResult()
+ {
+ return toStringResult_;
+ }
+
+ private:
+ // More or less an equivalent of JS_ReportErrorNumber/js::ReportErrorNumberVA
+ // but fills in an ErrorReport instead of reporting it. Uses varargs to
+ // make it simpler to call js::ExpandErrorArgumentsVA.
+ //
+ // Returns false if we fail to actually populate the ErrorReport
+ // for some reason (probably out of memory).
+ bool populateUncaughtExceptionReportUTF8(JSContext* cx, ...);
+ bool populateUncaughtExceptionReportUTF8VA(JSContext* cx, va_list ap);
+
+ // Reports exceptions from add-on scopes to telementry.
+ void ReportAddonExceptionToTelementry(JSContext* cx);
+
+ // We may have a provided JSErrorReport, so need a way to represent that.
+ JSErrorReport* reportp;
+
+ // Or we may need to synthesize a JSErrorReport one of our own.
+ JSErrorReport ownedReport;
+
+ // And we have a string to maybe keep alive that has pointers into
+ // it from ownedReport.
+ JS::RootedString str;
+
+ // And keep its chars alive too.
+ AutoStableStringChars strChars;
+
+ // And we need to root our exception value.
+ JS::RootedObject exnObject;
+
+ // And for our filename.
+ JSAutoByteString filename;
+
+ // We may have a result of error.toString().
+ // FIXME: We should not call error.toString(), since it could have side
+ // effect (see bug 633623).
+ JS::ConstUTF8CharsZ toStringResult_;
+ JSAutoByteString toStringResultBytesStorage;
+};
+
+/* Implemented in vm/StructuredClone.cpp. */
+extern JS_FRIEND_API(uint64_t)
+GetSCOffset(JSStructuredCloneWriter* writer);
+
+namespace Scalar {
+
+/**
+ * Scalar types that can appear in typed arrays and typed objects. The enum
+ * values must to be kept in sync with the JS_SCALARTYPEREPR_ constants, as
+ * well as the TypedArrayObject::classes and TypedArrayObject::protoClasses
+ * definitions.
+ */
+enum Type {
+ Int8 = 0,
+ Uint8,
+ Int16,
+ Uint16,
+ Int32,
+ Uint32,
+ Float32,
+ Float64,
+
+ /**
+ * Special type that is a uint8_t, but assignments are clamped to [0, 256).
+ * Treat the raw data type as a uint8_t.
+ */
+ Uint8Clamped,
+
+ /**
+ * Types that don't have their own TypedArray equivalent, for now.
+ */
+ MaxTypedArrayViewType,
+
+ Int64,
+ Float32x4,
+ Int8x16,
+ Int16x8,
+ Int32x4
+};
+
+static inline size_t
+byteSize(Type atype)
+{
+ switch (atype) {
+ case Int8:
+ case Uint8:
+ case Uint8Clamped:
+ return 1;
+ case Int16:
+ case Uint16:
+ return 2;
+ case Int32:
+ case Uint32:
+ case Float32:
+ return 4;
+ case Int64:
+ case Float64:
+ return 8;
+ case Int8x16:
+ case Int16x8:
+ case Int32x4:
+ case Float32x4:
+ return 16;
+ default:
+ MOZ_CRASH("invalid scalar type");
+ }
+}
+
+static inline bool
+isSignedIntType(Type atype) {
+ switch (atype) {
+ case Int8:
+ case Int16:
+ case Int32:
+ case Int64:
+ case Int8x16:
+ case Int16x8:
+ case Int32x4:
+ return true;
+ case Uint8:
+ case Uint8Clamped:
+ case Uint16:
+ case Uint32:
+ case Float32:
+ case Float64:
+ case Float32x4:
+ return false;
+ default:
+ MOZ_CRASH("invalid scalar type");
+ }
+}
+
+static inline bool
+isSimdType(Type atype) {
+ switch (atype) {
+ case Int8:
+ case Uint8:
+ case Uint8Clamped:
+ case Int16:
+ case Uint16:
+ case Int32:
+ case Uint32:
+ case Int64:
+ case Float32:
+ case Float64:
+ return false;
+ case Int8x16:
+ case Int16x8:
+ case Int32x4:
+ case Float32x4:
+ return true;
+ case MaxTypedArrayViewType:
+ break;
+ }
+ MOZ_CRASH("invalid scalar type");
+}
+
+static inline size_t
+scalarByteSize(Type atype) {
+ switch (atype) {
+ case Int8x16:
+ return 1;
+ case Int16x8:
+ return 2;
+ case Int32x4:
+ case Float32x4:
+ return 4;
+ case Int8:
+ case Uint8:
+ case Uint8Clamped:
+ case Int16:
+ case Uint16:
+ case Int32:
+ case Uint32:
+ case Int64:
+ case Float32:
+ case Float64:
+ case MaxTypedArrayViewType:
+ break;
+ }
+ MOZ_CRASH("invalid simd type");
+}
+
+} /* namespace Scalar */
+} /* namespace js */
+
+/*
+ * Create a new typed array with nelements elements.
+ *
+ * These functions (except the WithBuffer variants) fill in the array with zeros.
+ */
+
+extern JS_FRIEND_API(JSObject*)
+JS_NewInt8Array(JSContext* cx, uint32_t nelements);
+extern JS_FRIEND_API(JSObject*)
+JS_NewUint8Array(JSContext* cx, uint32_t nelements);
+extern JS_FRIEND_API(JSObject*)
+JS_NewUint8ClampedArray(JSContext* cx, uint32_t nelements);
+extern JS_FRIEND_API(JSObject*)
+JS_NewInt16Array(JSContext* cx, uint32_t nelements);
+extern JS_FRIEND_API(JSObject*)
+JS_NewUint16Array(JSContext* cx, uint32_t nelements);
+extern JS_FRIEND_API(JSObject*)
+JS_NewInt32Array(JSContext* cx, uint32_t nelements);
+extern JS_FRIEND_API(JSObject*)
+JS_NewUint32Array(JSContext* cx, uint32_t nelements);
+extern JS_FRIEND_API(JSObject*)
+JS_NewFloat32Array(JSContext* cx, uint32_t nelements);
+extern JS_FRIEND_API(JSObject*)
+JS_NewFloat64Array(JSContext* cx, uint32_t nelements);
+
+/*
+ * Create a new typed array and copy in values from the given object. The
+ * object is used as if it were an array; that is, the new array (if
+ * successfully created) will have length given by array.length, and its
+ * elements will be those specified by array[0], array[1], and so on, after
+ * conversion to the typed array element type.
+ */
+
+extern JS_FRIEND_API(JSObject*)
+JS_NewInt8ArrayFromArray(JSContext* cx, JS::HandleObject array);
+extern JS_FRIEND_API(JSObject*)
+JS_NewUint8ArrayFromArray(JSContext* cx, JS::HandleObject array);
+extern JS_FRIEND_API(JSObject*)
+JS_NewUint8ClampedArrayFromArray(JSContext* cx, JS::HandleObject array);
+extern JS_FRIEND_API(JSObject*)
+JS_NewInt16ArrayFromArray(JSContext* cx, JS::HandleObject array);
+extern JS_FRIEND_API(JSObject*)
+JS_NewUint16ArrayFromArray(JSContext* cx, JS::HandleObject array);
+extern JS_FRIEND_API(JSObject*)
+JS_NewInt32ArrayFromArray(JSContext* cx, JS::HandleObject array);
+extern JS_FRIEND_API(JSObject*)
+JS_NewUint32ArrayFromArray(JSContext* cx, JS::HandleObject array);
+extern JS_FRIEND_API(JSObject*)
+JS_NewFloat32ArrayFromArray(JSContext* cx, JS::HandleObject array);
+extern JS_FRIEND_API(JSObject*)
+JS_NewFloat64ArrayFromArray(JSContext* cx, JS::HandleObject array);
+
+/*
+ * Create a new typed array using the given ArrayBuffer or
+ * SharedArrayBuffer for storage. The length value is optional; if -1
+ * is passed, enough elements to use up the remainder of the byte
+ * array is used as the default value.
+ */
+
+extern JS_FRIEND_API(JSObject*)
+JS_NewInt8ArrayWithBuffer(JSContext* cx, JS::HandleObject arrayBuffer,
+ uint32_t byteOffset, int32_t length);
+extern JS_FRIEND_API(JSObject*)
+JS_NewUint8ArrayWithBuffer(JSContext* cx, JS::HandleObject arrayBuffer,
+ uint32_t byteOffset, int32_t length);
+extern JS_FRIEND_API(JSObject*)
+JS_NewUint8ClampedArrayWithBuffer(JSContext* cx, JS::HandleObject arrayBuffer,
+ uint32_t byteOffset, int32_t length);
+extern JS_FRIEND_API(JSObject*)
+JS_NewInt16ArrayWithBuffer(JSContext* cx, JS::HandleObject arrayBuffer,
+ uint32_t byteOffset, int32_t length);
+extern JS_FRIEND_API(JSObject*)
+JS_NewUint16ArrayWithBuffer(JSContext* cx, JS::HandleObject arrayBuffer,
+ uint32_t byteOffset, int32_t length);
+extern JS_FRIEND_API(JSObject*)
+JS_NewInt32ArrayWithBuffer(JSContext* cx, JS::HandleObject arrayBuffer,
+ uint32_t byteOffset, int32_t length);
+extern JS_FRIEND_API(JSObject*)
+JS_NewUint32ArrayWithBuffer(JSContext* cx, JS::HandleObject arrayBuffer,
+ uint32_t byteOffset, int32_t length);
+extern JS_FRIEND_API(JSObject*)
+JS_NewFloat32ArrayWithBuffer(JSContext* cx, JS::HandleObject arrayBuffer,
+ uint32_t byteOffset, int32_t length);
+extern JS_FRIEND_API(JSObject*)
+JS_NewFloat64ArrayWithBuffer(JSContext* cx, JS::HandleObject arrayBuffer,
+ uint32_t byteOffset, int32_t length);
+
+/**
+ * Create a new SharedArrayBuffer with the given byte length. This
+ * may only be called if
+ * JS::CompartmentCreationOptionsRef(cx).getSharedMemoryAndAtomicsEnabled() is
+ * true.
+ */
+extern JS_FRIEND_API(JSObject*)
+JS_NewSharedArrayBuffer(JSContext* cx, uint32_t nbytes);
+
+/**
+ * Create a new ArrayBuffer with the given byte length.
+ */
+extern JS_FRIEND_API(JSObject*)
+JS_NewArrayBuffer(JSContext* cx, uint32_t nbytes);
+
+/**
+ * Check whether obj supports JS_GetTypedArray* APIs. Note that this may return
+ * false if a security wrapper is encountered that denies the unwrapping. If
+ * this test or one of the JS_Is*Array tests succeeds, then it is safe to call
+ * the various accessor JSAPI calls defined below.
+ */
+extern JS_FRIEND_API(bool)
+JS_IsTypedArrayObject(JSObject* obj);
+
+/**
+ * Check whether obj supports JS_GetArrayBufferView* APIs. Note that this may
+ * return false if a security wrapper is encountered that denies the
+ * unwrapping. If this test or one of the more specific tests succeeds, then it
+ * is safe to call the various ArrayBufferView accessor JSAPI calls defined
+ * below.
+ */
+extern JS_FRIEND_API(bool)
+JS_IsArrayBufferViewObject(JSObject* obj);
+
+/*
+ * Test for specific typed array types (ArrayBufferView subtypes)
+ */
+
+extern JS_FRIEND_API(bool)
+JS_IsInt8Array(JSObject* obj);
+extern JS_FRIEND_API(bool)
+JS_IsUint8Array(JSObject* obj);
+extern JS_FRIEND_API(bool)
+JS_IsUint8ClampedArray(JSObject* obj);
+extern JS_FRIEND_API(bool)
+JS_IsInt16Array(JSObject* obj);
+extern JS_FRIEND_API(bool)
+JS_IsUint16Array(JSObject* obj);
+extern JS_FRIEND_API(bool)
+JS_IsInt32Array(JSObject* obj);
+extern JS_FRIEND_API(bool)
+JS_IsUint32Array(JSObject* obj);
+extern JS_FRIEND_API(bool)
+JS_IsFloat32Array(JSObject* obj);
+extern JS_FRIEND_API(bool)
+JS_IsFloat64Array(JSObject* obj);
+
+/**
+ * Return the isShared flag of a typed array, which denotes whether
+ * the underlying buffer is a SharedArrayBuffer.
+ *
+ * |obj| must have passed a JS_IsTypedArrayObject/JS_Is*Array test, or somehow
+ * be known that it would pass such a test: it is a typed array or a wrapper of
+ * a typed array, and the unwrapping will succeed.
+ */
+extern JS_FRIEND_API(bool)
+JS_GetTypedArraySharedness(JSObject* obj);
+
+/*
+ * Test for specific typed array types (ArrayBufferView subtypes) and return
+ * the unwrapped object if so, else nullptr. Never throws.
+ */
+
+namespace js {
+
+extern JS_FRIEND_API(JSObject*)
+UnwrapInt8Array(JSObject* obj);
+extern JS_FRIEND_API(JSObject*)
+UnwrapUint8Array(JSObject* obj);
+extern JS_FRIEND_API(JSObject*)
+UnwrapUint8ClampedArray(JSObject* obj);
+extern JS_FRIEND_API(JSObject*)
+UnwrapInt16Array(JSObject* obj);
+extern JS_FRIEND_API(JSObject*)
+UnwrapUint16Array(JSObject* obj);
+extern JS_FRIEND_API(JSObject*)
+UnwrapInt32Array(JSObject* obj);
+extern JS_FRIEND_API(JSObject*)
+UnwrapUint32Array(JSObject* obj);
+extern JS_FRIEND_API(JSObject*)
+UnwrapFloat32Array(JSObject* obj);
+extern JS_FRIEND_API(JSObject*)
+UnwrapFloat64Array(JSObject* obj);
+
+extern JS_FRIEND_API(JSObject*)
+UnwrapArrayBuffer(JSObject* obj);
+
+extern JS_FRIEND_API(JSObject*)
+UnwrapArrayBufferView(JSObject* obj);
+
+extern JS_FRIEND_API(JSObject*)
+UnwrapSharedArrayBuffer(JSObject* obj);
+
+
+namespace detail {
+
+extern JS_FRIEND_DATA(const Class* const) Int8ArrayClassPtr;
+extern JS_FRIEND_DATA(const Class* const) Uint8ArrayClassPtr;
+extern JS_FRIEND_DATA(const Class* const) Uint8ClampedArrayClassPtr;
+extern JS_FRIEND_DATA(const Class* const) Int16ArrayClassPtr;
+extern JS_FRIEND_DATA(const Class* const) Uint16ArrayClassPtr;
+extern JS_FRIEND_DATA(const Class* const) Int32ArrayClassPtr;
+extern JS_FRIEND_DATA(const Class* const) Uint32ArrayClassPtr;
+extern JS_FRIEND_DATA(const Class* const) Float32ArrayClassPtr;
+extern JS_FRIEND_DATA(const Class* const) Float64ArrayClassPtr;
+
+const size_t TypedArrayLengthSlot = 1;
+
+} // namespace detail
+
+#define JS_DEFINE_DATA_AND_LENGTH_ACCESSOR(Type, type) \
+inline void \
+Get ## Type ## ArrayLengthAndData(JSObject* obj, uint32_t* length, bool* isSharedMemory, type** data) \
+{ \
+ MOZ_ASSERT(GetObjectClass(obj) == detail::Type ## ArrayClassPtr); \
+ const JS::Value& lenSlot = GetReservedSlot(obj, detail::TypedArrayLengthSlot); \
+ *length = mozilla::AssertedCast<uint32_t>(lenSlot.toInt32()); \
+ *isSharedMemory = JS_GetTypedArraySharedness(obj); \
+ *data = static_cast<type*>(GetObjectPrivate(obj)); \
+}
+
+JS_DEFINE_DATA_AND_LENGTH_ACCESSOR(Int8, int8_t)
+JS_DEFINE_DATA_AND_LENGTH_ACCESSOR(Uint8, uint8_t)
+JS_DEFINE_DATA_AND_LENGTH_ACCESSOR(Uint8Clamped, uint8_t)
+JS_DEFINE_DATA_AND_LENGTH_ACCESSOR(Int16, int16_t)
+JS_DEFINE_DATA_AND_LENGTH_ACCESSOR(Uint16, uint16_t)
+JS_DEFINE_DATA_AND_LENGTH_ACCESSOR(Int32, int32_t)
+JS_DEFINE_DATA_AND_LENGTH_ACCESSOR(Uint32, uint32_t)
+JS_DEFINE_DATA_AND_LENGTH_ACCESSOR(Float32, float)
+JS_DEFINE_DATA_AND_LENGTH_ACCESSOR(Float64, double)
+
+#undef JS_DEFINE_DATA_AND_LENGTH_ACCESSOR
+
+// This one isn't inlined because it's rather tricky (by dint of having to deal
+// with a dozen-plus classes and varying slot layouts.
+extern JS_FRIEND_API(void)
+GetArrayBufferViewLengthAndData(JSObject* obj, uint32_t* length, bool* isSharedMemory, uint8_t** data);
+
+// This one isn't inlined because there are a bunch of different ArrayBuffer
+// classes that would have to be individually handled here.
+//
+// There is an isShared out argument for API consistency (eases use from DOM).
+// It will always be set to false.
+extern JS_FRIEND_API(void)
+GetArrayBufferLengthAndData(JSObject* obj, uint32_t* length, bool* isSharedMemory, uint8_t** data);
+
+// Ditto for SharedArrayBuffer.
+//
+// There is an isShared out argument for API consistency (eases use from DOM).
+// It will always be set to true.
+extern JS_FRIEND_API(void)
+GetSharedArrayBufferLengthAndData(JSObject* obj, uint32_t* length, bool* isSharedMemory, uint8_t** data);
+
+} // namespace js
+
+JS_FRIEND_API(uint8_t*)
+JS_GetSharedArrayBufferData(JSObject* obj, bool* isSharedMemory, const JS::AutoCheckCannotGC&);
+
+/*
+ * Unwrap Typed arrays all at once. Return nullptr without throwing if the
+ * object cannot be viewed as the correct typed array, or the typed array
+ * object on success, filling both outparameters.
+ */
+extern JS_FRIEND_API(JSObject*)
+JS_GetObjectAsInt8Array(JSObject* obj, uint32_t* length, bool* isSharedMemory, int8_t** data);
+extern JS_FRIEND_API(JSObject*)
+JS_GetObjectAsUint8Array(JSObject* obj, uint32_t* length, bool* isSharedMemory, uint8_t** data);
+extern JS_FRIEND_API(JSObject*)
+JS_GetObjectAsUint8ClampedArray(JSObject* obj, uint32_t* length, bool* isSharedMemory, uint8_t** data);
+extern JS_FRIEND_API(JSObject*)
+JS_GetObjectAsInt16Array(JSObject* obj, uint32_t* length, bool* isSharedMemory, int16_t** data);
+extern JS_FRIEND_API(JSObject*)
+JS_GetObjectAsUint16Array(JSObject* obj, uint32_t* length, bool* isSharedMemory, uint16_t** data);
+extern JS_FRIEND_API(JSObject*)
+JS_GetObjectAsInt32Array(JSObject* obj, uint32_t* length, bool* isSharedMemory, int32_t** data);
+extern JS_FRIEND_API(JSObject*)
+JS_GetObjectAsUint32Array(JSObject* obj, uint32_t* length, bool* isSharedMemory, uint32_t** data);
+extern JS_FRIEND_API(JSObject*)
+JS_GetObjectAsFloat32Array(JSObject* obj, uint32_t* length, bool* isSharedMemory, float** data);
+extern JS_FRIEND_API(JSObject*)
+JS_GetObjectAsFloat64Array(JSObject* obj, uint32_t* length, bool* isSharedMemory, double** data);
+extern JS_FRIEND_API(JSObject*)
+JS_GetObjectAsArrayBufferView(JSObject* obj, uint32_t* length, bool* isSharedMemory, uint8_t** data);
+
+/*
+ * Unwrap an ArrayBuffer, return nullptr if it's a different type.
+ */
+extern JS_FRIEND_API(JSObject*)
+JS_GetObjectAsArrayBuffer(JSObject* obj, uint32_t* length, uint8_t** data);
+
+/*
+ * Get the type of elements in a typed array, or MaxTypedArrayViewType if a DataView.
+ *
+ * |obj| must have passed a JS_IsArrayBufferView/JS_Is*Array test, or somehow
+ * be known that it would pass such a test: it is an ArrayBufferView or a
+ * wrapper of an ArrayBufferView, and the unwrapping will succeed.
+ */
+extern JS_FRIEND_API(js::Scalar::Type)
+JS_GetArrayBufferViewType(JSObject* obj);
+
+extern JS_FRIEND_API(js::Scalar::Type)
+JS_GetSharedArrayBufferViewType(JSObject* obj);
+
+/*
+ * Check whether obj supports the JS_GetArrayBuffer* APIs. Note that this may
+ * return false if a security wrapper is encountered that denies the
+ * unwrapping. If this test succeeds, then it is safe to call the various
+ * accessor JSAPI calls defined below.
+ */
+extern JS_FRIEND_API(bool)
+JS_IsArrayBufferObject(JSObject* obj);
+
+extern JS_FRIEND_API(bool)
+JS_IsSharedArrayBufferObject(JSObject* obj);
+
+/**
+ * Return the available byte length of an array buffer.
+ *
+ * |obj| must have passed a JS_IsArrayBufferObject test, or somehow be known
+ * that it would pass such a test: it is an ArrayBuffer or a wrapper of an
+ * ArrayBuffer, and the unwrapping will succeed.
+ */
+extern JS_FRIEND_API(uint32_t)
+JS_GetArrayBufferByteLength(JSObject* obj);
+
+extern JS_FRIEND_API(uint32_t)
+JS_GetSharedArrayBufferByteLength(JSObject* obj);
+
+/**
+ * Return true if the arrayBuffer contains any data. This will return false for
+ * ArrayBuffer.prototype and detached ArrayBuffers.
+ *
+ * |obj| must have passed a JS_IsArrayBufferObject test, or somehow be known
+ * that it would pass such a test: it is an ArrayBuffer or a wrapper of an
+ * ArrayBuffer, and the unwrapping will succeed.
+ */
+extern JS_FRIEND_API(bool)
+JS_ArrayBufferHasData(JSObject* obj);
+
+/**
+ * Return a pointer to the start of the data referenced by a typed array. The
+ * data is still owned by the typed array, and should not be modified on
+ * another thread. Furthermore, the pointer can become invalid on GC (if the
+ * data is small and fits inside the array's GC header), so callers must take
+ * care not to hold on across anything that could GC.
+ *
+ * |obj| must have passed a JS_IsArrayBufferObject test, or somehow be known
+ * that it would pass such a test: it is an ArrayBuffer or a wrapper of an
+ * ArrayBuffer, and the unwrapping will succeed.
+ *
+ * *isSharedMemory will be set to false, the argument is present to simplify
+ * its use from code that also interacts with SharedArrayBuffer.
+ */
+extern JS_FRIEND_API(uint8_t*)
+JS_GetArrayBufferData(JSObject* obj, bool* isSharedMemory, const JS::AutoCheckCannotGC&);
+
+/**
+ * Check whether the obj is ArrayBufferObject and memory mapped. Note that this
+ * may return false if a security wrapper is encountered that denies the
+ * unwrapping.
+ */
+extern JS_FRIEND_API(bool)
+JS_IsMappedArrayBufferObject(JSObject* obj);
+
+/**
+ * Return the number of elements in a typed array.
+ *
+ * |obj| must have passed a JS_IsTypedArrayObject/JS_Is*Array test, or somehow
+ * be known that it would pass such a test: it is a typed array or a wrapper of
+ * a typed array, and the unwrapping will succeed.
+ */
+extern JS_FRIEND_API(uint32_t)
+JS_GetTypedArrayLength(JSObject* obj);
+
+/**
+ * Return the byte offset from the start of an array buffer to the start of a
+ * typed array view.
+ *
+ * |obj| must have passed a JS_IsTypedArrayObject/JS_Is*Array test, or somehow
+ * be known that it would pass such a test: it is a typed array or a wrapper of
+ * a typed array, and the unwrapping will succeed.
+ */
+extern JS_FRIEND_API(uint32_t)
+JS_GetTypedArrayByteOffset(JSObject* obj);
+
+/**
+ * Return the byte length of a typed array.
+ *
+ * |obj| must have passed a JS_IsTypedArrayObject/JS_Is*Array test, or somehow
+ * be known that it would pass such a test: it is a typed array or a wrapper of
+ * a typed array, and the unwrapping will succeed.
+ */
+extern JS_FRIEND_API(uint32_t)
+JS_GetTypedArrayByteLength(JSObject* obj);
+
+/**
+ * Check whether obj supports JS_ArrayBufferView* APIs. Note that this may
+ * return false if a security wrapper is encountered that denies the
+ * unwrapping.
+ */
+extern JS_FRIEND_API(bool)
+JS_IsArrayBufferViewObject(JSObject* obj);
+
+/**
+ * More generic name for JS_GetTypedArrayByteLength to cover DataViews as well
+ */
+extern JS_FRIEND_API(uint32_t)
+JS_GetArrayBufferViewByteLength(JSObject* obj);
+
+/*
+ * Return a pointer to the start of the data referenced by a typed array. The
+ * data is still owned by the typed array, and should not be modified on
+ * another thread. Furthermore, the pointer can become invalid on GC (if the
+ * data is small and fits inside the array's GC header), so callers must take
+ * care not to hold on across anything that could GC.
+ *
+ * |obj| must have passed a JS_Is*Array test, or somehow be known that it would
+ * pass such a test: it is a typed array or a wrapper of a typed array, and the
+ * unwrapping will succeed.
+ *
+ * *isSharedMemory will be set to true if the typed array maps a
+ * SharedArrayBuffer, otherwise to false.
+ */
+
+extern JS_FRIEND_API(int8_t*)
+JS_GetInt8ArrayData(JSObject* obj, bool* isSharedMemory, const JS::AutoCheckCannotGC&);
+extern JS_FRIEND_API(uint8_t*)
+JS_GetUint8ArrayData(JSObject* obj, bool* isSharedMemory, const JS::AutoCheckCannotGC&);
+extern JS_FRIEND_API(uint8_t*)
+JS_GetUint8ClampedArrayData(JSObject* obj, bool* isSharedMemory, const JS::AutoCheckCannotGC&);
+extern JS_FRIEND_API(int16_t*)
+JS_GetInt16ArrayData(JSObject* obj, bool* isSharedMemory, const JS::AutoCheckCannotGC&);
+extern JS_FRIEND_API(uint16_t*)
+JS_GetUint16ArrayData(JSObject* obj, bool* isSharedMemory, const JS::AutoCheckCannotGC&);
+extern JS_FRIEND_API(int32_t*)
+JS_GetInt32ArrayData(JSObject* obj, bool* isSharedMemory, const JS::AutoCheckCannotGC&);
+extern JS_FRIEND_API(uint32_t*)
+JS_GetUint32ArrayData(JSObject* obj, bool* isSharedMemory, const JS::AutoCheckCannotGC&);
+extern JS_FRIEND_API(float*)
+JS_GetFloat32ArrayData(JSObject* obj, bool* isSharedMemory, const JS::AutoCheckCannotGC&);
+extern JS_FRIEND_API(double*)
+JS_GetFloat64ArrayData(JSObject* obj, bool* isSharedMemory, const JS::AutoCheckCannotGC&);
+
+/**
+ * Same as above, but for any kind of ArrayBufferView. Prefer the type-specific
+ * versions when possible.
+ */
+extern JS_FRIEND_API(void*)
+JS_GetArrayBufferViewData(JSObject* obj, bool* isSharedMemory, const JS::AutoCheckCannotGC&);
+
+/**
+ * Return the ArrayBuffer or SharedArrayBuffer underlying an ArrayBufferView.
+ * This may return a detached buffer. |obj| must be an object that would
+ * return true for JS_IsArrayBufferViewObject().
+ */
+extern JS_FRIEND_API(JSObject*)
+JS_GetArrayBufferViewBuffer(JSContext* cx, JS::HandleObject obj, bool* isSharedMemory);
+
+/**
+ * Detach an ArrayBuffer, causing all associated views to no longer refer to
+ * the ArrayBuffer's original attached memory.
+ *
+ * The |changeData| argument is obsolete and ignored.
+ */
+extern JS_FRIEND_API(bool)
+JS_DetachArrayBuffer(JSContext* cx, JS::HandleObject obj);
+
+/**
+ * Check whether the obj is a detached ArrayBufferObject. Note that this may
+ * return false if a security wrapper is encountered that denies the
+ * unwrapping.
+ */
+extern JS_FRIEND_API(bool)
+JS_IsDetachedArrayBufferObject(JSObject* obj);
+
+/**
+ * Check whether obj supports JS_GetDataView* APIs.
+ */
+JS_FRIEND_API(bool)
+JS_IsDataViewObject(JSObject* obj);
+
+/**
+ * Create a new DataView using the given ArrayBuffer for storage. The given
+ * buffer must be an ArrayBuffer (or a cross-compartment wrapper of an
+ * ArrayBuffer), and the offset and length must fit within the bounds of the
+ * arrayBuffer. Currently, nullptr will be returned and an exception will be
+ * thrown if these conditions do not hold, but do not depend on that behavior.
+ */
+JS_FRIEND_API(JSObject*)
+JS_NewDataView(JSContext* cx, JS::HandleObject arrayBuffer, uint32_t byteOffset, int32_t byteLength);
+
+/**
+ * Return the byte offset of a data view into its array buffer. |obj| must be a
+ * DataView.
+ *
+ * |obj| must have passed a JS_IsDataViewObject test, or somehow be known that
+ * it would pass such a test: it is a data view or a wrapper of a data view,
+ * and the unwrapping will succeed.
+ */
+JS_FRIEND_API(uint32_t)
+JS_GetDataViewByteOffset(JSObject* obj);
+
+/**
+ * Return the byte length of a data view.
+ *
+ * |obj| must have passed a JS_IsDataViewObject test, or somehow be known that
+ * it would pass such a test: it is a data view or a wrapper of a data view,
+ * and the unwrapping will succeed. If cx is nullptr, then DEBUG builds may be
+ * unable to assert when unwrapping should be disallowed.
+ */
+JS_FRIEND_API(uint32_t)
+JS_GetDataViewByteLength(JSObject* obj);
+
+/**
+ * Return a pointer to the beginning of the data referenced by a DataView.
+ *
+ * |obj| must have passed a JS_IsDataViewObject test, or somehow be known that
+ * it would pass such a test: it is a data view or a wrapper of a data view,
+ * and the unwrapping will succeed. If cx is nullptr, then DEBUG builds may be
+ * unable to assert when unwrapping should be disallowed.
+ */
+JS_FRIEND_API(void*)
+JS_GetDataViewData(JSObject* obj, const JS::AutoCheckCannotGC&);
+
+namespace js {
+
+/**
+ * Add a watchpoint -- in the Object.prototype.watch sense -- to |obj| for the
+ * property |id|, using the callable object |callable| as the function to be
+ * called for notifications.
+ *
+ * This is an internal function exposed -- temporarily -- only so that DOM
+ * proxies can be watchable. Don't use it! We'll soon kill off the
+ * Object.prototype.{,un}watch functions, at which point this will go too.
+ */
+extern JS_FRIEND_API(bool)
+WatchGuts(JSContext* cx, JS::HandleObject obj, JS::HandleId id, JS::HandleObject callable);
+
+/**
+ * Remove a watchpoint -- in the Object.prototype.watch sense -- from |obj| for
+ * the property |id|.
+ *
+ * This is an internal function exposed -- temporarily -- only so that DOM
+ * proxies can be watchable. Don't use it! We'll soon kill off the
+ * Object.prototype.{,un}watch functions, at which point this will go too.
+ */
+extern JS_FRIEND_API(bool)
+UnwatchGuts(JSContext* cx, JS::HandleObject obj, JS::HandleId id);
+
+namespace jit {
+
+enum class InlinableNative : uint16_t;
+
+} // namespace jit
+
+} // namespace js
+
+/**
+ * A class, expected to be passed by value, which represents the CallArgs for a
+ * JSJitGetterOp.
+ */
+class JSJitGetterCallArgs : protected JS::MutableHandleValue
+{
+ public:
+ explicit JSJitGetterCallArgs(const JS::CallArgs& args)
+ : JS::MutableHandleValue(args.rval())
+ {}
+
+ explicit JSJitGetterCallArgs(JS::RootedValue* rooted)
+ : JS::MutableHandleValue(rooted)
+ {}
+
+ JS::MutableHandleValue rval() {
+ return *this;
+ }
+};
+
+/**
+ * A class, expected to be passed by value, which represents the CallArgs for a
+ * JSJitSetterOp.
+ */
+class JSJitSetterCallArgs : protected JS::MutableHandleValue
+{
+ public:
+ explicit JSJitSetterCallArgs(const JS::CallArgs& args)
+ : JS::MutableHandleValue(args[0])
+ {}
+
+ JS::MutableHandleValue operator[](unsigned i) {
+ MOZ_ASSERT(i == 0);
+ return *this;
+ }
+
+ unsigned length() const { return 1; }
+
+ // Add get() or maybe hasDefined() as needed
+};
+
+struct JSJitMethodCallArgsTraits;
+
+/**
+ * A class, expected to be passed by reference, which represents the CallArgs
+ * for a JSJitMethodOp.
+ */
+class JSJitMethodCallArgs : protected JS::detail::CallArgsBase<JS::detail::NoUsedRval>
+{
+ private:
+ typedef JS::detail::CallArgsBase<JS::detail::NoUsedRval> Base;
+ friend struct JSJitMethodCallArgsTraits;
+
+ public:
+ explicit JSJitMethodCallArgs(const JS::CallArgs& args) {
+ argv_ = args.array();
+ argc_ = args.length();
+ }
+
+ JS::MutableHandleValue rval() const {
+ return Base::rval();
+ }
+
+ unsigned length() const { return Base::length(); }
+
+ JS::MutableHandleValue operator[](unsigned i) const {
+ return Base::operator[](i);
+ }
+
+ bool hasDefined(unsigned i) const {
+ return Base::hasDefined(i);
+ }
+
+ JSObject& callee() const {
+ // We can't use Base::callee() because that will try to poke at
+ // this->usedRval_, which we don't have.
+ return argv_[-2].toObject();
+ }
+
+ JS::HandleValue get(unsigned i) const {
+ return Base::get(i);
+ }
+};
+
+struct JSJitMethodCallArgsTraits
+{
+ static const size_t offsetOfArgv = offsetof(JSJitMethodCallArgs, argv_);
+ static const size_t offsetOfArgc = offsetof(JSJitMethodCallArgs, argc_);
+};
+
+typedef bool
+(* JSJitGetterOp)(JSContext* cx, JS::HandleObject thisObj,
+ void* specializedThis, JSJitGetterCallArgs args);
+typedef bool
+(* JSJitSetterOp)(JSContext* cx, JS::HandleObject thisObj,
+ void* specializedThis, JSJitSetterCallArgs args);
+typedef bool
+(* JSJitMethodOp)(JSContext* cx, JS::HandleObject thisObj,
+ void* specializedThis, const JSJitMethodCallArgs& args);
+
+/**
+ * This struct contains metadata passed from the DOM to the JS Engine for JIT
+ * optimizations on DOM property accessors. Eventually, this should be made
+ * available to general JSAPI users, but we are not currently ready to do so.
+ */
+struct JSJitInfo {
+ enum OpType {
+ Getter,
+ Setter,
+ Method,
+ StaticMethod,
+ InlinableNative,
+ // Must be last
+ OpTypeCount
+ };
+
+ enum ArgType {
+ // Basic types
+ String = (1 << 0),
+ Integer = (1 << 1), // Only 32-bit or less
+ Double = (1 << 2), // Maybe we want to add Float sometime too
+ Boolean = (1 << 3),
+ Object = (1 << 4),
+ Null = (1 << 5),
+
+ // And derived types
+ Numeric = Integer | Double,
+ // Should "Primitive" use the WebIDL definition, which
+ // excludes string and null, or the typical JS one that includes them?
+ Primitive = Numeric | Boolean | Null | String,
+ ObjectOrNull = Object | Null,
+ Any = ObjectOrNull | Primitive,
+
+ // Our sentinel value.
+ ArgTypeListEnd = (1 << 31)
+ };
+
+ static_assert(Any & String, "Any must include String.");
+ static_assert(Any & Integer, "Any must include Integer.");
+ static_assert(Any & Double, "Any must include Double.");
+ static_assert(Any & Boolean, "Any must include Boolean.");
+ static_assert(Any & Object, "Any must include Object.");
+ static_assert(Any & Null, "Any must include Null.");
+
+ /**
+ * An enum that describes what this getter/setter/method aliases. This
+ * determines what things can be hoisted past this call, and if this
+ * call is movable what it can be hoisted past.
+ */
+ enum AliasSet {
+ /**
+ * Alias nothing: a constant value, getting it can't affect any other
+ * values, nothing can affect it.
+ */
+ AliasNone,
+
+ /**
+ * Alias things that can modify the DOM but nothing else. Doing the
+ * call can't affect the behavior of any other function.
+ */
+ AliasDOMSets,
+
+ /**
+ * Alias the world. Calling this can change arbitrary values anywhere
+ * in the system. Most things fall in this bucket.
+ */
+ AliasEverything,
+
+ /** Must be last. */
+ AliasSetCount
+ };
+
+ bool needsOuterizedThisObject() const
+ {
+ return type() != Getter && type() != Setter;
+ }
+
+ bool isTypedMethodJitInfo() const
+ {
+ return isTypedMethod;
+ }
+
+ OpType type() const
+ {
+ return OpType(type_);
+ }
+
+ AliasSet aliasSet() const
+ {
+ return AliasSet(aliasSet_);
+ }
+
+ JSValueType returnType() const
+ {
+ return JSValueType(returnType_);
+ }
+
+ union {
+ JSJitGetterOp getter;
+ JSJitSetterOp setter;
+ JSJitMethodOp method;
+ /** A DOM static method, used for Promise wrappers */
+ JSNative staticMethod;
+ };
+
+ union {
+ uint16_t protoID;
+ js::jit::InlinableNative inlinableNative;
+ };
+
+ union {
+ uint16_t depth;
+
+ // Additional opcode for some InlinableNative functions.
+ uint16_t nativeOp;
+ };
+
+ // These fields are carefully packed to take up 4 bytes. If you need more
+ // bits for whatever reason, please see if you can steal bits from existing
+ // fields before adding more members to this structure.
+
+#define JITINFO_OP_TYPE_BITS 4
+#define JITINFO_ALIAS_SET_BITS 4
+#define JITINFO_RETURN_TYPE_BITS 8
+#define JITINFO_SLOT_INDEX_BITS 10
+
+ /** The OpType that says what sort of function we are. */
+ uint32_t type_ : JITINFO_OP_TYPE_BITS;
+
+ /**
+ * The alias set for this op. This is a _minimal_ alias set; in
+ * particular for a method it does not include whatever argument
+ * conversions might do. That's covered by argTypes and runtime
+ * analysis of the actual argument types being passed in.
+ */
+ uint32_t aliasSet_ : JITINFO_ALIAS_SET_BITS;
+
+ /** The return type tag. Might be JSVAL_TYPE_UNKNOWN. */
+ uint32_t returnType_ : JITINFO_RETURN_TYPE_BITS;
+
+ static_assert(OpTypeCount <= (1 << JITINFO_OP_TYPE_BITS),
+ "Not enough space for OpType");
+ static_assert(AliasSetCount <= (1 << JITINFO_ALIAS_SET_BITS),
+ "Not enough space for AliasSet");
+ static_assert((sizeof(JSValueType) * 8) <= JITINFO_RETURN_TYPE_BITS,
+ "Not enough space for JSValueType");
+
+#undef JITINFO_RETURN_TYPE_BITS
+#undef JITINFO_ALIAS_SET_BITS
+#undef JITINFO_OP_TYPE_BITS
+
+ /** Is op fallible? False in setters. */
+ uint32_t isInfallible : 1;
+
+ /**
+ * Is op movable? To be movable the op must
+ * not AliasEverything, but even that might
+ * not be enough (e.g. in cases when it can
+ * throw or is explicitly not movable).
+ */
+ uint32_t isMovable : 1;
+
+ /**
+ * Can op be dead-code eliminated? Again, this
+ * depends on whether the op can throw, in
+ * addition to the alias set.
+ */
+ uint32_t isEliminatable : 1;
+
+ // XXXbz should we have a JSValueType for the type of the member?
+ /**
+ * True if this is a getter that can always
+ * get the value from a slot of the "this" object.
+ */
+ uint32_t isAlwaysInSlot : 1;
+
+ /**
+ * True if this is a getter that can sometimes (if the slot doesn't contain
+ * UndefinedValue()) get the value from a slot of the "this" object.
+ */
+ uint32_t isLazilyCachedInSlot : 1;
+
+ /** True if this is an instance of JSTypedMethodJitInfo. */
+ uint32_t isTypedMethod : 1;
+
+ /**
+ * If isAlwaysInSlot or isSometimesInSlot is true,
+ * the index of the slot to get the value from.
+ * Otherwise 0.
+ */
+ uint32_t slotIndex : JITINFO_SLOT_INDEX_BITS;
+
+ static const size_t maxSlotIndex = (1 << JITINFO_SLOT_INDEX_BITS) - 1;
+
+#undef JITINFO_SLOT_INDEX_BITS
+};
+
+static_assert(sizeof(JSJitInfo) == (sizeof(void*) + 2 * sizeof(uint32_t)),
+ "There are several thousand instances of JSJitInfo stored in "
+ "a binary. Please don't increase its space requirements without "
+ "verifying that there is no other way forward (better packing, "
+ "smaller datatypes for fields, subclassing, etc.).");
+
+struct JSTypedMethodJitInfo
+{
+ // We use C-style inheritance here, rather than C++ style inheritance
+ // because not all compilers support brace-initialization for non-aggregate
+ // classes. Using C++ style inheritance and constructors instead of
+ // brace-initialization would also force the creation of static
+ // constructors (on some compilers) when JSJitInfo and JSTypedMethodJitInfo
+ // structures are declared. Since there can be several thousand of these
+ // structures present and we want to have roughly equivalent performance
+ // across a range of compilers, we do things manually.
+ JSJitInfo base;
+
+ const JSJitInfo::ArgType* const argTypes; /* For a method, a list of sets of
+ types that the function
+ expects. This can be used,
+ for example, to figure out
+ when argument coercions can
+ have side-effects. */
+};
+
+namespace js {
+
+static MOZ_ALWAYS_INLINE shadow::Function*
+FunctionObjectToShadowFunction(JSObject* fun)
+{
+ MOZ_ASSERT(GetObjectClass(fun) == FunctionClassPtr);
+ return reinterpret_cast<shadow::Function*>(fun);
+}
+
+/* Statically asserted in jsfun.h. */
+static const unsigned JS_FUNCTION_INTERPRETED_BITS = 0x0201;
+
+// Return whether the given function object is native.
+static MOZ_ALWAYS_INLINE bool
+FunctionObjectIsNative(JSObject* fun)
+{
+ return !(FunctionObjectToShadowFunction(fun)->flags & JS_FUNCTION_INTERPRETED_BITS);
+}
+
+static MOZ_ALWAYS_INLINE JSNative
+GetFunctionObjectNative(JSObject* fun)
+{
+ MOZ_ASSERT(FunctionObjectIsNative(fun));
+ return FunctionObjectToShadowFunction(fun)->native;
+}
+
+} // namespace js
+
+static MOZ_ALWAYS_INLINE const JSJitInfo*
+FUNCTION_VALUE_TO_JITINFO(const JS::Value& v)
+{
+ MOZ_ASSERT(js::FunctionObjectIsNative(&v.toObject()));
+ return js::FunctionObjectToShadowFunction(&v.toObject())->jitinfo;
+}
+
+static MOZ_ALWAYS_INLINE void
+SET_JITINFO(JSFunction * func, const JSJitInfo* info)
+{
+ js::shadow::Function* fun = reinterpret_cast<js::shadow::Function*>(func);
+ MOZ_ASSERT(!(fun->flags & js::JS_FUNCTION_INTERPRETED_BITS));
+ fun->jitinfo = info;
+}
+
+/*
+ * Engine-internal extensions of jsid. This code is here only until we
+ * eliminate Gecko's dependencies on it!
+ */
+
+static MOZ_ALWAYS_INLINE jsid
+JSID_FROM_BITS(size_t bits)
+{
+ jsid id;
+ JSID_BITS(id) = bits;
+ return id;
+}
+
+namespace js {
+namespace detail {
+bool IdMatchesAtom(jsid id, JSAtom* atom);
+} // namespace detail
+} // namespace js
+
+/**
+ * Must not be used on atoms that are representable as integer jsids.
+ * Prefer NameToId or AtomToId over this function:
+ *
+ * A PropertyName is an atom that does not contain an integer in the range
+ * [0, UINT32_MAX]. However, jsid can only hold an integer in the range
+ * [0, JSID_INT_MAX] (where JSID_INT_MAX == 2^31-1). Thus, for the range of
+ * integers (JSID_INT_MAX, UINT32_MAX], to represent as a jsid 'id', it must be
+ * the case JSID_IS_ATOM(id) and !JSID_TO_ATOM(id)->isPropertyName(). In most
+ * cases when creating a jsid, code does not have to care about this corner
+ * case because:
+ *
+ * - When given an arbitrary JSAtom*, AtomToId must be used, which checks for
+ * integer atoms representable as integer jsids, and does this conversion.
+ *
+ * - When given a PropertyName*, NameToId can be used which which does not need
+ * to do any dynamic checks.
+ *
+ * Thus, it is only the rare third case which needs this function, which
+ * handles any JSAtom* that is known not to be representable with an int jsid.
+ */
+static MOZ_ALWAYS_INLINE jsid
+NON_INTEGER_ATOM_TO_JSID(JSAtom* atom)
+{
+ MOZ_ASSERT(((size_t)atom & 0x7) == 0);
+ jsid id = JSID_FROM_BITS((size_t)atom);
+ MOZ_ASSERT(js::detail::IdMatchesAtom(id, atom));
+ return id;
+}
+
+/* All strings stored in jsids are atomized, but are not necessarily property names. */
+static MOZ_ALWAYS_INLINE bool
+JSID_IS_ATOM(jsid id)
+{
+ return JSID_IS_STRING(id);
+}
+
+static MOZ_ALWAYS_INLINE bool
+JSID_IS_ATOM(jsid id, JSAtom* atom)
+{
+ return id == JSID_FROM_BITS((size_t)atom);
+}
+
+static MOZ_ALWAYS_INLINE JSAtom*
+JSID_TO_ATOM(jsid id)
+{
+ return (JSAtom*)JSID_TO_STRING(id);
+}
+
+JS_STATIC_ASSERT(sizeof(jsid) == sizeof(void*));
+
+namespace js {
+
+static MOZ_ALWAYS_INLINE JS::Value
+IdToValue(jsid id)
+{
+ if (JSID_IS_STRING(id))
+ return JS::StringValue(JSID_TO_STRING(id));
+ if (JSID_IS_INT(id))
+ return JS::Int32Value(JSID_TO_INT(id));
+ if (JSID_IS_SYMBOL(id))
+ return JS::SymbolValue(JSID_TO_SYMBOL(id));
+ MOZ_ASSERT(JSID_IS_VOID(id));
+ return JS::UndefinedValue();
+}
+
+/**
+ * If the embedder has registered a ScriptEnvironmentPreparer,
+ * PrepareScriptEnvironmentAndInvoke will call the preparer's 'invoke' method
+ * with the given |closure|, with the assumption that the preparer will set up
+ * any state necessary to run script in |scope|, invoke |closure| with a valid
+ * JSContext*, report any exceptions thrown from the closure, and return.
+ *
+ * If no preparer is registered, PrepareScriptEnvironmentAndInvoke will assert
+ * that |rt| has exactly one JSContext associated with it, enter the compartment
+ * of |scope| on that context, and invoke |closure|.
+ *
+ * In both cases, PrepareScriptEnvironmentAndInvoke will report any exceptions
+ * that are thrown by the closure. Consumers who want to propagate back
+ * whether the closure succeeded should do so via members of the closure
+ * itself.
+ */
+
+struct ScriptEnvironmentPreparer {
+ struct Closure {
+ virtual bool operator()(JSContext* cx) = 0;
+ };
+
+ virtual void invoke(JS::HandleObject scope, Closure& closure) = 0;
+};
+
+extern JS_FRIEND_API(void)
+PrepareScriptEnvironmentAndInvoke(JSContext* cx, JS::HandleObject scope,
+ ScriptEnvironmentPreparer::Closure& closure);
+
+JS_FRIEND_API(void)
+SetScriptEnvironmentPreparer(JSContext* cx, ScriptEnvironmentPreparer* preparer);
+
+enum CTypesActivityType {
+ CTYPES_CALL_BEGIN,
+ CTYPES_CALL_END,
+ CTYPES_CALLBACK_BEGIN,
+ CTYPES_CALLBACK_END
+};
+
+typedef void
+(* CTypesActivityCallback)(JSContext* cx, CTypesActivityType type);
+
+/**
+ * Sets a callback that is run whenever js-ctypes is about to be used when
+ * calling into C.
+ */
+JS_FRIEND_API(void)
+SetCTypesActivityCallback(JSContext* cx, CTypesActivityCallback cb);
+
+class MOZ_RAII JS_FRIEND_API(AutoCTypesActivityCallback) {
+ private:
+ JSContext* cx;
+ CTypesActivityCallback callback;
+ CTypesActivityType endType;
+ MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER
+
+ public:
+ AutoCTypesActivityCallback(JSContext* cx, CTypesActivityType beginType,
+ CTypesActivityType endType
+ MOZ_GUARD_OBJECT_NOTIFIER_PARAM);
+ ~AutoCTypesActivityCallback() {
+ DoEndCallback();
+ }
+ void DoEndCallback() {
+ if (callback) {
+ callback(cx, endType);
+ callback = nullptr;
+ }
+ }
+};
+
+// Abstract base class for objects that build allocation metadata for JavaScript
+// values.
+struct AllocationMetadataBuilder {
+ AllocationMetadataBuilder() { }
+
+ // Return a metadata object for the newly constructed object |obj|, or
+ // nullptr if there's no metadata to attach.
+ //
+ // Implementations should treat all errors as fatal; there is no way to
+ // report errors from this callback. In particular, the caller provides an
+ // oomUnsafe for overriding implementations to use.
+ virtual JSObject* build(JSContext* cx, JS::HandleObject obj,
+ AutoEnterOOMUnsafeRegion& oomUnsafe) const
+ {
+ return nullptr;
+ }
+};
+
+/**
+ * Specify a callback to invoke when creating each JS object in the current
+ * compartment, which may return a metadata object to associate with the
+ * object.
+ */
+JS_FRIEND_API(void)
+SetAllocationMetadataBuilder(JSContext* cx, const AllocationMetadataBuilder *callback);
+
+/** Get the metadata associated with an object. */
+JS_FRIEND_API(JSObject*)
+GetAllocationMetadata(JSObject* obj);
+
+JS_FRIEND_API(bool)
+GetElementsWithAdder(JSContext* cx, JS::HandleObject obj, JS::HandleObject receiver,
+ uint32_t begin, uint32_t end, js::ElementAdder* adder);
+
+JS_FRIEND_API(bool)
+ForwardToNative(JSContext* cx, JSNative native, const JS::CallArgs& args);
+
+/**
+ * Helper function for HTMLDocument and HTMLFormElement.
+ *
+ * These are the only two interfaces that have [OverrideBuiltins], a named
+ * getter, and no named setter. They're implemented as proxies with a custom
+ * getOwnPropertyDescriptor() method. Unfortunately, overriding
+ * getOwnPropertyDescriptor() automatically affects the behavior of set(),
+ * which normally is just common sense but is *not* desired for these two
+ * interfaces.
+ *
+ * The fix is for these two interfaces to override set() to ignore the
+ * getOwnPropertyDescriptor() override.
+ *
+ * SetPropertyIgnoringNamedGetter is exposed to make it easier to override
+ * set() in this way. It carries out all the steps of BaseProxyHandler::set()
+ * except the initial getOwnPropertyDescriptor() call. The caller must supply
+ * that descriptor as the 'ownDesc' parameter.
+ *
+ * Implemented in proxy/BaseProxyHandler.cpp.
+ */
+JS_FRIEND_API(bool)
+SetPropertyIgnoringNamedGetter(JSContext* cx, JS::HandleObject obj, JS::HandleId id,
+ JS::HandleValue v, JS::HandleValue receiver,
+ JS::Handle<JS::PropertyDescriptor> ownDesc,
+ JS::ObjectOpResult& result);
+
+JS_FRIEND_API(void)
+ReportASCIIErrorWithId(JSContext* cx, const char* msg, JS::HandleId id);
+
+// This function is for one specific use case, please don't use this for anything else!
+extern JS_FRIEND_API(bool)
+ExecuteInGlobalAndReturnScope(JSContext* cx, JS::HandleObject obj, JS::HandleScript script,
+ JS::MutableHandleObject scope);
+
+#if defined(XP_WIN) && defined(_WIN64)
+// Parameters use void* types to avoid #including windows.h. The return value of
+// this function is returned from the exception handler.
+typedef long
+(*JitExceptionHandler)(void* exceptionRecord, // PEXECTION_RECORD
+ void* context); // PCONTEXT
+
+/**
+ * Windows uses "structured exception handling" to handle faults. When a fault
+ * occurs, the stack is searched for a handler (similar to C++ exception
+ * handling). If the search does not find a handler, the "unhandled exception
+ * filter" is called. Breakpad uses the unhandled exception filter to do crash
+ * reporting. Unfortunately, on Win64, JIT code on the stack completely throws
+ * off this unwinding process and prevents the unhandled exception filter from
+ * being called. The reason is that Win64 requires unwind information be
+ * registered for all code regions and JIT code has none. While it is possible
+ * to register full unwind information for JIT code, this is a lot of work (one
+ * has to be able to recover the frame pointer at any PC) so instead we register
+ * a handler for all JIT code that simply calls breakpad's unhandled exception
+ * filter (which will perform crash reporting and then terminate the process).
+ * This would be wrong if there was an outer __try block that expected to handle
+ * the fault, but this is not generally allowed.
+ *
+ * Gecko must call SetJitExceptionFilter before any JIT code is compiled and
+ * only once per process.
+ */
+extern JS_FRIEND_API(void)
+SetJitExceptionHandler(JitExceptionHandler handler);
+#endif
+
+/**
+ * Get the nearest enclosing with environment object for a given function. If
+ * the function is not scripted or is not enclosed by a with scope, returns
+ * the global.
+ */
+extern JS_FRIEND_API(JSObject*)
+GetNearestEnclosingWithEnvironmentObjectForFunction(JSFunction* fun);
+
+/**
+ * Get the first SavedFrame object in this SavedFrame stack whose principals are
+ * subsumed by the cx's principals. If there is no such frame, return nullptr.
+ *
+ * Do NOT pass a non-SavedFrame object here.
+ *
+ * The savedFrame and cx do not need to be in the same compartment.
+ */
+extern JS_FRIEND_API(JSObject*)
+GetFirstSubsumedSavedFrame(JSContext* cx, JS::HandleObject savedFrame, JS::SavedFrameSelfHosted selfHosted);
+
+extern JS_FRIEND_API(bool)
+ReportIsNotFunction(JSContext* cx, JS::HandleValue v);
+
+extern JS_FRIEND_API(JSObject*)
+ConvertArgsToArray(JSContext* cx, const JS::CallArgs& args);
+
+/**
+ * Window and WindowProxy
+ *
+ * The functions below have to do with Windows and WindowProxies. There's an
+ * invariant that actual Window objects (the global objects of web pages) are
+ * never directly exposed to script. Instead we often substitute a WindowProxy.
+ *
+ * The environment chain, on the other hand, contains the Window and never its
+ * WindowProxy.
+ *
+ * As a result, we have calls to these "substitute-this-object-for-that-object"
+ * functions sprinkled at apparently arbitrary (but actually *very* carefully
+ * and nervously selected) places throughout the engine and indeed the
+ * universe.
+ */
+
+/**
+ * Tell the JS engine which Class is used for WindowProxy objects. Used by the
+ * functions below.
+ */
+extern JS_FRIEND_API(void)
+SetWindowProxyClass(JSContext* cx, const Class* clasp);
+
+/**
+ * Associates a WindowProxy with a Window (global object). `windowProxy` must
+ * have the Class set by SetWindowProxyClass.
+ */
+extern JS_FRIEND_API(void)
+SetWindowProxy(JSContext* cx, JS::HandleObject global, JS::HandleObject windowProxy);
+
+namespace detail {
+
+JS_FRIEND_API(bool)
+IsWindowSlow(JSObject* obj);
+
+} // namespace detail
+
+/**
+ * Returns true iff `obj` is a global object with an associated WindowProxy,
+ * see SetWindowProxy.
+ */
+inline bool
+IsWindow(JSObject* obj)
+{
+ if (GetObjectClass(obj)->flags & JSCLASS_IS_GLOBAL)
+ return detail::IsWindowSlow(obj);
+ return false;
+}
+
+/**
+ * Returns true iff `obj` has the WindowProxy Class (see SetWindowProxyClass).
+ */
+JS_FRIEND_API(bool)
+IsWindowProxy(JSObject* obj);
+
+/**
+ * If `obj` is a Window, get its associated WindowProxy (or a CCW or dead
+ * wrapper if the page was navigated away from), else return `obj`. This
+ * function is infallible and never returns nullptr.
+ */
+extern JS_FRIEND_API(JSObject*)
+ToWindowProxyIfWindow(JSObject* obj);
+
+/**
+ * If `obj` is a WindowProxy, get its associated Window (the compartment's
+ * global), else return `obj`. This function is infallible and never returns
+ * nullptr.
+ */
+extern JS_FRIEND_API(JSObject*)
+ToWindowIfWindowProxy(JSObject* obj);
+
+} /* namespace js */
+
+class NativeProfiler
+{
+ public:
+ virtual ~NativeProfiler() {};
+ virtual void sampleNative(void* addr, uint32_t size) = 0;
+ virtual void removeNative(void* addr) = 0;
+ virtual void reset() = 0;
+};
+
+class GCHeapProfiler
+{
+ public:
+ virtual ~GCHeapProfiler() {};
+ virtual void sampleTenured(void* addr, uint32_t size) = 0;
+ virtual void sampleNursery(void* addr, uint32_t size) = 0;
+ virtual void markTenuredStart() = 0;
+ virtual void markTenured(void* addr) = 0;
+ virtual void sweepTenured() = 0;
+ virtual void sweepNursery() = 0;
+ virtual void moveNurseryToTenured(void* addrOld, void* addrNew) = 0;
+ virtual void reset() = 0;
+};
+
+class MemProfiler
+{
+ static mozilla::Atomic<uint32_t, mozilla::Relaxed> sActiveProfilerCount;
+ static JS_FRIEND_DATA(NativeProfiler*) sNativeProfiler;
+
+ static GCHeapProfiler* GetGCHeapProfiler(void* addr);
+ static GCHeapProfiler* GetGCHeapProfiler(JSRuntime* runtime);
+
+ static NativeProfiler* GetNativeProfiler() {
+ return sNativeProfiler;
+ }
+
+ GCHeapProfiler* mGCHeapProfiler;
+ JSRuntime* mRuntime;
+
+ public:
+ explicit MemProfiler(JSRuntime* aRuntime) : mGCHeapProfiler(nullptr), mRuntime(aRuntime) {}
+
+ JS_FRIEND_API(void) start(GCHeapProfiler* aGCHeapProfiler);
+ JS_FRIEND_API(void) stop();
+
+ GCHeapProfiler* getGCHeapProfiler() const {
+ return mGCHeapProfiler;
+ }
+
+ static MOZ_ALWAYS_INLINE bool enabled() {
+ return sActiveProfilerCount > 0;
+ }
+
+ static JS_FRIEND_API(MemProfiler*) GetMemProfiler(JSContext* context);
+
+ static void SetNativeProfiler(NativeProfiler* aProfiler) {
+ sNativeProfiler = aProfiler;
+ }
+
+ static MOZ_ALWAYS_INLINE void SampleNative(void* addr, uint32_t size) {
+ JS::AutoSuppressGCAnalysis nogc;
+
+ if (MOZ_LIKELY(!enabled()))
+ return;
+
+ NativeProfiler* profiler = GetNativeProfiler();
+ if (profiler)
+ profiler->sampleNative(addr, size);
+ }
+
+ static MOZ_ALWAYS_INLINE void SampleTenured(void* addr, uint32_t size) {
+ JS::AutoSuppressGCAnalysis nogc;
+
+ if (MOZ_LIKELY(!enabled()))
+ return;
+
+ GCHeapProfiler* profiler = GetGCHeapProfiler(addr);
+ if (profiler)
+ profiler->sampleTenured(addr, size);
+ }
+
+ static MOZ_ALWAYS_INLINE void SampleNursery(void* addr, uint32_t size) {
+ JS::AutoSuppressGCAnalysis nogc;
+
+ if (MOZ_LIKELY(!enabled()))
+ return;
+
+ GCHeapProfiler* profiler = GetGCHeapProfiler(addr);
+ if (profiler)
+ profiler->sampleNursery(addr, size);
+ }
+
+ static MOZ_ALWAYS_INLINE void RemoveNative(void* addr) {
+ JS::AutoSuppressGCAnalysis nogc;
+
+ if (MOZ_LIKELY(!enabled()))
+ return;
+
+ NativeProfiler* profiler = GetNativeProfiler();
+ if (profiler)
+ profiler->removeNative(addr);
+ }
+
+ static MOZ_ALWAYS_INLINE void MarkTenuredStart(JSRuntime* runtime) {
+ JS::AutoSuppressGCAnalysis nogc;
+
+ if (MOZ_LIKELY(!enabled()))
+ return;
+
+ GCHeapProfiler* profiler = GetGCHeapProfiler(runtime);
+ if (profiler)
+ profiler->markTenuredStart();
+ }
+
+ static MOZ_ALWAYS_INLINE void MarkTenured(void* addr) {
+ JS::AutoSuppressGCAnalysis nogc;
+
+ if (MOZ_LIKELY(!enabled()))
+ return;
+
+ GCHeapProfiler* profiler = GetGCHeapProfiler(addr);
+ if (profiler)
+ profiler->markTenured(addr);
+ }
+
+ static MOZ_ALWAYS_INLINE void SweepTenured(JSRuntime* runtime) {
+ JS::AutoSuppressGCAnalysis nogc;
+
+ if (MOZ_LIKELY(!enabled()))
+ return;
+
+ GCHeapProfiler* profiler = GetGCHeapProfiler(runtime);
+ if (profiler)
+ profiler->sweepTenured();
+ }
+
+ static MOZ_ALWAYS_INLINE void SweepNursery(JSRuntime* runtime) {
+ JS::AutoSuppressGCAnalysis nogc;
+
+ if (MOZ_LIKELY(!enabled()))
+ return;
+
+ GCHeapProfiler* profiler = GetGCHeapProfiler(runtime);
+ if (profiler)
+ profiler->sweepNursery();
+ }
+
+ static MOZ_ALWAYS_INLINE void MoveNurseryToTenured(void* addrOld, void* addrNew) {
+ JS::AutoSuppressGCAnalysis nogc;
+
+ if (MOZ_LIKELY(!enabled()))
+ return;
+
+ GCHeapProfiler* profiler = GetGCHeapProfiler(addrOld);
+ if (profiler)
+ profiler->moveNurseryToTenured(addrOld, addrNew);
+ }
+};
+
+#endif /* jsfriendapi_h */
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-10 22:43:13 +0000