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

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

@@ -9,29 +9,42 @@
 
 #include <type_traits>
 
-#include "v8-internal.h"  // NOLINT(build/include_directory)
+#include "v8-handle-base.h"  // NOLINT(build/include_directory)
 
 namespace v8 {
 
-class Boolean;
 template <class T>
-class BasicTracedReference;
-class Context;
-class EscapableHandleScope;
-template <class F>
-class Eternal;
-template <class F>
-class FunctionCallbackInfo;
-class Isolate;
+class LocalBase;
+template <class T>
+class Local;
 template <class F>
 class MaybeLocal;
+
+template <class T>
+class Eternal;
+template <class T>
+class Global;
+
 template <class T>
 class NonCopyablePersistentTraits;
-class Object;
+template <class T>
+class PersistentBase;
 template <class T, class M = NonCopyablePersistentTraits<T>>
 class Persistent;
+
+class TracedReferenceBase;
 template <class T>
-class PersistentBase;
+class BasicTracedReference;
+template <class F>
+class TracedReference;
+
+class Boolean;
+class Context;
+class EscapableHandleScope;
+template <class F>
+class FunctionCallbackInfo;
+class Isolate;
+class Object;
 template <class F1, class F2, class F3>
 class PersistentValueMapBase;
 template <class F1, class F2>
@@ -45,9 +58,6 @@ class ReturnValue;
 class String;
 template <class F>
 class Traced;
-template <class F>
-class TracedReference;
-class TracedReferenceBase;
 class Utils;
 
 namespace debug {
@@ -120,9 +130,9 @@ class V8_EXPORT V8_NODISCARD HandleScope {
   internal::Address* prev_next_;
   internal::Address* prev_limit_;
 
-  // Local::New uses CreateHandle with an Isolate* parameter.
-  template <class F>
-  friend class Local;
+  // LocalBase<T>::New uses CreateHandle with an Isolate* parameter.
+  template <typename T>
+  friend class LocalBase;
 
   // Object::GetInternalField and Context::GetEmbedderData use CreateHandle with
   // a HeapObject in their shortcuts.
@@ -130,32 +140,74 @@ class V8_EXPORT V8_NODISCARD HandleScope {
   friend class Context;
 };
 
-namespace internal {
-
 /**
- * Helper functions about handles.
+ * A base class for local handles.
+ * Its implementation depends on whether direct local support is enabled.
+ * When it is, a local handle contains a direct pointer to the referenced
+ * object, otherwise it contains an indirect pointer.
  */
-class HandleHelper final {
- public:
-  /**
-   * Checks whether two handles are equal.
-   * They are equal iff they are both empty or they are both non-empty and the
-   * objects to which they refer are physically equal.
-   *
-   * If both handles refer to JS objects, this is the same as strict equality.
-   * For primitives, such as numbers or strings, a `false` return value does not
-   * indicate that the values aren't equal in the JavaScript sense.
-   * Use `Value::StrictEquals()` to check primitives for equality.
-   */
-  template <typename T1, typename T2>
-  V8_INLINE static bool EqualHandles(const T1& lhs, const T2& rhs) {
-    if (lhs.IsEmpty()) return rhs.IsEmpty();
-    if (rhs.IsEmpty()) return false;
-    return lhs.address() == rhs.address();
+#ifdef V8_ENABLE_DIRECT_LOCAL
+
+template <typename T>
+class LocalBase : public DirectHandleBase {
+ protected:
+  template <class F>
+  friend class Local;
+
+  V8_INLINE LocalBase() = default;
+
+  V8_INLINE explicit LocalBase(internal::Address ptr) : DirectHandleBase(ptr) {}
+
+  template <typename S>
+  V8_INLINE LocalBase(const LocalBase<S>& other) : DirectHandleBase(other) {}
+
+  V8_INLINE static LocalBase<T> New(Isolate* isolate, internal::Address value) {
+    return LocalBase<T>(value);
+  }
+
+  V8_INLINE static LocalBase<T> New(Isolate* isolate, T* that) {
+    return LocalBase<T>::New(isolate,
+                             internal::ValueHelper::ValueAsAddress(that));
+  }
+
+  V8_INLINE static LocalBase<T> FromSlot(internal::Address* slot) {
+    return LocalBase<T>(*slot);
   }
 };
 
-}  // namespace internal
+#else  // !V8_ENABLE_DIRECT_LOCAL
+
+template <typename T>
+class LocalBase : public IndirectHandleBase {
+ protected:
+  template <class F>
+  friend class Local;
+
+  V8_INLINE LocalBase() = default;
+
+  V8_INLINE explicit LocalBase(internal::Address* location)
+      : IndirectHandleBase(location) {}
+
+  template <typename S>
+  V8_INLINE LocalBase(const LocalBase<S>& other) : IndirectHandleBase(other) {}
+
+  V8_INLINE static LocalBase<T> New(Isolate* isolate, internal::Address value) {
+    return LocalBase(HandleScope::CreateHandle(
+        reinterpret_cast<internal::Isolate*>(isolate), value));
+  }
+
+  V8_INLINE static LocalBase<T> New(Isolate* isolate, T* that) {
+    if (internal::ValueHelper::IsEmpty(that)) return LocalBase<T>();
+    return LocalBase<T>::New(isolate,
+                             internal::ValueHelper::ValueAsAddress(that));
+  }
+
+  V8_INLINE static LocalBase<T> FromSlot(internal::Address* slot) {
+    return LocalBase<T>(slot);
+  }
+};
+
+#endif  // V8_ENABLE_DIRECT_LOCAL
 
 /**
  * An object reference managed by the v8 garbage collector.
@@ -187,12 +239,12 @@ class HandleHelper final {
  * to these values as to their handles.
  */
 template <class T>
-class Local {
+class Local : public LocalBase<T> {
  public:
-  V8_INLINE Local() : val_(internal::ValueHelper::EmptyValue<T>()) {}
+  V8_INLINE Local() = default;
 
   template <class S>
-  V8_INLINE Local(Local<S> that) : val_(reinterpret_cast<T*>(*that)) {
+  V8_INLINE Local(Local<S> that) : LocalBase<T>(that) {
     /**
      * This check fails when trying to convert between incompatible
      * handles. For example, converting from a Local<String> to a
@@ -201,21 +253,9 @@ class Local {
     static_assert(std::is_base_of<T, S>::value, "type check");
   }
 
-  /**
-   * Returns true if the handle is empty.
-   */
-  V8_INLINE bool IsEmpty() const {
-    return val_ == internal::ValueHelper::EmptyValue<T>();
-  }
-
-  /**
-   * Sets the handle to be empty. IsEmpty() will then return true.
-   */
-  V8_INLINE void Clear() { val_ = internal::ValueHelper::EmptyValue<T>(); }
-
-  V8_INLINE T* operator->() const { return val_; }
+  V8_INLINE T* operator->() const { return this->template value<T>(); }
 
-  V8_INLINE T* operator*() const { return val_; }
+  V8_INLINE T* operator*() const { return this->operator->(); }
 
   /**
    * Checks whether two handles are equal or different.
@@ -259,8 +299,9 @@ class Local {
     // If we're going to perform the type check then we have to check
     // that the handle isn't empty before doing the checked cast.
     if (that.IsEmpty()) return Local<T>();
+    T::Cast(that.template value<S>());
 #endif
-    return Local<T>(T::Cast(*that));
+    return Local<T>(LocalBase<T>(that));
   }
 
   /**
@@ -279,17 +320,17 @@ class Local {
    * the original handle is destroyed/disposed.
    */
   V8_INLINE static Local<T> New(Isolate* isolate, Local<T> that) {
-    return New(isolate, that.val_);
+    return New(isolate, that.template value<T>());
   }
 
   V8_INLINE static Local<T> New(Isolate* isolate,
                                 const PersistentBase<T>& that) {
-    return New(isolate, internal::ValueHelper::SlotAsValue<T>(that.val_));
+    return New(isolate, that.template value<T>());
   }
 
   V8_INLINE static Local<T> New(Isolate* isolate,
                                 const BasicTracedReference<T>& that) {
-    return New(isolate, internal::ValueHelper::SlotAsValue<T>(*that));
+    return New(isolate, that.template value<T>());
   }
 
  private:
@@ -298,7 +339,13 @@ class Local {
   template <class F>
   friend class Eternal;
   template <class F>
+  friend class Global;
+  template <class F>
+  friend class Local;
+  template <class F>
   friend class MaybeLocal;
+  template <class F, class M>
+  friend class Persistent;
   template <class F>
   friend class FunctionCallbackInfo;
   template <class F>
@@ -328,28 +375,32 @@ class Local {
   friend class internal::HandleHelper;
   friend class debug::ConsoleCallArguments;
 
-  explicit V8_INLINE Local(T* that) : val_(that) {}
+  V8_INLINE explicit Local<T>(const LocalBase<T>& other)
+      : LocalBase<T>(other) {}
 
-  V8_INLINE internal::Address address() const {
-    return internal::ValueHelper::ValueAsAddress(val_);
+  V8_INLINE static Local<T> FromSlot(internal::Address* slot) {
+    return Local<T>(LocalBase<T>::FromSlot(slot));
   }
 
-  V8_INLINE static Local<T> FromSlot(internal::Address* slot) {
-    return Local<T>(internal::ValueHelper::SlotAsValue<T>(slot));
+#ifdef V8_ENABLE_DIRECT_LOCAL
+  V8_INLINE static Local<T> FromAddress(internal::Address ptr) {
+    return Local<T>(LocalBase<T>(ptr));
+  }
+#endif  // V8_ENABLE_DIRECT_LOCAL
+
+  V8_INLINE static Local<T> New(Isolate* isolate, internal::Address value) {
+    return Local<T>(LocalBase<T>::New(isolate, value));
   }
 
   V8_INLINE static Local<T> New(Isolate* isolate, T* that) {
-#ifdef V8_ENABLE_CONSERVATIVE_STACK_SCANNING
-    return Local<T>(that);
-#else
-    if (that == nullptr) return Local<T>();
-    internal::Address* p = reinterpret_cast<internal::Address*>(that);
-    return Local<T>(reinterpret_cast<T*>(HandleScope::CreateHandle(
-        reinterpret_cast<internal::Isolate*>(isolate), *p)));
-#endif
+    return Local<T>(LocalBase<T>::New(isolate, that));
   }
 
-  T* val_;
+  // Unsafe cast, should be avoided.
+  template <class S>
+  V8_INLINE Local<S> UnsafeAs() const {
+    return Local<S>(LocalBase<S>(*this));
+  }
 };
 
 #if !defined(V8_IMMINENT_DEPRECATION_WARNINGS)
@@ -371,15 +422,11 @@ using Handle = Local<T>;
 template <class T>
 class MaybeLocal {
  public:
-  V8_INLINE MaybeLocal() : val_(internal::ValueHelper::EmptyValue<T>()) {}
+  V8_INLINE MaybeLocal() : local_() {}
   template <class S>
-  V8_INLINE MaybeLocal(Local<S> that) : val_(reinterpret_cast<T*>(*that)) {
-    static_assert(std::is_base_of<T, S>::value, "type check");
-  }
+  V8_INLINE MaybeLocal(Local<S> that) : local_(that) {}
 
-  V8_INLINE bool IsEmpty() const {
-    return val_ == internal::ValueHelper::EmptyValue<T>();
-  }
+  V8_INLINE bool IsEmpty() const { return local_.IsEmpty(); }
 
   /**
    * Converts this MaybeLocal<> to a Local<>. If this MaybeLocal<> is empty,
@@ -387,7 +434,7 @@ class MaybeLocal {
    */
   template <class S>
   V8_WARN_UNUSED_RESULT V8_INLINE bool ToLocal(Local<S>* out) const {
-    out->val_ = IsEmpty() ? internal::ValueHelper::EmptyValue<T>() : this->val_;
+    *out = local_;
     return !IsEmpty();
   }
 
@@ -397,7 +444,7 @@ class MaybeLocal {
    */
   V8_INLINE Local<T> ToLocalChecked() {
     if (V8_UNLIKELY(IsEmpty())) api_internal::ToLocalEmpty();
-    return Local<T>(val_);
+    return local_;
   }
 
   /**
@@ -406,11 +453,11 @@ class MaybeLocal {
    */
   template <class S>
   V8_INLINE Local<S> FromMaybe(Local<S> default_value) const {
-    return IsEmpty() ? default_value : Local<S>(val_);
+    return IsEmpty() ? default_value : Local<S>(local_);
   }
 
  private:
-  T* val_;
+  Local<T> local_;
 };
 
 /**
@@ -428,12 +475,10 @@ class V8_EXPORT V8_NODISCARD EscapableHandleScope : public HandleScope {
    */
   template <class T>
   V8_INLINE Local<T> Escape(Local<T> value) {
-#ifdef V8_ENABLE_CONSERVATIVE_STACK_SCANNING
+#ifdef V8_ENABLE_DIRECT_LOCAL
     return value;
 #else
-    internal::Address* slot =
-        Escape(reinterpret_cast<internal::Address*>(*value));
-    return Local<T>(reinterpret_cast<T*>(slot));
+    return Local<T>::FromSlot(Escape(value.slot()));
 #endif
   }
 

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

@@ -165,17 +165,16 @@ using AccessorNameSetterCallback =
 /**
  * Access control specifications.
  *
- * Some accessors should be accessible across contexts.  These
+ * Some accessors should be accessible across contexts. These
  * accessors have an explicit access control parameter which specifies
  * the kind of cross-context access that should be allowed.
  *
- * TODO(dcarney): Remove PROHIBITS_OVERWRITING as it is now unused.
  */
 enum AccessControl {
   DEFAULT = 0,
   ALL_CAN_READ = 1,
   ALL_CAN_WRITE = 1 << 1,
-  PROHIBITS_OVERWRITING = 1 << 2
+  PROHIBITS_OVERWRITING V8_ENUM_DEPRECATE_SOON("unused") = 1 << 2
 };
 
 /**
@@ -247,13 +246,16 @@ class V8_EXPORT Object : public Value {
   V8_WARN_UNUSED_RESULT Maybe<bool> Set(Local<Context> context, uint32_t index,
                                         Local<Value> value);
 
-  // Implements CreateDataProperty (ECMA-262, 7.3.4).
-  //
-  // Defines a configurable, writable, enumerable property with the given value
-  // on the object unless the property already exists and is not configurable
-  // or the object is not extensible.
-  //
-  // Returns true on success.
+  /**
+   * Implements CreateDataProperty(O, P, V), see
+   * https://tc39.es/ecma262/#sec-createdataproperty.
+   *
+   * Defines a configurable, writable, enumerable property with the given value
+   * on the object unless the property already exists and is not configurable
+   * or the object is not extensible.
+   *
+   * Returns true on success.
+   */
   V8_WARN_UNUSED_RESULT Maybe<bool> CreateDataProperty(Local<Context> context,
                                                        Local<Name> key,
                                                        Local<Value> value);
@@ -261,29 +263,35 @@ class V8_EXPORT Object : public Value {
                                                        uint32_t index,
                                                        Local<Value> value);
 
-  // Implements DefineOwnProperty.
-  //
-  // In general, CreateDataProperty will be faster, however, does not allow
-  // for specifying attributes.
-  //
-  // Returns true on success.
+  /**
+   * Implements [[DefineOwnProperty]] for data property case, see
+   * https://tc39.es/ecma262/#table-essential-internal-methods.
+   *
+   * In general, CreateDataProperty will be faster, however, does not allow
+   * for specifying attributes.
+   *
+   * Returns true on success.
+   */
   V8_WARN_UNUSED_RESULT Maybe<bool> DefineOwnProperty(
       Local<Context> context, Local<Name> key, Local<Value> value,
       PropertyAttribute attributes = None);
 
-  // Implements Object.DefineProperty(O, P, Attributes), see Ecma-262 19.1.2.4.
-  //
-  // The defineProperty function is used to add an own property or
-  // update the attributes of an existing own property of an object.
-  //
-  // Both data and accessor descriptors can be used.
-  //
-  // In general, CreateDataProperty is faster, however, does not allow
-  // for specifying attributes or an accessor descriptor.
-  //
-  // The PropertyDescriptor can change when redefining a property.
-  //
-  // Returns true on success.
+  /**
+   * Implements Object.defineProperty(O, P, Attributes), see
+   * https://tc39.es/ecma262/#sec-object.defineproperty.
+   *
+   * The defineProperty function is used to add an own property or
+   * update the attributes of an existing own property of an object.
+   *
+   * Both data and accessor descriptors can be used.
+   *
+   * In general, CreateDataProperty is faster, however, does not allow
+   * for specifying attributes or an accessor descriptor.
+   *
+   * The PropertyDescriptor can change when redefining a property.
+   *
+   * Returns true on success.
+   */
   V8_WARN_UNUSED_RESULT Maybe<bool> DefineProperty(
       Local<Context> context, Local<Name> key, PropertyDescriptor& descriptor);
 
@@ -302,14 +310,15 @@ class V8_EXPORT Object : public Value {
       Local<Context> context, Local<Value> key);
 
   /**
-   * Returns Object.getOwnPropertyDescriptor as per ES2016 section 19.1.2.6.
+   * Implements Object.getOwnPropertyDescriptor(O, P), see
+   * https://tc39.es/ecma262/#sec-object.getownpropertydescriptor.
    */
   V8_WARN_UNUSED_RESULT MaybeLocal<Value> GetOwnPropertyDescriptor(
       Local<Context> context, Local<Name> key);
 
   /**
-   * Object::Has() calls the abstract operation HasProperty(O, P) described
-   * in ECMA-262, 7.3.10. Has() returns
+   * Object::Has() calls the abstract operation HasProperty(O, P), see
+   * https://tc39.es/ecma262/#sec-hasproperty. Has() returns
    * true, if the object has the property, either own or on the prototype chain.
    * Interceptors, i.e., PropertyQueryCallbacks, are called if present.
    *
@@ -347,7 +356,7 @@ class V8_EXPORT Object : public Value {
 
   void SetAccessorProperty(Local<Name> name, Local<Function> getter,
                            Local<Function> setter = Local<Function>(),
-                           PropertyAttribute attribute = None,
+                           PropertyAttribute attributes = None,
                            AccessControl settings = DEFAULT);
 
   /**
@@ -465,20 +474,29 @@ class V8_EXPORT Object : public Value {
   /** Same as above, but works for PersistentBase. */
   V8_INLINE static int InternalFieldCount(
       const PersistentBase<Object>& object) {
-    return object.val_->InternalFieldCount();
+    return object.template value<Object>()->InternalFieldCount();
   }
 
   /** Same as above, but works for BasicTracedReference. */
   V8_INLINE static int InternalFieldCount(
       const BasicTracedReference<Object>& object) {
-    return object->InternalFieldCount();
+    return object.template value<Object>()->InternalFieldCount();
   }
 
-  /** Gets the value from an internal field. */
-  V8_INLINE Local<Value> GetInternalField(int index);
+  /**
+   * Gets the data from an internal field.
+   * To cast the return value into v8::Value subtypes, it needs to be
+   * casted to a v8::Value first. For example, to cast it into v8::External:
+   *
+   * object->GetInternalField(index).As<v8::Value>().As<v8::External>();
+   *
+   * The embedder should make sure that the internal field being retrieved
+   * using this method has already been set with SetInternalField() before.
+   **/
+  V8_INLINE Local<Data> GetInternalField(int index);
 
-  /** Sets the value in an internal field. */
-  void SetInternalField(int index, Local<Value> value);
+  /** Sets the data in an internal field. */
+  void SetInternalField(int index, Local<Data> data);
 
   /**
    * Gets a 2-byte-aligned native pointer from an internal field. This field
@@ -490,13 +508,15 @@ class V8_EXPORT Object : public Value {
   /** Same as above, but works for PersistentBase. */
   V8_INLINE static void* GetAlignedPointerFromInternalField(
       const PersistentBase<Object>& object, int index) {
-    return object.val_->GetAlignedPointerFromInternalField(index);
+    return object.template value<Object>()->GetAlignedPointerFromInternalField(
+        index);
   }
 
   /** Same as above, but works for TracedReference. */
   V8_INLINE static void* GetAlignedPointerFromInternalField(
       const BasicTracedReference<Object>& object, int index) {
-    return object->GetAlignedPointerFromInternalField(index);
+    return object.template value<Object>()->GetAlignedPointerFromInternalField(
+        index);
   }
 
   /**
@@ -604,7 +624,7 @@ class V8_EXPORT Object : public Value {
   /** Same as above, but works for Persistents */
   V8_INLINE static MaybeLocal<Context> GetCreationContext(
       const PersistentBase<Object>& object) {
-    return object.val_->GetCreationContext();
+    return object.template value<Object>()->GetCreationContext();
   }
 
   /**
@@ -670,6 +690,10 @@ class V8_EXPORT Object : public Value {
    */
   Isolate* GetIsolate();
 
+  V8_INLINE static Isolate* GetIsolate(const TracedReference<Object>& handle) {
+    return handle.template value<Object>()->GetIsolate();
+  }
+
   /**
    * If this object is a Set, Map, WeakSet or WeakMap, this returns a
    * representation of the elements of this object as an array.
@@ -710,13 +734,13 @@ class V8_EXPORT Object : public Value {
  private:
   Object();
   static void CheckCast(Value* obj);
-  Local<Value> SlowGetInternalField(int index);
+  Local<Data> SlowGetInternalField(int index);
   void* SlowGetAlignedPointerFromInternalField(int index);
 };
 
 // --- Implementation ---
 
-Local<Value> Object::GetInternalField(int index) {
+Local<Data> Object::GetInternalField(int index) {
 #ifndef V8_ENABLE_CHECKS
   using A = internal::Address;
   using I = internal::Internals;
@@ -733,14 +757,9 @@ Local<Value> Object::GetInternalField(int index) {
     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
+    auto isolate = reinterpret_cast<v8::Isolate*>(
+        internal::IsolateFromNeverReadOnlySpaceObject(obj));
+    return Local<Data>::New(isolate, value);
   }
 #endif
   return SlowGetInternalField(index);