node-linux-arm64 20.8.1 → 21.0.0

package/include/node/v8-profiler.h

@@ -11,6 +11,7 @@
 #include <unordered_set>
 #include <vector>
 
+#include "cppgc/common.h"          // NOLINT(build/include_directory)
 #include "v8-local-handle.h"       // NOLINT(build/include_directory)
 #include "v8-message.h"            // NOLINT(build/include_directory)
 #include "v8-persistent-handle.h"  // NOLINT(build/include_directory)
@@ -24,7 +25,7 @@ enum class EmbedderStateTag : uint8_t;
 class HeapGraphNode;
 struct HeapStatsUpdate;
 class Object;
-enum StateTag : int;
+enum StateTag : uint16_t;
 
 using NativeObject = void*;
 using SnapshotObjectId = uint32_t;
@@ -596,7 +597,6 @@ class V8_EXPORT HeapGraphNode {
     kBigInt = 13,        // BigInt.
     kObjectShape = 14,   // Internal data used for tracking the shapes (or
                          // "hidden classes") of JS objects.
-    kWasmObject = 15,    // A WasmGC struct or array.
   };
 
   /** Returns node type (see HeapGraphNode::Type). */
@@ -883,6 +883,15 @@ class V8_EXPORT EmbedderGraph {
      */
     virtual Detachedness GetDetachedness() { return Detachedness::kUnknown; }
 
+    /**
+     * Returns the address of the object in the embedder heap, or nullptr to not
+     * specify the address. If this address is provided, then V8 can generate
+     * consistent IDs for objects across subsequent heap snapshots, which allows
+     * devtools to determine which objects were retained from one snapshot to
+     * the next. This value is used only if GetNativeObject returns nullptr.
+     */
+    virtual const void* GetAddress() { return nullptr; }
+
     Node(const Node&) = delete;
     Node& operator=(const Node&) = delete;
   };
@@ -1045,6 +1054,11 @@ class V8_EXPORT HeapProfiler {
      * Mode for dealing with numeric values, see `NumericsMode`.
      */
     NumericsMode numerics_mode = NumericsMode::kHideNumericValues;
+    /**
+     * Whether stack is considered as a root set.
+     */
+    cppgc::EmbedderStackState stack_state =
+        cppgc::EmbedderStackState::kMayContainHeapPointers;
   };
 
   /**

package/include/node/v8-script.h

@@ -9,6 +9,7 @@
 #include <stdint.h>
 
 #include <memory>
+#include <tuple>
 #include <vector>
 
 #include "v8-callbacks.h"     // NOLINT(build/include_directory)
@@ -55,7 +56,7 @@ class V8_EXPORT ScriptOrModule {
 /**
  * A compiled JavaScript script, not yet tied to a Context.
  */
-class V8_EXPORT UnboundScript {
+class V8_EXPORT UnboundScript : public Data {
  public:
   /**
    * Binds the script to the currently entered context.
@@ -142,10 +143,9 @@ class V8_EXPORT ModuleRequest : public Data {
    *
    * All assertions present in the module request will be supplied in this
    * list, regardless of whether they are supported by the host. Per
-   * https://tc39.es/proposal-import-assertions/#sec-hostgetsupportedimportassertions,
-   * hosts are expected to ignore assertions that they do not support (as
-   * opposed to, for example, triggering an error if an unsupported assertion is
-   * present).
+   * https://tc39.es/proposal-import-attributes/#sec-hostgetsupportedimportattributes,
+   * hosts are expected to throw for assertions that they do not support (as
+   * opposed to, for example, ignoring them).
    */
   Local<FixedArray> GetImportAssertions() const;
 
@@ -320,7 +320,7 @@ class V8_EXPORT Module : public Data {
  * A compiled JavaScript script, tied to a Context which was active when the
  * script was compiled.
  */
-class V8_EXPORT Script {
+class V8_EXPORT Script : public Data {
  public:
   /**
    * A shorthand for ScriptCompiler::Compile().
@@ -650,7 +650,9 @@ class V8_EXPORT ScriptCompiler {
   static ScriptStreamingTask* StartStreaming(
       Isolate* isolate, StreamedSource* source,
       ScriptType type = ScriptType::kClassic,
-      CompileOptions options = kNoCompileOptions);
+      CompileOptions options = kNoCompileOptions,
+      CompileHintCallback compile_hint_callback = nullptr,
+      void* compile_hint_callback_data = nullptr);
 
   static ConsumeCodeCacheTask* StartConsumingCodeCache(
       Isolate* isolate, std::unique_ptr<CachedData> source);

package/include/node/v8-snapshot.h

@@ -88,10 +88,13 @@ class V8_EXPORT SnapshotCreator {
    * \param existing_blob existing snapshot from which to create this one.
    * \param external_references a null-terminated array of external references
    *        that must be equivalent to CreateParams::external_references.
+   * \param owns_isolate whether this SnapshotCreator should call
+   *        v8::Isolate::Dispose() during its destructor.
    */
   SnapshotCreator(Isolate* isolate,
                   const intptr_t* external_references = nullptr,
-                  const StartupData* existing_blob = nullptr);
+                  const StartupData* existing_blob = nullptr,
+                  bool owns_isolate = true);
 
   /**
    * Create and enter an isolate, and set it up for serialization.

package/include/node/v8-source-location.h

@@ -0,0 +1,92 @@
+// Copyright 2020 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef INCLUDE_SOURCE_LOCATION_H_
+#define INCLUDE_SOURCE_LOCATION_H_
+
+#include <cstddef>
+#include <string>
+
+#include "v8config.h"  // NOLINT(build/include_directory)
+
+#if defined(__has_builtin)
+#define V8_SUPPORTS_SOURCE_LOCATION                                      \
+  (__has_builtin(__builtin_FUNCTION) && __has_builtin(__builtin_FILE) && \
+   __has_builtin(__builtin_LINE))  // NOLINT
+#elif defined(V8_CC_GNU) && __GNUC__ >= 7
+#define V8_SUPPORTS_SOURCE_LOCATION 1
+#elif defined(V8_CC_INTEL) && __ICC >= 1800
+#define V8_SUPPORTS_SOURCE_LOCATION 1
+#else
+#define V8_SUPPORTS_SOURCE_LOCATION 0
+#endif
+
+namespace v8 {
+
+/**
+ * Encapsulates source location information. Mimics C++20's
+ * `std::source_location`.
+ */
+class V8_EXPORT SourceLocation final {
+ public:
+  /**
+   * Construct source location information corresponding to the location of the
+   * call site.
+   */
+#if V8_SUPPORTS_SOURCE_LOCATION
+  static constexpr SourceLocation Current(
+      const char* function = __builtin_FUNCTION(),
+      const char* file = __builtin_FILE(), size_t line = __builtin_LINE()) {
+    return SourceLocation(function, file, line);
+  }
+#else
+  static constexpr SourceLocation Current() { return SourceLocation(); }
+#endif  // V8_SUPPORTS_SOURCE_LOCATION
+
+  /**
+   * Constructs unspecified source location information.
+   */
+  constexpr SourceLocation() = default;
+
+  /**
+   * Returns the name of the function associated with the position represented
+   * by this object, if any.
+   *
+   * \returns the function name as cstring.
+   */
+  constexpr const char* Function() const { return function_; }
+
+  /**
+   * Returns the name of the current source file represented by this object.
+   *
+   * \returns the file name as cstring.
+   */
+  constexpr const char* FileName() const { return file_; }
+
+  /**
+   * Returns the line number represented by this object.
+   *
+   * \returns the line number.
+   */
+  constexpr size_t Line() const { return line_; }
+
+  /**
+   * Returns a human-readable string representing this object.
+   *
+   * \returns a human-readable string representing source location information.
+   */
+  std::string ToString() const;
+
+ private:
+  constexpr SourceLocation(const char* function, const char* file, size_t line)
+      : function_(function), file_(file), line_(line) {}
+
+  const char* function_ = nullptr;
+  const char* file_ = nullptr;
+  size_t line_ = 0u;
+};
+
+}  // namespace v8
+
+#endif  // INCLUDE_SOURCE_LOCATION_H_

package/include/node/v8-statistics.h

@@ -46,6 +46,10 @@ enum class MeasureMemoryExecution { kDefault, kEager, kLazy };
  *
  * It specifies the contexts that need to be measured and gets called when
  * the measurement is completed to report the results.
+ *
+ * Both MeasurementComplete() callbacks will be invoked on completion.
+ * Each implementation of this class should hence implement only one of them,
+ * and leave the other empty.
  */
 class V8_EXPORT MeasureMemoryDelegate {
  public:
@@ -66,10 +70,41 @@ class V8_EXPORT MeasureMemoryDelegate {
    * \param unattributed_size_in_bytes total size of objects that were not
    *   attributed to any context (i.e. are likely shared objects).
    */
+  V8_DEPRECATE_SOON("Please use the version that takes a result struct")
   virtual void MeasurementComplete(
       const std::vector<std::pair<Local<Context>, size_t>>&
           context_sizes_in_bytes,
-      size_t unattributed_size_in_bytes) = 0;
+      size_t unattributed_size_in_bytes) {}
+
+  /** Holds the result of a memory measurement request. */
+  struct Result {
+    /**
+     * a vector of (context, size) pairs that includes each context for
+     * which ShouldMeasure returned true and that was not garbage collected
+     * while the memory measurement was in progress.
+     */
+    const std::vector<std::pair<Local<Context>, size_t>>&
+        context_sizes_in_bytes;
+
+    /**
+     * total size of objects that were not attributed to any context (i.e. are
+     * likely shared objects).
+     */
+    size_t unattributed_size_in_bytes;
+
+    /** total size of generated code for Wasm (shared across contexts). */
+    size_t wasm_code_size_in_bytes;
+
+    /** total size of Wasm metadata (except code; shared across contexts). */
+    size_t wasm_metadata_size_in_bytes;
+  };
+
+  /**
+   * This function is called when memory measurement finishes.
+   *
+   * \param result the result of the measurement.
+   */
+  virtual void MeasurementComplete(Result result) {}
 
   /**
    * Returns a default delegate that resolves the given promise when

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

@@ -33,7 +33,7 @@ enum class GlobalHandleStoreMode {
 };
 
 V8_EXPORT internal::Address* GlobalizeTracedReference(
-    internal::Isolate* isolate, internal::Address* handle,
+    internal::Isolate* isolate, internal::Address value,
     internal::Address* slot, GlobalHandleStoreMode store_mode);
 V8_EXPORT void MoveTracedReference(internal::Address** from,
                                    internal::Address** to);
@@ -43,14 +43,12 @@ V8_EXPORT void DisposeTracedReference(internal::Address* global_handle);
 
 }  // namespace internal
 
-class TracedReferenceBase {
+/**
+ * An indirect handle, where the indirect pointer points to a GlobalHandles
+ * node.
+ */
+class TracedReferenceBase : public IndirectHandleBase {
  public:
-  /**
-   * Returns true if the reference is empty, i.e., has not been assigned
-   * object.
-   */
-  bool IsEmpty() const { return val_ == nullptr; }
-
   /**
    * If non-empty, destroy the underlying storage cell. |IsEmpty| will return
    * true after this call.
@@ -60,10 +58,9 @@ class TracedReferenceBase {
   /**
    * Construct a Local<Value> from this handle.
    */
-  V8_INLINE v8::Local<v8::Value> Get(v8::Isolate* isolate) const {
+  V8_INLINE Local<Value> Get(Isolate* isolate) const {
     if (IsEmpty()) return Local<Value>();
-    return Local<Value>::New(isolate,
-                             internal::ValueHelper::SlotAsValue<Value>(val_));
+    return Local<Value>::New(isolate, this->value<Value>());
   }
 
   /**
@@ -86,11 +83,13 @@ class TracedReferenceBase {
   V8_INLINE uint16_t WrapperClassId() const;
 
  protected:
+  V8_INLINE TracedReferenceBase() = default;
+
   /**
    * Update this reference in a thread-safe way.
    */
   void SetSlotThreadSafe(void* new_val) {
-    reinterpret_cast<std::atomic<void*>*>(&val_)->store(
+    reinterpret_cast<std::atomic<void*>*>(&slot())->store(
         new_val, std::memory_order_relaxed);
   }
 
@@ -98,19 +97,13 @@ class TracedReferenceBase {
    * Get this reference in a thread-safe way
    */
   const void* GetSlotThreadSafe() const {
-    return reinterpret_cast<std::atomic<const void*> const*>(&val_)->load(
+    return reinterpret_cast<std::atomic<const void*> const*>(&slot())->load(
         std::memory_order_relaxed);
   }
 
   V8_EXPORT void CheckValue() const;
 
-  V8_INLINE internal::Address address() const { return *val_; }
-
-  // val_ points to a GlobalHandles node.
-  internal::Address* val_ = nullptr;
-
   friend class internal::BasicTracedReferenceExtractor;
-  friend class internal::HandleHelper;
   template <typename F>
   friend class Local;
   template <typename U>
@@ -139,12 +132,7 @@ class BasicTracedReference : public TracedReferenceBase {
   /**
    * Construct a Local<T> from this handle.
    */
-  Local<T> Get(Isolate* isolate) const {
-#ifdef V8_ENABLE_CONSERVATIVE_STACK_SCANNING
-    if (val_ == nullptr) return Local<T>();
-#endif
-    return Local<T>::New(isolate, *this);
-  }
+  Local<T> Get(Isolate* isolate) const { return Local<T>::New(isolate, *this); }
 
   template <class S>
   V8_INLINE BasicTracedReference<S>& As() const {
@@ -152,19 +140,17 @@ class BasicTracedReference : public TracedReferenceBase {
         const_cast<BasicTracedReference<T>&>(*this));
   }
 
-  T* operator->() const {
+  V8_DEPRECATE_SOON("Use Get to convert to Local instead")
+  V8_INLINE T* operator->() const {
 #ifdef V8_ENABLE_CHECKS
     CheckValue();
 #endif  // V8_ENABLE_CHECKS
-    return reinterpret_cast<T*>(val_);
-  }
-  T* operator*() const {
-#ifdef V8_ENABLE_CHECKS
-    CheckValue();
-#endif  // V8_ENABLE_CHECKS
-    return reinterpret_cast<T*>(val_);
+    return this->template value<T>();
   }
 
+  V8_DEPRECATE_SOON("Use Get to convert to Local instead")
+  V8_INLINE T* operator*() const { return this->operator->(); }
+
  private:
   /**
    * An empty BasicTracedReference without storage cell.
@@ -172,7 +158,7 @@ class BasicTracedReference : public TracedReferenceBase {
   BasicTracedReference() = default;
 
   V8_INLINE static internal::Address* New(
-      Isolate* isolate, T* that, void* slot,
+      Isolate* isolate, T* that, internal::Address** slot,
       internal::GlobalHandleStoreMode store_mode);
 
   template <typename F>
@@ -199,7 +185,7 @@ class TracedReference : public BasicTracedReference<T> {
   /**
    * An empty TracedReference without storage cell.
    */
-  TracedReference() : BasicTracedReference<T>() {}
+  V8_INLINE TracedReference() = default;
 
   /**
    * Construct a TracedReference from a Local.
@@ -209,8 +195,9 @@ class TracedReference : public BasicTracedReference<T> {
    */
   template <class S>
   TracedReference(Isolate* isolate, Local<S> that) : BasicTracedReference<T>() {
-    this->val_ = this->New(isolate, *that, &this->val_,
-                           internal::GlobalHandleStoreMode::kInitializingStore);
+    this->slot() =
+        this->New(isolate, *that, &this->slot(),
+                  internal::GlobalHandleStoreMode::kInitializingStore);
     static_assert(std::is_base_of<T, S>::value, "type check");
   }
 
@@ -291,18 +278,18 @@ class TracedReference : public BasicTracedReference<T> {
 // --- Implementation ---
 template <class T>
 internal::Address* BasicTracedReference<T>::New(
-    Isolate* isolate, T* that, void* slot,
+    Isolate* isolate, T* that, internal::Address** slot,
     internal::GlobalHandleStoreMode store_mode) {
-  if (that == internal::ValueHelper::EmptyValue<T>()) return nullptr;
-  internal::Address* p = reinterpret_cast<internal::Address*>(that);
+  if (internal::ValueHelper::IsEmpty(that)) return nullptr;
   return internal::GlobalizeTracedReference(
-      reinterpret_cast<internal::Isolate*>(isolate), p,
+      reinterpret_cast<internal::Isolate*>(isolate),
+      internal::ValueHelper::ValueAsAddress(that),
       reinterpret_cast<internal::Address*>(slot), store_mode);
 }
 
 void TracedReferenceBase::Reset() {
   if (IsEmpty()) return;
-  internal::DisposeTracedReference(reinterpret_cast<internal::Address*>(val_));
+  internal::DisposeTracedReference(slot());
   SetSlotThreadSafe(nullptr);
 }
 
@@ -347,7 +334,7 @@ void TracedReference<T>::Reset(Isolate* isolate, const Local<S>& other) {
   this->Reset();
   if (other.IsEmpty()) return;
   this->SetSlotThreadSafe(
-      this->New(isolate, *other, &this->val_,
+      this->New(isolate, *other, &this->slot(),
                 internal::GlobalHandleStoreMode::kAssigningStore));
 }
 
@@ -373,9 +360,7 @@ template <class T>
 TracedReference<T>& TracedReference<T>::operator=(
     TracedReference&& rhs) noexcept {
   if (this != &rhs) {
-    internal::MoveTracedReference(
-        reinterpret_cast<internal::Address**>(&rhs.val_),
-        reinterpret_cast<internal::Address**>(&this->val_));
+    internal::MoveTracedReference(&rhs.slot(), &this->slot());
   }
   return *this;
 }
@@ -384,10 +369,8 @@ template <class T>
 TracedReference<T>& TracedReference<T>::operator=(const TracedReference& rhs) {
   if (this != &rhs) {
     this->Reset();
-    if (rhs.val_ != nullptr) {
-      internal::CopyTracedReference(
-          reinterpret_cast<const internal::Address* const*>(&rhs.val_),
-          reinterpret_cast<internal::Address**>(&this->val_));
+    if (!rhs.IsEmpty()) {
+      internal::CopyTracedReference(&rhs.slot(), &this->slot());
     }
   }
   return *this;
@@ -396,16 +379,16 @@ TracedReference<T>& TracedReference<T>::operator=(const TracedReference& rhs) {
 void TracedReferenceBase::SetWrapperClassId(uint16_t class_id) {
   using I = internal::Internals;
   if (IsEmpty()) return;
-  internal::Address* obj = reinterpret_cast<internal::Address*>(val_);
-  uint8_t* addr = reinterpret_cast<uint8_t*>(obj) + I::kTracedNodeClassIdOffset;
+  uint8_t* addr =
+      reinterpret_cast<uint8_t*>(slot()) + I::kTracedNodeClassIdOffset;
   *reinterpret_cast<uint16_t*>(addr) = class_id;
 }
 
 uint16_t TracedReferenceBase::WrapperClassId() const {
   using I = internal::Internals;
   if (IsEmpty()) return 0;
-  internal::Address* obj = reinterpret_cast<internal::Address*>(val_);
-  uint8_t* addr = reinterpret_cast<uint8_t*>(obj) + I::kTracedNodeClassIdOffset;
+  uint8_t* addr =
+      reinterpret_cast<uint8_t*>(slot()) + I::kTracedNodeClassIdOffset;
   return *reinterpret_cast<uint16_t*>(addr);
 }
 

package/include/node/v8-unwinder.h

@@ -33,7 +33,7 @@ struct V8_EXPORT RegisterState {
 };
 
 // A StateTag represents a possible state of the VM.
-enum StateTag : int {
+enum StateTag : uint16_t {
   JS,
   GC,
   PARSER,

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

@@ -75,6 +75,20 @@ class V8_EXPORT ValueSerializer {
      */
     virtual void ThrowDataCloneError(Local<String> message) = 0;
 
+    /**
+     * The embedder overrides this method to enable custom host object filter
+     * with Delegate::IsHostObject.
+     *
+     * This method is called at most once per serializer.
+     */
+    virtual bool HasCustomHostObject(Isolate* isolate);
+
+    /**
+     * The embedder overrides this method to determine if an JS object is a
+     * host object and needs to be serialized by the host.
+     */
+    virtual Maybe<bool> IsHostObject(Isolate* isolate, Local<Object> object);
+
     /**
      * The embedder overrides this method to write some kind of host object, if
      * possible. If not, a suitable exception should be thrown and

package/include/node/v8-value.h

@@ -16,6 +16,8 @@
  */
 namespace v8 {
 
+class Primiitive;
+class Numeric;
 class BigInt;
 class Int32;
 class Integer;
@@ -354,6 +356,18 @@ class V8_EXPORT Value : public Data {
    */
   bool IsModuleNamespaceObject() const;
 
+  /**
+   * Perform `ToPrimitive(value)` as specified in:
+   * https://tc39.es/ecma262/#sec-toprimitive.
+   */
+  V8_WARN_UNUSED_RESULT MaybeLocal<Primitive> ToPrimitive(
+      Local<Context> context) const;
+  /**
+   * Perform `ToNumeric(value)` as specified in:
+   * https://tc39.es/ecma262/#sec-tonumeric.
+   */
+  V8_WARN_UNUSED_RESULT MaybeLocal<Numeric> ToNumeric(
+      Local<Context> context) const;
   /**
    * Perform the equivalent of `BigInt(value)` in JS.
    */

package/include/node/v8-version.h

@@ -9,9 +9,9 @@
 // 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 11
-#define V8_MINOR_VERSION 3
-#define V8_BUILD_NUMBER 244
-#define V8_PATCH_LEVEL 8
+#define V8_MINOR_VERSION 8
+#define V8_BUILD_NUMBER 172
+#define V8_PATCH_LEVEL 13
 
 // Use 1 for candidates and 0 otherwise.
 // (Boolean macro values are not supported by all preprocessors.)

package/include/node/v8config.h

@@ -367,6 +367,7 @@ path. Add it with -I<path> to the command line
 # define V8_HAS_ATTRIBUTE_VISIBILITY (__has_attribute(visibility))
 # define V8_HAS_ATTRIBUTE_WARN_UNUSED_RESULT \
     (__has_attribute(warn_unused_result))
+# define V8_HAS_ATTRIBUTE_WEAK (__has_attribute(weak))
 
 # define V8_HAS_CPP_ATTRIBUTE_NODISCARD (V8_HAS_CPP_ATTRIBUTE(nodiscard))
 # define V8_HAS_CPP_ATTRIBUTE_NO_UNIQUE_ADDRESS \
@@ -417,6 +418,7 @@ path. Add it with -I<path> to the command line
 # define V8_HAS_ATTRIBUTE_UNUSED 1
 # define V8_HAS_ATTRIBUTE_VISIBILITY 1
 # define V8_HAS_ATTRIBUTE_WARN_UNUSED_RESULT (!V8_CC_INTEL)
+# define V8_HAS_ATTRIBUTE_WEAK 1
 
 // [[nodiscard]] does not work together with with
 // __attribute__((visibility(""))) on GCC 7.4 which is why there is no define
@@ -462,14 +464,16 @@ path. Add it with -I<path> to the command line
 
 #ifdef DEBUG
 // In debug mode, check assumptions instead of actually adding annotations.
-# define V8_ASSUME(condition) DCHECK(condition)
+# define V8_ASSUME DCHECK
 #elif V8_HAS_BUILTIN_ASSUME
-# define V8_ASSUME(condition) __builtin_assume(condition)
+# define V8_ASSUME __builtin_assume
 #elif V8_HAS_BUILTIN_UNREACHABLE
-# define V8_ASSUME(condition) \
-  do { if (!(condition)) __builtin_unreachable(); } while (false)
+# define V8_ASSUME(condition)                  \
+  do {                                         \
+    if (!(condition)) __builtin_unreachable(); \
+  } while (false)
 #else
-# define V8_ASSUME(condition)
+# define V8_ASSUME USE
 #endif
 
 #if V8_HAS_BUILTIN_ASSUME_ALIGNED
@@ -525,9 +529,6 @@ path. Add it with -I<path> to the command line
 // A macro used to change the calling conventions to preserve all registers (no
 // caller-saved registers). Use this for cold functions called from hot
 // functions.
-// Note: The attribute is considered experimental, so apply with care. Also,
-// "preserve_most" is currently not handling the return value correctly, so only
-// use it for functions returning void (see https://reviews.llvm.org/D141020).
 // Use like:
 //   V8_NOINLINE V8_PRESERVE_MOST void UnlikelyMethod();
 #if V8_HAS_ATTRIBUTE_PRESERVE_MOST
@@ -610,6 +611,14 @@ path. Add it with -I<path> to the command line
 #endif
 
 
+// Annotate functions/variables as weak to allow overriding the symbol.
+#if V8_HAS_ATTRIBUTE_WEAK
+#define V8_WEAK __attribute__((weak))
+#else
+#define V8_WEAK /* NOT SUPPORTED */
+#endif
+
+
 // Annotate a class or constructor indicating the caller must assign the
 // constructed instances.
 // Apply to the whole class like:
@@ -749,7 +758,7 @@ V8 shared library set USING_V8_SHARED.
 #elif defined(__mips64)
 #define V8_HOST_ARCH_MIPS64 1
 #define V8_HOST_ARCH_64_BIT 1
-#elif defined(__loongarch64)
+#elif defined(__loongarch_lp64)
 #define V8_HOST_ARCH_LOONG64 1
 #define V8_HOST_ARCH_64_BIT 1
 #elif defined(__PPC64__) || defined(_ARCH_PPC64)
@@ -799,7 +808,7 @@ V8 shared library set USING_V8_SHARED.
 #define V8_TARGET_ARCH_ARM 1
 #elif defined(__mips64)
 #define V8_TARGET_ARCH_MIPS64 1
-#elif defined(__loongarch64)
+#elif defined(__loongarch_lp64)
 #define V8_TARGET_ARCH_LOONG64 1
 #elif defined(_ARCH_PPC64)
 #define V8_TARGET_ARCH_PPC64 1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-linux-arm64",
-  "version": "v20.8.1",
+  "version": "v21.0.0",
   "description": "node",
   "bin": {
     "node": "bin/node"