libv8-node 22.7.0.3-x86_64-linux → 23.6.1.0-x86_64-linux

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

@@ -182,7 +182,7 @@ class PersistentValueMapBase {
    */
   Local<V> Get(const K& key) {
     V* p = FromVal(Traits::Get(&impl_, key));
-#ifdef V8_ENABLE_DIRECT_LOCAL
+#ifdef V8_ENABLE_DIRECT_HANDLE
     if (p == nullptr) return Local<V>();
 #endif
     return Local<V>::New(isolate_, p);
@@ -544,122 +544,6 @@ class StdGlobalValueMap : public GlobalValueMap<K, V, Traits> {
       : GlobalValueMap<K, V, Traits>(isolate) {}
 };
 
-class DefaultPersistentValueVectorTraits {
- public:
-  typedef std::vector<PersistentContainerValue> Impl;
-
-  static void Append(Impl* impl, PersistentContainerValue value) {
-    impl->push_back(value);
-  }
-  static bool IsEmpty(const Impl* impl) {
-    return impl->empty();
-  }
-  static size_t Size(const Impl* impl) {
-    return impl->size();
-  }
-  static PersistentContainerValue Get(const Impl* impl, size_t i) {
-    return (i < impl->size()) ? impl->at(i) : kPersistentContainerNotFound;
-  }
-  static void ReserveCapacity(Impl* impl, size_t capacity) {
-    impl->reserve(capacity);
-  }
-  static void Clear(Impl* impl) {
-    impl->clear();
-  }
-};
-
-/**
- * A vector wrapper that safely stores Global values.
- * C++11 embedders don't need this class, as they can use Global
- * directly in std containers.
- *
- * This class relies on a backing vector implementation, whose type and methods
- * are described by the Traits class. The backing map will handle values of type
- * PersistentContainerValue, with all conversion into and out of V8
- * handles being transparently handled by this class.
- */
-template <typename V, typename Traits = DefaultPersistentValueVectorTraits>
-class V8_DEPRECATE_SOON("Use std::vector<Global<V>>.") PersistentValueVector {
- public:
-  explicit PersistentValueVector(Isolate* isolate) : isolate_(isolate) { }
-
-  ~PersistentValueVector() {
-    Clear();
-  }
-
-  /**
-   * Append a value to the vector.
-   */
-  void Append(Local<V> value) {
-    Global<V> persistent(isolate_, value);
-    Traits::Append(&impl_, ClearAndLeak(&persistent));
-  }
-
-  /**
-   * Append a persistent's value to the vector.
-   */
-  void Append(Global<V> persistent) {
-    Traits::Append(&impl_, ClearAndLeak(&persistent));
-  }
-
-  /**
-   * Are there any values in the vector?
-   */
-  bool IsEmpty() const {
-    return Traits::IsEmpty(&impl_);
-  }
-
-  /**
-   * How many elements are in the vector?
-   */
-  size_t Size() const {
-    return Traits::Size(&impl_);
-  }
-
-  /**
-   * Retrieve the i-th value in the vector.
-   */
-  Local<V> Get(size_t index) const {
-    return Local<V>::New(isolate_, internal::ValueHelper::SlotAsValue<V>(
-                                       Traits::Get(&impl_, index)));
-  }
-
-  /**
-   * Remove all elements from the vector.
-   */
-  void Clear() {
-    size_t length = Traits::Size(&impl_);
-    for (size_t i = 0; i < length; i++) {
-      Global<V> p;
-      p.slot() = reinterpret_cast<internal::Address>(Traits::Get(&impl_, i));
-    }
-    Traits::Clear(&impl_);
-  }
-
-  /**
-   * Reserve capacity in the vector.
-   * (Efficiency gains depend on the backing implementation.)
-   */
-  void ReserveCapacity(size_t capacity) {
-    Traits::ReserveCapacity(&impl_, capacity);
-  }
-
- private:
-  static PersistentContainerValue ClearAndLeak(Global<V>* persistent) {
-    auto slot = persistent->slot();
-    persistent->Clear();
-    return reinterpret_cast<PersistentContainerValue>(slot);
-  }
-
-  static V* FromVal(PersistentContainerValue v) {
-    return internal::ValueHelper::SlotAsValue<V>(
-        reinterpret_cast<internal::Address*>(v));
-  }
-
-  Isolate* isolate_;
-  typename Traits::Impl impl_;
-};
-
 }  // namespace v8
 
 #endif  // V8_UTIL_H

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

@@ -635,8 +635,9 @@ bool Value::QuickIsString() const {
   A obj = internal::ValueHelper::ValueAsAddress(this);
   if (!I::HasHeapObjectTag(obj)) return false;
 #if V8_STATIC_ROOTS_BOOL && !V8_MAP_PACKING
-  return I::CheckInstanceMapRange(obj, I::StaticReadOnlyRoot::kFirstStringMap,
-                                  I::StaticReadOnlyRoot::kLastStringMap);
+  return I::CheckInstanceMapRange(obj,
+                                  I::StaticReadOnlyRoot::kStringMapLowerBound,
+                                  I::StaticReadOnlyRoot::kStringMapUpperBound);
 #else
   return (I::GetInstanceType(obj) < I::kFirstNonstringType);
 #endif  // V8_STATIC_ROOTS_BOOL

data/vendor/v8/include/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 12
-#define V8_MINOR_VERSION 4
-#define V8_BUILD_NUMBER 254
-#define V8_PATCH_LEVEL 21
+#define V8_MINOR_VERSION 9
+#define V8_BUILD_NUMBER 202
+#define V8_PATCH_LEVEL 28
 
 // Use 1 for candidates and 0 otherwise.
 // (Boolean macro values are not supported by all preprocessors.)

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

@@ -9,6 +9,7 @@
 #include <memory>
 #include <string>
 
+#include "v8-internal.h"      // NOLINT(build/include_directory)
 #include "v8-local-handle.h"  // NOLINT(build/include_directory)
 #include "v8-memory-span.h"   // NOLINT(build/include_directory)
 #include "v8-object.h"        // NOLINT(build/include_directory)
@@ -129,6 +130,8 @@ class V8_EXPORT WasmModuleObject : public Object {
  */
 class V8_EXPORT WasmStreaming final {
  public:
+  static constexpr internal::ExternalPointerTag kManagedTag =
+      internal::kWasmWasmStreamingTag;
   class WasmStreamingImpl;
 
   explicit WasmStreaming(std::unique_ptr<WasmStreamingImpl> impl);

data/vendor/v8/include/v8config.h

@@ -5,8 +5,16 @@
 #ifndef V8CONFIG_H_
 #define V8CONFIG_H_
 
+// gcc 10 defines __cplusplus to "an unspecified value strictly larger than
+// 201703L" for its experimental -std=gnu++2a config.
+// TODO(leszeks): Change to `__cplusplus <= 202002L` once we only support
+// compilers with full C++20 support.
+#if __cplusplus <= 201703L
+#error "C++20 or later required."
+#endif
+
 #ifdef V8_GN_HEADER
-#if __cplusplus >= 201703L && !__has_include("v8-gn.h")
+#if !__has_include("v8-gn.h")
 #error Missing v8-gn.h. The configuration for v8 is missing from the include \
 path. Add it with -I<path> to the command line
 #endif
@@ -23,6 +31,8 @@ path. Add it with -I<path> to the command line
 # include <TargetConditionals.h>
 #elif defined(__linux__)
 # include <features.h>
+#elif defined(__MVS__)
+# include "zos-base.h"
 #endif
 
 
@@ -83,6 +93,7 @@ path. Add it with -I<path> to the command line
 //  V8_OS_STARBOARD     - Starboard (platform abstraction for Cobalt)
 //  V8_OS_AIX           - AIX
 //  V8_OS_WIN           - Microsoft Windows
+//  V8_OS_ZOS           - z/OS
 
 #if defined(__ANDROID__)
 # define V8_OS_ANDROID 1
@@ -163,6 +174,11 @@ path. Add it with -I<path> to the command line
 #elif defined(_WIN32)
 # define V8_OS_WIN 1
 # define V8_OS_STRING "windows"
+
+#elif defined(__MVS__)
+# define V8_OS_POSIX 1
+# define V8_OS_ZOS 1
+# define V8_OS_STRING "zos"
 #endif
 
 // -----------------------------------------------------------------------------
@@ -376,8 +392,14 @@ path. Add it with -I<path> to the command line
 # define V8_HAS_ATTRIBUTE_WEAK (__has_attribute(weak))
 
 # define V8_HAS_CPP_ATTRIBUTE_NODISCARD (V8_HAS_CPP_ATTRIBUTE(nodiscard))
+#if defined(V8_CC_MSVC)
+# define V8_HAS_CPP_ATTRIBUTE_NO_UNIQUE_ADDRESS       \
+    (V8_HAS_CPP_ATTRIBUTE(msvc::no_unique_address) || \
+     V8_HAS_CPP_ATTRIBUTE(no_unique_address))
+#else
 # define V8_HAS_CPP_ATTRIBUTE_NO_UNIQUE_ADDRESS \
     (V8_HAS_CPP_ATTRIBUTE(no_unique_address))
+#endif
 
 # define V8_HAS_BUILTIN_ADD_OVERFLOW (__has_builtin(__builtin_add_overflow))
 # define V8_HAS_BUILTIN_ASSUME (__has_builtin(__builtin_assume))
@@ -477,22 +499,32 @@ path. Add it with -I<path> to the command line
 # define V8_INLINE inline
 #endif
 
+#if V8_HAS_BUILTIN_ASSUME
 #ifdef DEBUG
-// In debug mode, check assumptions instead of actually adding annotations.
-# define V8_ASSUME DCHECK
-#elif V8_HAS_BUILTIN_ASSUME
+// In debug mode, check assumptions in addition to adding annotations.
+// This helps GCC (and maybe other compilers) figure out that certain
+// situations are unreachable.
+# define V8_ASSUME(condition)    \
+  do {                           \
+    DCHECK(condition);           \
+    __builtin_assume(condition); \
+  } while (false)
+#else  // DEBUG
 # define V8_ASSUME __builtin_assume
+#endif  // DEBUG
 #elif V8_HAS_BUILTIN_UNREACHABLE
 # define V8_ASSUME(condition)                  \
   do {                                         \
+    DCHECK(condition);                         \
     if (!(condition)) __builtin_unreachable(); \
   } while (false)
 #else
 # define V8_ASSUME USE
 #endif
 
-// Prefer c++20 std::assume_aligned
-#if __cplusplus >= 202002L && defined(__cpp_lib_assume_aligned)
+// Prefer c++20 std::assume_aligned. Don't use it on MSVC though, because it's
+// not happy with our large 4GB alignment values.
+#if __cplusplus >= 202002L && defined(__cpp_lib_assume_aligned) && !V8_CC_MSVC
 # define V8_ASSUME_ALIGNED(ptr, alignment) \
   std::assume_aligned<(alignment)>(ptr)
 #elif V8_HAS_BUILTIN_ASSUME_ALIGNED
@@ -549,11 +581,15 @@ path. Add it with -I<path> to the command line
 // functions.
 // Use like:
 //   V8_NOINLINE V8_PRESERVE_MOST void UnlikelyMethod();
+#if V8_OS_WIN
+# define V8_PRESERVE_MOST
+#else
 #if V8_HAS_ATTRIBUTE_PRESERVE_MOST
 # define V8_PRESERVE_MOST __attribute__((preserve_most))
 #else
 # define V8_PRESERVE_MOST /* NOT SUPPORTED */
 #endif
+#endif
 
 
 // A macro (V8_DEPRECATED) to mark classes or functions as deprecated.
@@ -645,7 +681,7 @@ path. Add it with -I<path> to the command line
 //   V8_NODISCARD Foo() { ... };
 // [[nodiscard]] comes in C++17 but supported in clang with -std >= c++11.
 #if V8_HAS_CPP_ATTRIBUTE_NODISCARD
-#define V8_NODISCARD [[nodiscard]]
+#define V8_NODISCARD
 #else
 #define V8_NODISCARD /* NOT SUPPORTED */
 #endif
@@ -666,7 +702,15 @@ path. Add it with -I<path> to the command line
 // [[no_unique_address]] comes in C++20 but supported in clang with
 // -std >= c++11.
 #if V8_HAS_CPP_ATTRIBUTE_NO_UNIQUE_ADDRESS
+#if defined(V8_CC_MSVC) && V8_HAS_CPP_ATTRIBUTE(msvc::no_unique_address)
+// Unfortunately MSVC ignores [[no_unique_address]] (see
+// https://devblogs.microsoft.com/cppblog/msvc-cpp20-and-the-std-cpp20-switch/#msvc-extensions-and-abi),
+// and clang-cl matches it for ABI compatibility reasons. We need to prefer
+// [[msvc::no_unique_address]] when available if we actually want any effect.
+#define V8_NO_UNIQUE_ADDRESS [[msvc::no_unique_address]]
+#else
 #define V8_NO_UNIQUE_ADDRESS [[no_unique_address]]
+#endif
 #else
 #define V8_NO_UNIQUE_ADDRESS /* NOT SUPPORTED */
 #endif

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: libv8-node
 version: !ruby/object:Gem::Version
-  version: 22.7.0.3
+  version: 23.6.1.0
 platform: x86_64-linux
 authors:
 - ''
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-09-07 00:00:00.000000000 Z
+date: 2025-02-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -137,6 +137,7 @@ files:
 - vendor/v8/include/v8-promise.h
 - vendor/v8/include/v8-proxy.h
 - vendor/v8/include/v8-regexp.h
+- vendor/v8/include/v8-sandbox.h
 - vendor/v8/include/v8-script.h
 - vendor/v8/include/v8-snapshot.h
 - vendor/v8/include/v8-source-location.h
@@ -163,7 +164,7 @@ homepage: https://github.com/rubyjs/libv8-node
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -180,7 +181,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.3.26
-signing_key: 
+signing_key:
 specification_version: 4
 summary: Node.JS's V8 JavaScript engine
 test_files: []