node-linux-arm64 17.9.1 → 18.0.0

package/include/node/v8-traced-handle.h

@@ -11,10 +11,8 @@
 
 #include <atomic>
 #include <memory>
-#include <string>
 #include <type_traits>
 #include <utility>
-#include <vector>
 
 #include "v8-internal.h"            // NOLINT(build/include_directory)
 #include "v8-local-handle.h"        // NOLINT(build/include_directory)
@@ -26,28 +24,24 @@ namespace v8 {
 class Value;
 
 namespace internal {
+
 class BasicTracedReferenceExtractor;
-}  // namespace internal
 
-namespace api_internal {
+enum class GlobalHandleStoreMode {
+  kInitializingStore,
+  kAssigningStore,
+};
+
 V8_EXPORT internal::Address* GlobalizeTracedReference(
     internal::Isolate* isolate, internal::Address* handle,
-    internal::Address* slot, bool has_destructor);
-V8_EXPORT void MoveTracedGlobalReference(internal::Address** from,
-                                         internal::Address** to);
-V8_EXPORT void CopyTracedGlobalReference(const internal::Address* const* from,
-                                         internal::Address** to);
-V8_EXPORT void DisposeTracedGlobal(internal::Address* global_handle);
-V8_EXPORT void SetFinalizationCallbackTraced(
-    internal::Address* location, void* parameter,
-    WeakCallbackInfo<void>::Callback callback);
-}  // namespace api_internal
+    internal::Address* slot, GlobalHandleStoreMode store_mode);
+V8_EXPORT void MoveTracedReference(internal::Address** from,
+                                   internal::Address** to);
+V8_EXPORT void CopyTracedReference(const internal::Address* const* from,
+                                   internal::Address** to);
+V8_EXPORT void DisposeTracedReference(internal::Address* global_handle);
 
-/**
- * Deprecated. Use |TracedReference<T>| instead.
- */
-template <typename T>
-struct TracedGlobalTrait {};
+}  // namespace internal
 
 class TracedReferenceBase {
  public:
@@ -132,9 +126,8 @@ class TracedReferenceBase {
  *   |v8::EmbedderRootsHandler::IsRoot()| whether the handle should
  * be treated as root or not.
  *
- * Note that the base class cannot be instantiated itself. Choose from
- * - TracedGlobal
- * - TracedReference
+ * Note that the base class cannot be instantiated itself, use |TracedReference|
+ * instead.
  */
 template <typename T>
 class BasicTracedReference : public TracedReferenceBase {
@@ -164,23 +157,20 @@ class BasicTracedReference : public TracedReferenceBase {
   }
 
  private:
-  enum DestructionMode { kWithDestructor, kWithoutDestructor };
-
   /**
    * An empty BasicTracedReference without storage cell.
    */
   BasicTracedReference() = default;
 
-  V8_INLINE static internal::Address* New(Isolate* isolate, T* that, void* slot,
-                                          DestructionMode destruction_mode);
+  V8_INLINE static internal::Address* New(
+      Isolate* isolate, T* that, void* slot,
+      internal::GlobalHandleStoreMode store_mode);
 
   friend class EmbedderHeapTracer;
   template <typename F>
   friend class Local;
   friend class Object;
   template <typename F>
-  friend class TracedGlobal;
-  template <typename F>
   friend class TracedReference;
   template <typename F>
   friend class BasicTracedReference;
@@ -188,127 +178,6 @@ class BasicTracedReference : public TracedReferenceBase {
   friend class ReturnValue;
 };
 
-/**
- * A traced handle with destructor that clears the handle. For more details see
- * BasicTracedReference.
- */
-template <typename T>
-class TracedGlobal : public BasicTracedReference<T> {
- public:
-  using BasicTracedReference<T>::Reset;
-
-  /**
-   * Destructor resetting the handle.Is
-   */
-  ~TracedGlobal() { this->Reset(); }
-
-  /**
-   * An empty TracedGlobal without storage cell.
-   */
-  TracedGlobal() : BasicTracedReference<T>() {}
-
-  /**
-   * Construct a TracedGlobal from a Local.
-   *
-   * When the Local is non-empty, a new storage cell is created
-   * pointing to the same object.
-   */
-  template <class S>
-  TracedGlobal(Isolate* isolate, Local<S> that) : BasicTracedReference<T>() {
-    this->val_ = this->New(isolate, that.val_, &this->val_,
-                           BasicTracedReference<T>::kWithDestructor);
-    static_assert(std::is_base_of<T, S>::value, "type check");
-  }
-
-  /**
-   * Move constructor initializing TracedGlobal from an existing one.
-   */
-  V8_INLINE TracedGlobal(TracedGlobal&& other) {
-    // Forward to operator=.
-    *this = std::move(other);
-  }
-
-  /**
-   * Move constructor initializing TracedGlobal from an existing one.
-   */
-  template <typename S>
-  V8_INLINE TracedGlobal(TracedGlobal<S>&& other) {
-    // Forward to operator=.
-    *this = std::move(other);
-  }
-
-  /**
-   * Copy constructor initializing TracedGlobal from an existing one.
-   */
-  V8_INLINE TracedGlobal(const TracedGlobal& other) {
-    // Forward to operator=;
-    *this = other;
-  }
-
-  /**
-   * Copy constructor initializing TracedGlobal from an existing one.
-   */
-  template <typename S>
-  V8_INLINE TracedGlobal(const TracedGlobal<S>& other) {
-    // Forward to operator=;
-    *this = other;
-  }
-
-  /**
-   * Move assignment operator initializing TracedGlobal from an existing one.
-   */
-  V8_INLINE TracedGlobal& operator=(TracedGlobal&& rhs);
-
-  /**
-   * Move assignment operator initializing TracedGlobal from an existing one.
-   */
-  template <class S>
-  V8_INLINE TracedGlobal& operator=(TracedGlobal<S>&& rhs);
-
-  /**
-   * Copy assignment operator initializing TracedGlobal from an existing one.
-   *
-   * Note: Prohibited when |other| has a finalization callback set through
-   * |SetFinalizationCallback|.
-   */
-  V8_INLINE TracedGlobal& operator=(const TracedGlobal& rhs);
-
-  /**
-   * Copy assignment operator initializing TracedGlobal from an existing one.
-   *
-   * Note: Prohibited when |other| has a finalization callback set through
-   * |SetFinalizationCallback|.
-   */
-  template <class S>
-  V8_INLINE TracedGlobal& operator=(const TracedGlobal<S>& rhs);
-
-  /**
-   * If non-empty, destroy the underlying storage cell and create a new one with
-   * the contents of other if other is non empty
-   */
-  template <class S>
-  V8_INLINE void Reset(Isolate* isolate, const Local<S>& other);
-
-  template <class S>
-  V8_INLINE TracedGlobal<S>& As() const {
-    return reinterpret_cast<TracedGlobal<S>&>(
-        const_cast<TracedGlobal<T>&>(*this));
-  }
-
-  /**
-   * Adds a finalization callback to the handle. The type of this callback is
-   * similar to WeakCallbackType::kInternalFields, i.e., it will pass the
-   * parameter and the first two internal fields of the object.
-   *
-   * The callback is then supposed to reset the handle in the callback. No
-   * further V8 API may be called in this callback. In case additional work
-   * involving V8 needs to be done, a second callback can be scheduled using
-   * WeakCallbackInfo<void>::SetSecondPassCallback.
-   */
-  V8_INLINE void SetFinalizationCallback(
-      void* parameter, WeakCallbackInfo<void>::Callback callback);
-};
-
 /**
  * A traced handle without destructor that clears the handle. The embedder needs
  * to ensure that the handle is not accessed once the V8 object has been
@@ -339,7 +208,7 @@ class TracedReference : public BasicTracedReference<T> {
   template <class S>
   TracedReference(Isolate* isolate, Local<S> that) : BasicTracedReference<T>() {
     this->val_ = this->New(isolate, that.val_, &this->val_,
-                           BasicTracedReference<T>::kWithoutDestructor);
+                           internal::GlobalHandleStoreMode::kInitializingStore);
     static_assert(std::is_base_of<T, S>::value, "type check");
   }
 
@@ -347,7 +216,7 @@ class TracedReference : public BasicTracedReference<T> {
    * Move constructor initializing TracedReference from an
    * existing one.
    */
-  V8_INLINE TracedReference(TracedReference&& other) {
+  V8_INLINE TracedReference(TracedReference&& other) noexcept {
     // Forward to operator=.
     *this = std::move(other);
   }
@@ -357,7 +226,7 @@ class TracedReference : public BasicTracedReference<T> {
    * existing one.
    */
   template <typename S>
-  V8_INLINE TracedReference(TracedReference<S>&& other) {
+  V8_INLINE TracedReference(TracedReference<S>&& other) noexcept {
     // Forward to operator=.
     *this = std::move(other);
   }
@@ -382,23 +251,23 @@ class TracedReference : public BasicTracedReference<T> {
   }
 
   /**
-   * Move assignment operator initializing TracedGlobal from an existing one.
+   * Move assignment operator initializing TracedReference from an existing one.
    */
-  V8_INLINE TracedReference& operator=(TracedReference&& rhs);
+  V8_INLINE TracedReference& operator=(TracedReference&& rhs) noexcept;
 
   /**
-   * Move assignment operator initializing TracedGlobal from an existing one.
+   * Move assignment operator initializing TracedReference from an existing one.
    */
   template <class S>
-  V8_INLINE TracedReference& operator=(TracedReference<S>&& rhs);
+  V8_INLINE TracedReference& operator=(TracedReference<S>&& rhs) noexcept;
 
   /**
-   * Copy assignment operator initializing TracedGlobal from an existing one.
+   * Copy assignment operator initializing TracedReference from an existing one.
    */
   V8_INLINE TracedReference& operator=(const TracedReference& rhs);
 
   /**
-   * Copy assignment operator initializing TracedGlobal from an existing one.
+   * Copy assignment operator initializing TracedReference from an existing one.
    */
   template <class S>
   V8_INLINE TracedReference& operator=(const TracedReference<S>& rhs);
@@ -420,18 +289,18 @@ class TracedReference : public BasicTracedReference<T> {
 // --- Implementation ---
 template <class T>
 internal::Address* BasicTracedReference<T>::New(
-    Isolate* isolate, T* that, void* slot, DestructionMode destruction_mode) {
+    Isolate* isolate, T* that, void* slot,
+    internal::GlobalHandleStoreMode store_mode) {
   if (that == nullptr) return nullptr;
   internal::Address* p = reinterpret_cast<internal::Address*>(that);
-  return api_internal::GlobalizeTracedReference(
+  return internal::GlobalizeTracedReference(
       reinterpret_cast<internal::Isolate*>(isolate), p,
-      reinterpret_cast<internal::Address*>(slot),
-      destruction_mode == kWithDestructor);
+      reinterpret_cast<internal::Address*>(slot), store_mode);
 }
 
 void TracedReferenceBase::Reset() {
   if (IsEmpty()) return;
-  api_internal::DisposeTracedGlobal(reinterpret_cast<internal::Address*>(val_));
+  internal::DisposeTracedReference(reinterpret_cast<internal::Address*>(val_));
   SetSlotThreadSafe(nullptr);
 }
 
@@ -477,55 +346,6 @@ V8_INLINE bool operator!=(const v8::Local<U>& lhs,
   return !(rhs == lhs);
 }
 
-template <class T>
-template <class S>
-void TracedGlobal<T>::Reset(Isolate* isolate, const Local<S>& other) {
-  static_assert(std::is_base_of<T, S>::value, "type check");
-  Reset();
-  if (other.IsEmpty()) return;
-  this->val_ = this->New(isolate, other.val_, &this->val_,
-                         BasicTracedReference<T>::kWithDestructor);
-}
-
-template <class T>
-template <class S>
-TracedGlobal<T>& TracedGlobal<T>::operator=(TracedGlobal<S>&& rhs) {
-  static_assert(std::is_base_of<T, S>::value, "type check");
-  *this = std::move(rhs.template As<T>());
-  return *this;
-}
-
-template <class T>
-template <class S>
-TracedGlobal<T>& TracedGlobal<T>::operator=(const TracedGlobal<S>& rhs) {
-  static_assert(std::is_base_of<T, S>::value, "type check");
-  *this = rhs.template As<T>();
-  return *this;
-}
-
-template <class T>
-TracedGlobal<T>& TracedGlobal<T>::operator=(TracedGlobal&& rhs) {
-  if (this != &rhs) {
-    api_internal::MoveTracedGlobalReference(
-        reinterpret_cast<internal::Address**>(&rhs.val_),
-        reinterpret_cast<internal::Address**>(&this->val_));
-  }
-  return *this;
-}
-
-template <class T>
-TracedGlobal<T>& TracedGlobal<T>::operator=(const TracedGlobal& rhs) {
-  if (this != &rhs) {
-    this->Reset();
-    if (rhs.val_ != nullptr) {
-      api_internal::CopyTracedGlobalReference(
-          reinterpret_cast<const internal::Address* const*>(&rhs.val_),
-          reinterpret_cast<internal::Address**>(&this->val_));
-    }
-  }
-  return *this;
-}
-
 template <class T>
 template <class S>
 void TracedReference<T>::Reset(Isolate* isolate, const Local<S>& other) {
@@ -534,12 +354,13 @@ void TracedReference<T>::Reset(Isolate* isolate, const Local<S>& other) {
   if (other.IsEmpty()) return;
   this->SetSlotThreadSafe(
       this->New(isolate, other.val_, &this->val_,
-                BasicTracedReference<T>::kWithoutDestructor));
+                internal::GlobalHandleStoreMode::kAssigningStore));
 }
 
 template <class T>
 template <class S>
-TracedReference<T>& TracedReference<T>::operator=(TracedReference<S>&& rhs) {
+TracedReference<T>& TracedReference<T>::operator=(
+    TracedReference<S>&& rhs) noexcept {
   static_assert(std::is_base_of<T, S>::value, "type check");
   *this = std::move(rhs.template As<T>());
   return *this;
@@ -555,9 +376,10 @@ TracedReference<T>& TracedReference<T>::operator=(
 }
 
 template <class T>
-TracedReference<T>& TracedReference<T>::operator=(TracedReference&& rhs) {
+TracedReference<T>& TracedReference<T>::operator=(
+    TracedReference&& rhs) noexcept {
   if (this != &rhs) {
-    api_internal::MoveTracedGlobalReference(
+    internal::MoveTracedReference(
         reinterpret_cast<internal::Address**>(&rhs.val_),
         reinterpret_cast<internal::Address**>(&this->val_));
   }
@@ -569,7 +391,7 @@ TracedReference<T>& TracedReference<T>::operator=(const TracedReference& rhs) {
   if (this != &rhs) {
     this->Reset();
     if (rhs.val_ != nullptr) {
-      api_internal::CopyTracedGlobalReference(
+      internal::CopyTracedReference(
           reinterpret_cast<const internal::Address* const*>(&rhs.val_),
           reinterpret_cast<internal::Address**>(&this->val_));
     }
@@ -593,13 +415,6 @@ uint16_t TracedReferenceBase::WrapperClassId() const {
   return *reinterpret_cast<uint16_t*>(addr);
 }
 
-template <class T>
-void TracedGlobal<T>::SetFinalizationCallback(
-    void* parameter, typename WeakCallbackInfo<void>::Callback callback) {
-  api_internal::SetFinalizationCallbackTraced(
-      reinterpret_cast<internal::Address*>(this->val_), parameter, callback);
-}
-
 }  // namespace v8
 
 #endif  // INCLUDE_V8_TRACED_HANDLE_H_

package/include/node/v8-unwinder.h

@@ -7,7 +7,8 @@
 
 #include <memory>
 
-#include "v8config.h"  // NOLINT(build/include_directory)
+#include "v8-embedder-state-scope.h"  // NOLINT(build/include_directory)
+#include "v8config.h"                 // NOLINT(build/include_directory)
 
 namespace v8 {
 // Holds the callee saved registers needed for the stack unwinder. It is the
@@ -32,7 +33,7 @@ struct V8_EXPORT RegisterState {
 };
 
 // A StateTag represents a possible state of the VM.
-enum StateTag {
+enum StateTag : int {
   JS,
   GC,
   PARSER,
@@ -46,11 +47,13 @@ enum StateTag {
 
 // The output structure filled up by GetStackSample API function.
 struct SampleInfo {
-  size_t frames_count;            // Number of frames collected.
-  StateTag vm_state;              // Current VM state.
-  void* external_callback_entry;  // External callback address if VM is
-                                  // executing an external callback.
-  void* context;                  // Incumbent native context address.
+  size_t frames_count;              // Number of frames collected.
+  void* external_callback_entry;    // External callback address if VM is
+                                    // executing an external callback.
+  void* context;                    // Incumbent native context address.
+  void* embedder_context;           // Native context address for embedder state
+  StateTag vm_state;                // Current VM state.
+  EmbedderStateTag embedder_state;  // Current Embedder state
 };
 
 struct MemoryRange {

package/include/node/v8-value-serializer.h

@@ -67,6 +67,23 @@ class V8_EXPORT ValueSerializer {
 
     virtual Maybe<uint32_t> GetWasmModuleTransferId(
         Isolate* isolate, Local<WasmModuleObject> module);
+
+    /**
+     * Returns whether shared values are supported. GetSharedValueId is only
+     * called if SupportsSharedValues() returns true.
+     */
+    virtual bool SupportsSharedValues() const;
+
+    /**
+     * Called when the ValueSerializer serializes a value that is shared across
+     * Isolates. The embedder must return an ID for the object. This function
+     * must be idempotent for the same object. When deserializing, the ID will
+     * be passed to ValueDeserializer::Delegate::GetSharedValueFromId as
+     * |shared_value_id|.
+     */
+    virtual Maybe<uint32_t> GetSharedValueId(Isolate* isolate,
+                                             Local<Value> shared_value);
+
     /**
      * Allocates memory for the buffer of at least the size provided. The actual
      * size (which may be greater or equal) is written to |actual_size|. If no
@@ -166,17 +183,30 @@ class V8_EXPORT ValueDeserializer {
 
     /**
      * Get a WasmModuleObject given a transfer_id previously provided
-     * by ValueSerializer::GetWasmModuleTransferId
+     * by ValueSerializer::Delegate::GetWasmModuleTransferId
      */
     virtual MaybeLocal<WasmModuleObject> GetWasmModuleFromId(
         Isolate* isolate, uint32_t transfer_id);
 
     /**
      * Get a SharedArrayBuffer given a clone_id previously provided
-     * by ValueSerializer::GetSharedArrayBufferId
+     * by ValueSerializer::Delegate::GetSharedArrayBufferId
      */
     virtual MaybeLocal<SharedArrayBuffer> GetSharedArrayBufferFromId(
         Isolate* isolate, uint32_t clone_id);
+
+    /**
+     * Returns whether shared values are supported. GetSharedValueFromId is only
+     * called if SupportsSharedValues() returns true.
+     */
+    virtual bool SupportsSharedValues() const;
+
+    /**
+     * Get a value shared across Isolates given a shared_value_id provided by
+     * ValueSerializer::Delegate::GetSharedValueId.
+     */
+    virtual MaybeLocal<Value> GetSharedValueFromId(Isolate* isolate,
+                                                   uint32_t shared_value_id);
   };
 
   ValueDeserializer(Isolate* isolate, const uint8_t* data, size_t size);

package/include/node/v8-version.h

@@ -8,10 +8,10 @@
 // These macros define the version number for the current version.
 // NOTE these macros are used by some of the tool scripts and the build
 // system so their names cannot be changed without changing the scripts.
-#define V8_MAJOR_VERSION 9
-#define V8_MINOR_VERSION 6
-#define V8_BUILD_NUMBER 180
-#define V8_PATCH_LEVEL 15
+#define V8_MAJOR_VERSION 10
+#define V8_MINOR_VERSION 1
+#define V8_BUILD_NUMBER 124
+#define V8_PATCH_LEVEL 8
 
 // Use 1 for candidates and 0 otherwise.
 // (Boolean macro values are not supported by all preprocessors.)

package/include/node/v8-wasm.h

@@ -103,6 +103,12 @@ class V8_EXPORT WasmModuleObject : public Object {
    */
   CompiledWasmModule GetCompiledModule();
 
+  /**
+   * Compile a Wasm module from the provided uncompiled bytes.
+   */
+  static MaybeLocal<WasmModuleObject> Compile(
+      Isolate* isolate, MemorySpan<const uint8_t> wire_bytes);
+
   V8_INLINE static WasmModuleObject* Cast(Value* value) {
 #ifdef V8_ENABLE_CHECKS
     CheckCast(value);
@@ -151,8 +157,12 @@ class V8_EXPORT WasmStreaming final {
    * {Finish} should be called after all received bytes where passed to
    * {OnBytesReceived} to tell V8 that there will be no more bytes. {Finish}
    * does not have to be called after {Abort} has been called already.
+   * If {can_use_compiled_module} is true and {SetCompiledModuleBytes} was
+   * previously called, the compiled module bytes can be used.
+   * If {can_use_compiled_module} is false, the compiled module bytes previously
+   * set by {SetCompiledModuleBytes} should not be used.
    */
-  void Finish();
+  void Finish(bool can_use_compiled_module = true);
 
   /**
    * Abort streaming compilation. If {exception} has a value, then the promise
@@ -167,6 +177,8 @@ class V8_EXPORT WasmStreaming final {
    * can be used, false otherwise. The buffer passed via {bytes} and {size}
    * is owned by the caller. If {SetCompiledModuleBytes} returns true, the
    * buffer must remain valid until either {Finish} or {Abort} completes.
+   * The compiled module bytes should not be used until {Finish(true)} is
+   * called, because they can be invalidated later by {Finish(false)}.
    */
   bool SetCompiledModuleBytes(const uint8_t* bytes, size_t size);
 

package/include/node/v8-weak-callback-info.h

@@ -51,12 +51,26 @@ class WeakCallbackInfo {
   void* embedder_fields_[kEmbedderFieldsInWeakCallback];
 };
 
-// kParameter will pass a void* parameter back to the callback, kInternalFields
-// will pass the first two internal fields back to the callback, kFinalizer
-// will pass a void* parameter back, but is invoked before the object is
-// actually collected, so it can be resurrected. In the last case, it is not
-// possible to request a second pass callback.
-enum class WeakCallbackType { kParameter, kInternalFields, kFinalizer };
+/**
+ * Weakness type for weak handles.
+ */
+enum class WeakCallbackType {
+  /**
+   * Passes a user-defined void* parameter back to the callback.
+   */
+  kParameter,
+  /**
+   * Passes the first two internal fields of the object back to the callback.
+   */
+  kInternalFields,
+  /**
+   * Passes a user-defined void* parameter back to the callback. Will do so
+   * before the object is actually reclaimed, allowing it to be resurrected. In
+   * this case it is not possible to set a second-pass callback.
+   */
+  kFinalizer V8_ENUM_DEPRECATED("Resurrecting finalizers are deprecated "
+                                "and will not be supported going forward.")
+};
 
 template <class T>
 void* WeakCallbackInfo<T>::GetInternalField(int index) const {

package/include/node/v8.h

@@ -19,7 +19,6 @@
 #include <stdint.h>
 
 #include <memory>
-#include <vector>
 
 #include "cppgc/common.h"
 #include "v8-array-buffer.h"       // NOLINT(build/include_directory)