libv8-node 21.7.2.0-x86_64-linux → 22.5.1.0-x86_64-linux

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,24 @@ 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;
+};
 
 /**
  * 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 +78,24 @@ 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;
+};
 
 /**
  * Helper class to create a snapshot data blob.
@@ -91,10 +119,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 +133,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 +179,37 @@ 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().
+   *
    */
-  void SetDefaultContext(Local<Context> context,
-                         SerializeInternalFieldsCallback callback =
-                             SerializeInternalFieldsCallback());
+  void SetDefaultContext(
+      Local<Context> context,
+      SerializeInternalFieldsCallback internal_fields_serializer =
+          SerializeInternalFieldsCallback(),
+      SerializeContextDataCallback context_data_serializer =
+          SerializeContextDataCallback());
 
   /**
    * 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.
    *
-   * \returns the index of the context in the snapshot blob.
+   * \param context_data_serializer Similar to context_data_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());
 
   /**
    * Attach arbitrary V8::Data to the context snapshot, which can be retrieved
@@ -177,7 +247,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-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;
   };