libv8-node 17.9.1.1-aarch64-linux-musl → 18.8.0.0-aarch64-linux-musl

data/vendor/v8/include/cppgc/internal/pointer-policies.h

@@ -92,19 +92,19 @@ class DisabledCheckingPolicy {
   void CheckPointer(const void*) {}
 };
 
-#if V8_ENABLE_CHECKS
+#ifdef DEBUG
 // Off heap members are not connected to object graph and thus cannot ressurect
 // dead objects.
 using DefaultMemberCheckingPolicy =
     SameThreadEnabledCheckingPolicy<false /* kCheckOffHeapAssignments*/>;
 using DefaultPersistentCheckingPolicy =
     SameThreadEnabledCheckingPolicy<true /* kCheckOffHeapAssignments*/>;
-#else
+#else   // !DEBUG
 using DefaultMemberCheckingPolicy = DisabledCheckingPolicy;
 using DefaultPersistentCheckingPolicy = DisabledCheckingPolicy;
-#endif
+#endif  // !DEBUG
 // For CT(W)P neither marking information (for value), nor objectstart bitmap
-// (for slot) are guaranteed to be present because there's no synchonization
+// (for slot) are guaranteed to be present because there's no synchronization
 // between heaps after marking.
 using DefaultCrossThreadPersistentCheckingPolicy = DisabledCheckingPolicy;
 

data/vendor/v8/include/cppgc/internal/write-barrier.h

@@ -70,10 +70,6 @@ class V8_EXPORT WriteBarrier final {
   // Returns the required write barrier for a given  `value`.
   static V8_INLINE Type GetWriteBarrierType(const void* value, Params& params);
 
-  template <typename HeapHandleCallback>
-  static V8_INLINE Type GetWriteBarrierTypeForExternallyReferencedObject(
-      const void* value, Params& params, HeapHandleCallback callback);
-
   static V8_INLINE void DijkstraMarkingBarrier(const Params& params,
                                                const void* object);
   static V8_INLINE void DijkstraMarkingBarrierRange(
@@ -84,9 +80,13 @@ class V8_EXPORT WriteBarrier final {
 #if defined(CPPGC_YOUNG_GENERATION)
   static V8_INLINE void GenerationalBarrier(const Params& params,
                                             const void* slot);
-#else   // !CPPGC_YOUNG_GENERATION
+  static V8_INLINE void GenerationalBarrierForSourceObject(
+      const Params& params, const void* inner_pointer);
+#else  // !CPPGC_YOUNG_GENERATION
   static V8_INLINE void GenerationalBarrier(const Params& params,
                                             const void* slot) {}
+  static V8_INLINE void GenerationalBarrierForSourceObject(
+      const Params& params, const void* inner_pointer) {}
 #endif  // CPPGC_YOUNG_GENERATION
 
 #if V8_ENABLE_CHECKS
@@ -124,8 +124,10 @@ class V8_EXPORT WriteBarrier final {
 #if defined(CPPGC_YOUNG_GENERATION)
   static CagedHeapLocalData& GetLocalData(HeapHandle&);
   static void GenerationalBarrierSlow(const CagedHeapLocalData& local_data,
-                                      const AgeTable& ageTable,
+                                      const AgeTable& age_table,
                                       const void* slot, uintptr_t value_offset);
+  static void GenerationalBarrierForSourceObjectSlow(
+      const CagedHeapLocalData& local_data, const void* object);
 #endif  // CPPGC_YOUNG_GENERATION
 
   static AtomicEntryFlag incremental_or_concurrent_marking_flag_;
@@ -157,13 +159,6 @@ class V8_EXPORT WriteBarrierTypeForCagedHeapPolicy final {
     return GetNoSlot(value, params, callback);
   }
 
-  template <typename HeapHandleCallback>
-  static V8_INLINE WriteBarrier::Type GetForExternallyReferenced(
-      const void* value, WriteBarrier::Params& params,
-      HeapHandleCallback callback) {
-    return GetNoSlot(value, params, callback);
-  }
-
  private:
   WriteBarrierTypeForCagedHeapPolicy() = delete;
 
@@ -292,15 +287,6 @@ class V8_EXPORT WriteBarrierTypeForNonCagedHeapPolicy final {
                                                        callback);
   }
 
-  template <typename HeapHandleCallback>
-  static V8_INLINE WriteBarrier::Type GetForExternallyReferenced(
-      const void* value, WriteBarrier::Params& params,
-      HeapHandleCallback callback) {
-    // The slot will never be used in `Get()` below.
-    return Get<WriteBarrier::ValueMode::kValuePresent>(nullptr, value, params,
-                                                       callback);
-  }
-
  private:
   template <WriteBarrier::ValueMode value_mode>
   struct ValueModeDispatch;
@@ -375,15 +361,6 @@ WriteBarrier::Type WriteBarrier::GetWriteBarrierType(
                                                                []() {});
 }
 
-// static
-template <typename HeapHandleCallback>
-WriteBarrier::Type
-WriteBarrier::GetWriteBarrierTypeForExternallyReferencedObject(
-    const void* value, Params& params, HeapHandleCallback callback) {
-  return WriteBarrierTypePolicy::GetForExternallyReferenced(value, params,
-                                                            callback);
-}
-
 // static
 void WriteBarrier::DijkstraMarkingBarrier(const Params& params,
                                           const void* object) {
@@ -428,11 +405,28 @@ void WriteBarrier::GenerationalBarrier(const Params& params, const void* slot) {
   const AgeTable& age_table = local_data.age_table;
 
   // Bail out if the slot is in young generation.
-  if (V8_LIKELY(age_table[params.slot_offset] == AgeTable::Age::kYoung)) return;
+  if (V8_LIKELY(age_table.GetAge(params.slot_offset) == AgeTable::Age::kYoung))
+    return;
 
   GenerationalBarrierSlow(local_data, age_table, slot, params.value_offset);
 }
 
+// static
+void WriteBarrier::GenerationalBarrierForSourceObject(
+    const Params& params, const void* inner_pointer) {
+  CheckParams(Type::kGenerational, params);
+
+  const CagedHeapLocalData& local_data = params.caged_heap();
+  const AgeTable& age_table = local_data.age_table;
+
+  // Assume that if the first element is in young generation, the whole range is
+  // in young generation.
+  if (V8_LIKELY(age_table.GetAge(params.slot_offset) == AgeTable::Age::kYoung))
+    return;
+
+  GenerationalBarrierForSourceObjectSlow(local_data, inner_pointer);
+}
+
 #endif  // !CPPGC_YOUNG_GENERATION
 
 }  // namespace internal

data/vendor/v8/include/cppgc/member.h

@@ -26,7 +26,7 @@ class MemberBase {
  protected:
   struct AtomicInitializerTag {};
 
-  MemberBase() = default;
+  MemberBase() : raw_(nullptr) {}
   explicit MemberBase(const void* value) : raw_(value) {}
   MemberBase(const void* value, AtomicInitializerTag) { SetRawAtomic(value); }
 
@@ -46,7 +46,10 @@ class MemberBase {
   void ClearFromGC() const { raw_ = nullptr; }
 
  private:
-  mutable const void* raw_ = nullptr;
+  // All constructors initialize `raw_`. Do not add a default value here as it
+  // results in a non-atomic write on some builds, even when the atomic version
+  // of the constructor is used.
+  mutable const void* raw_;
 };
 
 // The basic class from which all Member classes are 'generated'.

data/vendor/v8/include/cppgc/persistent.h

@@ -118,10 +118,10 @@ class BasicPersistent final : public PersistentBase,
   template <typename U, typename MemberBarrierPolicy,
             typename MemberWeaknessTag, typename MemberCheckingPolicy,
             typename = std::enable_if_t<std::is_base_of<T, U>::value>>
-  BasicPersistent(internal::BasicMember<U, MemberBarrierPolicy,
-                                        MemberWeaknessTag, MemberCheckingPolicy>
-                      member,
-                  const SourceLocation& loc = SourceLocation::Current())
+  BasicPersistent(
+      const internal::BasicMember<U, MemberBarrierPolicy, MemberWeaknessTag,
+                                  MemberCheckingPolicy>& member,
+      const SourceLocation& loc = SourceLocation::Current())
       : BasicPersistent(member.Get(), loc) {}
 
   ~BasicPersistent() { Clear(); }
@@ -159,9 +159,8 @@ class BasicPersistent final : public PersistentBase,
             typename MemberWeaknessTag, typename MemberCheckingPolicy,
             typename = std::enable_if_t<std::is_base_of<T, U>::value>>
   BasicPersistent& operator=(
-      internal::BasicMember<U, MemberBarrierPolicy, MemberWeaknessTag,
-                            MemberCheckingPolicy>
-          member) {
+      const internal::BasicMember<U, MemberBarrierPolicy, MemberWeaknessTag,
+                                  MemberCheckingPolicy>& member) {
     return operator=(member.Get());
   }
 
@@ -292,12 +291,12 @@ template <typename T1, typename PersistentWeaknessPolicy,
           typename PersistentLocationPolicy, typename PersistentCheckingPolicy,
           typename T2, typename MemberWriteBarrierPolicy,
           typename MemberWeaknessTag, typename MemberCheckingPolicy>
-bool operator==(const BasicPersistent<T1, PersistentWeaknessPolicy,
-                                      PersistentLocationPolicy,
-                                      PersistentCheckingPolicy>& p,
-                BasicMember<T2, MemberWeaknessTag, MemberWriteBarrierPolicy,
-                            MemberCheckingPolicy>
-                    m) {
+bool operator==(
+    const BasicPersistent<T1, PersistentWeaknessPolicy,
+                          PersistentLocationPolicy, PersistentCheckingPolicy>&
+        p,
+    const BasicMember<T2, MemberWeaknessTag, MemberWriteBarrierPolicy,
+                      MemberCheckingPolicy>& m) {
   return p.Get() == m.Get();
 }
 
@@ -305,12 +304,12 @@ template <typename T1, typename PersistentWeaknessPolicy,
           typename PersistentLocationPolicy, typename PersistentCheckingPolicy,
           typename T2, typename MemberWriteBarrierPolicy,
           typename MemberWeaknessTag, typename MemberCheckingPolicy>
-bool operator!=(const BasicPersistent<T1, PersistentWeaknessPolicy,
-                                      PersistentLocationPolicy,
-                                      PersistentCheckingPolicy>& p,
-                BasicMember<T2, MemberWeaknessTag, MemberWriteBarrierPolicy,
-                            MemberCheckingPolicy>
-                    m) {
+bool operator!=(
+    const BasicPersistent<T1, PersistentWeaknessPolicy,
+                          PersistentLocationPolicy, PersistentCheckingPolicy>&
+        p,
+    const BasicMember<T2, MemberWeaknessTag, MemberWriteBarrierPolicy,
+                      MemberCheckingPolicy>& m) {
   return !(p == m);
 }
 
@@ -318,12 +317,12 @@ template <typename T1, typename MemberWriteBarrierPolicy,
           typename MemberWeaknessTag, typename MemberCheckingPolicy,
           typename T2, typename PersistentWeaknessPolicy,
           typename PersistentLocationPolicy, typename PersistentCheckingPolicy>
-bool operator==(BasicMember<T2, MemberWeaknessTag, MemberWriteBarrierPolicy,
-                            MemberCheckingPolicy>
-                    m,
-                const BasicPersistent<T1, PersistentWeaknessPolicy,
-                                      PersistentLocationPolicy,
-                                      PersistentCheckingPolicy>& p) {
+bool operator==(
+    const BasicMember<T2, MemberWeaknessTag, MemberWriteBarrierPolicy,
+                      MemberCheckingPolicy>& m,
+    const BasicPersistent<T1, PersistentWeaknessPolicy,
+                          PersistentLocationPolicy, PersistentCheckingPolicy>&
+        p) {
   return m.Get() == p.Get();
 }
 
@@ -331,12 +330,12 @@ template <typename T1, typename MemberWriteBarrierPolicy,
           typename MemberWeaknessTag, typename MemberCheckingPolicy,
           typename T2, typename PersistentWeaknessPolicy,
           typename PersistentLocationPolicy, typename PersistentCheckingPolicy>
-bool operator!=(BasicMember<T2, MemberWeaknessTag, MemberWriteBarrierPolicy,
-                            MemberCheckingPolicy>
-                    m,
-                const BasicPersistent<T1, PersistentWeaknessPolicy,
-                                      PersistentLocationPolicy,
-                                      PersistentCheckingPolicy>& p) {
+bool operator!=(
+    const BasicMember<T2, MemberWeaknessTag, MemberWriteBarrierPolicy,
+                      MemberCheckingPolicy>& m,
+    const BasicPersistent<T1, PersistentWeaknessPolicy,
+                          PersistentLocationPolicy, PersistentCheckingPolicy>&
+        p) {
   return !(m == p);
 }
 

data/vendor/v8/include/cppgc/platform.h

@@ -7,6 +7,7 @@
 
 #include <memory>
 
+#include "cppgc/source-location.h"
 #include "v8-platform.h"  // NOLINT(build/include_directory)
 #include "v8config.h"     // NOLINT(build/include_directory)
 
@@ -145,7 +146,8 @@ V8_EXPORT void ShutdownProcess();
 
 namespace internal {
 
-V8_EXPORT void Abort();
+V8_EXPORT void Fatal(const std::string& reason = std::string(),
+                     const SourceLocation& = SourceLocation::Current());
 
 }  // namespace internal
 

data/vendor/v8/include/cppgc/prefinalizer.h

@@ -6,23 +6,17 @@
 #define INCLUDE_CPPGC_PREFINALIZER_H_
 
 #include "cppgc/internal/compiler-specific.h"
-#include "cppgc/internal/prefinalizer-handler.h"
 #include "cppgc/liveness-broker.h"
 
 namespace cppgc {
 
 namespace internal {
 
-template <typename T>
-class PrefinalizerRegistration final {
+class V8_EXPORT PrefinalizerRegistration final {
  public:
-  explicit PrefinalizerRegistration(T* self) {
-    static_assert(sizeof(&T::InvokePreFinalizer) > 0,
-                  "USING_PRE_FINALIZER(T) must be defined.");
+  using Callback = bool (*)(const cppgc::LivenessBroker&, void*);
 
-    cppgc::internal::PreFinalizerRegistrationDispatcher::RegisterPrefinalizer(
-        {self, T::InvokePreFinalizer});
-  }
+  PrefinalizerRegistration(void*, Callback);
 
   void* operator new(size_t, void* location) = delete;
   void* operator new(size_t) = delete;
@@ -30,6 +24,35 @@ class PrefinalizerRegistration final {
 
 }  // namespace internal
 
+/**
+ * Macro must be used in the private section of `Class` and registers a
+ * prefinalization callback `void Class::PreFinalizer()`. The callback is
+ * invoked on garbage collection after the collector has found an object to be
+ * dead.
+ *
+ * Callback properties:
+ * - The callback is invoked before a possible destructor for the corresponding
+ *   object.
+ * - The callback may access the whole object graph, irrespective of whether
+ *   objects are considered dead or alive.
+ * - The callback is invoked on the same thread as the object was created on.
+ *
+ * Example:
+ * \code
+ * class WithPrefinalizer : public GarbageCollected<WithPrefinalizer> {
+ *   CPPGC_USING_PRE_FINALIZER(WithPrefinalizer, Dispose);
+ *
+ *  public:
+ *   void Trace(Visitor*) const {}
+ *   void Dispose() { prefinalizer_called = true; }
+ *   ~WithPrefinalizer() {
+ *     // prefinalizer_called == true
+ *   }
+ *  private:
+ *   bool prefinalizer_called = false;
+ * };
+ * \endcode
+ */
 #define CPPGC_USING_PRE_FINALIZER(Class, PreFinalizer)                         \
  public:                                                                       \
   static bool InvokePreFinalizer(const cppgc::LivenessBroker& liveness_broker, \
@@ -43,8 +66,8 @@ class PrefinalizerRegistration final {
   }                                                                            \
                                                                                \
  private:                                                                      \
-  CPPGC_NO_UNIQUE_ADDRESS cppgc::internal::PrefinalizerRegistration<Class>     \
-      prefinalizer_dummy_{this};                                               \
+  CPPGC_NO_UNIQUE_ADDRESS cppgc::internal::PrefinalizerRegistration            \
+      prefinalizer_dummy_{this, Class::InvokePreFinalizer};                    \
   static_assert(true, "Force semicolon.")
 
 }  // namespace cppgc

data/vendor/v8/include/cppgc/testing.h

@@ -19,8 +19,13 @@ class HeapHandle;
 namespace testing {
 
 /**
- * Overrides the state of the stack with the provided value. Takes precedence
- * over other parameters that set the stack state. Must no be nested.
+ * Overrides the state of the stack with the provided value. Parameters passed
+ * to explicit garbage collection calls still take precedence. Must not be
+ * nested.
+ *
+ * This scope is useful to make the garbage collector consider the stack when
+ * tasks that invoke garbage collection (through the provided platform) contain
+ * interesting pointers on its stack.
  */
 class V8_EXPORT V8_NODISCARD OverrideEmbedderStackStateScope final {
   CPPGC_STACK_ALLOCATED();
@@ -93,6 +98,8 @@ class V8_EXPORT StandaloneTestingHeap final {
   HeapHandle& heap_handle_;
 };
 
+V8_EXPORT bool IsHeapObjectOld(void*);
+
 }  // namespace testing
 }  // namespace cppgc
 

data/vendor/v8/include/cppgc/type-traits.h

@@ -24,14 +24,6 @@ class StrongMemberTag;
 class UntracedMemberTag;
 class WeakMemberTag;
 
-// Pre-C++17 custom implementation of std::void_t.
-template <typename... Ts>
-struct make_void {
-  typedef void type;
-};
-template <typename... Ts>
-using void_t = typename make_void<Ts...>::type;
-
 // Not supposed to be specialized by the user.
 template <typename T>
 struct IsWeak : std::false_type {};
@@ -42,7 +34,7 @@ template <typename T, typename = void>
 struct IsTraceMethodConst : std::false_type {};
 
 template <typename T>
-struct IsTraceMethodConst<T, void_t<decltype(std::declval<const T>().Trace(
+struct IsTraceMethodConst<T, std::void_t<decltype(std::declval<const T>().Trace(
                                  std::declval<Visitor*>()))>> : std::true_type {
 };
 
@@ -53,7 +45,7 @@ struct IsTraceable : std::false_type {
 
 template <typename T>
 struct IsTraceable<
-    T, void_t<decltype(std::declval<T>().Trace(std::declval<Visitor*>()))>>
+    T, std::void_t<decltype(std::declval<T>().Trace(std::declval<Visitor*>()))>>
     : std::true_type {
   // All Trace methods should be marked as const. If an object of type
   // 'T' is traceable then any object of type 'const T' should also
@@ -72,8 +64,8 @@ struct HasGarbageCollectedMixinTypeMarker : std::false_type {
 
 template <typename T>
 struct HasGarbageCollectedMixinTypeMarker<
-    T,
-    void_t<typename std::remove_const_t<T>::IsGarbageCollectedMixinTypeMarker>>
+    T, std::void_t<
+           typename std::remove_const_t<T>::IsGarbageCollectedMixinTypeMarker>>
     : std::true_type {
   static_assert(sizeof(T), "T must be fully defined");
 };
@@ -85,7 +77,8 @@ struct HasGarbageCollectedTypeMarker : std::false_type {
 
 template <typename T>
 struct HasGarbageCollectedTypeMarker<
-    T, void_t<typename std::remove_const_t<T>::IsGarbageCollectedTypeMarker>>
+    T,
+    std::void_t<typename std::remove_const_t<T>::IsGarbageCollectedTypeMarker>>
     : std::true_type {
   static_assert(sizeof(T), "T must be fully defined");
 };

data/vendor/v8/include/libplatform/libplatform.h

@@ -89,17 +89,6 @@ V8_PLATFORM_EXPORT void RunIdleTasks(v8::Platform* platform,
                                      v8::Isolate* isolate,
                                      double idle_time_in_seconds);
 
-/**
- * Attempts to set the tracing controller for the given platform.
- *
- * The |platform| has to be created using |NewDefaultPlatform|.
- *
- */
-V8_DEPRECATE_SOON("Access the DefaultPlatform directly")
-V8_PLATFORM_EXPORT void SetTracingController(
-    v8::Platform* platform,
-    v8::platform::tracing::TracingController* tracing_controller);
-
 /**
  * Notifies the given platform about the Isolate getting deleted soon. Has to be
  * called for all Isolates which are deleted - unless we're shutting down the

data/vendor/v8/include/libplatform/v8-tracing.h

@@ -37,7 +37,6 @@ const int kTraceMaxNumArgs = 2;
 class V8_PLATFORM_EXPORT TraceObject {
  public:
   union ArgValue {
-    V8_DEPRECATED("use as_uint ? true : false") bool as_bool;
     uint64_t as_uint;
     int64_t as_int;
     double as_double;

data/vendor/v8/include/v8-array-buffer.h

@@ -175,8 +175,8 @@ class V8_EXPORT ArrayBuffer : public Object {
     /**
      * Convenience allocator.
      *
-     * When the virtual memory cage is enabled, this allocator will allocate its
-     * backing memory inside the cage. Otherwise, it will rely on malloc/free.
+     * When the sandbox is enabled, this allocator will allocate its backing
+     * memory inside the sandbox. Otherwise, it will rely on malloc/free.
      *
      * Caller takes ownership, i.e. the returned object needs to be freed using
      * |delete allocator| once it is no longer in use.
@@ -256,6 +256,12 @@ class V8_EXPORT ArrayBuffer : public Object {
    */
   std::shared_ptr<BackingStore> GetBackingStore();
 
+  /**
+   * More efficient shortcut for GetBackingStore()->Data(). The returned pointer
+   * is valid as long as the ArrayBuffer is alive.
+   */
+  void* Data() const;
+
   V8_INLINE static ArrayBuffer* Cast(Value* value) {
 #ifdef V8_ENABLE_CHECKS
     CheckCast(value);
@@ -414,6 +420,12 @@ class V8_EXPORT SharedArrayBuffer : public Object {
    */
   std::shared_ptr<BackingStore> GetBackingStore();
 
+  /**
+   * More efficient shortcut for GetBackingStore()->Data(). The returned pointer
+   * is valid as long as the ArrayBuffer is alive.
+   */
+  void* Data() const;
+
   V8_INLINE static SharedArrayBuffer* Cast(Value* value) {
 #ifdef V8_ENABLE_CHECKS
     CheckCast(value);

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

@@ -148,11 +148,13 @@ using JitCodeEventHandler = void (*)(const JitCodeEvent* event);
  */
 enum GCType {
   kGCTypeScavenge = 1 << 0,
-  kGCTypeMarkSweepCompact = 1 << 1,
-  kGCTypeIncrementalMarking = 1 << 2,
-  kGCTypeProcessWeakCallbacks = 1 << 3,
-  kGCTypeAll = kGCTypeScavenge | kGCTypeMarkSweepCompact |
-               kGCTypeIncrementalMarking | kGCTypeProcessWeakCallbacks
+  kGCTypeMinorMarkCompact = 1 << 1,
+  kGCTypeMarkSweepCompact = 1 << 2,
+  kGCTypeIncrementalMarking = 1 << 3,
+  kGCTypeProcessWeakCallbacks = 1 << 4,
+  kGCTypeAll = kGCTypeScavenge | kGCTypeMinorMarkCompact |
+               kGCTypeMarkSweepCompact | kGCTypeIncrementalMarking |
+               kGCTypeProcessWeakCallbacks
 };
 
 /**
@@ -316,7 +318,7 @@ using SharedArrayBufferConstructorEnabledCallback =
     bool (*)(Local<Context> context);
 
 /**
- * HostImportModuleDynamicallyWithImportAssertionsCallback is called when we
+ * HostImportModuleDynamicallyCallback is called when we
  * require the embedder to load a module. This is used as part of the dynamic
  * import syntax.
  *
@@ -346,6 +348,10 @@ using HostImportModuleDynamicallyWithImportAssertionsCallback =
                             Local<ScriptOrModule> referrer,
                             Local<String> specifier,
                             Local<FixedArray> import_assertions);
+using HostImportModuleDynamicallyCallback = MaybeLocal<Promise> (*)(
+    Local<Context> context, Local<Data> host_defined_options,
+    Local<Value> resource_name, Local<String> specifier,
+    Local<FixedArray> import_assertions);
 
 /**
  * HostInitializeImportMetaObjectCallback is called the first time import.meta
@@ -361,6 +367,20 @@ using HostInitializeImportMetaObjectCallback = void (*)(Local<Context> context,
                                                         Local<Module> module,
                                                         Local<Object> meta);
 
+/**
+ * HostCreateShadowRealmContextCallback is called each time a ShadowRealm is
+ * being constructed in the initiator_context.
+ *
+ * The method combines Context creation and implementation defined abstract
+ * operation HostInitializeShadowRealm into one.
+ *
+ * The embedder should use v8::Context::New or v8::Context:NewFromSnapshot to
+ * create a new context. If the creation fails, the embedder must propagate
+ * that exception by returning an empty MaybeLocal.
+ */
+using HostCreateShadowRealmContextCallback =
+    MaybeLocal<Context> (*)(Local<Context> initiator_context);
+
 /**
  * PrepareStackTraceCallback is called when the stack property of an error is
  * first accessed. The return value will be used as the stack value. If this

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

@@ -313,17 +313,6 @@ class V8_EXPORT Context : public Data {
     explicit BackupIncumbentScope(Local<Context> backup_incumbent_context);
     ~BackupIncumbentScope();
 
-    /**
-     * Returns address that is comparable with JS stack address.  Note that JS
-     * stack may be allocated separately from the native stack.  See also
-     * |TryCatch::JSStackComparableAddressPrivate| for details.
-     */
-    V8_DEPRECATE_SOON(
-        "This is private V8 information that should not be exposed in the API.")
-    uintptr_t JSStackComparableAddress() const {
-      return JSStackComparableAddressPrivate();
-    }
-
    private:
     friend class internal::Isolate;
 
@@ -379,7 +368,7 @@ Local<Value> Context::GetEmbedderData(int index) {
 }
 
 void* Context::GetAlignedPointerFromEmbedderData(int index) {
-#ifndef V8_ENABLE_CHECKS
+#if !defined(V8_ENABLE_CHECKS)
   using A = internal::Address;
   using I = internal::Internals;
   A ctx = *reinterpret_cast<const A*>(this);
@@ -387,10 +376,10 @@ void* Context::GetAlignedPointerFromEmbedderData(int index) {
       I::ReadTaggedPointerField(ctx, I::kNativeContextEmbedderDataOffset);
   int value_offset =
       I::kEmbedderDataArrayHeaderSize + (I::kEmbedderDataSlotSize * index);
-#ifdef V8_HEAP_SANDBOX
+#ifdef V8_SANDBOXED_EXTERNAL_POINTERS
   value_offset += I::kEmbedderDataSlotRawPayloadOffset;
 #endif
-  internal::Isolate* isolate = I::GetIsolateForHeapSandbox(ctx);
+  internal::Isolate* isolate = I::GetIsolateForSandbox(ctx);
   return reinterpret_cast<void*>(
       I::ReadExternalPointerField(isolate, embedder_data, value_offset,
                                   internal::kEmbedderDataSlotPayloadTag));