libv8-node 21.7.2.0-aarch64-linux-musl → 24.12.0.0-aarch64-linux-musl

data/vendor/v8/include/v8-memory-span.h

@@ -7,12 +7,51 @@
 
 #include <stddef.h>
 
+#include <array>
+#include <cstddef>
+#include <iterator>
+#include <type_traits>
+
 #include "v8config.h"  // NOLINT(build/include_directory)
 
+// TODO(pkasting): Use <compare>/spaceship unconditionally after dropping
+// support for old libstdc++ versions.
+#if __has_include(<version>)
+#include <version>
+#endif
+#if defined(__cpp_lib_three_way_comparison) && \
+    __cpp_lib_three_way_comparison >= 201711L
+#define V8_HAVE_SPACESHIP_OPERATOR 1
+#else
+#define V8_HAVE_SPACESHIP_OPERATOR 0
+#endif
+
+// TODO(pkasting): Make this block unconditional after dropping support for old
+// libstdc++ versions.
+#if __has_include(<ranges>)
+#include <ranges>
+
+namespace v8 {
+
+template <typename T>
+class V8_EXPORT MemorySpan;
+
+}  // namespace v8
+
+// Mark `MemorySpan` as satisfying the `view` and `borrowed_range` concepts.
+// This should be done before the definition of `MemorySpan`, so that any
+// inlined calls to range functionality use the correct specializations.
+template <typename T>
+inline constexpr bool std::ranges::enable_view<v8::MemorySpan<T>> = true;
+template <typename T>
+inline constexpr bool std::ranges::enable_borrowed_range<v8::MemorySpan<T>> =
+    true;
+#endif
+
 namespace v8 {
 
 /**
- * Points to an unowned continous buffer holding a known number of elements.
+ * Points to an unowned contiguous buffer holding a known number of elements.
  *
  * This is similar to std::span (under consideration for C++20), but does not
  * require advanced C++ support. In the (far) future, this may be replaced with
@@ -23,21 +62,262 @@ namespace v8 {
  */
 template <typename T>
 class V8_EXPORT MemorySpan {
+ private:
+  /** Some C++ machinery, brought from the future. */
+  template <typename From, typename To>
+  using is_array_convertible = std::is_convertible<From (*)[], To (*)[]>;
+  template <typename From, typename To>
+  static constexpr bool is_array_convertible_v =
+      is_array_convertible<From, To>::value;
+
+  template <typename It>
+  using iter_reference_t = decltype(*std::declval<It&>());
+
+  template <typename It, typename = void>
+  struct is_compatible_iterator : std::false_type {};
+  template <typename It>
+  struct is_compatible_iterator<
+      It,
+      std::void_t<
+          std::is_base_of<std::random_access_iterator_tag,
+                          typename std::iterator_traits<It>::iterator_category>,
+          is_array_convertible<std::remove_reference_t<iter_reference_t<It>>,
+                               T>>> : std::true_type {};
+  template <typename It>
+  static constexpr bool is_compatible_iterator_v =
+      is_compatible_iterator<It>::value;
+
+  template <typename U>
+  [[nodiscard]] static constexpr U* to_address(U* p) noexcept {
+    return p;
+  }
+
+  template <typename It,
+            typename = std::void_t<decltype(std::declval<It&>().operator->())>>
+  [[nodiscard]] static constexpr auto to_address(It it) noexcept {
+    return it.operator->();
+  }
+
  public:
   /** The default constructor creates an empty span. */
   constexpr MemorySpan() = default;
 
-  constexpr MemorySpan(T* data, size_t size) : data_(data), size_(size) {}
+  /** Constructor from nullptr and count, for backwards compatibility.
+   * This is not compatible with C++20 std::span.
+   */
+  constexpr MemorySpan(std::nullptr_t, size_t) {}
+
+  /** Constructor from "iterator" and count. */
+  template <typename Iterator,
+            std::enable_if_t<is_compatible_iterator_v<Iterator>, bool> = true>
+  constexpr MemorySpan(Iterator first,
+                       size_t count)  // NOLINT(runtime/explicit)
+      : data_(to_address(first)), size_(count) {}
+
+  /** Constructor from two "iterators". */
+  template <typename Iterator,
+            std::enable_if_t<is_compatible_iterator_v<Iterator> &&
+                                 !std::is_convertible_v<Iterator, size_t>,
+                             bool> = true>
+  constexpr MemorySpan(Iterator first,
+                       Iterator last)  // NOLINT(runtime/explicit)
+      : data_(to_address(first)), size_(last - first) {}
+
+  /** Implicit conversion from C-style array. */
+  template <size_t N>
+  constexpr MemorySpan(T (&a)[N]) noexcept  // NOLINT(runtime/explicit)
+      : data_(a), size_(N) {}
+
+  /** Implicit conversion from std::array. */
+  template <typename U, size_t N,
+            std::enable_if_t<is_array_convertible_v<U, T>, bool> = true>
+  constexpr MemorySpan(
+      std::array<U, N>& a) noexcept  // NOLINT(runtime/explicit)
+      : data_(a.data()), size_{N} {}
+
+  /** Implicit conversion from const std::array. */
+  template <typename U, size_t N,
+            std::enable_if_t<is_array_convertible_v<const U, T>, bool> = true>
+  constexpr MemorySpan(
+      const std::array<U, N>& a) noexcept  // NOLINT(runtime/explicit)
+      : data_(a.data()), size_{N} {}
 
   /** Returns a pointer to the beginning of the buffer. */
-  constexpr T* data() const { return data_; }
+  [[nodiscard]] constexpr T* data() const { return data_; }
   /** Returns the number of elements that the buffer holds. */
-  constexpr size_t size() const { return size_; }
+  [[nodiscard]] constexpr size_t size() const { return size_; }
+
+  [[nodiscard]] constexpr T& operator[](size_t i) const { return data_[i]; }
+
+  /** Returns true if the buffer is empty. */
+  [[nodiscard]] constexpr bool empty() const { return size() == 0; }
+
+  class Iterator {
+   public:
+    using difference_type = std::ptrdiff_t;
+    using value_type = T;
+    using pointer = value_type*;
+    using reference = value_type&;
+    using iterator_category = std::random_access_iterator_tag;
+    // There seems to be no feature-test macro covering this, so use the
+    // presence of `<ranges>` as a crude proxy, since it was added to the
+    // standard as part of the Ranges papers.
+    // TODO(pkasting): Add this unconditionally after dropping support for old
+    // libstdc++ versions.
+#if __has_include(<ranges>)
+    using iterator_concept = std::contiguous_iterator_tag;
+#endif
+
+    // Required to satisfy `std::semiregular<>`.
+    constexpr Iterator() = default;
+
+    [[nodiscard]] friend constexpr bool operator==(const Iterator& a,
+                                                   const Iterator& b) {
+      // TODO(pkasting): Replace this body with `= default` after dropping
+      // support for old gcc versions.
+      return a.ptr_ == b.ptr_;
+    }
+#if V8_HAVE_SPACESHIP_OPERATOR
+    [[nodiscard]] friend constexpr auto operator<=>(const Iterator&,
+                                                    const Iterator&) = default;
+#else
+    // Assume that if spaceship isn't present, operator rewriting might not be
+    // either.
+    [[nodiscard]] friend constexpr bool operator!=(const Iterator& a,
+                                                   const Iterator& b) {
+      return a.ptr_ != b.ptr_;
+    }
+
+    [[nodiscard]] friend constexpr bool operator<(const Iterator& a,
+                                                  const Iterator& b) {
+      return a.ptr_ < b.ptr_;
+    }
+    [[nodiscard]] friend constexpr bool operator<=(const Iterator& a,
+                                                   const Iterator& b) {
+      return a.ptr_ <= b.ptr_;
+    }
+    [[nodiscard]] friend constexpr bool operator>(const Iterator& a,
+                                                  const Iterator& b) {
+      return a.ptr_ > b.ptr_;
+    }
+    [[nodiscard]] friend constexpr bool operator>=(const Iterator& a,
+                                                   const Iterator& b) {
+      return a.ptr_ >= b.ptr_;
+    }
+#endif
+
+    constexpr Iterator& operator++() {
+      ++ptr_;
+      return *this;
+    }
+
+    constexpr Iterator operator++(int) {
+      Iterator temp = *this;
+      ++*this;
+      return temp;
+    }
+
+    constexpr Iterator& operator--() {
+      --ptr_;
+      return *this;
+    }
+
+    constexpr Iterator operator--(int) {
+      Iterator temp = *this;
+      --*this;
+      return temp;
+    }
+
+    constexpr Iterator& operator+=(difference_type rhs) {
+      ptr_ += rhs;
+      return *this;
+    }
+
+    [[nodiscard]] friend constexpr Iterator operator+(Iterator lhs,
+                                                      difference_type rhs) {
+      lhs += rhs;
+      return lhs;
+    }
+
+    [[nodiscard]] friend constexpr Iterator operator+(difference_type lhs,
+                                                      const Iterator& rhs) {
+      return rhs + lhs;
+    }
+
+    constexpr Iterator& operator-=(difference_type rhs) {
+      ptr_ -= rhs;
+      return *this;
+    }
+
+    [[nodiscard]] friend constexpr Iterator operator-(Iterator lhs,
+                                                      difference_type rhs) {
+      lhs -= rhs;
+      return lhs;
+    }
+
+    [[nodiscard]] friend constexpr difference_type operator-(
+        const Iterator& lhs, const Iterator& rhs) {
+      return lhs.ptr_ - rhs.ptr_;
+    }
+
+    [[nodiscard]] constexpr reference operator*() const { return *ptr_; }
+    [[nodiscard]] constexpr pointer operator->() const { return ptr_; }
+    [[nodiscard]] constexpr reference operator[](size_t offset) const {
+      return ptr_[offset];
+    }
+
+   private:
+    friend class MemorySpan<T>;
+
+    constexpr explicit Iterator(T* ptr) : ptr_(ptr) {}
+
+    T* ptr_ = nullptr;
+  };
+
+  [[nodiscard]] Iterator begin() const { return Iterator(data_); }
+  [[nodiscard]] Iterator end() const { return Iterator(data_ + size_); }
 
  private:
   T* data_ = nullptr;
   size_t size_ = 0;
 };
 
+/**
+ * Helper function template to create an array of fixed length, initialized by
+ * the provided initializer list, without explicitly specifying the array size,
+ * e.g.
+ *
+ *   auto arr = v8::to_array<Local<String>>({v8_str("one"), v8_str("two")});
+ *
+ * In the future, this may be replaced with or aliased to std::to_array (under
+ * consideration for C++20).
+ */
+
+namespace detail {
+template <class T, std::size_t N, std::size_t... I>
+[[nodiscard]] constexpr std::array<std::remove_cv_t<T>, N> to_array_lvalue_impl(
+    T (&a)[N], std::index_sequence<I...>) {
+  return {{a[I]...}};
+}
+
+template <class T, std::size_t N, std::size_t... I>
+[[nodiscard]] constexpr std::array<std::remove_cv_t<T>, N> to_array_rvalue_impl(
+    T (&&a)[N], std::index_sequence<I...>) {
+  return {{std::move(a[I])...}};
+}
+}  // namespace detail
+
+template <class T, std::size_t N>
+[[nodiscard]] constexpr std::array<std::remove_cv_t<T>, N> to_array(T (&a)[N]) {
+  return detail::to_array_lvalue_impl(a, std::make_index_sequence<N>{});
+}
+
+template <class T, std::size_t N>
+[[nodiscard]] constexpr std::array<std::remove_cv_t<T>, N> to_array(
+    T (&&a)[N]) {
+  return detail::to_array_rvalue_impl(std::move(a),
+                                      std::make_index_sequence<N>{});
+}
+
 }  // namespace v8
 #endif  // INCLUDE_V8_MEMORY_SPAN_H_

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

@@ -9,6 +9,7 @@
 
 #include <iosfwd>
 
+#include "v8-callbacks.h"     // NOLINT(build/include_directory)
 #include "v8-local-handle.h"  // NOLINT(build/include_directory)
 #include "v8-maybe.h"         // NOLINT(build/include_directory)
 #include "v8-primitive.h"     // NOLINT(build/include_directory)
@@ -61,7 +62,7 @@ class ScriptOriginOptions {
  */
 class V8_EXPORT ScriptOrigin {
  public:
-  V8_INLINE ScriptOrigin(Isolate* isolate, Local<Value> resource_name,
+  V8_INLINE ScriptOrigin(Local<Value> resource_name,
                          int resource_line_offset = 0,
                          int resource_column_offset = 0,
                          bool resource_is_shared_cross_origin = false,
@@ -70,8 +71,7 @@ class V8_EXPORT ScriptOrigin {
                          bool resource_is_opaque = false, bool is_wasm = false,
                          bool is_module = false,
                          Local<Data> host_defined_options = Local<Data>())
-      : v8_isolate_(isolate),
-        resource_name_(resource_name),
+      : resource_name_(resource_name),
         resource_line_offset_(resource_line_offset),
         resource_column_offset_(resource_column_offset),
         options_(resource_is_shared_cross_origin, resource_is_opaque, is_wasm,
@@ -92,7 +92,6 @@ class V8_EXPORT ScriptOrigin {
 
  private:
   void VerifyHostDefinedOptions() const;
-  Isolate* v8_isolate_;
   Local<Value> resource_name_;
   int resource_line_offset_;
   int resource_column_offset_;
@@ -187,7 +186,14 @@ class V8_EXPORT Message {
   bool IsSharedCrossOrigin() const;
   bool IsOpaque() const;
 
-  static void PrintCurrentStackTrace(Isolate* isolate, std::ostream& out);
+  /**
+   * If provided, the callback can be used to selectively include
+   * or redact frames based on their script names. (true to include a frame)
+   */
+  static void PrintCurrentStackTrace(
+      Isolate* isolate, std::ostream& out,
+      PrintCurrentStackTraceFilterCallback should_include_frame_callback =
+          nullptr);
 
   static const int kNoLineNumberInfo = 0;
   static const int kNoColumnInfo = 0;

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

@@ -8,9 +8,11 @@
 #include <stddef.h>
 #include <stdint.h>
 
+#include <optional>
 #include <vector>
 
 #include "v8-internal.h"      // NOLINT(build/include_directory)
+#include "v8-isolate.h"       // NOLINT(build/include_directory)
 #include "v8-local-handle.h"  // NOLINT(build/include_directory)
 #include "v8config.h"         // NOLINT(build/include_directory)
 
@@ -37,6 +39,10 @@ struct GarbageCollectionSizes {
 
 struct GarbageCollectionFullCycle {
   int reason = -1;
+  // The priority of the isolate during the GC cycle. A nullopt value denotes a
+  // mixed priority cycle, meaning the Isolate's priority was changed while the
+  // cycle was in progress.
+  std::optional<v8::Isolate::Priority> priority = std::nullopt;
   GarbageCollectionPhases total;
   GarbageCollectionPhases total_cpp;
   GarbageCollectionPhases main_thread;
@@ -55,6 +61,11 @@ struct GarbageCollectionFullCycle {
   double efficiency_cpp_in_bytes_per_us = -1.0;
   double main_thread_efficiency_in_bytes_per_us = -1.0;
   double main_thread_efficiency_cpp_in_bytes_per_us = -1.0;
+  double collection_weight_in_percent = -1.0;
+  double collection_weight_cpp_in_percent = -1.0;
+  double main_thread_collection_weight_in_percent = -1.0;
+  double main_thread_collection_weight_cpp_in_percent = -1.0;
+  int64_t incremental_marking_start_stop_wall_clock_duration_in_us = -1;
 };
 
 struct GarbageCollectionFullMainThreadIncrementalMark {
@@ -81,6 +92,10 @@ using GarbageCollectionFullMainThreadBatchedIncrementalSweep =
 
 struct GarbageCollectionYoungCycle {
   int reason = -1;
+  // The priority of the isolate during the GC cycle. A nullopt value denotes a
+  // mixed priority cycle, meaning the Isolate's priority was changed while the
+  // cycle was in progress.
+  std::optional<v8::Isolate::Priority> priority = std::nullopt;
   int64_t total_wall_clock_duration_in_us = -1;
   int64_t main_thread_wall_clock_duration_in_us = -1;
   double collection_rate_in_percent = -1.0;

data/vendor/v8/include/v8-microtask-queue.h

@@ -118,11 +118,6 @@ class V8_EXPORT V8_NODISCARD MicrotasksScope {
  public:
   enum Type { kRunMicrotasks, kDoNotRunMicrotasks };
 
-  V8_DEPRECATE_SOON(
-      "May be incorrect if context was created with non-default microtask "
-      "queue")
-  MicrotasksScope(Isolate* isolate, Type type);
-
   MicrotasksScope(Local<Context> context, Type type);
   MicrotasksScope(Isolate* isolate, MicrotaskQueue* microtask_queue, Type type);
   ~MicrotasksScope();