libv8-node 18.13.0.1-x86_64-linux-musl → 20.2.0.0-x86_64-linux-musl

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

@@ -70,7 +70,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>())
-      : isolate_(isolate),
+      : v8_isolate_(isolate),
         resource_name_(resource_name),
         resource_line_offset_(resource_line_offset),
         resource_column_offset_(resource_column_offset),
@@ -87,14 +87,12 @@ class V8_EXPORT ScriptOrigin {
   V8_INLINE int ColumnOffset() const;
   V8_INLINE int ScriptId() const;
   V8_INLINE Local<Value> SourceMapUrl() const;
-  V8_DEPRECATE_SOON("Use GetHostDefinedOptions")
-  Local<PrimitiveArray> HostDefinedOptions() const;
   V8_INLINE Local<Data> GetHostDefinedOptions() const;
   V8_INLINE ScriptOriginOptions Options() const { return options_; }
 
  private:
   void VerifyHostDefinedOptions() const;
-  Isolate* isolate_;
+  Isolate* v8_isolate_;
   Local<Value> resource_name_;
   int resource_line_offset_;
   int resource_column_offset_;

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

@@ -12,6 +12,7 @@
 
 #include "v8-internal.h"      // NOLINT(build/include_directory)
 #include "v8-local-handle.h"  // NOLINT(build/include_directory)
+#include "v8config.h"         // NOLINT(build/include_directory)
 
 namespace v8 {
 
@@ -96,16 +97,42 @@ struct GarbageCollectionYoungCycle {
 };
 
 struct WasmModuleDecoded {
+  WasmModuleDecoded() = default;
+  WasmModuleDecoded(bool async, bool streamed, bool success,
+                    size_t module_size_in_bytes, size_t function_count,
+                    int64_t wall_clock_duration_in_us)
+      : async(async),
+        streamed(streamed),
+        success(success),
+        module_size_in_bytes(module_size_in_bytes),
+        function_count(function_count),
+        wall_clock_duration_in_us(wall_clock_duration_in_us) {}
+
   bool async = false;
   bool streamed = false;
   bool success = false;
   size_t module_size_in_bytes = 0;
   size_t function_count = 0;
   int64_t wall_clock_duration_in_us = -1;
-  int64_t cpu_duration_in_us = -1;
 };
 
 struct WasmModuleCompiled {
+  WasmModuleCompiled() = default;
+
+  WasmModuleCompiled(bool async, bool streamed, bool cached, bool deserialized,
+                     bool lazy, bool success, size_t code_size_in_bytes,
+                     size_t liftoff_bailout_count,
+                     int64_t wall_clock_duration_in_us)
+      : async(async),
+        streamed(streamed),
+        cached(cached),
+        deserialized(deserialized),
+        lazy(lazy),
+        success(success),
+        code_size_in_bytes(code_size_in_bytes),
+        liftoff_bailout_count(liftoff_bailout_count),
+        wall_clock_duration_in_us(wall_clock_duration_in_us) {}
+
   bool async = false;
   bool streamed = false;
   bool cached = false;
@@ -115,7 +142,6 @@ struct WasmModuleCompiled {
   size_t code_size_in_bytes = 0;
   size_t liftoff_bailout_count = 0;
   int64_t wall_clock_duration_in_us = -1;
-  int64_t cpu_duration_in_us = -1;
 };
 
 struct WasmModuleInstantiated {
@@ -125,31 +151,10 @@ struct WasmModuleInstantiated {
   int64_t wall_clock_duration_in_us = -1;
 };
 
-struct WasmModuleTieredUp {
-  bool lazy = false;
-  size_t code_size_in_bytes = 0;
-  int64_t wall_clock_duration_in_us = -1;
-  int64_t cpu_duration_in_us = -1;
-};
-
 struct WasmModulesPerIsolate {
   size_t count = 0;
 };
 
-#define V8_MAIN_THREAD_METRICS_EVENTS(V)                    \
-  V(GarbageCollectionFullCycle)                             \
-  V(GarbageCollectionFullMainThreadIncrementalMark)         \
-  V(GarbageCollectionFullMainThreadBatchedIncrementalMark)  \
-  V(GarbageCollectionFullMainThreadIncrementalSweep)        \
-  V(GarbageCollectionFullMainThreadBatchedIncrementalSweep) \
-  V(GarbageCollectionYoungCycle)                            \
-  V(WasmModuleDecoded)                                      \
-  V(WasmModuleCompiled)                                     \
-  V(WasmModuleInstantiated)                                 \
-  V(WasmModuleTieredUp)
-
-#define V8_THREAD_SAFE_METRICS_EVENTS(V) V(WasmModulesPerIsolate)
-
 /**
  * This class serves as a base class for recording event-based metrics in V8.
  * There a two kinds of metrics, those which are expected to be thread-safe and
@@ -159,19 +164,6 @@ struct WasmModulesPerIsolate {
  * background thread, it will be delayed and executed by the foreground task
  * runner.
  *
- * The thread-safe events are listed in the V8_THREAD_SAFE_METRICS_EVENTS
- * macro above while the main thread event are listed in
- * V8_MAIN_THREAD_METRICS_EVENTS above. For the former, a virtual method
- * AddMainThreadEvent(const E& event, v8::Context::Token token) will be
- * generated and for the latter AddThreadSafeEvent(const E& event).
- *
- * Thread-safe events are not allowed to access the context and therefore do
- * not carry a context ID with them. These IDs can be generated using
- * Recorder::GetContextId() and the ID will be valid throughout the lifetime
- * of the isolate. It is not guaranteed that the ID will still resolve to
- * a valid context using Recorder::GetContext() at the time the metric is
- * recorded. In this case, an empty handle will be returned.
- *
  * The embedder is expected to call v8::Isolate::SetMetricsRecorder()
  * providing its implementation and have the virtual methods overwritten
  * for the events it cares about.
@@ -202,14 +194,30 @@ class V8_EXPORT Recorder {
 
   virtual ~Recorder() = default;
 
+  // Main thread events. Those are only triggered on the main thread, and hence
+  // can access the context.
 #define ADD_MAIN_THREAD_EVENT(E) \
-  virtual void AddMainThreadEvent(const E& event, ContextId context_id) {}
-  V8_MAIN_THREAD_METRICS_EVENTS(ADD_MAIN_THREAD_EVENT)
+  virtual void AddMainThreadEvent(const E&, ContextId) {}
+  ADD_MAIN_THREAD_EVENT(GarbageCollectionFullCycle)
+  ADD_MAIN_THREAD_EVENT(GarbageCollectionFullMainThreadIncrementalMark)
+  ADD_MAIN_THREAD_EVENT(GarbageCollectionFullMainThreadBatchedIncrementalMark)
+  ADD_MAIN_THREAD_EVENT(GarbageCollectionFullMainThreadIncrementalSweep)
+  ADD_MAIN_THREAD_EVENT(GarbageCollectionFullMainThreadBatchedIncrementalSweep)
+  ADD_MAIN_THREAD_EVENT(GarbageCollectionYoungCycle)
+  ADD_MAIN_THREAD_EVENT(WasmModuleDecoded)
+  ADD_MAIN_THREAD_EVENT(WasmModuleCompiled)
+  ADD_MAIN_THREAD_EVENT(WasmModuleInstantiated)
 #undef ADD_MAIN_THREAD_EVENT
 
+  // Thread-safe events are not allowed to access the context and therefore do
+  // not carry a context ID with them. These IDs can be generated using
+  // Recorder::GetContextId() and the ID will be valid throughout the lifetime
+  // of the isolate. It is not guaranteed that the ID will still resolve to
+  // a valid context using Recorder::GetContext() at the time the metric is
+  // recorded. In this case, an empty handle will be returned.
 #define ADD_THREAD_SAFE_EVENT(E) \
-  virtual void AddThreadSafeEvent(const E& event) {}
-  V8_THREAD_SAFE_METRICS_EVENTS(ADD_THREAD_SAFE_EVENT)
+  virtual void AddThreadSafeEvent(const E&) {}
+  ADD_THREAD_SAFE_EVENT(WasmModulesPerIsolate)
 #undef ADD_THREAD_SAFE_EVENT
 
   virtual void NotifyIsolateDisposal() {}

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

@@ -118,7 +118,12 @@ 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();
 
@@ -142,7 +147,7 @@ class V8_EXPORT V8_NODISCARD MicrotasksScope {
   MicrotasksScope& operator=(const MicrotasksScope&) = delete;
 
  private:
-  internal::Isolate* const isolate_;
+  internal::Isolate* const i_isolate_;
   internal::MicrotaskQueue* const microtask_queue_;
   bool run_;
 };

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

@@ -594,8 +594,6 @@ class V8_EXPORT Object : public Value {
   /**
    * Returns the context in which the object was created.
    */
-  V8_DEPRECATED("Use MaybeLocal<Context> GetCreationContext()")
-  Local<Context> CreationContext();
   MaybeLocal<Context> GetCreationContext();
 
   /**
@@ -604,15 +602,24 @@ class V8_EXPORT Object : public Value {
   Local<Context> GetCreationContextChecked();
 
   /** Same as above, but works for Persistents */
-  V8_DEPRECATED(
-      "Use MaybeLocal<Context> GetCreationContext(const "
-      "PersistentBase<Object>& object)")
-  static Local<Context> CreationContext(const PersistentBase<Object>& object);
   V8_INLINE static MaybeLocal<Context> GetCreationContext(
       const PersistentBase<Object>& object) {
     return object.val_->GetCreationContext();
   }
 
+  /**
+   * Gets the context in which the object was created (see GetCreationContext())
+   * and if it's available reads respective embedder field value.
+   * If the context can't be obtained nullptr is returned.
+   * Basically it's a shortcut for
+   *   obj->GetCreationContext().GetAlignedPointerFromEmbedderData(index)
+   * which doesn't create a handle for Context object on the way and doesn't
+   * try to expand the embedder data attached to the context.
+   * In case the Local<Context> is already available because of other reasons,
+   * it's fine to keep using Context::GetAlignedPointerFromEmbedderData().
+   */
+  void* GetAlignedPointerFromEmbedderDataInCreationContext(int index);
+
   /**
    * Checks whether a callback is set by the
    * ObjectTemplate::SetCallAsFunctionHandler method.
@@ -713,22 +720,27 @@ Local<Value> Object::GetInternalField(int index) {
 #ifndef V8_ENABLE_CHECKS
   using A = internal::Address;
   using I = internal::Internals;
-  A obj = *reinterpret_cast<A*>(this);
+  A obj = internal::ValueHelper::ValueAsAddress(this);
   // Fast path: If the object is a plain JSObject, which is the common case, we
   // know where to find the internal fields and can return the value directly.
   int instance_type = I::GetInstanceType(obj);
-  if (v8::internal::CanHaveInternalField(instance_type)) {
+  if (I::CanHaveInternalField(instance_type)) {
     int offset = I::kJSObjectHeaderSize + (I::kEmbedderDataSlotSize * index);
     A value = I::ReadRawField<A>(obj, offset);
 #ifdef V8_COMPRESS_POINTERS
     // We read the full pointer value and then decompress it in order to avoid
     // dealing with potential endiannes issues.
-    value = I::DecompressTaggedAnyField(obj, static_cast<uint32_t>(value));
+    value = I::DecompressTaggedField(obj, static_cast<uint32_t>(value));
 #endif
+
+#ifdef V8_ENABLE_CONSERVATIVE_STACK_SCANNING
+    return Local<Value>(reinterpret_cast<Value*>(value));
+#else
     internal::Isolate* isolate =
         internal::IsolateFromNeverReadOnlySpaceObject(obj);
     A* result = HandleScope::CreateHandle(isolate, value);
     return Local<Value>(reinterpret_cast<Value*>(result));
+#endif
   }
 #endif
   return SlowGetInternalField(index);
@@ -738,18 +750,17 @@ void* Object::GetAlignedPointerFromInternalField(int index) {
 #if !defined(V8_ENABLE_CHECKS)
   using A = internal::Address;
   using I = internal::Internals;
-  A obj = *reinterpret_cast<A*>(this);
+  A obj = internal::ValueHelper::ValueAsAddress(this);
   // Fast path: If the object is a plain JSObject, which is the common case, we
   // know where to find the internal fields and can return the value directly.
   auto instance_type = I::GetInstanceType(obj);
-  if (v8::internal::CanHaveInternalField(instance_type)) {
-    int offset = I::kJSObjectHeaderSize + (I::kEmbedderDataSlotSize * index);
-#ifdef V8_SANDBOXED_EXTERNAL_POINTERS
-    offset += I::kEmbedderDataSlotRawPayloadOffset;
-#endif
-    internal::Isolate* isolate = I::GetIsolateForSandbox(obj);
-    A value = I::ReadExternalPointerField(
-        isolate, obj, offset, internal::kEmbedderDataSlotPayloadTag);
+  if (I::CanHaveInternalField(instance_type)) {
+    int offset = I::kJSObjectHeaderSize + (I::kEmbedderDataSlotSize * index) +
+                 I::kEmbedderDataSlotExternalPointerOffset;
+    Isolate* isolate = I::GetIsolateForSandbox(obj);
+    A value =
+        I::ReadExternalPointerField<internal::kEmbedderDataSlotPayloadTag>(
+            isolate, obj, offset);
     return reinterpret_cast<void*>(value);
   }
 #endif

data/vendor/v8/include/v8-persistent-handle.h

@@ -55,7 +55,7 @@ class Eternal {
   V8_INLINE Local<T> Get(Isolate* isolate) const {
     // The eternal handle will never go away, so as with the roots, we don't
     // even need to open a handle.
-    return Local<T>(val_);
+    return Local<T>(internal::ValueHelper::SlotAsValue<T>(val_));
   }
 
   V8_INLINE bool IsEmpty() const { return val_ == nullptr; }
@@ -68,6 +68,10 @@ class Eternal {
   }
 
  private:
+  V8_INLINE internal::Address address() const {
+    return *reinterpret_cast<internal::Address*>(val_);
+  }
+
   T* val_;
 };
 
@@ -122,20 +126,12 @@ class PersistentBase {
 
   template <class S>
   V8_INLINE bool operator==(const PersistentBase<S>& that) const {
-    internal::Address* a = reinterpret_cast<internal::Address*>(this->val_);
-    internal::Address* b = reinterpret_cast<internal::Address*>(that.val_);
-    if (a == nullptr) return b == nullptr;
-    if (b == nullptr) return false;
-    return *a == *b;
+    return internal::HandleHelper::EqualHandles(*this, that);
   }
 
   template <class S>
   V8_INLINE bool operator==(const Local<S>& that) const {
-    internal::Address* a = reinterpret_cast<internal::Address*>(this->val_);
-    internal::Address* b = reinterpret_cast<internal::Address*>(that.val_);
-    if (a == nullptr) return b == nullptr;
-    if (b == nullptr) return false;
-    return *a == *b;
+    return internal::HandleHelper::EqualHandles(*this, that);
   }
 
   template <class S>
@@ -169,8 +165,6 @@ class PersistentBase {
    * Turns this handle into a weak phantom handle without finalization callback.
    * The handle will be reset automatically when the garbage collector detects
    * that the object is no longer reachable.
-   * A related function Isolate::NumberOfPhantomHandleResetsSinceLastCall
-   * returns how many phantom handles were reset by the garbage collector.
    */
   V8_INLINE void SetWeak();
 
@@ -223,8 +217,15 @@ class PersistentBase {
   template <class F1, class F2>
   friend class PersistentValueVector;
   friend class Object;
+  friend class internal::HandleHelper;
 
   explicit V8_INLINE PersistentBase(T* val) : val_(val) {}
+  V8_INLINE T* operator*() const { return this->val_; }
+  V8_INLINE internal::Address address() const {
+    return *reinterpret_cast<internal::Address*>(val_);
+  }
+
+  V8_INLINE static T* New(Isolate* isolate, Local<T> that);
   V8_INLINE static T* New(Isolate* isolate, T* that);
 
   T* val_;
@@ -284,11 +285,13 @@ class Persistent : public PersistentBase<T> {
    * When the Local is non-empty, a new storage cell is created
    * pointing to the same object, and no flags are set.
    */
+
   template <class S>
   V8_INLINE Persistent(Isolate* isolate, Local<S> that)
-      : PersistentBase<T>(PersistentBase<T>::New(isolate, *that)) {
+      : PersistentBase<T>(PersistentBase<T>::New(isolate, that)) {
     static_assert(std::is_base_of<T, S>::value, "type check");
   }
+
   /**
    * Construct a Persistent from a Persistent.
    * When the Persistent is non-empty, a new storage cell is created
@@ -358,7 +361,6 @@ class Persistent : public PersistentBase<T> {
   friend class ReturnValue;
 
   explicit V8_INLINE Persistent(T* that) : PersistentBase<T>(that) {}
-  V8_INLINE T* operator*() const { return this->val_; }
   template <class S, class M2>
   V8_INLINE void Copy(const Persistent<S, M2>& that);
 };
@@ -383,7 +385,7 @@ class Global : public PersistentBase<T> {
    */
   template <class S>
   V8_INLINE Global(Isolate* isolate, Local<S> that)
-      : PersistentBase<T>(PersistentBase<T>::New(isolate, *that)) {
+      : PersistentBase<T>(PersistentBase<T>::New(isolate, that)) {
     static_assert(std::is_base_of<T, S>::value, "type check");
   }
 
@@ -427,7 +429,6 @@ class Global : public PersistentBase<T> {
  private:
   template <class F>
   friend class ReturnValue;
-  V8_INLINE T* operator*() const { return this->val_; }
 };
 
 // UniquePersistent is an alias for Global for historical reason.
@@ -444,6 +445,12 @@ class V8_EXPORT PersistentHandleVisitor {
                                      uint16_t class_id) {}
 };
 
+template <class T>
+T* PersistentBase<T>::New(Isolate* isolate, Local<T> that) {
+  return PersistentBase<T>::New(isolate,
+                                internal::ValueHelper::ValueAsSlot(*that));
+}
+
 template <class T>
 T* PersistentBase<T>::New(Isolate* isolate, T* that) {
   if (that == nullptr) return nullptr;
@@ -488,7 +495,7 @@ void PersistentBase<T>::Reset(Isolate* isolate, const Local<S>& other) {
   static_assert(std::is_base_of<T, S>::value, "type check");
   Reset();
   if (other.IsEmpty()) return;
-  this->val_ = New(isolate, other.val_);
+  this->val_ = New(isolate, internal::ValueHelper::ValueAsSlot(*other));
 }
 
 /**