libv8-node 19.9.0.0-x86_64-linux → 20.12.1.0-x86_64-linux

data/vendor/v8/include/v8-function-callback.h

@@ -21,6 +21,7 @@ class Value;
 namespace internal {
 class FunctionCallbackArguments;
 class PropertyCallbackArguments;
+class Builtins;
 }  // namespace internal
 
 namespace debug {
@@ -74,6 +75,11 @@ class ReturnValue {
   V8_INLINE void SetInternal(internal::Address value) { *value_ = value; }
   V8_INLINE internal::Address GetDefaultValue();
   V8_INLINE explicit ReturnValue(internal::Address* slot);
+
+  // See FunctionCallbackInfo.
+  static constexpr int kIsolateValueIndex = -2;
+  static constexpr int kDefaultValueValueIndex = -1;
+
   internal::Address* value_;
 };
 
@@ -116,19 +122,35 @@ class FunctionCallbackInfo {
   V8_INLINE Isolate* GetIsolate() const;
   /** The ReturnValue for the call. */
   V8_INLINE ReturnValue<T> GetReturnValue() const;
-  // This shouldn't be public, but the arm compiler needs it.
-  static const int kArgsLength = 6;
 
- protected:
+ private:
   friend class internal::FunctionCallbackArguments;
   friend class internal::CustomArguments<FunctionCallbackInfo>;
   friend class debug::ConsoleCallArguments;
-  static const int kHolderIndex = 0;
-  static const int kIsolateIndex = 1;
-  static const int kReturnValueDefaultValueIndex = 2;
-  static const int kReturnValueIndex = 3;
-  static const int kDataIndex = 4;
-  static const int kNewTargetIndex = 5;
+  friend class internal::Builtins;
+  static constexpr int kHolderIndex = 0;
+  static constexpr int kIsolateIndex = 1;
+  static constexpr int kReturnValueDefaultValueIndex = 2;
+  static constexpr int kReturnValueIndex = 3;
+  static constexpr int kDataIndex = 4;
+  static constexpr int kNewTargetIndex = 5;
+
+  static constexpr int kArgsLength = 6;
+  static constexpr int kArgsLengthWithReceiver = 7;
+
+  // Codegen constants:
+  static constexpr int kSize = 3 * internal::kApiSystemPointerSize;
+  static constexpr int kImplicitArgsOffset = 0;
+  static constexpr int kValuesOffset =
+      kImplicitArgsOffset + internal::kApiSystemPointerSize;
+  static constexpr int kLengthOffset =
+      kValuesOffset + internal::kApiSystemPointerSize;
+
+  static constexpr int kThisValuesIndex = -1;
+  static_assert(ReturnValue<Value>::kDefaultValueValueIndex ==
+                kReturnValueDefaultValueIndex - kReturnValueIndex);
+  static_assert(ReturnValue<Value>::kIsolateValueIndex ==
+                kIsolateIndex - kReturnValueIndex);
 
   V8_INLINE FunctionCallbackInfo(internal::Address* implicit_args,
                                  internal::Address* values, int length);
@@ -229,22 +251,24 @@ class PropertyCallbackInfo {
    */
   V8_INLINE bool ShouldThrowOnError() const;
 
-  // This shouldn't be public, but the arm compiler needs it.
-  static const int kArgsLength = 7;
-
- protected:
+ private:
   friend class MacroAssembler;
   friend class internal::PropertyCallbackArguments;
   friend class internal::CustomArguments<PropertyCallbackInfo>;
-  static const int kShouldThrowOnErrorIndex = 0;
-  static const int kHolderIndex = 1;
-  static const int kIsolateIndex = 2;
-  static const int kReturnValueDefaultValueIndex = 3;
-  static const int kReturnValueIndex = 4;
-  static const int kDataIndex = 5;
-  static const int kThisIndex = 6;
-
-  V8_INLINE PropertyCallbackInfo(internal::Address* args) : args_(args) {}
+  static constexpr int kShouldThrowOnErrorIndex = 0;
+  static constexpr int kHolderIndex = 1;
+  static constexpr int kIsolateIndex = 2;
+  static constexpr int kReturnValueDefaultValueIndex = 3;
+  static constexpr int kReturnValueIndex = 4;
+  static constexpr int kDataIndex = 5;
+  static constexpr int kThisIndex = 6;
+
+  static constexpr int kArgsLength = 7;
+
+  static constexpr int kSize = 1 * internal::kApiSystemPointerSize;
+
+  V8_INLINE explicit PropertyCallbackInfo(internal::Address* args)
+      : args_(args) {}
   internal::Address* args_;
 };
 
@@ -285,7 +309,7 @@ void ReturnValue<T>::Set(const Local<S> handle) {
   if (V8_UNLIKELY(handle.IsEmpty())) {
     *value_ = GetDefaultValue();
   } else {
-    *value_ = *reinterpret_cast<internal::Address*>(*handle);
+    *value_ = internal::ValueHelper::ValueAsAddress(*handle);
   }
 }
 
@@ -328,41 +352,46 @@ void ReturnValue<T>::Set(bool value) {
   } else {
     root_index = I::kFalseValueRootIndex;
   }
-  *value_ = *I::GetRoot(GetIsolate(), root_index);
+  *value_ = I::GetRoot(GetIsolate(), root_index);
 }
 
 template <typename T>
 void ReturnValue<T>::SetNull() {
   static_assert(std::is_base_of<T, Primitive>::value, "type check");
   using I = internal::Internals;
-  *value_ = *I::GetRoot(GetIsolate(), I::kNullValueRootIndex);
+  *value_ = I::GetRoot(GetIsolate(), I::kNullValueRootIndex);
 }
 
 template <typename T>
 void ReturnValue<T>::SetUndefined() {
   static_assert(std::is_base_of<T, Primitive>::value, "type check");
   using I = internal::Internals;
-  *value_ = *I::GetRoot(GetIsolate(), I::kUndefinedValueRootIndex);
+  *value_ = I::GetRoot(GetIsolate(), I::kUndefinedValueRootIndex);
 }
 
 template <typename T>
 void ReturnValue<T>::SetEmptyString() {
   static_assert(std::is_base_of<T, String>::value, "type check");
   using I = internal::Internals;
-  *value_ = *I::GetRoot(GetIsolate(), I::kEmptyStringRootIndex);
+  *value_ = I::GetRoot(GetIsolate(), I::kEmptyStringRootIndex);
 }
 
 template <typename T>
 Isolate* ReturnValue<T>::GetIsolate() const {
   // Isolate is always the pointer below the default value on the stack.
-  return *reinterpret_cast<Isolate**>(&value_[-2]);
+  return *reinterpret_cast<Isolate**>(&value_[kIsolateValueIndex]);
 }
 
 template <typename T>
 Local<Value> ReturnValue<T>::Get() const {
   using I = internal::Internals;
-  if (*value_ == *I::GetRoot(GetIsolate(), I::kTheHoleValueRootIndex))
-    return Local<Value>(*Undefined(GetIsolate()));
+#if V8_STATIC_ROOTS_BOOL
+  if (I::is_identical(*value_, I::StaticReadOnlyRoot::kTheHoleValue)) {
+#else
+  if (*value_ == I::GetRoot(GetIsolate(), I::kTheHoleValueRootIndex)) {
+#endif
+    return Undefined(GetIsolate());
+  }
   return Local<Value>::New(GetIsolate(), reinterpret_cast<Value*>(value_));
 }
 
@@ -375,7 +404,7 @@ void ReturnValue<T>::Set(S* whatever) {
 template <typename T>
 internal::Address ReturnValue<T>::GetDefaultValue() {
   // Default value is always the pointer below value_ on the stack.
-  return value_[-1];
+  return value_[kDefaultValueValueIndex];
 }
 
 template <typename T>
@@ -387,31 +416,29 @@ FunctionCallbackInfo<T>::FunctionCallbackInfo(internal::Address* implicit_args,
 template <typename T>
 Local<Value> FunctionCallbackInfo<T>::operator[](int i) const {
   // values_ points to the first argument (not the receiver).
-  if (i < 0 || length_ <= i) return Local<Value>(*Undefined(GetIsolate()));
-  return Local<Value>(reinterpret_cast<Value*>(values_ + i));
+  if (i < 0 || length_ <= i) return Undefined(GetIsolate());
+  return Local<Value>::FromSlot(values_ + i);
 }
 
 template <typename T>
 Local<Object> FunctionCallbackInfo<T>::This() const {
   // values_ points to the first argument (not the receiver).
-  return Local<Object>(reinterpret_cast<Object*>(values_ - 1));
+  return Local<Object>::FromSlot(values_ + kThisValuesIndex);
 }
 
 template <typename T>
 Local<Object> FunctionCallbackInfo<T>::Holder() const {
-  return Local<Object>(
-      reinterpret_cast<Object*>(&implicit_args_[kHolderIndex]));
+  return Local<Object>::FromSlot(&implicit_args_[kHolderIndex]);
 }
 
 template <typename T>
 Local<Value> FunctionCallbackInfo<T>::NewTarget() const {
-  return Local<Value>(
-      reinterpret_cast<Value*>(&implicit_args_[kNewTargetIndex]));
+  return Local<Value>::FromSlot(&implicit_args_[kNewTargetIndex]);
 }
 
 template <typename T>
 Local<Value> FunctionCallbackInfo<T>::Data() const {
-  return Local<Value>(reinterpret_cast<Value*>(&implicit_args_[kDataIndex]));
+  return Local<Value>::FromSlot(&implicit_args_[kDataIndex]);
 }
 
 template <typename T>
@@ -441,17 +468,17 @@ Isolate* PropertyCallbackInfo<T>::GetIsolate() const {
 
 template <typename T>
 Local<Value> PropertyCallbackInfo<T>::Data() const {
-  return Local<Value>(reinterpret_cast<Value*>(&args_[kDataIndex]));
+  return Local<Value>::FromSlot(&args_[kDataIndex]);
 }
 
 template <typename T>
 Local<Object> PropertyCallbackInfo<T>::This() const {
-  return Local<Object>(reinterpret_cast<Object*>(&args_[kThisIndex]));
+  return Local<Object>::FromSlot(&args_[kThisIndex]);
 }
 
 template <typename T>
 Local<Object> PropertyCallbackInfo<T>::Holder() const {
-  return Local<Object>(reinterpret_cast<Object*>(&args_[kHolderIndex]));
+  return Local<Object>::FromSlot(&args_[kHolderIndex]);
 }
 
 template <typename T>

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

@@ -59,6 +59,7 @@ class V8_EXPORT Function : public Object {
   void SetName(Local<String> name);
   Local<Value> GetName() const;
 
+  V8_DEPRECATED("No direct replacement")
   MaybeLocal<UnboundScript> GetUnboundScript() const;
 
   /**

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

@@ -32,19 +32,19 @@ namespace Debugger {
 namespace API {
 class SearchMatch;
 }
-}
+}  // namespace Debugger
 namespace Runtime {
 namespace API {
 class RemoteObject;
 class StackTrace;
 class StackTraceId;
-}
-}
+}  // namespace API
+}  // namespace Runtime
 namespace Schema {
 namespace API {
 class Domain;
 }
-}
+}  // namespace Schema
 }  // namespace protocol
 
 class V8_EXPORT StringView {
@@ -134,6 +134,13 @@ class V8_EXPORT V8DebuggerId {
   int64_t m_second = 0;
 };
 
+struct V8_EXPORT V8StackFrame {
+  StringView sourceURL;
+  StringView functionName;
+  int lineNumber;
+  int columnNumber;
+};
+
 class V8_EXPORT V8StackTrace {
  public:
   virtual StringView firstNonEmptySourceURL() const = 0;
@@ -151,6 +158,8 @@ class V8_EXPORT V8StackTrace {
 
   // Safe to pass between threads, drops async chain.
   virtual std::unique_ptr<V8StackTrace> clone() = 0;
+
+  virtual std::vector<V8StackFrame> frames() const = 0;
 };
 
 class V8_EXPORT V8InspectorSession {
@@ -203,6 +212,9 @@ class V8_EXPORT V8InspectorSession {
                             std::unique_ptr<StringBuffer>* objectGroup) = 0;
   virtual void releaseObjectGroup(StringView) = 0;
   virtual void triggerPreciseCoverageDeltaUpdate(StringView occasion) = 0;
+
+  // Prepare for shutdown (disables debugger pausing, etc.).
+  virtual void stop() = 0;
 };
 
 class V8_EXPORT WebDriverValue {
@@ -365,9 +377,12 @@ class V8_EXPORT V8Inspector {
     virtual void flushProtocolNotifications() = 0;
   };
   enum ClientTrustLevel { kUntrusted, kFullyTrusted };
+  enum SessionPauseState { kWaitingForDebugger, kNotWaitingForDebugger };
+  // TODO(chromium:1352175): remove default value once downstream change lands.
   virtual std::unique_ptr<V8InspectorSession> connect(
       int contextGroupId, Channel*, StringView state,
-      ClientTrustLevel client_trust_level) {
+      ClientTrustLevel client_trust_level,
+      SessionPauseState = kNotWaitingForDebugger) {
     return nullptr;
   }