libv8-node 22.7.0.4-aarch64-linux → 24.1.0.0-aarch64-linux

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

@@ -1,4 +1,3 @@
-
 // Copyright 2021 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.

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

@@ -0,0 +1,173 @@
+// Copyright 2024 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_V8_SANDBOX_H_
+#define INCLUDE_V8_SANDBOX_H_
+
+#include <cstdint>
+
+#include "v8-internal.h"  // NOLINT(build/include_directory)
+#include "v8config.h"     // NOLINT(build/include_directory)
+
+namespace v8 {
+
+/**
+ * A pointer tag used for wrapping and unwrapping `CppHeap` pointers as used
+ * with JS API wrapper objects that rely on `v8::Object::Wrap()` and
+ * `v8::Object::Unwrap()`.
+ *
+ * The CppHeapPointers use a range-based type checking scheme, where on access
+ * to a pointer, the actual type of the pointer is checked to be within a
+ * specified range of types. This allows supporting type hierarchies, where a
+ * type check for a supertype must succeed for any subtype.
+ *
+ * The tag is currently in practice limited to 15 bits since it needs to fit
+ * together with a marking bit into the unused parts of a pointer.
+ */
+enum class CppHeapPointerTag : uint16_t {
+  kFirstTag = 0,
+  kNullTag = 0,
+
+  /**
+   * The lower type ids are reserved for the embedder to assign. For that, the
+   * main requirement is that all (transitive) child classes of a given parent
+   * class have type ids in the same range, and that there are no unrelated
+   * types in that range. For example, given the following type hierarchy:
+   *
+   *          A     F
+   *         / \
+   *        B   E
+   *       / \
+   *      C   D
+   *
+   * a potential type id assignment that satistifes these requirements is
+   * {C: 0, D: 1, B: 2, A: 3, E: 4, F: 5}. With that, the type check for type A
+   * would check for the range [0, 4], while the check for B would check range
+   * [0, 2], and for F it would simply check [5, 5].
+   *
+   * In addition, there is an option for performance tweaks: if the size of the
+   * type range corresponding to a supertype is a power of two and starts at a
+   * power of two (e.g. [0x100, 0x13f]), then the compiler can often optimize
+   * the type check to use even fewer instructions (essentially replace a AND +
+   * SUB with a single AND).
+   */
+
+  kDefaultTag = 0x7000,
+
+  kZappedEntryTag = 0x7ffd,
+  kEvacuationEntryTag = 0x7ffe,
+  kFreeEntryTag = 0x7fff,
+  // The tags are limited to 15 bits, so the last tag is 0x7fff.
+  kLastTag = 0x7fff,
+};
+
+// Convenience struct to represent tag ranges. This is used for type checks
+// against supertypes, which cover a range of types (their subtypes).
+// Both the lower- and the upper bound are inclusive. In other words, this
+// struct represents the range [lower_bound, upper_bound].
+// TODO(saelo): reuse internal::TagRange here.
+struct CppHeapPointerTagRange {
+  constexpr CppHeapPointerTagRange(CppHeapPointerTag lower,
+                                   CppHeapPointerTag upper)
+      : lower_bound(lower), upper_bound(upper) {}
+  CppHeapPointerTag lower_bound;
+  CppHeapPointerTag upper_bound;
+
+  // Check whether the tag of the given CppHeapPointerTable entry is within
+  // this range. This method encodes implementation details of the
+  // CppHeapPointerTable, which is necessary as it is used by
+  // ReadCppHeapPointerField below.
+  // Returns true if the check is successful and the tag of the given entry is
+  // within this range, false otherwise.
+  bool CheckTagOf(uint64_t entry) {
+    // Note: the cast to uint32_t is important here. Otherwise, the uint16_t's
+    // would be promoted to int in the range check below, which would result in
+    // undefined behavior (signed integer undeflow) if the actual value is less
+    // than the lower bound. Then, the compiler would take advantage of the
+    // undefined behavior and turn the range check into a simple
+    // `actual_tag <= last_tag` comparison, which is incorrect.
+    uint32_t actual_tag = static_cast<uint16_t>(entry);
+    // The actual_tag is shifted to the left by one and contains the marking
+    // bit in the LSB. To ignore that during the type check, simply add one to
+    // the (shifted) range.
+    constexpr int kTagShift = internal::kCppHeapPointerTagShift;
+    uint32_t first_tag = static_cast<uint32_t>(lower_bound) << kTagShift;
+    uint32_t last_tag = (static_cast<uint32_t>(upper_bound) << kTagShift) + 1;
+    return actual_tag >= first_tag && actual_tag <= last_tag;
+  }
+};
+
+constexpr CppHeapPointerTagRange kAnyCppHeapPointer(
+    CppHeapPointerTag::kFirstTag, CppHeapPointerTag::kLastTag);
+
+class SandboxHardwareSupport {
+ public:
+  /**
+   * Initialize sandbox hardware support. This needs to be called before
+   * creating any thread that might access sandbox memory since it sets up
+   * hardware permissions to the memory that will be inherited on clone.
+   */
+  V8_EXPORT static void InitializeBeforeThreadCreation();
+};
+
+namespace internal {
+
+#ifdef V8_COMPRESS_POINTERS
+V8_INLINE static Address* GetCppHeapPointerTableBase(v8::Isolate* isolate) {
+  Address addr = reinterpret_cast<Address>(isolate) +
+                 Internals::kIsolateCppHeapPointerTableOffset +
+                 Internals::kExternalPointerTableBasePointerOffset;
+  return *reinterpret_cast<Address**>(addr);
+}
+#endif  // V8_COMPRESS_POINTERS
+
+template <typename T>
+V8_INLINE static T* ReadCppHeapPointerField(v8::Isolate* isolate,
+                                            Address heap_object_ptr, int offset,
+                                            CppHeapPointerTagRange tag_range) {
+#ifdef V8_COMPRESS_POINTERS
+  // See src/sandbox/cppheap-pointer-table-inl.h. Logic duplicated here so
+  // it can be inlined and doesn't require an additional call.
+  const CppHeapPointerHandle handle =
+      Internals::ReadRawField<CppHeapPointerHandle>(heap_object_ptr, offset);
+  const uint32_t index = handle >> kExternalPointerIndexShift;
+  const Address* table = GetCppHeapPointerTableBase(isolate);
+  const std::atomic<Address>* ptr =
+      reinterpret_cast<const std::atomic<Address>*>(&table[index]);
+  Address entry = std::atomic_load_explicit(ptr, std::memory_order_relaxed);
+
+  Address pointer = entry;
+  if (V8_LIKELY(tag_range.CheckTagOf(entry))) {
+    pointer = entry >> kCppHeapPointerPayloadShift;
+  } else {
+    // If the type check failed, we simply return nullptr here. That way:
+    //  1. The null handle always results in nullptr being returned here, which
+    //     is a desired property. Otherwise, we would need an explicit check for
+    //     the null handle above, and therefore an additional branch. This
+    //     works because the 0th entry of the table always contains nullptr
+    //     tagged with the null tag (i.e. an all-zeros entry). As such,
+    //     regardless of whether the type check succeeds, the result will
+    //     always be nullptr.
+    //  2. The returned pointer is guaranteed to crash even on platforms with
+    //     top byte ignore (TBI), such as Arm64. The alternative would be to
+    //     simply return the original entry with the left-shifted payload.
+    //     However, due to TBI, an access to that may not always result in a
+    //     crash (specifically, if the second most significant byte happens to
+    //     be zero). In addition, there shouldn't be a difference on Arm64
+    //     between returning nullptr or the original entry, since it will
+    //     simply compile to a `csel x0, x8, xzr, lo` instead of a
+    //     `csel x0, x10, x8, lo` instruction.
+    pointer = 0;
+  }
+  return reinterpret_cast<T*>(pointer);
+#else   // !V8_COMPRESS_POINTERS
+  return reinterpret_cast<T*>(
+      Internals::ReadRawField<Address>(heap_object_ptr, offset));
+#endif  // !V8_COMPRESS_POINTERS
+}
+
+}  // namespace internal
+}  // namespace v8
+
+#endif  // INCLUDE_V8_SANDBOX_H_

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

@@ -129,6 +129,11 @@ class V8_EXPORT ModuleRequest : public Data {
    */
   Local<String> GetSpecifier() const;
 
+  /**
+   * Returns the module import phase for this ModuleRequest.
+   */
+  ModuleImportPhase GetPhase() const;
+
   /**
    * Returns the source code offset of this module request.
    * Use Module::SourceOffsetToLocation to convert this to line/column numbers.
@@ -150,7 +155,7 @@ class V8_EXPORT ModuleRequest : public Data {
    */
   Local<FixedArray> GetImportAttributes() const;
 
-  V8_DEPRECATE_SOON("Use GetImportAttributes instead")
+  V8_DEPRECATED("Use GetImportAttributes instead")
   Local<FixedArray> GetImportAssertions() const {
     return GetImportAttributes();
   }
@@ -210,7 +215,10 @@ class V8_EXPORT Module : public Data {
 
   using ResolveModuleCallback = MaybeLocal<Module> (*)(
       Local<Context> context, Local<String> specifier,
-      Local<FixedArray> import_assertions, Local<Module> referrer);
+      Local<FixedArray> import_attributes, Local<Module> referrer);
+  using ResolveSourceCallback = MaybeLocal<Object> (*)(
+      Local<Context> context, Local<String> specifier,
+      Local<FixedArray> import_attributes, Local<Module> referrer);
 
   /**
    * Instantiates the module and its dependencies.
@@ -220,7 +228,8 @@ class V8_EXPORT Module : public Data {
    * exception is propagated.)
    */
   V8_WARN_UNUSED_RESULT Maybe<bool> InstantiateModule(
-      Local<Context> context, ResolveModuleCallback callback);
+      Local<Context> context, ResolveModuleCallback module_callback,
+      ResolveSourceCallback source_callback = nullptr);
 
   /**
    * Evaluates the module and its dependencies.
@@ -264,6 +273,13 @@ class V8_EXPORT Module : public Data {
    */
   bool IsGraphAsync() const;
 
+  /**
+   * Returns whether this module is individually asynchronous (for example,
+   * if it's a Source Text Module Record containing a top-level await).
+   * See [[HasTLA]] in https://tc39.es/ecma262/#sec-cyclic-module-records
+   */
+  bool HasTopLevelAwait() const;
+
   /**
    * Returns whether the module is a SourceTextModule.
    */
@@ -322,6 +338,14 @@ class V8_EXPORT Module : public Data {
   static void CheckCast(Data* obj);
 };
 
+class V8_EXPORT CompileHintsCollector : public Data {
+ public:
+  /**
+   * Returns the positions of lazy functions which were compiled and executed.
+   */
+  std::vector<int> GetCompileHints(Isolate* isolate) const;
+};
+
 /**
  * A compiled JavaScript script, tied to a Context which was active when the
  * script was compiled.
@@ -359,7 +383,15 @@ class V8_EXPORT Script : public Data {
    * If the script was compiled, returns the positions of lazy functions which
    * were eventually compiled and executed.
    */
+  V8_DEPRECATE_SOON("Use GetCompileHintsCollector instead")
   std::vector<int> GetProducedCompileHints() const;
+
+  /**
+   * Get a compile hints collector object which we can use later for retrieving
+   * compile hints (= positions of lazy functions which were compiled and
+   * executed).
+   */
+  Local<CompileHintsCollector> GetCompileHintsCollector() const;
 };
 
 enum class ScriptType { kClassic, kModule };
@@ -640,12 +672,34 @@ class V8_EXPORT ScriptCompiler {
 
   enum CompileOptions {
     kNoCompileOptions = 0,
-    kConsumeCodeCache,
-    kEagerCompile,
-    kProduceCompileHints,
-    kConsumeCompileHints
+    kConsumeCodeCache = 1 << 0,
+    kEagerCompile = 1 << 1,
+    kProduceCompileHints = 1 << 2,
+    kConsumeCompileHints = 1 << 3,
+    kFollowCompileHintsMagicComment = 1 << 4,
+    kFollowCompileHintsPerFunctionMagicComment = 1 << 5,
   };
 
+  static inline bool CompileOptionsIsValid(CompileOptions compile_options) {
+    // kConsumeCodeCache is mutually exclusive with all other flag bits.
+    if ((compile_options & kConsumeCodeCache) &&
+        compile_options != kConsumeCodeCache) {
+      return false;
+    }
+    // kEagerCompile is mutually exclusive with all other flag bits.
+    if ((compile_options & kEagerCompile) && compile_options != kEagerCompile) {
+      return false;
+    }
+    // We don't currently support producing and consuming compile hints at the
+    // same time.
+    constexpr int produce_and_consume = CompileOptions::kProduceCompileHints |
+                                        CompileOptions::kConsumeCompileHints;
+    if ((compile_options & produce_and_consume) == produce_and_consume) {
+      return false;
+    }
+    return true;
+  }
+
   /**
    * The reason for which we are not requesting or providing a code cache.
    */
@@ -664,7 +718,8 @@ class V8_EXPORT ScriptCompiler {
     kNoCacheBecausePacScript,
     kNoCacheBecauseInDocumentWrite,
     kNoCacheBecauseResourceWithNoCacheHandler,
-    kNoCacheBecauseDeferredProduceCodeCache
+    kNoCacheBecauseDeferredProduceCodeCache,
+    kNoCacheBecauseStaticCodeCache,
   };
 
   /**
@@ -722,6 +777,8 @@ class V8_EXPORT ScriptCompiler {
 
   static ConsumeCodeCacheTask* StartConsumingCodeCache(
       Isolate* isolate, std::unique_ptr<CachedData> source);
+  static ConsumeCodeCacheTask* StartConsumingCodeCacheOnBackground(
+      Isolate* isolate, std::unique_ptr<CachedData> source);
 
   /**
    * Compiles a streamed script (bound to current context).
@@ -787,15 +844,6 @@ class V8_EXPORT ScriptCompiler {
    * It is possible to specify multiple context extensions (obj in the above
    * example).
    */
-  V8_DEPRECATED("Use CompileFunction")
-  static V8_WARN_UNUSED_RESULT MaybeLocal<Function> CompileFunctionInContext(
-      Local<Context> context, Source* source, size_t arguments_count,
-      Local<String> arguments[], size_t context_extension_count,
-      Local<Object> context_extensions[],
-      CompileOptions options = kNoCompileOptions,
-      NoCacheReason no_cache_reason = kNoCacheNoReason,
-      Local<ScriptOrModule>* script_or_module_out = nullptr);
-
   static V8_WARN_UNUSED_RESULT MaybeLocal<Function> CompileFunction(
       Local<Context> context, Source* source, size_t arguments_count = 0,
       Local<String> arguments[] = nullptr, size_t context_extension_count = 0,

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

@@ -68,6 +68,22 @@ struct SerializeContextDataCallback {
   void* data;
 };
 
+/**
+ * Similar to `SerializeInternalFieldsCallback`, but is used exclusively to
+ * serialize API wrappers. The pointers for API wrappers always point into the
+ * CppHeap.
+ */
+struct SerializeAPIWrapperCallback {
+  using CallbackFunction = StartupData (*)(Local<Object> holder,
+                                           void* cpp_heap_pointer, void* data);
+  explicit SerializeAPIWrapperCallback(CallbackFunction function = nullptr,
+                                       void* data = nullptr)
+      : callback(function), data(data) {}
+
+  CallbackFunction callback;
+  void* data;
+};
+
 /**
  * Callback and supporting data used to implement embedder logic to deserialize
  * internal fields of v8::Objects.
@@ -97,6 +113,17 @@ struct DeserializeContextDataCallback {
   void* data;
 };
 
+struct DeserializeAPIWrapperCallback {
+  using CallbackFunction = void (*)(Local<Object> holder, StartupData payload,
+                                    void* data);
+  explicit DeserializeAPIWrapperCallback(CallbackFunction function = nullptr,
+                                         void* data = nullptr)
+      : callback(function), data(data) {}
+
+  CallbackFunction callback;
+  void* data;
+};
+
 /**
  * Helper class to create a snapshot data blob.
  *
@@ -187,13 +214,17 @@ class V8_EXPORT SnapshotCreator {
    * context embedder data set by
    * v8::Context::SetAlignedPointerInEmbedderData().
    *
+   * \param api_wrapper_serializer An optional callback used to serialize API
+   * wrapper references set via `v8::Object::Wrap()`.
    */
   void SetDefaultContext(
       Local<Context> context,
       SerializeInternalFieldsCallback internal_fields_serializer =
           SerializeInternalFieldsCallback(),
       SerializeContextDataCallback context_data_serializer =
-          SerializeContextDataCallback());
+          SerializeContextDataCallback(),
+      SerializeAPIWrapperCallback api_wrapper_serializer =
+          SerializeAPIWrapperCallback());
 
   /**
    * Add additional context to be included in the snapshot blob.
@@ -204,12 +235,17 @@ class V8_EXPORT SnapshotCreator {
    *
    * \param context_data_serializer Similar to context_data_serializer
    * in SetDefaultContext() but only applies to the context being added.
+   *
+   * \param api_wrapper_serializer Similar to api_wrapper_serializer
+   * in SetDefaultContext() but only applies to the context being added.
    */
   size_t AddContext(Local<Context> context,
                     SerializeInternalFieldsCallback internal_fields_serializer =
                         SerializeInternalFieldsCallback(),
                     SerializeContextDataCallback context_data_serializer =
-                        SerializeContextDataCallback());
+                        SerializeContextDataCallback(),
+                    SerializeAPIWrapperCallback api_wrapper_serializer =
+                        SerializeAPIWrapperCallback());
 
   /**
    * Attach arbitrary V8::Data to the context snapshot, which can be retrieved

data/vendor/v8/include/v8-source-location.h

@@ -76,7 +76,12 @@ class V8_EXPORT SourceLocation final {
    *
    * \returns a human-readable string representing source location information.
    */
-  std::string ToString() const;
+  std::string ToString() const {
+    if (!file_) {
+      return {};
+    }
+    return std::string(function_) + "@" + file_ + ":" + std::to_string(line_);
+  }
 
  private:
   constexpr SourceLocation(const char* function, const char* file, size_t line)