libv8-node 17.9.1.0-aarch64-linux-musl → 18.13.0.0-aarch64-linux-musl

data/vendor/v8/include/v8-initialization.h

@@ -8,10 +8,11 @@
 #include <stddef.h>
 #include <stdint.h>
 
-#include "v8-internal.h"  // NOLINT(build/include_directory)
-#include "v8-isolate.h"   // NOLINT(build/include_directory)
-#include "v8-platform.h"  // NOLINT(build/include_directory)
-#include "v8config.h"     // NOLINT(build/include_directory)
+#include "v8-callbacks.h"  // NOLINT(build/include_directory)
+#include "v8-internal.h"   // NOLINT(build/include_directory)
+#include "v8-isolate.h"    // NOLINT(build/include_directory)
+#include "v8-platform.h"   // NOLINT(build/include_directory)
+#include "v8config.h"      // NOLINT(build/include_directory)
 
 // We reserve the V8_* prefix for macros defined in V8 public API and
 // assume there are no name conflicts with the embedder's code.
@@ -99,8 +100,10 @@ class V8_EXPORT V8 {
     const int kBuildConfiguration =
         (internal::PointerCompressionIsEnabled() ? kPointerCompression : 0) |
         (internal::SmiValuesAre31Bits() ? k31BitSmis : 0) |
-        (internal::HeapSandboxIsEnabled() ? kHeapSandbox : 0) |
-        (internal::VirtualMemoryCageIsEnabled() ? kVirtualMemoryCage : 0);
+        (internal::SandboxedExternalPointersAreEnabled()
+             ? kSandboxedExternalPointers
+             : 0) |
+        (internal::SandboxIsEnabled() ? kSandbox : 0);
     return Initialize(kBuildConfiguration);
   }
 
@@ -180,53 +183,75 @@ class V8_EXPORT V8 {
    * Clears all references to the v8::Platform. This should be invoked after
    * V8 was disposed.
    */
-  static void ShutdownPlatform();
+  static void DisposePlatform();
+  V8_DEPRECATED("Use DisposePlatform()")
+  static void ShutdownPlatform() { DisposePlatform(); }
 
-#ifdef V8_VIRTUAL_MEMORY_CAGE
+#ifdef V8_SANDBOX
   //
-  // Virtual Memory Cage related API.
+  // Sandbox related API.
   //
   // This API is not yet stable and subject to changes in the future.
   //
 
   /**
-   * Initializes the virtual memory cage for V8.
+   * Initializes the V8 sandbox.
    *
    * This must be invoked after the platform was initialized but before V8 is
-   * initialized. The virtual memory cage is torn down during platform shutdown.
+   * initialized. The sandbox is torn down during platform shutdown.
    * Returns true on success, false otherwise.
    *
-   * TODO(saelo) Once it is no longer optional to create the virtual memory
-   * cage when compiling with V8_VIRTUAL_MEMORY_CAGE, the cage initialization
-   * will likely happen as part of V8::Initialize, at which point this function
-   * should be removed.
+   * TODO(saelo) Once it is no longer optional to initialize the sandbox when
+   * compiling with V8_SANDBOX, the sandbox initialization will likely happen
+   * as part of V8::Initialize, at which point this function should be removed.
    */
-  static bool InitializeVirtualMemoryCage();
+  static bool InitializeSandbox();
+  V8_DEPRECATE_SOON("Use InitializeSandbox()")
+  static bool InitializeVirtualMemoryCage() { return InitializeSandbox(); }
 
   /**
-   * Provides access to the virtual memory cage page allocator.
+   * Provides access to the virtual address subspace backing the sandbox.
    *
-   * This allocator allocates pages inside the virtual memory cage. It can for
-   * example be used to obtain virtual memory for ArrayBuffer backing stores,
-   * which must be located inside the cage.
+   * This can be used to allocate pages inside the sandbox, for example to
+   * obtain virtual memory for ArrayBuffer backing stores, which must be
+   * located inside the sandbox.
    *
-   * It should be assumed that an attacker can corrupt data inside the cage,
-   * and so in particular the contents of pages returned by this allocator,
-   * arbitrarily and concurrently. Due to this, it is recommended to to only
-   * place pure data buffers in pages obtained through this allocator.
+   * It should be assumed that an attacker can corrupt data inside the sandbox,
+   * and so in particular the contents of pages allocagted in this virtual
+   * address space, arbitrarily and concurrently. Due to this, it is
+   * recommended to to only place pure data buffers in them.
    *
-   * This function must only be called after initializing the virtual memory
-   * cage and V8.
+   * This function must only be called after initializing the sandbox.
    */
+  static VirtualAddressSpace* GetSandboxAddressSpace();
+  V8_DEPRECATE_SOON("Use GetSandboxAddressSpace()")
   static PageAllocator* GetVirtualMemoryCagePageAllocator();
 
   /**
-   * Returns the size of the virtual memory cage in bytes.
+   * Returns the size of the sandbox in bytes.
    *
-   * If the cage has not been initialized, or if the initialization failed,
+   * If the sandbox has not been initialized, or if the initialization failed,
    * this returns zero.
    */
-  static size_t GetVirtualMemoryCageSizeInBytes();
+  static size_t GetSandboxSizeInBytes();
+  V8_DEPRECATE_SOON("Use GetSandboxSizeInBytes()")
+  static size_t GetVirtualMemoryCageSizeInBytes() {
+    return GetSandboxSizeInBytes();
+  }
+
+  /**
+   * Returns whether the sandbox is configured securely.
+   *
+   * If V8 cannot create a proper sandbox, it will fall back to creating a
+   * sandbox that doesn't have the desired security properties but at least
+   * still allows V8 to function. This API can be used to determine if such an
+   * insecure sandbox is being used, in which case it will return false.
+   */
+  static bool IsSandboxConfiguredSecurely();
+  V8_DEPRECATE_SOON("Use IsSandboxConfiguredSecurely()")
+  static bool IsUsingSecureVirtualMemoryCage() {
+    return IsSandboxConfiguredSecurely();
+  }
 #endif
 
   /**
@@ -251,6 +276,14 @@ class V8_EXPORT V8 {
       UnhandledExceptionCallback unhandled_exception_callback);
 #endif
 
+  /**
+   * Allows the host application to provide a callback that will be called when
+   * v8 has encountered a fatal failure to allocate memory and is about to
+   * terminate.
+   */
+
+  static void SetFatalMemoryErrorCallback(OOMErrorCallback oom_error_callback);
+
   /**
    * Get statistics about the shared memory usage.
    */
@@ -262,8 +295,8 @@ class V8_EXPORT V8 {
   enum BuildConfigurationFeatures {
     kPointerCompression = 1 << 0,
     k31BitSmis = 1 << 1,
-    kHeapSandbox = 1 << 2,
-    kVirtualMemoryCage = 1 << 3,
+    kSandboxedExternalPointers = 1 << 2,
+    kSandbox = 1 << 3,
   };
 
   /**

data/vendor/v8/include/v8-inspector.h

@@ -23,6 +23,10 @@ class Value;
 
 namespace v8_inspector {
 
+namespace internal {
+class V8DebuggerId;
+}  // namespace internal
+
 namespace protocol {
 namespace Debugger {
 namespace API {
@@ -106,6 +110,30 @@ class V8_EXPORT V8ContextInfo {
   V8ContextInfo& operator=(const V8ContextInfo&) = delete;
 };
 
+// This debugger id tries to be unique by generating two random
+// numbers, which should most likely avoid collisions.
+// Debugger id has a 1:1 mapping to context group. It is used to
+// attribute stack traces to a particular debugging, when doing any
+// cross-debugger operations (e.g. async step in).
+// See also Runtime.UniqueDebuggerId in the protocol.
+class V8_EXPORT V8DebuggerId {
+ public:
+  V8DebuggerId() = default;
+  V8DebuggerId(const V8DebuggerId&) = default;
+  V8DebuggerId& operator=(const V8DebuggerId&) = default;
+
+  std::unique_ptr<StringBuffer> toString() const;
+  bool isValid() const;
+  std::pair<int64_t, int64_t> pair() const;
+
+ private:
+  friend class internal::V8DebuggerId;
+  explicit V8DebuggerId(std::pair<int64_t, int64_t>);
+
+  int64_t m_first = 0;
+  int64_t m_second = 0;
+};
+
 class V8_EXPORT V8StackTrace {
  public:
   virtual StringView firstNonEmptySourceURL() const = 0;
@@ -114,14 +142,10 @@ class V8_EXPORT V8StackTrace {
   virtual int topLineNumber() const = 0;
   virtual int topColumnNumber() const = 0;
   virtual int topScriptId() const = 0;
-  V8_DEPRECATE_SOON("Use V8::StackTrace::topScriptId() instead.")
-  int topScriptIdAsInteger() const { return topScriptId(); }
   virtual StringView topFunctionName() const = 0;
 
   virtual ~V8StackTrace() = default;
   virtual std::unique_ptr<protocol::Runtime::API::StackTrace>
-  buildInspectorObject() const = 0;
-  virtual std::unique_ptr<protocol::Runtime::API::StackTrace>
   buildInspectorObject(int maxAsyncDepth) const = 0;
   virtual std::unique_ptr<StringBuffer> toString() const = 0;
 
@@ -181,6 +205,15 @@ class V8_EXPORT V8InspectorSession {
   virtual void triggerPreciseCoverageDeltaUpdate(StringView occasion) = 0;
 };
 
+class V8_EXPORT WebDriverValue {
+ public:
+  explicit WebDriverValue(StringView type, v8::MaybeLocal<v8::Value> value = {})
+      : type(type), value(value) {}
+
+  StringView type;
+  v8::MaybeLocal<v8::Value> value;
+};
+
 class V8_EXPORT V8InspectorClient {
  public:
   virtual ~V8InspectorClient() = default;
@@ -195,6 +228,10 @@ class V8_EXPORT V8InspectorClient {
   virtual void beginUserGesture() {}
   virtual void endUserGesture() {}
 
+  virtual std::unique_ptr<WebDriverValue> serializeToWebDriverValue(
+      v8::Local<v8::Value> v8_value, int max_depth) {
+    return nullptr;
+  }
   virtual std::unique_ptr<StringBuffer> valueSubtype(v8::Local<v8::Value>) {
     return nullptr;
   }
@@ -246,6 +283,9 @@ class V8_EXPORT V8InspectorClient {
   // The caller would defer to generating a random 64 bit integer if
   // this method returns 0.
   virtual int64_t generateUniqueId() { return 0; }
+
+  virtual void dispatchError(v8::Local<v8::Context>, v8::Local<v8::Message>,
+                             v8::Local<v8::Value>) {}
 };
 
 // These stack trace ids are intended to be passed between debuggers and be
@@ -280,6 +320,7 @@ class V8_EXPORT V8Inspector {
   virtual void contextDestroyed(v8::Local<v8::Context>) = 0;
   virtual void resetContextGroup(int contextGroupId) = 0;
   virtual v8::MaybeLocal<v8::Context> contextById(int contextId) = 0;
+  virtual V8DebuggerId uniqueDebuggerId(int contextId) = 0;
 
   // Various instrumentation.
   virtual void idleStarted() = 0;

data/vendor/v8/include/v8-internal.h

@@ -29,6 +29,13 @@ class Isolate;
 typedef uintptr_t Address;
 static const Address kNullAddress = 0;
 
+constexpr int KB = 1024;
+constexpr int MB = KB * 1024;
+constexpr int GB = MB * 1024;
+#ifdef V8_TARGET_ARCH_X64
+constexpr size_t TB = size_t{GB} * 1024;
+#endif
+
 /**
  * Configuration of tagging scheme.
  */
@@ -109,6 +116,11 @@ struct SmiTagging<8> {
 };
 
 #ifdef V8_COMPRESS_POINTERS
+// See v8:7703 or src/common/ptr-compr-inl.h for details about pointer
+// compression.
+constexpr size_t kPtrComprCageReservationSize = size_t{1} << 32;
+constexpr size_t kPtrComprCageBaseAlignment = size_t{1} << 32;
+
 static_assert(
     kApiSystemPointerSize == kApiInt64Size,
     "Pointer compression can be enabled only for 64-bit architectures");
@@ -121,36 +133,6 @@ constexpr bool PointerCompressionIsEnabled() {
   return kApiTaggedSize != kApiSystemPointerSize;
 }
 
-constexpr bool HeapSandboxIsEnabled() {
-#ifdef V8_HEAP_SANDBOX
-  return true;
-#else
-  return false;
-#endif
-}
-
-using ExternalPointer_t = Address;
-
-// If the heap sandbox is enabled, these tag values will be ORed with the
-// external pointers in the external pointer table to prevent use of pointers of
-// the wrong type. When a pointer is loaded, it is ANDed with the inverse of the
-// expected type's tag. The tags are constructed in a way that guarantees that a
-// failed type check will result in one or more of the top bits of the pointer
-// to be set, rendering the pointer inacessible. This construction allows
-// performing the type check and removing GC marking bits from the pointer at
-// the same time.
-enum ExternalPointerTag : uint64_t {
-  kExternalPointerNullTag = 0x0000000000000000,
-  kExternalStringResourceTag = 0x00ff000000000000,       // 0b000000011111111
-  kExternalStringResourceDataTag = 0x017f000000000000,   // 0b000000101111111
-  kForeignForeignAddressTag = 0x01bf000000000000,        // 0b000000110111111
-  kNativeContextMicrotaskQueueTag = 0x01df000000000000,  // 0b000000111011111
-  kEmbedderDataSlotPayloadTag = 0x01ef000000000000,      // 0b000000111101111
-  kCodeEntryPointTag = 0x01f7000000000000,               // 0b000000111110111
-};
-
-constexpr uint64_t kExternalPointerTagMask = 0xffff000000000000;
-
 #ifdef V8_31BIT_SMIS_ON_64BIT_ARCH
 using PlatformSmiTagging = SmiTagging<kApiInt32Size>;
 #else
@@ -171,6 +153,164 @@ V8_INLINE static constexpr internal::Address IntToSmi(int value) {
          kSmiTag;
 }
 
+/*
+ * Sandbox related types, constants, and functions.
+ */
+constexpr bool SandboxIsEnabled() {
+#ifdef V8_SANDBOX
+  return true;
+#else
+  return false;
+#endif
+}
+
+constexpr bool SandboxedExternalPointersAreEnabled() {
+#ifdef V8_SANDBOXED_EXTERNAL_POINTERS
+  return true;
+#else
+  return false;
+#endif
+}
+
+// SandboxedPointers are guaranteed to point into the sandbox. This is achieved
+// for example by storing them as offset rather than as raw pointers.
+using SandboxedPointer_t = Address;
+
+// ExternalPointers point to objects located outside the sandbox. When sandboxed
+// external pointers are enabled, these are stored in an external pointer table
+// and referenced from HeapObjects through indices.
+#ifdef V8_SANDBOXED_EXTERNAL_POINTERS
+using ExternalPointer_t = uint32_t;
+#else
+using ExternalPointer_t = Address;
+#endif
+
+#ifdef V8_SANDBOX_IS_AVAILABLE
+
+// Size of the sandbox, excluding the guard regions surrounding it.
+constexpr size_t kSandboxSizeLog2 = 40;  // 1 TB
+constexpr size_t kSandboxSize = 1ULL << kSandboxSizeLog2;
+
+// Required alignment of the sandbox. For simplicity, we require the
+// size of the guard regions to be a multiple of this, so that this specifies
+// the alignment of the sandbox including and excluding surrounding guard
+// regions. The alignment requirement is due to the pointer compression cage
+// being located at the start of the sandbox.
+constexpr size_t kSandboxAlignment = kPtrComprCageBaseAlignment;
+
+// Sandboxed pointers are stored inside the heap as offset from the sandbox
+// base shifted to the left. This way, it is guaranteed that the offset is
+// smaller than the sandbox size after shifting it to the right again. This
+// constant specifies the shift amount.
+constexpr uint64_t kSandboxedPointerShift = 64 - kSandboxSizeLog2;
+
+// Size of the guard regions surrounding the sandbox. This assumes a worst-case
+// scenario of a 32-bit unsigned index used to access an array of 64-bit
+// values.
+constexpr size_t kSandboxGuardRegionSize = 32ULL * GB;
+
+static_assert((kSandboxGuardRegionSize % kSandboxAlignment) == 0,
+              "The size of the guard regions around the sandbox must be a "
+              "multiple of its required alignment.");
+
+// Minimum size of the sandbox, excluding the guard regions surrounding it. If
+// the virtual memory reservation for the sandbox fails, its size is currently
+// halved until either the reservation succeeds or the minimum size is reached.
+// A minimum of 32GB allows the 4GB pointer compression region as well as the
+// ArrayBuffer partition and two 10GB Wasm memory cages to fit into the
+// sandbox. 32GB should also be the minimum possible size of the userspace
+// address space as there are some machine configurations with only 36 virtual
+// address bits.
+constexpr size_t kSandboxMinimumSize = 32ULL * GB;
+
+static_assert(kSandboxMinimumSize <= kSandboxSize,
+              "The minimal size of the sandbox must be smaller or equal to the "
+              "regular size.");
+
+// On OSes where reserving virtual memory is too expensive to reserve the
+// entire address space backing the sandbox, notably Windows pre 8.1, we create
+// a partially reserved sandbox that doesn't actually reserve most of the
+// memory, and so doesn't have the desired security properties as unrelated
+// memory allocations could end up inside of it, but which still ensures that
+// objects that should be located inside the sandbox are allocated within
+// kSandboxSize bytes from the start of the sandbox. The minimum size of the
+// region that is actually reserved for such a sandbox is specified by this
+// constant and should be big enough to contain the pointer compression cage as
+// well as the ArrayBuffer partition.
+constexpr size_t kSandboxMinimumReservationSize = 8ULL * GB;
+
+static_assert(kSandboxMinimumSize > kPtrComprCageReservationSize,
+              "The sandbox must be larger than the pointer compression cage "
+              "contained within it.");
+static_assert(kSandboxMinimumReservationSize > kPtrComprCageReservationSize,
+              "The minimum reservation size for a sandbox must be larger than "
+              "the pointer compression cage contained within it.");
+
+// For now, even if the sandbox is enabled, we still allow backing stores to be
+// allocated outside of it as fallback. This will simplify the initial rollout.
+// However, if sandboxed pointers are also enabled, we must always place
+// backing stores inside the sandbox as they will be referenced though them.
+#ifdef V8_SANDBOXED_POINTERS
+constexpr bool kAllowBackingStoresOutsideSandbox = false;
+#else
+constexpr bool kAllowBackingStoresOutsideSandbox = true;
+#endif  // V8_SANDBOXED_POINTERS
+
+// The size of the virtual memory reservation for an external pointer table.
+// This determines the maximum number of entries in a table. Using a maximum
+// size allows omitting bounds checks on table accesses if the indices are
+// guaranteed (e.g. through shifting) to be below the maximum index. This
+// value must be a power of two.
+static const size_t kExternalPointerTableReservationSize = 128 * MB;
+
+// The maximum number of entries in an external pointer table.
+static const size_t kMaxSandboxedExternalPointers =
+    kExternalPointerTableReservationSize / kApiSystemPointerSize;
+
+// The external pointer table indices stored in HeapObjects as external
+// pointers are shifted to the left by this amount to guarantee that they are
+// smaller than the maximum table size.
+static const uint32_t kExternalPointerIndexShift = 8;
+static_assert((1 << (32 - kExternalPointerIndexShift)) ==
+                  kMaxSandboxedExternalPointers,
+              "kExternalPointerTableReservationSize and "
+              "kExternalPointerIndexShift don't match");
+
+#endif  // V8_SANDBOX_IS_AVAILABLE
+
+// If sandboxed external pointers are enabled, these tag values will be ORed
+// with the external pointers in the external pointer table to prevent use of
+// pointers of the wrong type. When a pointer is loaded, it is ANDed with the
+// inverse of the expected type's tag. The tags are constructed in a way that
+// guarantees that a failed type check will result in one or more of the top
+// bits of the pointer to be set, rendering the pointer inacessible. Besides
+// the type tag bits (48 through 62), the tags also have the GC mark bit (63)
+// set, so that the mark bit is automatically set when a pointer is written
+// into the external pointer table (in which case it is clearly alive) and is
+// cleared when the pointer is loaded. The exception to this is the free entry
+// tag, which doesn't have the mark bit set, as the entry is not alive. This
+// construction allows performing the type check and removing GC marking bits
+// (the MSB) from the pointer at the same time.
+// Note: this scheme assumes a 48-bit address space and will likely break if
+// more virtual address bits are used.
+constexpr uint64_t kExternalPointerTagMask = 0xffff000000000000;
+constexpr uint64_t kExternalPointerTagShift = 48;
+#define MAKE_TAG(v) (static_cast<uint64_t>(v) << kExternalPointerTagShift)
+// clang-format off
+enum ExternalPointerTag : uint64_t {
+  kExternalPointerNullTag =         MAKE_TAG(0b0000000000000000),
+  kExternalPointerFreeEntryTag =    MAKE_TAG(0b0111111110000000),
+  kExternalStringResourceTag =      MAKE_TAG(0b1000000011111111),
+  kExternalStringResourceDataTag =  MAKE_TAG(0b1000000101111111),
+  kForeignForeignAddressTag =       MAKE_TAG(0b1000000110111111),
+  kNativeContextMicrotaskQueueTag = MAKE_TAG(0b1000000111011111),
+  kEmbedderDataSlotPayloadTag =     MAKE_TAG(0b1000000111101111),
+  kCodeEntryPointTag =              MAKE_TAG(0b1000000111110111),
+  kExternalObjectValueTag =         MAKE_TAG(0b1000000111111011),
+};
+// clang-format on
+#undef MAKE_TAG
+
 // Converts encoded external pointer to address.
 V8_EXPORT Address DecodeExternalPointerImpl(const Isolate* isolate,
                                             ExternalPointer_t pointer,
@@ -214,19 +354,19 @@ class Internals {
   static const int kFixedArrayHeaderSize = 2 * kApiTaggedSize;
   static const int kEmbedderDataArrayHeaderSize = 2 * kApiTaggedSize;
   static const int kEmbedderDataSlotSize = kApiSystemPointerSize;
-#ifdef V8_HEAP_SANDBOX
+#ifdef V8_SANDBOXED_EXTERNAL_POINTERS
   static const int kEmbedderDataSlotRawPayloadOffset = kApiTaggedSize;
 #endif
   static const int kNativeContextEmbedderDataOffset = 6 * kApiTaggedSize;
-  static const int kFullStringRepresentationMask = 0x0f;
+  static const int kStringRepresentationAndEncodingMask = 0x0f;
   static const int kStringEncodingMask = 0x8;
   static const int kExternalTwoByteRepresentationTag = 0x02;
   static const int kExternalOneByteRepresentationTag = 0x0a;
 
   static const uint32_t kNumIsolateDataSlots = 4;
   static const int kStackGuardSize = 7 * kApiSystemPointerSize;
-  static const int kBuiltinTier0EntryTableSize = 13 * kApiSystemPointerSize;
-  static const int kBuiltinTier0TableSize = 13 * kApiSystemPointerSize;
+  static const int kBuiltinTier0EntryTableSize = 10 * kApiSystemPointerSize;
+  static const int kBuiltinTier0TableSize = 10 * kApiSystemPointerSize;
 
   // IsolateData layout guarantees.
   static const int kIsolateCageBaseOffset = 0;
@@ -250,10 +390,10 @@ class Internals {
       kIsolateLongTaskStatsCounterOffset + kApiSizetSize;
 
   static const int kExternalPointerTableBufferOffset = 0;
-  static const int kExternalPointerTableLengthOffset =
-      kExternalPointerTableBufferOffset + kApiSystemPointerSize;
   static const int kExternalPointerTableCapacityOffset =
-      kExternalPointerTableLengthOffset + kApiInt32Size;
+      kExternalPointerTableBufferOffset + kApiSystemPointerSize;
+  static const int kExternalPointerTableFreelistHeadOffset =
+      kExternalPointerTableCapacityOffset + kApiInt32Size;
 
   static const int kUndefinedValueRootIndex = 4;
   static const int kTheHoleValueRootIndex = 5;
@@ -268,9 +408,9 @@ class Internals {
   static const int kNodeStateIsWeakValue = 2;
   static const int kNodeStateIsPendingValue = 3;
 
-  static const int kFirstNonstringType = 0x40;
-  static const int kOddballType = 0x43;
-  static const int kForeignType = 0x46;
+  static const int kFirstNonstringType = 0x80;
+  static const int kOddballType = 0x83;
+  static const int kForeignType = 0xcc;
   static const int kJSSpecialApiObjectType = 0x410;
   static const int kJSObjectType = 0x421;
   static const int kFirstJSApiObjectType = 0x422;
@@ -337,7 +477,7 @@ class Internals {
   }
 
   V8_INLINE static bool IsExternalTwoByteString(int instance_type) {
-    int representation = (instance_type & kFullStringRepresentationMask);
+    int representation = (instance_type & kStringRepresentationAndEncodingMask);
     return representation == kExternalTwoByteRepresentationTag;
   }
 
@@ -432,9 +572,9 @@ class Internals {
 #endif
   }
 
-  V8_INLINE static internal::Isolate* GetIsolateForHeapSandbox(
+  V8_INLINE static internal::Isolate* GetIsolateForSandbox(
       internal::Address obj) {
-#ifdef V8_HEAP_SANDBOX
+#ifdef V8_SANDBOXED_EXTERNAL_POINTERS
     return internal::IsolateFromNeverReadOnlySpaceObject(obj);
 #else
     // Not used in non-sandbox mode.
@@ -445,7 +585,7 @@ class Internals {
   V8_INLINE static Address DecodeExternalPointer(
       const Isolate* isolate, ExternalPointer_t encoded_pointer,
       ExternalPointerTag tag) {
-#ifdef V8_HEAP_SANDBOX
+#ifdef V8_SANDBOXED_EXTERNAL_POINTERS
     return internal::DecodeExternalPointerImpl(isolate, encoded_pointer, tag);
 #else
     return encoded_pointer;
@@ -455,7 +595,7 @@ class Internals {
   V8_INLINE static internal::Address ReadExternalPointerField(
       internal::Isolate* isolate, internal::Address heap_object_ptr, int offset,
       ExternalPointerTag tag) {
-#ifdef V8_HEAP_SANDBOX
+#ifdef V8_SANDBOXED_EXTERNAL_POINTERS
     internal::ExternalPointer_t encoded_value =
         ReadRawField<uint32_t>(heap_object_ptr, offset);
     // We currently have to treat zero as nullptr in embedder slots.
@@ -467,10 +607,6 @@ class Internals {
   }
 
 #ifdef V8_COMPRESS_POINTERS
-  // See v8:7703 or src/ptr-compr.* for details about pointer compression.
-  static constexpr size_t kPtrComprCageReservationSize = size_t{1} << 32;
-  static constexpr size_t kPtrComprCageBaseAlignment = size_t{1} << 32;
-
   V8_INLINE static internal::Address GetPtrComprCageBaseFromOnHeapAddress(
       internal::Address addr) {
     return addr & -static_cast<intptr_t>(kPtrComprCageBaseAlignment);
@@ -486,59 +622,6 @@ class Internals {
 #endif  // V8_COMPRESS_POINTERS
 };
 
-constexpr bool VirtualMemoryCageIsEnabled() {
-#ifdef V8_VIRTUAL_MEMORY_CAGE
-  return true;
-#else
-  return false;
-#endif
-}
-
-#ifdef V8_VIRTUAL_MEMORY_CAGE
-// Size of the virtual memory cage, excluding the guard regions surrounding it.
-constexpr size_t kVirtualMemoryCageSize = size_t{1} << 40;  // 1 TB
-
-static_assert(kVirtualMemoryCageSize > Internals::kPtrComprCageReservationSize,
-              "The virtual memory cage must be larger than the pointer "
-              "compression cage contained within it.");
-
-// Required alignment of the virtual memory cage. For simplicity, we require the
-// size of the guard regions to be a multiple of this, so that this specifies
-// the alignment of the cage including and excluding surrounding guard regions.
-// The alignment requirement is due to the pointer compression cage being
-// located at the start of the virtual memory cage.
-constexpr size_t kVirtualMemoryCageAlignment =
-    Internals::kPtrComprCageBaseAlignment;
-
-// Size of the guard regions surrounding the virtual memory cage. This assumes a
-// worst-case scenario of a 32-bit unsigned index being used to access an array
-// of 64-bit values.
-constexpr size_t kVirtualMemoryCageGuardRegionSize = size_t{32} << 30;  // 32 GB
-
-static_assert((kVirtualMemoryCageGuardRegionSize %
-               kVirtualMemoryCageAlignment) == 0,
-              "The size of the virtual memory cage guard region must be a "
-              "multiple of its required alignment.");
-
-// Minimum size of the virtual memory cage, excluding the guard regions
-// surrounding it. If the cage reservation fails, its size is currently halved
-// until either the reservation succeeds or the minimum size is reached. A
-// minimum of 32GB allows the 4GB pointer compression region as well as the
-// ArrayBuffer partition and two 10GB WASM memory cages to fit into the cage.
-constexpr size_t kVirtualMemoryCageMinimumSize = size_t{32} << 30;  // 32 GB
-
-// For now, even if the virtual memory cage is enabled, we still allow backing
-// stores to be allocated outside of it as fallback. This will simplify the
-// initial rollout. However, if the heap sandbox is also enabled, we already use
-// the "enforcing mode" of the virtual memory cage. This is useful for testing.
-#ifdef V8_HEAP_SANDBOX
-constexpr bool kAllowBackingStoresOutsideCage = false;
-#else
-constexpr bool kAllowBackingStoresOutsideCage = true;
-#endif  // V8_HEAP_SANDBOX
-
-#endif  // V8_VIRTUAL_MEMORY_CAGE
-
 // Only perform cast check for types derived from v8::Data since
 // other types do not implement the Cast method.
 template <bool PerformCheck>
@@ -567,6 +650,10 @@ V8_INLINE void PerformCastCheck(T* data) {
 // how static casts work with std::shared_ptr.
 class BackingStoreBase {};
 
+// The maximum value in enum GarbageCollectionReason, defined in heap.h.
+// This is needed for histograms sampling garbage collection reasons.
+constexpr int kGarbageCollectionReasonMaxValue = 25;
+
 }  // namespace internal
 
 }  // namespace v8