Adding upstream version 124.0.1.upstream/124.0.1

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

1 files changed, 1553 insertions, 0 deletions

diff --git a/js/public/Value.h b/js/public/Value.h
new file mode 100644
index 0000000000..59f71da4f1
--- /dev/null
+++ b/js/public/Value.h
@@ -0,0 +1,1553 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ * vim: set ts=8 sts=2 et sw=2 tw=80:
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/* JS::Value implementation. */
+
+#ifndef js_Value_h
+#define js_Value_h
+
+#include "mozilla/Attributes.h"
+#include "mozilla/Casting.h"
+#include "mozilla/FloatingPoint.h"
+#include "mozilla/Likely.h"
+#include "mozilla/Maybe.h"
+
+#include <limits> /* for std::numeric_limits */
+#include <type_traits>
+
+#include "jstypes.h"
+
+#include "js/HeapAPI.h"
+#include "js/RootingAPI.h"
+#include "js/TypeDecls.h"
+
+namespace JS {
+class JS_PUBLIC_API Value;
+}
+
+// [SMDOC] JS::Value Boxing Formats
+//
+// JS::Value is a 64-bit value, on all architectures. It is conceptually a
+// discriminated union of all the types of values that can be represented in SM:
+// - Object Pointers
+// - 64 bit IEEE 754 floats
+// - 32-bit integer values
+// - and quite a few more (see JSValueType)
+//
+// The ECMAScript standard specifies that ECMAScript numbers are IEEE 64-bit
+// floating-point values. A JS::Value can represent any JavaScript number
+// value directly, without referring to additional storage, or represent an
+// object, string, or other ECMAScript value, and remember which type it is.
+//
+// This may seem surprising: how can a 64-bit type hold all the 64-bit IEEE
+// values, and still distinguish them from objects, strings, and so on,
+// which have 64-bit addresses ?
+//
+// This is possible for two reasons:
+//
+// - First, ECMAScript implementations aren't required to distinguish all
+//   the values the IEEE 64-bit format can represent.
+//
+//   The IEEE 754 format for floating point numbers specifies that every
+//   floating-point value whose 11-bit exponent field is all ones, and whose
+//   52-bit fraction field is non-zero, has the value NaN. EMCAScript requires
+//   only one NaN value. This means we can use one IEEE NaN to represent
+//   ECMAScript's NaN, and use all the other 2^52-2 NaN bitstrings to
+//   represent the other ECMAScript values.
+//
+// - Second, on the 64 bit architectures we suppport, only the
+//   lower 48 bits of an address are currently significant. The upper sixteen
+//   bits are required to be the sign-extension of bit 48. Furthermore, user
+//   code always runs in "positive addresses": those in which bit 48 is zero. So
+//   we only actually need 47 bits to store all possible object or string
+//   addresses, even on 64-bit platforms.
+//
+//   Our memory initialization system ensures that all pointers we will store in
+//   objects use only 47 bits. See js::gc::MapAlignedPagesRandom.
+//
+//   The introduction of 5-level page tables, supporting 57-bit virtual
+//   addresses, is a potential complication. For now, large addresses are
+//   opt-in, and we simply don't use them.
+//
+// With a 52-bit fraction field, and 47 bits needed for the 'payload', we
+// have up to five bits left to store a 'tag' value, to indicate which
+// branch of our discriminated union is live. (In practice, one of those
+// bits is used up to simplify NaN representation; see micro-optimization 5
+// below.)
+//
+// Thus, we define JS::Value representations in terms of the IEEE 64-bit
+// floating-point format:
+//
+// - Any bitstring that IEEE calls a number or an infinity represents that
+//   ECMAScript number.
+//
+// - Any bitstring that IEEE calls a NaN represents either an ECMAScript NaN
+//   or a non-number ECMAScript value, as determined by a tag field stored
+//   towards the most significant end of the fraction field (exactly where
+//   depends on the address size). If the tag field indicates that this
+//   JS::Value is an object, the fraction field's least significant end
+//   holds the address of a JSObject; if a string, the address of a
+//   JSString; and so on.
+//
+//   To enforce this invariant, anywhere that may provide a numerical value
+//   which may have a non-canonical NaN value (NaN, but not the one we've chosen
+//   for ECMAScript) we must convert that to the canonical NaN. See
+//   JS::CanonicalizeNaN.
+//
+// We have two boxing modes defined: NUNBOX32 and PUNBOX64.The first is
+// "NaN unboxed boxing" (or Nunboxing), as non-Number payload are stored
+// unaltered in the lower bits. The second is "Packed NaN boxing" (or
+// punboxing), which is 'logically like nunboxing, but with all the unused bits
+// sucked out' [1],  as we rely on unused bits of the payload to pack the
+// payload in the lower bits using Nunboxing.
+//
+// - In NUNBOX32 the tag is stored in the least-significant bits of the high
+//   word of the NaN. Since it's used on 32-bit systems, this has the nice
+//   property that boxed values are simply stored in the low-word of the 8-byte
+//   NaN.
+//
+// - In PUNBOX64, since we need to store more pointer bits (47, see above), the
+//   tag is stored in the 5 most significant bits of the fraction adjacent to
+//   the exponent.
+//
+// Tag values are carefully ordered to support a set of micro-optimizations. In
+// particular:
+//
+// 1. Object is the highest tag, to simplify isPrimitive checks. (See
+//    ValueUpperExclPrimitiveTag)
+// 2. Numbers (Double and Int32) are the lowest tags, to simplify isNumber
+//    checks. (See ValueUpperInclNumberTag)
+// 3. Non-GC tags are ordered before GC-tags, to simplify isGCThing checks. (See
+//    ValueLowerInclGCThingTag)
+// 4. The tags for Object and Null differ by a single flipped bit, to simplify
+//    toObjectOrNull. (See ValueObjectOrNullBit)
+// 5. In PUNBOX64, the most significant bit of every non-Double tag is always
+//    set. This is to simplify isDouble checks. Note that the highest bitstring
+//    that corresponds to a non-NaN double is -Infinity:
+//      0xfff0_0000_0000_0000
+//    But the canonical hardware NaN (produced by, for example, 0/0) is:
+//      0x?ff8_0000_0000_0000
+//    on all platforms with JIT support*. (The most significant bit is the sign
+//    bit; it is 1 on x86, but 0 on ARM.) The most significant bit of the
+//    fraction field is set, which corresponds to the most significant of the 5
+//    tag bits. Because we only use tags that have the high bit set, any Value
+//    represented by a bitstring less than or equal to 0xfff8_..._0000 is a
+//    Double. (If we wanted to use all five bits, we could define 0x10 as
+//    JSVAL_TYPE_NAN, and mask off the most significant bit of the tag for
+//    IsDouble checks. This is not yet necessary, because we still have room
+//    left to allocate new tags.)
+//
+//    * But see JS_NONCANONICAL_HARDWARE_NAN below.
+//
+// [1]:
+// https://wingolog.org/archives/2011/05/18/value-representation-in-javascript-implementations#969f63bbe4eb912778c9da85feb0f5763e7a7862
+
+/* JS::Value can store a full int32_t. */
+#define JSVAL_INT_BITS 32
+#define JSVAL_INT_MIN ((int32_t)0x80000000)
+#define JSVAL_INT_MAX ((int32_t)0x7fffffff)
+
+#if defined(JS_NUNBOX32)
+#  define JSVAL_TAG_SHIFT 32
+#elif defined(JS_PUNBOX64)
+#  define JSVAL_TAG_SHIFT 47
+#endif
+
+// Use enums so that printing a JS::Value in the debugger shows nice
+// symbolic type tags.
+
+enum JSValueType : uint8_t {
+  JSVAL_TYPE_DOUBLE = 0x00,
+  JSVAL_TYPE_INT32 = 0x01,
+  JSVAL_TYPE_BOOLEAN = 0x02,
+  JSVAL_TYPE_UNDEFINED = 0x03,
+  JSVAL_TYPE_NULL = 0x04,
+  JSVAL_TYPE_MAGIC = 0x05,
+  JSVAL_TYPE_STRING = 0x06,
+  JSVAL_TYPE_SYMBOL = 0x07,
+  JSVAL_TYPE_PRIVATE_GCTHING = 0x08,
+  JSVAL_TYPE_BIGINT = 0x09,
+#ifdef ENABLE_RECORD_TUPLE
+  JSVAL_TYPE_EXTENDED_PRIMITIVE = 0x0b,
+#endif
+  JSVAL_TYPE_OBJECT = 0x0c,
+
+  // This type never appears in a Value; it's only an out-of-band value.
+  JSVAL_TYPE_UNKNOWN = 0x20
+};
+
+namespace JS {
+enum class ValueType : uint8_t {
+  Double = JSVAL_TYPE_DOUBLE,
+  Int32 = JSVAL_TYPE_INT32,
+  Boolean = JSVAL_TYPE_BOOLEAN,
+  Undefined = JSVAL_TYPE_UNDEFINED,
+  Null = JSVAL_TYPE_NULL,
+  Magic = JSVAL_TYPE_MAGIC,
+  String = JSVAL_TYPE_STRING,
+  Symbol = JSVAL_TYPE_SYMBOL,
+  PrivateGCThing = JSVAL_TYPE_PRIVATE_GCTHING,
+  BigInt = JSVAL_TYPE_BIGINT,
+#ifdef ENABLE_RECORD_TUPLE
+  ExtendedPrimitive = JSVAL_TYPE_EXTENDED_PRIMITIVE,
+#endif
+  Object = JSVAL_TYPE_OBJECT,
+};
+}  // namespace JS
+
+static_assert(sizeof(JSValueType) == 1,
+              "compiler typed enum support is apparently buggy");
+
+#if defined(JS_NUNBOX32)
+
+enum JSValueTag : uint32_t {
+  JSVAL_TAG_CLEAR = 0xFFFFFF80,
+  JSVAL_TAG_INT32 = JSVAL_TAG_CLEAR | JSVAL_TYPE_INT32,
+  JSVAL_TAG_UNDEFINED = JSVAL_TAG_CLEAR | JSVAL_TYPE_UNDEFINED,
+  JSVAL_TAG_NULL = JSVAL_TAG_CLEAR | JSVAL_TYPE_NULL,
+  JSVAL_TAG_BOOLEAN = JSVAL_TAG_CLEAR | JSVAL_TYPE_BOOLEAN,
+  JSVAL_TAG_MAGIC = JSVAL_TAG_CLEAR | JSVAL_TYPE_MAGIC,
+  JSVAL_TAG_STRING = JSVAL_TAG_CLEAR | JSVAL_TYPE_STRING,
+  JSVAL_TAG_SYMBOL = JSVAL_TAG_CLEAR | JSVAL_TYPE_SYMBOL,
+  JSVAL_TAG_PRIVATE_GCTHING = JSVAL_TAG_CLEAR | JSVAL_TYPE_PRIVATE_GCTHING,
+  JSVAL_TAG_BIGINT = JSVAL_TAG_CLEAR | JSVAL_TYPE_BIGINT,
+#  ifdef ENABLE_RECORD_TUPLE
+  JSVAL_TAG_EXTENDED_PRIMITIVE =
+      JSVAL_TAG_CLEAR | JSVAL_TYPE_EXTENDED_PRIMITIVE,
+#  endif
+  JSVAL_TAG_OBJECT = JSVAL_TAG_CLEAR | JSVAL_TYPE_OBJECT
+};
+
+static_assert(sizeof(JSValueTag) == sizeof(uint32_t),
+              "compiler typed enum support is apparently buggy");
+
+#elif defined(JS_PUNBOX64)
+
+enum JSValueTag : uint32_t {
+  JSVAL_TAG_MAX_DOUBLE = 0x1FFF0,
+  JSVAL_TAG_INT32 = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_INT32,
+  JSVAL_TAG_UNDEFINED = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_UNDEFINED,
+  JSVAL_TAG_NULL = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_NULL,
+  JSVAL_TAG_BOOLEAN = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_BOOLEAN,
+  JSVAL_TAG_MAGIC = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_MAGIC,
+  JSVAL_TAG_STRING = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_STRING,
+  JSVAL_TAG_SYMBOL = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_SYMBOL,
+  JSVAL_TAG_PRIVATE_GCTHING = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_PRIVATE_GCTHING,
+  JSVAL_TAG_BIGINT = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_BIGINT,
+#  ifdef ENABLE_RECORD_TUPLE
+  JSVAL_TAG_EXTENDED_PRIMITIVE =
+      JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_EXTENDED_PRIMITIVE,
+#  endif
+  JSVAL_TAG_OBJECT = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_OBJECT
+};
+
+static_assert(sizeof(JSValueTag) == sizeof(uint32_t),
+              "compiler typed enum support is apparently buggy");
+
+enum JSValueShiftedTag : uint64_t {
+  // See Bug 584653 for why we include 0xFFFFFFFF.
+  JSVAL_SHIFTED_TAG_MAX_DOUBLE =
+      ((uint64_t(JSVAL_TAG_MAX_DOUBLE) << JSVAL_TAG_SHIFT) | 0xFFFFFFFF),
+  JSVAL_SHIFTED_TAG_INT32 = (uint64_t(JSVAL_TAG_INT32) << JSVAL_TAG_SHIFT),
+  JSVAL_SHIFTED_TAG_UNDEFINED =
+      (uint64_t(JSVAL_TAG_UNDEFINED) << JSVAL_TAG_SHIFT),
+  JSVAL_SHIFTED_TAG_NULL = (uint64_t(JSVAL_TAG_NULL) << JSVAL_TAG_SHIFT),
+  JSVAL_SHIFTED_TAG_BOOLEAN = (uint64_t(JSVAL_TAG_BOOLEAN) << JSVAL_TAG_SHIFT),
+  JSVAL_SHIFTED_TAG_MAGIC = (uint64_t(JSVAL_TAG_MAGIC) << JSVAL_TAG_SHIFT),
+  JSVAL_SHIFTED_TAG_STRING = (uint64_t(JSVAL_TAG_STRING) << JSVAL_TAG_SHIFT),
+  JSVAL_SHIFTED_TAG_SYMBOL = (uint64_t(JSVAL_TAG_SYMBOL) << JSVAL_TAG_SHIFT),
+  JSVAL_SHIFTED_TAG_PRIVATE_GCTHING =
+      (uint64_t(JSVAL_TAG_PRIVATE_GCTHING) << JSVAL_TAG_SHIFT),
+  JSVAL_SHIFTED_TAG_BIGINT = (uint64_t(JSVAL_TAG_BIGINT) << JSVAL_TAG_SHIFT),
+#  ifdef ENABLE_RECORD_TUPLE
+  JSVAL_SHIFTED_TAG_EXTENDED_PRIMITIVE =
+      (uint64_t(JSVAL_TYPE_EXTENDED_PRIMITIVE) << JSVAL_TAG_SHIFT),
+#  endif
+  JSVAL_SHIFTED_TAG_OBJECT = (uint64_t(JSVAL_TAG_OBJECT) << JSVAL_TAG_SHIFT)
+};
+
+static_assert(sizeof(JSValueShiftedTag) == sizeof(uint64_t),
+              "compiler typed enum support is apparently buggy");
+
+#endif
+
+namespace JS {
+namespace detail {
+
+#if defined(JS_NUNBOX32)
+
+constexpr JSValueTag ValueTypeToTag(JSValueType type) {
+  return static_cast<JSValueTag>(JSVAL_TAG_CLEAR |
+                                 std::underlying_type_t<JSValueType>(type));
+}
+
+constexpr bool ValueIsDouble(uint64_t bits) {
+  return uint32_t(bits >> JSVAL_TAG_SHIFT) <= uint32_t(JSVAL_TAG_CLEAR);
+}
+
+constexpr JSValueTag ValueUpperExclPrimitiveTag = JSVAL_TAG_OBJECT;
+constexpr JSValueTag ValueUpperInclNumberTag = JSVAL_TAG_INT32;
+constexpr JSValueTag ValueLowerInclGCThingTag = JSVAL_TAG_STRING;
+
+#elif defined(JS_PUNBOX64)
+
+constexpr JSValueTag ValueTypeToTag(JSValueType type) {
+  return static_cast<JSValueTag>(JSVAL_TAG_MAX_DOUBLE |
+                                 std::underlying_type_t<JSValueType>(type));
+}
+
+constexpr bool ValueIsDouble(uint64_t bits) {
+  return bits <= JSVAL_SHIFTED_TAG_MAX_DOUBLE;
+}
+
+constexpr uint64_t ValueTagMask = 0xFFFF'8000'0000'0000;
+
+// This should only be used in toGCThing. See the 'Spectre mitigations' comment.
+constexpr uint64_t ValueGCThingPayloadMask = 0x0000'7FFF'FFFF'FFFF;
+
+// Mask used to combine an unbox operation with getting the chunk base.
+constexpr uint64_t ValueGCThingPayloadChunkMask =
+    ValueGCThingPayloadMask & ~js::gc::ChunkMask;
+
+constexpr uint64_t ValueTypeToShiftedTag(JSValueType type) {
+  return static_cast<uint64_t>(ValueTypeToTag(type)) << JSVAL_TAG_SHIFT;
+}
+#  define JSVAL_TYPE_TO_SHIFTED_TAG(type) \
+    (JS::detail::ValueTypeToShiftedTag(type))
+
+constexpr JSValueTag ValueUpperExclPrimitiveTag = JSVAL_TAG_OBJECT;
+constexpr JSValueTag ValueUpperInclNumberTag = JSVAL_TAG_INT32;
+constexpr JSValueTag ValueLowerInclGCThingTag = JSVAL_TAG_STRING;
+
+constexpr uint64_t ValueUpperExclShiftedPrimitiveTag = JSVAL_SHIFTED_TAG_OBJECT;
+constexpr uint64_t ValueUpperExclShiftedNumberTag = JSVAL_SHIFTED_TAG_BOOLEAN;
+constexpr uint64_t ValueLowerInclShiftedGCThingTag = JSVAL_SHIFTED_TAG_STRING;
+
+// JSVAL_TYPE_OBJECT and JSVAL_TYPE_NULL differ by one bit. We can use this to
+// implement toObjectOrNull more efficiently.
+constexpr uint64_t ValueObjectOrNullBit = 0x8ULL << JSVAL_TAG_SHIFT;
+static_assert(
+    (JSVAL_SHIFTED_TAG_NULL ^ JSVAL_SHIFTED_TAG_OBJECT) == ValueObjectOrNullBit,
+    "ValueObjectOrNullBit must be consistent with object and null tags");
+
+constexpr uint64_t IsValidUserModePointer(uint64_t bits) {
+  // All 64-bit platforms that we support actually have a 48-bit address space
+  // for user-mode pointers, with the top 16 bits all set to zero.
+  return (bits & 0xFFFF'0000'0000'0000) == 0;
+}
+
+#endif /* JS_PUNBOX64 */
+
+}  // namespace detail
+}  // namespace JS
+
+#define JSVAL_TYPE_TO_TAG(type) (JS::detail::ValueTypeToTag(type))
+
+enum JSWhyMagic {
+  /** a hole in a native object's elements */
+  JS_ELEMENTS_HOLE,
+
+  /** there is not a pending iterator value */
+  JS_NO_ITER_VALUE,
+
+  /** exception value thrown when closing a generator */
+  JS_GENERATOR_CLOSING,
+
+  /** used in debug builds to catch tracing errors */
+  JS_ARG_POISON,
+
+  /** an empty subnode in the AST serializer */
+  JS_SERIALIZE_NO_NODE,
+
+  /** magic value passed to natives to indicate construction */
+  JS_IS_CONSTRUCTING,
+
+  /** see class js::HashableValue */
+  JS_HASH_KEY_EMPTY,
+
+  /** error while running Ion code */
+  JS_ION_ERROR,
+
+  /** missing recover instruction result */
+  JS_ION_BAILOUT,
+
+  /** optimized out slot */
+  JS_OPTIMIZED_OUT,
+
+  /** uninitialized lexical bindings that produce ReferenceError on touch. */
+  JS_UNINITIALIZED_LEXICAL,
+
+  /** arguments object can't be created because environment is dead. */
+  JS_MISSING_ARGUMENTS,
+
+  /** for local use */
+  JS_GENERIC_MAGIC,
+
+  /**
+   * When an error object is created without the error cause argument, we set
+   * the error's cause slot to this magic value.
+   */
+  JS_ERROR_WITHOUT_CAUSE,
+
+  JS_WHY_MAGIC_COUNT
+};
+
+namespace js {
+class JS_PUBLIC_API GenericPrinter;
+class JSONPrinter;
+
+static inline JS::Value PoisonedObjectValue(uintptr_t poison);
+#ifdef ENABLE_RECORD_TUPLE
+// Re-defined in vm/RecordTupleBoxShared.h. We cannot include that
+// file because it circularly includes this one.
+bool IsExtendedPrimitive(const JSObject& obj);
+namespace gc {
+bool MaybeForwardedIsExtendedPrimitive(const JSObject& obj);
+}  // namespace gc
+#endif
+}  // namespace js
+
+namespace JS {
+
+namespace detail {
+
+// IEEE-754 bit pattern for double-precision positive infinity.
+constexpr int InfinitySignBit = 0;
+constexpr uint64_t InfinityBits =
+    mozilla::InfinityBits<double, detail::InfinitySignBit>::value;
+
+// This is a quiet NaN on IEEE-754[2008] compatible platforms, including X86,
+// ARM, SPARC, RISC-V and modern MIPS.
+//
+// Note: The default sign bit for a hardware synthesized NaN differs between X86
+//       and ARM. Both values are considered compatible values on both
+//       platforms.
+constexpr int CanonicalizedNaNSignBit = 0;
+constexpr uint64_t CanonicalizedNaNSignificand = 0x8000000000000;
+
+#if defined(__sparc__)
+// Some architectures (not to name names) generate NaNs with bit patterns that
+// are incompatible with JS::Value's bit pattern restrictions. Instead we must
+// canonicalize all hardware values before storing in JS::Value.
+#  define JS_NONCANONICAL_HARDWARE_NAN
+#endif
+
+#if defined(__mips__) && !defined(__mips_nan_2008)
+// These builds may run on hardware that has differing polarity of the signaling
+// NaN bit. While the kernel may handle the trap for us, it is a performance
+// issue so instead we compute the NaN to use on startup. The runtime value must
+// still meet `ValueIsDouble` requirements which are checked on startup.
+
+// In particular, we expect one of the following values on MIPS:
+//  - 0x7FF7FFFFFFFFFFFF    Legacy
+//  - 0x7FF8000000000000    IEEE-754[2008]
+#  define JS_RUNTIME_CANONICAL_NAN
+#endif
+
+#if defined(JS_RUNTIME_CANONICAL_NAN)
+extern uint64_t CanonicalizedNaNBits;
+#else
+constexpr uint64_t CanonicalizedNaNBits =
+    mozilla::SpecificNaNBits<double, detail::CanonicalizedNaNSignBit,
+                             detail::CanonicalizedNaNSignificand>::value;
+#endif
+}  // namespace detail
+
+// Return a quiet NaN that is compatible with JS::Value restrictions.
+static MOZ_ALWAYS_INLINE double GenericNaN() {
+#if !defined(JS_RUNTIME_CANONICAL_NAN)
+  static_assert(detail::ValueIsDouble(detail::CanonicalizedNaNBits),
+                "Canonical NaN must be compatible with JS::Value");
+#endif
+
+  return mozilla::BitwiseCast<double>(detail::CanonicalizedNaNBits);
+}
+
+// Return the infinity the engine uses
+static MOZ_ALWAYS_INLINE double Infinity() {
+  return mozilla::BitwiseCast<double>(detail::InfinityBits);
+}
+
+// Convert an arbitrary double to one compatible with JS::Value representation
+// by replacing any NaN value with a canonical one.
+static MOZ_ALWAYS_INLINE double CanonicalizeNaN(double d) {
+  if (MOZ_UNLIKELY(std::isnan(d))) {
+    return GenericNaN();
+  }
+  return d;
+}
+
+/**
+ * [SMDOC] JS::Value type
+ *
+ * JS::Value is the interface for a single JavaScript Engine value.  A few
+ * general notes on JS::Value:
+ *
+ * - JS::Value has setX() and isX() members for X in
+ *
+ *     { Int32, Double, String, Symbol, BigInt, Boolean, Undefined, Null,
+ *       Object, Magic }
+ *
+ *   JS::Value also contains toX() for each of the non-singleton types.
+ *
+ * - Magic is a singleton type whose payload contains either a JSWhyMagic
+ *   "reason" for the magic value or a uint32_t value. By providing JSWhyMagic
+ *   values when creating and checking for magic values, it is possible to
+ *   assert, at runtime, that only magic values with the expected reason flow
+ *   through a particular value. For example, if cx->exception has a magic
+ *   value, the reason must be JS_GENERATOR_CLOSING.
+ *
+ * - The JS::Value operations are preferred.  The JSVAL_* operations remain for
+ *   compatibility; they may be removed at some point.  These operations mostly
+ *   provide similar functionality.  But there are a few key differences.  One
+ *   is that JS::Value gives null a separate type.
+ *   Also, to help prevent mistakenly boxing a nullable JSObject* as an object,
+ *   Value::setObject takes a JSObject&. (Conversely, Value::toObject returns a
+ *   JSObject&.)  A convenience member Value::setObjectOrNull is provided.
+ *
+ * - Note that JS::Value is 8 bytes on 32 and 64-bit architectures. Thus, on
+ *   32-bit user code should avoid copying jsval/JS::Value as much as possible,
+ *   preferring to pass by const Value&.
+ *
+ * Spectre mitigations
+ * ===================
+ * To mitigate Spectre attacks, we do the following:
+ *
+ * - On 64-bit platforms, when unboxing a Value, we XOR the bits with the
+ *   expected type tag (instead of masking the payload bits). This guarantees
+ *   that toString, toObject, toSymbol will return an invalid pointer (because
+ *   some high bits will be set) when called on a Value with a different type
+ *   tag.
+ *
+ * - On 32-bit platforms,when unboxing an object/string/symbol Value, we use a
+ *   conditional move (not speculated) to zero the payload register if the type
+ *   doesn't match.
+ */
+class alignas(8) Value {
+ private:
+  uint64_t asBits_;
+
+ public:
+  constexpr Value() : asBits_(bitsFromTagAndPayload(JSVAL_TAG_UNDEFINED, 0)) {}
+
+ private:
+  explicit constexpr Value(uint64_t asBits) : asBits_(asBits) {}
+
+  static uint64_t bitsFromDouble(double d) {
+#if defined(JS_NONCANONICAL_HARDWARE_NAN)
+    d = CanonicalizeNaN(d);
+#endif
+    return mozilla::BitwiseCast<uint64_t>(d);
+  }
+
+  static_assert(sizeof(JSValueType) == 1,
+                "type bits must fit in a single byte");
+  static_assert(sizeof(JSValueTag) == 4,
+                "32-bit Value's tag_ must have size 4 to complement the "
+                "payload union's size 4");
+  static_assert(sizeof(JSWhyMagic) <= 4,
+                "32-bit Value's JSWhyMagic payload field must not inflate "
+                "the payload beyond 4 bytes");
+
+ public:
+#if defined(JS_NUNBOX32)
+  using PayloadType = uint32_t;
+#elif defined(JS_PUNBOX64)
+  using PayloadType = uint64_t;
+#endif
+
+  static constexpr uint64_t bitsFromTagAndPayload(JSValueTag tag,
+                                                  PayloadType payload) {
+    return (uint64_t(tag) << JSVAL_TAG_SHIFT) | payload;
+  }
+
+  static constexpr Value fromTagAndPayload(JSValueTag tag,
+                                           PayloadType payload) {
+    return fromRawBits(bitsFromTagAndPayload(tag, payload));
+  }
+
+  static constexpr Value fromRawBits(uint64_t asBits) { return Value(asBits); }
+
+  static constexpr Value fromInt32(int32_t i) {
+    return fromTagAndPayload(JSVAL_TAG_INT32, uint32_t(i));
+  }
+
+  static Value fromDouble(double d) { return fromRawBits(bitsFromDouble(d)); }
+
+  /**
+   * Returns false if creating a NumberValue containing the given type would
+   * be lossy, true otherwise.
+   */
+  template <typename T>
+  static bool isNumberRepresentable(const T t) {
+    return T(double(t)) == t;
+  }
+
+  /*** Mutators ***/
+
+  void setNull() {
+    asBits_ = bitsFromTagAndPayload(JSVAL_TAG_NULL, 0);
+    MOZ_ASSERT(isNull());
+  }
+
+  void setUndefined() {
+    asBits_ = bitsFromTagAndPayload(JSVAL_TAG_UNDEFINED, 0);
+    MOZ_ASSERT(isUndefined());
+  }
+
+  void setInt32(int32_t i) {
+    asBits_ = bitsFromTagAndPayload(JSVAL_TAG_INT32, uint32_t(i));
+    MOZ_ASSERT(toInt32() == i);
+  }
+
+  void setDouble(double d) {
+    asBits_ = bitsFromDouble(d);
+    MOZ_ASSERT(isDouble());
+  }
+
+  void setString(JSString* str) {
+    MOZ_ASSERT(js::gc::IsCellPointerValid(str));
+    asBits_ = bitsFromTagAndPayload(JSVAL_TAG_STRING, PayloadType(str));
+    MOZ_ASSERT(toString() == str);
+  }
+
+  void setSymbol(JS::Symbol* sym) {
+    MOZ_ASSERT(js::gc::IsCellPointerValid(sym));
+    asBits_ = bitsFromTagAndPayload(JSVAL_TAG_SYMBOL, PayloadType(sym));
+    MOZ_ASSERT(toSymbol() == sym);
+  }
+
+  void setBigInt(JS::BigInt* bi) {
+    MOZ_ASSERT(js::gc::IsCellPointerValid(bi));
+    asBits_ = bitsFromTagAndPayload(JSVAL_TAG_BIGINT, PayloadType(bi));
+    MOZ_ASSERT(toBigInt() == bi);
+  }
+
+  void setObject(JSObject& obj) {
+    MOZ_ASSERT(js::gc::IsCellPointerValid(&obj));
+#ifdef ENABLE_RECORD_TUPLE
+    MOZ_ASSERT(!js::gc::MaybeForwardedIsExtendedPrimitive(obj));
+#endif
+    setObjectNoCheck(&obj);
+    MOZ_ASSERT(&toObject() == &obj);
+  }
+
+#ifdef ENABLE_RECORD_TUPLE
+  void setExtendedPrimitive(JSObject& obj) {
+    MOZ_ASSERT(js::gc::IsCellPointerValid(&obj));
+    MOZ_ASSERT(js::gc::MaybeForwardedIsExtendedPrimitive(obj));
+    asBits_ =
+        bitsFromTagAndPayload(JSVAL_TAG_EXTENDED_PRIMITIVE, PayloadType(&obj));
+    MOZ_ASSERT(&toExtendedPrimitive() == &obj);
+  }
+#endif
+
+ private:
+  void setObjectNoCheck(JSObject* obj) {
+    asBits_ = bitsFromTagAndPayload(JSVAL_TAG_OBJECT, PayloadType(obj));
+  }
+
+  friend inline Value js::PoisonedObjectValue(uintptr_t poison);
+
+ public:
+  void setBoolean(bool b) {
+    asBits_ = bitsFromTagAndPayload(JSVAL_TAG_BOOLEAN, uint32_t(b));
+    MOZ_ASSERT(toBoolean() == b);
+  }
+
+  void setMagic(JSWhyMagic why) {
+    asBits_ = bitsFromTagAndPayload(JSVAL_TAG_MAGIC, uint32_t(why));
+    MOZ_ASSERT(whyMagic() == why);
+  }
+
+  void setMagicUint32(uint32_t payload) {
+    MOZ_ASSERT(payload >= JS_WHY_MAGIC_COUNT,
+               "This should only be used for non-standard magic values");
+    asBits_ = bitsFromTagAndPayload(JSVAL_TAG_MAGIC, payload);
+    MOZ_ASSERT(magicUint32() == payload);
+  }
+
+  void setNumber(float f) {
+    int32_t i;
+    if (mozilla::NumberIsInt32(f, &i)) {
+      setInt32(i);
+      return;
+    }
+
+    setDouble(double(f));
+  }
+
+  void setNumber(double d) {
+    int32_t i;
+    if (mozilla::NumberIsInt32(d, &i)) {
+      setInt32(i);
+      return;
+    }
+
+    setDouble(d);
+  }
+
+  template <typename T>
+  void setNumber(const T t) {
+    static_assert(std::is_integral<T>::value, "must be integral type");
+    MOZ_ASSERT(isNumberRepresentable(t), "value creation would be lossy");
+
+    if constexpr (std::numeric_limits<T>::is_signed) {
+      if constexpr (sizeof(t) <= sizeof(int32_t)) {
+        setInt32(int32_t(t));
+      } else {
+        if (JSVAL_INT_MIN <= t && t <= JSVAL_INT_MAX) {
+          setInt32(int32_t(t));
+        } else {
+          setDouble(double(t));
+        }
+      }
+    } else {
+      if constexpr (sizeof(t) <= sizeof(uint16_t)) {
+        setInt32(int32_t(t));
+      } else {
+        if (t <= JSVAL_INT_MAX) {
+          setInt32(int32_t(t));
+        } else {
+          setDouble(double(t));
+        }
+      }
+    }
+  }
+
+  void setObjectOrNull(JSObject* arg) {
+    if (arg) {
+      setObject(*arg);
+    } else {
+      setNull();
+    }
+  }
+
+  void swap(Value& rhs) {
+    uint64_t tmp = rhs.asBits_;
+    rhs.asBits_ = asBits_;
+    asBits_ = tmp;
+  }
+
+ private:
+  JSValueTag toTag() const { return JSValueTag(asBits_ >> JSVAL_TAG_SHIFT); }
+
+  template <typename T, JSValueTag Tag>
+  T* unboxGCPointer() const {
+    MOZ_ASSERT((asBits_ & js::gc::CellAlignMask) == 0,
+               "GC pointer is not aligned. Is this memory corruption?");
+#if defined(JS_NUNBOX32)
+    uintptr_t payload = uint32_t(asBits_);
+    return reinterpret_cast<T*>(payload);
+#elif defined(JS_PUNBOX64)
+    // Note: the 'Spectre mitigations' comment at the top of this class
+    // explains why we use XOR here.
+    constexpr uint64_t shiftedTag = uint64_t(Tag) << JSVAL_TAG_SHIFT;
+    return reinterpret_cast<T*>(uintptr_t(asBits_ ^ shiftedTag));
+#endif
+  }
+
+ public:
+  /*** JIT-only interfaces to interact with and create raw Values ***/
+#if defined(JS_NUNBOX32)
+  PayloadType toNunboxPayload() const { return uint32_t(asBits_); }
+
+  JSValueTag toNunboxTag() const { return toTag(); }
+#elif defined(JS_PUNBOX64)
+  const void* bitsAsPunboxPointer() const {
+    return reinterpret_cast<void*>(asBits_);
+  }
+#endif
+
+  /*** Value type queries ***/
+
+  /*
+   * N.B. GCC, in some but not all cases, chooses to emit signed comparison
+   * of JSValueTag even though its underlying type has been forced to be
+   * uint32_t.  Thus, all comparisons should explicitly cast operands to
+   * uint32_t.
+   */
+
+  bool isUndefined() const {
+#if defined(JS_NUNBOX32)
+    return toTag() == JSVAL_TAG_UNDEFINED;
+#elif defined(JS_PUNBOX64)
+    return asBits_ == JSVAL_SHIFTED_TAG_UNDEFINED;
+#endif
+  }
+
+  bool isNull() const {
+#if defined(JS_NUNBOX32)
+    return toTag() == JSVAL_TAG_NULL;
+#elif defined(JS_PUNBOX64)
+    return asBits_ == JSVAL_SHIFTED_TAG_NULL;
+#endif
+  }
+
+  bool isNullOrUndefined() const { return isNull() || isUndefined(); }
+
+  bool isInt32() const { return toTag() == JSVAL_TAG_INT32; }
+
+  bool isInt32(int32_t i32) const {
+    return asBits_ == bitsFromTagAndPayload(JSVAL_TAG_INT32, uint32_t(i32));
+  }
+
+  bool isDouble() const { return detail::ValueIsDouble(asBits_); }
+
+  bool isNumber() const {
+#if defined(JS_NUNBOX32)
+    MOZ_ASSERT(toTag() != JSVAL_TAG_CLEAR);
+    return uint32_t(toTag()) <= uint32_t(detail::ValueUpperInclNumberTag);
+#elif defined(JS_PUNBOX64)
+    return asBits_ < detail::ValueUpperExclShiftedNumberTag;
+#endif
+  }
+
+  bool isString() const { return toTag() == JSVAL_TAG_STRING; }
+
+  bool isSymbol() const { return toTag() == JSVAL_TAG_SYMBOL; }
+
+  bool isBigInt() const { return toTag() == JSVAL_TAG_BIGINT; }
+
+  bool isObject() const {
+#if defined(JS_NUNBOX32)
+    return toTag() == JSVAL_TAG_OBJECT;
+#elif defined(JS_PUNBOX64)
+    MOZ_ASSERT((asBits_ >> JSVAL_TAG_SHIFT) <= JSVAL_TAG_OBJECT);
+    return asBits_ >= JSVAL_SHIFTED_TAG_OBJECT;
+#endif
+  }
+
+#ifdef ENABLE_RECORD_TUPLE
+  bool isExtendedPrimitive() const {
+    return toTag() == JSVAL_TAG_EXTENDED_PRIMITIVE;
+  }
+#endif
+
+  bool hasObjectPayload() const {
+    return isObject() || IF_RECORD_TUPLE(isExtendedPrimitive(), false);
+  }
+
+  bool isPrimitive() const {
+#if defined(JS_NUNBOX32)
+    return uint32_t(toTag()) < uint32_t(detail::ValueUpperExclPrimitiveTag);
+#elif defined(JS_PUNBOX64)
+    return asBits_ < detail::ValueUpperExclShiftedPrimitiveTag;
+#endif
+  }
+
+  bool isObjectOrNull() const { return isObject() || isNull(); }
+
+  bool isNumeric() const { return isNumber() || isBigInt(); }
+
+  bool isGCThing() const {
+#if defined(JS_NUNBOX32)
+    /* gcc sometimes generates signed < without explicit casts. */
+    return uint32_t(toTag()) >= uint32_t(detail::ValueLowerInclGCThingTag);
+#elif defined(JS_PUNBOX64)
+    return asBits_ >= detail::ValueLowerInclShiftedGCThingTag;
+#endif
+  }
+
+  bool isBoolean() const { return toTag() == JSVAL_TAG_BOOLEAN; }
+
+  bool isTrue() const {
+    return asBits_ == bitsFromTagAndPayload(JSVAL_TAG_BOOLEAN, uint32_t(true));
+  }
+
+  bool isFalse() const {
+    return asBits_ == bitsFromTagAndPayload(JSVAL_TAG_BOOLEAN, uint32_t(false));
+  }
+
+  bool isMagic() const { return toTag() == JSVAL_TAG_MAGIC; }
+
+  bool isMagic(JSWhyMagic why) const {
+    if (!isMagic()) {
+      return false;
+    }
+    MOZ_RELEASE_ASSERT(whyMagic() == why);
+    return true;
+  }
+
+  // Like isMagic, but without the release assertion.
+  bool isMagicNoReleaseCheck(JSWhyMagic why) const {
+    if (!isMagic()) {
+      return false;
+    }
+    MOZ_ASSERT(whyMagic() == why);
+    return true;
+  }
+
+  JS::TraceKind traceKind() const {
+    MOZ_ASSERT(isGCThing());
+    static_assert((JSVAL_TAG_STRING & 0x03) == size_t(JS::TraceKind::String),
+                  "Value type tags must correspond with JS::TraceKinds.");
+    static_assert((JSVAL_TAG_SYMBOL & 0x03) == size_t(JS::TraceKind::Symbol),
+                  "Value type tags must correspond with JS::TraceKinds.");
+    static_assert((JSVAL_TAG_OBJECT & 0x03) == size_t(JS::TraceKind::Object),
+                  "Value type tags must correspond with JS::TraceKinds.");
+    static_assert((JSVAL_TAG_BIGINT & 0x03) == size_t(JS::TraceKind::BigInt),
+                  "Value type tags must correspond with JS::TraceKinds.");
+    if (MOZ_UNLIKELY(isPrivateGCThing())) {
+      return JS::GCThingTraceKind(toGCThing());
+    }
+#ifdef ENABLE_RECORD_TUPLE
+    if (isExtendedPrimitive()) {
+      return JS::TraceKind::Object;
+    }
+#endif
+    return JS::TraceKind(toTag() & 0x03);
+  }
+
+  JSWhyMagic whyMagic() const {
+    MOZ_ASSERT(magicUint32() < JS_WHY_MAGIC_COUNT);
+    return static_cast<JSWhyMagic>(magicUint32());
+  }
+
+  uint32_t magicUint32() const {
+    MOZ_ASSERT(isMagic());
+    return uint32_t(asBits_);
+  }
+
+  /*** Comparison ***/
+
+  bool operator==(const Value& rhs) const { return asBits_ == rhs.asBits_; }
+
+  bool operator!=(const Value& rhs) const { return asBits_ != rhs.asBits_; }
+
+  friend inline bool SameType(const Value& lhs, const Value& rhs);
+
+  /*** Extract the value's typed payload ***/
+
+  int32_t toInt32() const {
+    MOZ_ASSERT(isInt32());
+    return int32_t(asBits_);
+  }
+
+  double toDouble() const {
+    MOZ_ASSERT(isDouble());
+    return mozilla::BitwiseCast<double>(asBits_);
+  }
+
+  double toNumber() const {
+    MOZ_ASSERT(isNumber());
+    return isDouble() ? toDouble() : double(toInt32());
+  }
+
+  JSString* toString() const {
+    MOZ_ASSERT(isString());
+    return unboxGCPointer<JSString, JSVAL_TAG_STRING>();
+  }
+
+  JS::Symbol* toSymbol() const {
+    MOZ_ASSERT(isSymbol());
+    return unboxGCPointer<JS::Symbol, JSVAL_TAG_SYMBOL>();
+  }
+
+  JS::BigInt* toBigInt() const {
+    MOZ_ASSERT(isBigInt());
+    return unboxGCPointer<JS::BigInt, JSVAL_TAG_BIGINT>();
+  }
+
+  JSObject& toObject() const {
+    MOZ_ASSERT(isObject());
+#if defined(JS_PUNBOX64)
+    MOZ_ASSERT((asBits_ & detail::ValueGCThingPayloadMask) != 0);
+#endif
+    return *unboxGCPointer<JSObject, JSVAL_TAG_OBJECT>();
+  }
+
+  JSObject* toObjectOrNull() const {
+    MOZ_ASSERT(isObjectOrNull());
+#if defined(JS_NUNBOX32)
+    return reinterpret_cast<JSObject*>(uintptr_t(asBits_));
+#elif defined(JS_PUNBOX64)
+    // Note: the 'Spectre mitigations' comment at the top of this class
+    // explains why we use XOR here and in other to* methods.
+    uint64_t ptrBits =
+        (asBits_ ^ JSVAL_SHIFTED_TAG_OBJECT) & ~detail::ValueObjectOrNullBit;
+    MOZ_ASSERT((ptrBits & 0x7) == 0);
+    return reinterpret_cast<JSObject*>(ptrBits);
+#endif
+  }
+
+#ifdef ENABLE_RECORD_TUPLE
+  JSObject& toExtendedPrimitive() const {
+    MOZ_ASSERT(isExtendedPrimitive());
+#  if defined(JS_PUNBOX64)
+    MOZ_ASSERT((asBits_ & detail::ValueGCThingPayloadMask) != 0);
+#  endif
+    return *unboxGCPointer<JSObject, JSVAL_TAG_EXTENDED_PRIMITIVE>();
+  }
+#endif
+
+  JSObject& getObjectPayload() const {
+#ifdef ENABLE_RECORD_TUPLE
+    return isExtendedPrimitive() ? toExtendedPrimitive() : toObject();
+#else
+    return toObject();
+#endif
+  }
+
+  js::gc::Cell* toGCThing() const {
+    MOZ_ASSERT(isGCThing());
+#if defined(JS_NUNBOX32)
+    return reinterpret_cast<js::gc::Cell*>(uintptr_t(asBits_));
+#elif defined(JS_PUNBOX64)
+    uint64_t ptrBits = asBits_ & detail::ValueGCThingPayloadMask;
+    MOZ_ASSERT((ptrBits & 0x7) == 0);
+    return reinterpret_cast<js::gc::Cell*>(ptrBits);
+#endif
+  }
+
+  GCCellPtr toGCCellPtr() const { return GCCellPtr(toGCThing(), traceKind()); }
+
+  bool toBoolean() const {
+    MOZ_ASSERT(isBoolean());
+#if defined(JS_NUNBOX32)
+    return bool(toNunboxPayload());
+#elif defined(JS_PUNBOX64)
+    return bool(asBits_ & 0x1);
+#endif
+  }
+
+  constexpr uint64_t asRawBits() const { return asBits_; }
+
+  JSValueType extractNonDoubleType() const {
+    uint32_t type = toTag() & 0xF;
+    MOZ_ASSERT(type > JSVAL_TYPE_DOUBLE);
+    return JSValueType(type);
+  }
+
+  JS::ValueType type() const {
+    if (isDouble()) {
+      return JS::ValueType::Double;
+    }
+
+    JSValueType type = extractNonDoubleType();
+    MOZ_ASSERT(type <= JSVAL_TYPE_OBJECT);
+    return JS::ValueType(type);
+  }
+
+  /*
+   * Private API
+   *
+   * Private setters/getters allow the caller to read/write arbitrary
+   * word-size pointers or uint32s.  After storing to a value with
+   * setPrivateX, it is the caller's responsibility to only read using
+   * toPrivateX. Private values are given a type which ensures they
+   * aren't marked by the GC.
+   */
+
+  void setPrivate(void* ptr) {
+#if defined(JS_PUNBOX64)
+    MOZ_ASSERT(detail::IsValidUserModePointer(uintptr_t(ptr)));
+#endif
+    asBits_ = uintptr_t(ptr);
+    MOZ_ASSERT(isDouble());
+  }
+
+  void* toPrivate() const {
+    MOZ_ASSERT(isDouble());
+#if defined(JS_PUNBOX64)
+    MOZ_ASSERT(detail::IsValidUserModePointer(asBits_));
+#endif
+    return reinterpret_cast<void*>(uintptr_t(asBits_));
+  }
+
+  void* toPrivateUnchecked() const {
+    return reinterpret_cast<void*>(uintptr_t(asBits_));
+  }
+
+  void setPrivateUint32(uint32_t ui) {
+    MOZ_ASSERT(uint32_t(int32_t(ui)) == ui);
+    setInt32(int32_t(ui));
+  }
+
+  uint32_t toPrivateUint32() const { return uint32_t(toInt32()); }
+
+  /*
+   * Private GC Thing API
+   *
+   * Non-JSObject, JSString, and JS::Symbol cells may be put into the 64-bit
+   * payload as private GC things. Such Values are considered isGCThing(), and
+   * as such, automatically marked. Their traceKind() is gotten via their
+   * cells.
+   */
+
+  void setPrivateGCThing(js::gc::Cell* cell) {
+    MOZ_ASSERT(JS::GCThingTraceKind(cell) != JS::TraceKind::String,
+               "Private GC thing Values must not be strings. Make a "
+               "StringValue instead.");
+    MOZ_ASSERT(JS::GCThingTraceKind(cell) != JS::TraceKind::Symbol,
+               "Private GC thing Values must not be symbols. Make a "
+               "SymbolValue instead.");
+    MOZ_ASSERT(JS::GCThingTraceKind(cell) != JS::TraceKind::BigInt,
+               "Private GC thing Values must not be BigInts. Make a "
+               "BigIntValue instead.");
+    MOZ_ASSERT(JS::GCThingTraceKind(cell) != JS::TraceKind::Object,
+               "Private GC thing Values must not be objects. Make an "
+               "ObjectValue instead.");
+
+    MOZ_ASSERT(js::gc::IsCellPointerValid(cell));
+#if defined(JS_PUNBOX64)
+    // VisualStudio cannot contain parenthesized C++ style cast and shift
+    // inside decltype in template parameter:
+    //   AssertionConditionType<decltype((uintptr_t(x) >> 1))>
+    // It throws syntax error.
+    MOZ_ASSERT((((uintptr_t)cell) >> JSVAL_TAG_SHIFT) == 0);
+#endif
+    asBits_ =
+        bitsFromTagAndPayload(JSVAL_TAG_PRIVATE_GCTHING, PayloadType(cell));
+  }
+
+  bool isPrivateGCThing() const { return toTag() == JSVAL_TAG_PRIVATE_GCTHING; }
+
+#if defined(DEBUG) || defined(JS_JITSPEW)
+  void dump() const;
+  void dump(js::GenericPrinter& out) const;
+  void dump(js::JSONPrinter& json) const;
+
+  void dumpFields(js::JSONPrinter& json) const;
+  void dumpStringContent(js::GenericPrinter& out) const;
+#endif
+} JS_HAZ_GC_POINTER MOZ_NON_PARAM;
+
+static_assert(sizeof(Value) == 8,
+              "Value size must leave three tag bits, be a binary power, and "
+              "is ubiquitously depended upon everywhere");
+
+static MOZ_ALWAYS_INLINE void ExposeValueToActiveJS(const Value& v) {
+#ifdef DEBUG
+  Value tmp = v;
+  MOZ_ASSERT(!js::gc::EdgeNeedsSweepUnbarrieredSlow(&tmp));
+#endif
+  if (v.isGCThing()) {
+    js::gc::ExposeGCThingToActiveJS(v.toGCCellPtr());
+  }
+}
+
+/************************************************************************/
+
+static inline MOZ_MAY_CALL_AFTER_MUST_RETURN Value NullValue() {
+  Value v;
+  v.setNull();
+  return v;
+}
+
+static constexpr Value UndefinedValue() { return Value(); }
+
+static constexpr Value Int32Value(int32_t i32) { return Value::fromInt32(i32); }
+
+static inline Value DoubleValue(double dbl) {
+  Value v;
+  v.setDouble(dbl);
+  return v;
+}
+
+static inline Value CanonicalizedDoubleValue(double d) {
+  return Value::fromDouble(CanonicalizeNaN(d));
+}
+
+static inline Value NaNValue() {
+  return Value::fromRawBits(detail::CanonicalizedNaNBits);
+}
+
+static inline Value InfinityValue() {
+  return Value::fromRawBits(detail::InfinityBits);
+}
+
+static inline Value Float32Value(float f) {
+  Value v;
+  v.setDouble(f);
+  return v;
+}
+
+static inline Value StringValue(JSString* str) {
+  Value v;
+  v.setString(str);
+  return v;
+}
+
+static inline Value SymbolValue(JS::Symbol* sym) {
+  Value v;
+  v.setSymbol(sym);
+  return v;
+}
+
+static inline Value BigIntValue(JS::BigInt* bi) {
+  Value v;
+  v.setBigInt(bi);
+  return v;
+}
+
+static inline Value BooleanValue(bool boo) {
+  Value v;
+  v.setBoolean(boo);
+  return v;
+}
+
+static inline Value TrueValue() {
+  Value v;
+  v.setBoolean(true);
+  return v;
+}
+
+static inline Value FalseValue() {
+  Value v;
+  v.setBoolean(false);
+  return v;
+}
+
+static inline Value ObjectValue(JSObject& obj) {
+  Value v;
+  v.setObject(obj);
+  return v;
+}
+
+#ifdef ENABLE_RECORD_TUPLE
+static inline Value ExtendedPrimitiveValue(JSObject& obj) {
+  Value v;
+  v.setExtendedPrimitive(obj);
+  return v;
+}
+#endif
+
+static inline Value MagicValue(JSWhyMagic why) {
+  Value v;
+  v.setMagic(why);
+  return v;
+}
+
+static inline Value MagicValueUint32(uint32_t payload) {
+  Value v;
+  v.setMagicUint32(payload);
+  return v;
+}
+
+static constexpr Value NumberValue(uint32_t i) {
+  return i <= JSVAL_INT_MAX ? Int32Value(int32_t(i))
+                            : Value::fromDouble(double(i));
+}
+
+template <typename T>
+static inline Value NumberValue(const T t) {
+  Value v;
+  v.setNumber(t);
+  return v;
+}
+
+static inline Value ObjectOrNullValue(JSObject* obj) {
+  Value v;
+  v.setObjectOrNull(obj);
+  return v;
+}
+
+static inline Value PrivateValue(void* ptr) {
+  Value v;
+  v.setPrivate(ptr);
+  return v;
+}
+
+static inline Value PrivateValue(uintptr_t ptr) {
+  return PrivateValue(reinterpret_cast<void*>(ptr));
+}
+
+static inline Value PrivateUint32Value(uint32_t ui) {
+  Value v;
+  v.setPrivateUint32(ui);
+  return v;
+}
+
+static inline Value PrivateGCThingValue(js::gc::Cell* cell) {
+  Value v;
+  v.setPrivateGCThing(cell);
+  return v;
+}
+
+inline bool SameType(const Value& lhs, const Value& rhs) {
+#if defined(JS_NUNBOX32)
+  JSValueTag ltag = lhs.toTag(), rtag = rhs.toTag();
+  return ltag == rtag || (ltag < JSVAL_TAG_CLEAR && rtag < JSVAL_TAG_CLEAR);
+#elif defined(JS_PUNBOX64)
+  return (lhs.isDouble() && rhs.isDouble()) ||
+         (((lhs.asBits_ ^ rhs.asBits_) & 0xFFFF800000000000ULL) == 0);
+#endif
+}
+
+}  // namespace JS
+
+/************************************************************************/
+
+namespace JS {
+JS_PUBLIC_API void HeapValuePostWriteBarrier(Value* valuep, const Value& prev,
+                                             const Value& next);
+JS_PUBLIC_API void HeapValueWriteBarriers(Value* valuep, const Value& prev,
+                                          const Value& next);
+
+template <>
+struct GCPolicy<JS::Value> {
+  static void trace(JSTracer* trc, Value* v, const char* name) {
+    // This should only be called as part of root marking since that's the only
+    // time we should trace unbarriered GC thing pointers. This will assert if
+    // called at other times.
+    TraceRoot(trc, v, name);
+  }
+  static bool isTenured(const Value& thing) {
+    return !thing.isGCThing() || !IsInsideNursery(thing.toGCThing());
+  }
+  static bool isValid(const Value& value) {
+    return !value.isGCThing() || js::gc::IsCellPointerValid(value.toGCThing());
+  }
+};
+
+}  // namespace JS
+
+namespace js {
+
+template <>
+struct BarrierMethods<JS::Value> {
+  static gc::Cell* asGCThingOrNull(const JS::Value& v) {
+    return v.isGCThing() ? v.toGCThing() : nullptr;
+  }
+  static void postWriteBarrier(JS::Value* v, const JS::Value& prev,
+                               const JS::Value& next) {
+    JS::HeapValuePostWriteBarrier(v, prev, next);
+  }
+  static void exposeToJS(const JS::Value& v) { JS::ExposeValueToActiveJS(v); }
+  static void readBarrier(const JS::Value& v) {
+    if (v.isGCThing()) {
+      js::gc::IncrementalReadBarrier(v.toGCCellPtr());
+    }
+  }
+};
+
+template <class Wrapper>
+class MutableValueOperations;
+
+/**
+ * A class designed for CRTP use in implementing the non-mutating parts of the
+ * Value interface in Value-like classes.  Wrapper must be a class inheriting
+ * ValueOperations<Wrapper> with a visible get() method returning a const
+ * reference to the Value abstracted by Wrapper.
+ */
+template <class Wrapper>
+class WrappedPtrOperations<JS::Value, Wrapper> {
+  const JS::Value& value() const {
+    return static_cast<const Wrapper*>(this)->get();
+  }
+
+ public:
+  bool isUndefined() const { return value().isUndefined(); }
+  bool isNull() const { return value().isNull(); }
+  bool isBoolean() const { return value().isBoolean(); }
+  bool isTrue() const { return value().isTrue(); }
+  bool isFalse() const { return value().isFalse(); }
+  bool isNumber() const { return value().isNumber(); }
+  bool isInt32() const { return value().isInt32(); }
+  bool isInt32(int32_t i32) const { return value().isInt32(i32); }
+  bool isDouble() const { return value().isDouble(); }
+  bool isString() const { return value().isString(); }
+  bool isSymbol() const { return value().isSymbol(); }
+  bool isBigInt() const { return value().isBigInt(); }
+  bool isObject() const { return value().isObject(); }
+#ifdef ENABLE_RECORD_TUPLE
+  bool isExtendedPrimitive() const { return value().isExtendedPrimitive(); }
+#endif
+  bool hasObjectPayload() const { return value().hasObjectPayload(); }
+  bool isMagic() const { return value().isMagic(); }
+  bool isMagic(JSWhyMagic why) const { return value().isMagic(why); }
+  bool isGCThing() const { return value().isGCThing(); }
+  bool isPrivateGCThing() const { return value().isPrivateGCThing(); }
+  bool isPrimitive() const { return value().isPrimitive(); }
+
+  bool isNullOrUndefined() const { return value().isNullOrUndefined(); }
+  bool isObjectOrNull() const { return value().isObjectOrNull(); }
+  bool isNumeric() const { return value().isNumeric(); }
+
+  bool toBoolean() const { return value().toBoolean(); }
+  double toNumber() const { return value().toNumber(); }
+  int32_t toInt32() const { return value().toInt32(); }
+  double toDouble() const { return value().toDouble(); }
+  JSString* toString() const { return value().toString(); }
+  JS::Symbol* toSymbol() const { return value().toSymbol(); }
+  JS::BigInt* toBigInt() const { return value().toBigInt(); }
+  JSObject& toObject() const { return value().toObject(); }
+  JSObject* toObjectOrNull() const { return value().toObjectOrNull(); }
+#ifdef ENABLE_RECORD_TUPLE
+  JSObject& toExtendedPrimitive() const {
+    return value().toExtendedPrimitive();
+  }
+#endif
+  JSObject& getObjectPayload() const { return value().getObjectPayload(); }
+  JS::GCCellPtr toGCCellPtr() const { return value().toGCCellPtr(); }
+  gc::Cell* toGCThing() const { return value().toGCThing(); }
+  JS::TraceKind traceKind() const { return value().traceKind(); }
+  void* toPrivate() const { return value().toPrivate(); }
+  uint32_t toPrivateUint32() const { return value().toPrivateUint32(); }
+
+  uint64_t asRawBits() const { return value().asRawBits(); }
+  JSValueType extractNonDoubleType() const {
+    return value().extractNonDoubleType();
+  }
+  JS::ValueType type() const { return value().type(); }
+
+  JSWhyMagic whyMagic() const { return value().whyMagic(); }
+  uint32_t magicUint32() const { return value().magicUint32(); }
+};
+
+/**
+ * A class designed for CRTP use in implementing all the mutating parts of the
+ * Value interface in Value-like classes.  Wrapper must be a class inheriting
+ * MutableWrappedPtrOperations<Wrapper> with visible get() methods returning
+ * const and non-const references to the Value abstracted by Wrapper.
+ */
+template <class Wrapper>
+class MutableWrappedPtrOperations<JS::Value, Wrapper>
+    : public WrappedPtrOperations<JS::Value, Wrapper> {
+ protected:
+  void set(const JS::Value& v) {
+    // Call Wrapper::set to trigger any barriers.
+    static_cast<Wrapper*>(this)->set(v);
+  }
+
+ public:
+  void setNull() { set(JS::NullValue()); }
+  void setUndefined() { set(JS::UndefinedValue()); }
+  void setInt32(int32_t i) { set(JS::Int32Value(i)); }
+  void setDouble(double d) { set(JS::DoubleValue(d)); }
+  void setNaN() { set(JS::NaNValue()); }
+  void setInfinity() { set(JS::InfinityValue()); }
+  void setBoolean(bool b) { set(JS::BooleanValue(b)); }
+  void setMagic(JSWhyMagic why) { set(JS::MagicValue(why)); }
+  template <typename T>
+  void setNumber(T t) {
+    set(JS::NumberValue(t));
+  }
+  void setString(JSString* str) { set(JS::StringValue(str)); }
+  void setSymbol(JS::Symbol* sym) { set(JS::SymbolValue(sym)); }
+  void setBigInt(JS::BigInt* bi) { set(JS::BigIntValue(bi)); }
+  void setObject(JSObject& obj) { set(JS::ObjectValue(obj)); }
+  void setObjectOrNull(JSObject* arg) { set(JS::ObjectOrNullValue(arg)); }
+#ifdef ENABLE_RECORD_TUPLE
+  void setExtendedPrimitive(JSObject& obj) {
+    return set(JS::ExtendedPrimitiveValue(obj));
+  }
+#endif
+  void setPrivate(void* ptr) { set(JS::PrivateValue(ptr)); }
+  void setPrivateUint32(uint32_t ui) { set(JS::PrivateUint32Value(ui)); }
+  void setPrivateGCThing(js::gc::Cell* cell) {
+    set(JS::PrivateGCThingValue(cell));
+  }
+};
+
+/*
+ * Augment the generic Heap<T> interface when T = Value with
+ * type-querying, value-extracting, and mutating operations.
+ */
+template <typename Wrapper>
+class HeapOperations<JS::Value, Wrapper>
+    : public MutableWrappedPtrOperations<JS::Value, Wrapper> {};
+
+MOZ_HAVE_NORETURN MOZ_COLD MOZ_NEVER_INLINE void ReportBadValueTypeAndCrash(
+    const JS::Value& val);
+
+// If the Value is a GC pointer type, call |f| with the pointer cast to that
+// type and return the result wrapped in a Maybe, otherwise return None().
+template <typename F>
+auto MapGCThingTyped(const JS::Value& val, F&& f) {
+  switch (val.type()) {
+    case JS::ValueType::String: {
+      JSString* str = val.toString();
+      MOZ_ASSERT(gc::IsCellPointerValid(str));
+      return mozilla::Some(f(str));
+    }
+#ifdef ENABLE_RECORD_TUPLE
+    case JS::ValueType::ExtendedPrimitive:
+#endif
+    case JS::ValueType::Object: {
+      JSObject* obj = &val.getObjectPayload();
+      MOZ_ASSERT(gc::IsCellPointerValid(obj));
+      return mozilla::Some(f(obj));
+    }
+    case JS::ValueType::Symbol: {
+      JS::Symbol* sym = val.toSymbol();
+      MOZ_ASSERT(gc::IsCellPointerValid(sym));
+      return mozilla::Some(f(sym));
+    }
+    case JS::ValueType::BigInt: {
+      JS::BigInt* bi = val.toBigInt();
+      MOZ_ASSERT(gc::IsCellPointerValid(bi));
+      return mozilla::Some(f(bi));
+    }
+    case JS::ValueType::PrivateGCThing: {
+      MOZ_ASSERT(gc::IsCellPointerValid(val.toGCThing()));
+      return mozilla::Some(MapGCThingTyped(val.toGCCellPtr(), std::move(f)));
+    }
+    case JS::ValueType::Double:
+    case JS::ValueType::Int32:
+    case JS::ValueType::Boolean:
+    case JS::ValueType::Undefined:
+    case JS::ValueType::Null:
+    case JS::ValueType::Magic: {
+      MOZ_ASSERT(!val.isGCThing());
+      using ReturnType = decltype(f(static_cast<JSObject*>(nullptr)));
+      return mozilla::Maybe<ReturnType>();
+    }
+  }
+
+  ReportBadValueTypeAndCrash(val);
+}
+
+// If the Value is a GC pointer type, call |f| with the pointer cast to that
+// type. Return whether this happened.
+template <typename F>
+bool ApplyGCThingTyped(const JS::Value& val, F&& f) {
+  return MapGCThingTyped(val,
+                         [&f](auto t) {
+                           f(t);
+                           return true;
+                         })
+      .isSome();
+}
+
+static inline JS::Value PoisonedObjectValue(uintptr_t poison) {
+  JS::Value v;
+  v.setObjectNoCheck(reinterpret_cast<JSObject*>(poison));
+  return v;
+}
+
+}  // namespace js
+
+#ifdef DEBUG
+namespace JS {
+
+MOZ_ALWAYS_INLINE void AssertValueIsNotGray(const Value& value) {
+  if (value.isGCThing()) {
+    AssertCellIsNotGray(value.toGCThing());
+  }
+}
+
+MOZ_ALWAYS_INLINE void AssertValueIsNotGray(const Heap<Value>& value) {
+  AssertValueIsNotGray(value.unbarrieredGet());
+}
+
+}  // namespace JS
+#endif
+
+/************************************************************************/
+
+namespace JS {
+
+extern JS_PUBLIC_DATA const HandleValue NullHandleValue;
+extern JS_PUBLIC_DATA const HandleValue UndefinedHandleValue;
+extern JS_PUBLIC_DATA const HandleValue TrueHandleValue;
+extern JS_PUBLIC_DATA const HandleValue FalseHandleValue;
+extern JS_PUBLIC_DATA const Handle<mozilla::Maybe<Value>> NothingHandleValue;
+
+}  // namespace JS
+
+#endif /* js_Value_h */