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

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

@@ -16,6 +16,7 @@
 #include "v8-data.h"          // NOLINT(build/include_directory)
 #include "v8-local-handle.h"  // NOLINT(build/include_directory)
 #include "v8-maybe.h"         // NOLINT(build/include_directory)
+#include "v8-memory-span.h"   // NOLINT(build/include_directory)
 #include "v8-message.h"       // NOLINT(build/include_directory)
 #include "v8config.h"         // NOLINT(build/include_directory)
 
@@ -128,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.
@@ -135,19 +141,24 @@ class V8_EXPORT ModuleRequest : public Data {
   int GetSourceOffset() const;
 
   /**
-   * Contains the import assertions for this request in the form:
+   * Contains the import attributes for this request in the form:
    * [key1, value1, source_offset1, key2, value2, source_offset2, ...].
    * The keys and values are of type v8::String, and the source offsets are of
    * type Int32. Use Module::SourceOffsetToLocation to convert the source
    * offsets to Locations with line/column numbers.
    *
-   * All assertions present in the module request will be supplied in this
+   * All attributes 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-attributes/#sec-hostgetsupportedimportattributes,
-   * hosts are expected to throw for assertions that they do not support (as
+   * hosts are expected to throw for attributes that they do not support (as
    * opposed to, for example, ignoring them).
    */
-  Local<FixedArray> GetImportAssertions() const;
+  Local<FixedArray> GetImportAttributes() const;
+
+  V8_DEPRECATED("Use GetImportAttributes instead")
+  Local<FixedArray> GetImportAssertions() const {
+    return GetImportAttributes();
+  }
 
   V8_INLINE static ModuleRequest* Cast(Data* data);
 
@@ -204,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.
@@ -214,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.
@@ -258,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.
    */
@@ -287,7 +309,7 @@ class V8_EXPORT Module : public Data {
    */
   static Local<Module> CreateSyntheticModule(
       Isolate* isolate, Local<String> module_name,
-      const std::vector<Local<String>>& export_names,
+      const MemorySpan<const Local<String>>& export_names,
       SyntheticModuleEvaluationSteps evaluation_steps);
 
   /**
@@ -303,12 +325,12 @@ class V8_EXPORT Module : public Data {
   /**
    * Search the modules requested directly or indirectly by the module for
    * any top-level await that has not yet resolved. If there is any, the
-   * returned vector contains a tuple of the unresolved module and a message
-   * with the pending top-level await.
+   * returned pair of vectors (of equal size) contain the unresolved module
+   * and corresponding message with the pending top-level await.
    * An embedder may call this before exiting to improve error messages.
    */
-  std::vector<std::tuple<Local<Module>, Local<Message>>>
-  GetStalledTopLevelAwaitMessage(Isolate* isolate);
+  std::pair<LocalVector<Module>, LocalVector<Message>>
+  GetStalledTopLevelAwaitMessages(Isolate* isolate);
 
   V8_INLINE static Module* Cast(Data* data);
 
@@ -316,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.
@@ -353,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 };
@@ -421,6 +459,33 @@ class V8_EXPORT ScriptCompiler {
     CachedData& operator=(const CachedData&) = delete;
   };
 
+  enum class InMemoryCacheResult {
+    // V8 did not attempt to find this script in its in-memory cache.
+    kNotAttempted,
+
+    // V8 found a previously compiled copy of this script in its in-memory
+    // cache. Any data generated by a streaming compilation or background
+    // deserialization was abandoned.
+    kHit,
+
+    // V8 didn't have any previously compiled data for this script.
+    kMiss,
+
+    // V8 had some previously compiled data for an identical script, but the
+    // data was incomplete.
+    kPartial,
+  };
+
+  // Details about what happened during a compilation.
+  struct CompilationDetails {
+    InMemoryCacheResult in_memory_cache_result =
+        InMemoryCacheResult::kNotAttempted;
+
+    static constexpr int64_t kTimeNotMeasured = -1;
+    int64_t foreground_time_in_microseconds = kTimeNotMeasured;
+    int64_t background_time_in_microseconds = kTimeNotMeasured;
+  };
+
   /**
    * Source code which can be then compiled to a UnboundScript or Script.
    */
@@ -446,6 +511,8 @@ class V8_EXPORT ScriptCompiler {
 
     V8_INLINE const ScriptOriginOptions& GetResourceOptions() const;
 
+    V8_INLINE const CompilationDetails& GetCompilationDetails() const;
+
    private:
     friend class ScriptCompiler;
 
@@ -453,8 +520,8 @@ class V8_EXPORT ScriptCompiler {
 
     // Origin information
     Local<Value> resource_name;
-    int resource_line_offset;
-    int resource_column_offset;
+    int resource_line_offset = -1;
+    int resource_column_offset = -1;
     ScriptOriginOptions resource_options;
     Local<Value> source_map_url;
     Local<Data> host_defined_options;
@@ -468,6 +535,10 @@ class V8_EXPORT ScriptCompiler {
     // For requesting compile hints from the embedder.
     CompileHintCallback compile_hint_callback = nullptr;
     void* compile_hint_callback_data = nullptr;
+
+    // V8 writes this data and never reads it. It exists only to be informative
+    // to the embedder.
+    CompilationDetails compilation_details;
   };
 
   /**
@@ -522,8 +593,14 @@ class V8_EXPORT ScriptCompiler {
     StreamedSource(const StreamedSource&) = delete;
     StreamedSource& operator=(const StreamedSource&) = delete;
 
+    CompilationDetails& compilation_details() { return compilation_details_; }
+
    private:
     std::unique_ptr<internal::ScriptStreamingData> impl_;
+
+    // V8 writes this data and never reads it. It exists only to be informative
+    // to the embedder.
+    CompilationDetails compilation_details_;
   };
 
   /**
@@ -595,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.
    */
@@ -619,7 +718,8 @@ class V8_EXPORT ScriptCompiler {
     kNoCacheBecausePacScript,
     kNoCacheBecauseInDocumentWrite,
     kNoCacheBecauseResourceWithNoCacheHandler,
-    kNoCacheBecauseDeferredProduceCodeCache
+    kNoCacheBecauseDeferredProduceCodeCache,
+    kNoCacheBecauseStaticCodeCache,
   };
 
   /**
@@ -677,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).
@@ -742,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,
@@ -835,6 +928,11 @@ const ScriptOriginOptions& ScriptCompiler::Source::GetResourceOptions() const {
   return resource_options;
 }
 
+const ScriptCompiler::CompilationDetails&
+ScriptCompiler::Source::GetCompilationDetails() const {
+  return compilation_details;
+}
+
 ModuleRequest* ModuleRequest::Cast(Data* data) {
 #ifdef V8_ENABLE_CHECKS
   CheckCast(data);

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

@@ -6,6 +6,7 @@
 #define INCLUDE_V8_SNAPSHOT_H_
 
 #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)
 
@@ -13,6 +14,10 @@ namespace v8 {
 
 class Object;
 
+namespace internal {
+class SnapshotCreatorImpl;
+}  // namespace internal
+
 class V8_EXPORT StartupData {
  public:
   /**
@@ -33,7 +38,7 @@ class V8_EXPORT StartupData {
 
 /**
  * Callback and supporting data used in SnapshotCreator to implement embedder
- * logic to serialize internal fields.
+ * logic to serialize internal fields of v8::Objects.
  * Internal fields that directly reference V8 objects are serialized without
  * calling this callback. Internal fields that contain aligned pointers are
  * serialized by this callback if it returns non-zero result. Otherwise it is
@@ -48,13 +53,40 @@ struct SerializeInternalFieldsCallback {
   CallbackFunction callback;
   void* data;
 };
-// Note that these fields are called "internal fields" in the API and called
-// "embedder fields" within V8.
-using SerializeEmbedderFieldsCallback = SerializeInternalFieldsCallback;
+
+/**
+ * Similar to SerializeInternalFieldsCallback, but works with the embedder data
+ * in a v8::Context.
+ */
+struct SerializeContextDataCallback {
+  using CallbackFunction = StartupData (*)(Local<Context> holder, int index,
+                                           void* data);
+  SerializeContextDataCallback(CallbackFunction function = nullptr,
+                               void* data_arg = nullptr)
+      : callback(function), data(data_arg) {}
+  CallbackFunction callback;
+  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.
+ * internal fields of v8::Objects.
  */
 struct DeserializeInternalFieldsCallback {
   using CallbackFunction = void (*)(Local<Object> holder, int index,
@@ -62,12 +94,35 @@ struct DeserializeInternalFieldsCallback {
   DeserializeInternalFieldsCallback(CallbackFunction function = nullptr,
                                     void* data_arg = nullptr)
       : callback(function), data(data_arg) {}
-  void (*callback)(Local<Object> holder, int index, StartupData payload,
-                   void* data);
+
+  CallbackFunction callback;
   void* data;
 };
 
-using DeserializeEmbedderFieldsCallback = DeserializeInternalFieldsCallback;
+/**
+ * Similar to DeserializeInternalFieldsCallback, but works with the embedder
+ * data in a v8::Context.
+ */
+struct DeserializeContextDataCallback {
+  using CallbackFunction = void (*)(Local<Context> holder, int index,
+                                    StartupData payload, void* data);
+  DeserializeContextDataCallback(CallbackFunction function = nullptr,
+                                 void* data_arg = nullptr)
+      : callback(function), data(data_arg) {}
+  CallbackFunction callback;
+  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.
@@ -91,10 +146,11 @@ class V8_EXPORT SnapshotCreator {
    * \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,
-                  bool owns_isolate = true);
+  V8_DEPRECATE_SOON("Use the version that passes CreateParams instead.")
+  explicit SnapshotCreator(Isolate* isolate,
+                           const intptr_t* external_references = nullptr,
+                           const StartupData* existing_blob = nullptr,
+                           bool owns_isolate = true);
 
   /**
    * Create and enter an isolate, and set it up for serialization.
@@ -104,8 +160,35 @@ class V8_EXPORT SnapshotCreator {
    * \param external_references a null-terminated array of external references
    *        that must be equivalent to CreateParams::external_references.
    */
-  SnapshotCreator(const intptr_t* external_references = nullptr,
-                  const StartupData* existing_blob = nullptr);
+  V8_DEPRECATE_SOON("Use the version that passes CreateParams instead.")
+  explicit SnapshotCreator(const intptr_t* external_references = nullptr,
+                           const StartupData* existing_blob = nullptr);
+
+  /**
+   * Creates an Isolate for serialization and enters it. The creator fully owns
+   * the Isolate and will invoke `v8::Isolate::Dispose()` during destruction.
+   *
+   * \param params The parameters to initialize the Isolate for. Details:
+   *               - `params.external_references` are expected to be a
+   *                 null-terminated array of external references.
+   *               - `params.existing_blob` is an optional snapshot blob from
+   *                 which can be used to initialize the new blob.
+   */
+  explicit SnapshotCreator(const v8::Isolate::CreateParams& params);
+
+  /**
+   * Initializes an Isolate for serialization and enters it. The creator does
+   * not own the Isolate but merely initialize it properly.
+   *
+   * \param isolate The isolate that was allocated by `Isolate::Allocate()~.
+   * \param params The parameters to initialize the Isolate for. Details:
+   *               - `params.external_references` are expected to be a
+   *                 null-terminated array of external references.
+   *               - `params.existing_blob` is an optional snapshot blob from
+   *                 which can be used to initialize the new blob.
+   */
+  SnapshotCreator(v8::Isolate* isolate,
+                  const v8::Isolate::CreateParams& params);
 
   /**
    * Destroy the snapshot creator, and exit and dispose of the Isolate
@@ -123,23 +206,46 @@ class V8_EXPORT SnapshotCreator {
    * The snapshot will not contain the global proxy, and we expect one or a
    * global object template to create one, to be provided upon deserialization.
    *
-   * \param callback optional callback to serialize internal fields.
+   * \param internal_fields_serializer An optional callback used to serialize
+   * internal pointer fields set by
+   * v8::Object::SetAlignedPointerInInternalField().
+   *
+   * \param context_data_serializer An optional callback used to serialize
+   * 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 callback =
-                             SerializeInternalFieldsCallback());
+  void SetDefaultContext(
+      Local<Context> context,
+      SerializeInternalFieldsCallback internal_fields_serializer =
+          SerializeInternalFieldsCallback(),
+      SerializeContextDataCallback context_data_serializer =
+          SerializeContextDataCallback(),
+      SerializeAPIWrapperCallback api_wrapper_serializer =
+          SerializeAPIWrapperCallback());
 
   /**
    * Add additional context to be included in the snapshot blob.
    * The snapshot will include the global proxy.
    *
-   * \param callback optional callback to serialize internal fields.
+   * \param internal_fields_serializer Similar to internal_fields_serializer
+   * in SetDefaultContext() but only applies to the context being added.
+   *
+   * \param context_data_serializer Similar to context_data_serializer
+   * in SetDefaultContext() but only applies to the context being added.
    *
-   * \returns the index of the context in the snapshot blob.
+   * \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 callback =
-                        SerializeInternalFieldsCallback());
+                    SerializeInternalFieldsCallback internal_fields_serializer =
+                        SerializeInternalFieldsCallback(),
+                    SerializeContextDataCallback context_data_serializer =
+                        SerializeContextDataCallback(),
+                    SerializeAPIWrapperCallback api_wrapper_serializer =
+                        SerializeAPIWrapperCallback());
 
   /**
    * Attach arbitrary V8::Data to the context snapshot, which can be retrieved
@@ -177,7 +283,8 @@ class V8_EXPORT SnapshotCreator {
   size_t AddData(Local<Context> context, internal::Address object);
   size_t AddData(internal::Address object);
 
-  void* data_;
+  internal::SnapshotCreatorImpl* impl_;
+  friend class internal::SnapshotCreatorImpl;
 };
 
 template <class T>

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)

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

@@ -13,6 +13,7 @@
 #include <vector>
 
 #include "v8-local-handle.h"  // NOLINT(build/include_directory)
+#include "v8-memory-span.h"   // NOLINT(build/include_directory)
 #include "v8-promise.h"       // NOLINT(build/include_directory)
 #include "v8config.h"         // NOLINT(build/include_directory)
 
@@ -60,42 +61,27 @@ class V8_EXPORT MeasureMemoryDelegate {
    */
   virtual bool ShouldMeasure(Local<Context> context) = 0;
 
-  /**
-   * This function is called when memory measurement finishes.
-   *
-   * \param context_sizes_in_bytes 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.
-   *
-   * \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) {}
-
   /** 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.
+     * Two spans of equal length: the first includes each context for which
+     * ShouldMeasure returned true and that was not garbage collected while
+     * the memory measurement was in progress; the second includes the size
+     * of the respective context.
      */
-    const std::vector<std::pair<Local<Context>, size_t>>&
-        context_sizes_in_bytes;
+    const MemorySpan<const Local<Context>>& contexts;
+    const MemorySpan<const size_t>& sizes_in_bytes;
 
     /**
-     * total size of objects that were not attributed to any context (i.e. are
+     * 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). */
+    /** 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). */
+    /** Total size of Wasm metadata (except code; shared across contexts). */
     size_t wasm_metadata_size_in_bytes;
   };