node-linux-arm64 23.11.0 → 24.0.0

package/include/node/v8-array-buffer.h

@@ -10,13 +10,20 @@
 #include <memory>
 
 #include "v8-local-handle.h"  // NOLINT(build/include_directory)
+#include "v8-memory-span.h"   // NOLINT(build/include_directory)
 #include "v8-object.h"        // NOLINT(build/include_directory)
+#include "v8-platform.h"      // NOLINT(build/include_directory)
 #include "v8config.h"         // NOLINT(build/include_directory)
 
 namespace v8 {
 
 class SharedArrayBuffer;
 
+#if defined(V8_COMPRESS_POINTERS) && \
+    !defined(V8_COMPRESS_POINTERS_IN_SHARED_CAGE)
+class IsolateGroup;
+#endif
+
 #ifndef V8_ARRAY_BUFFER_INTERNAL_FIELD_COUNT
 // Defined using gn arg `v8_array_buffer_internal_field_count`.
 #define V8_ARRAY_BUFFER_INTERNAL_FIELD_COUNT 2
@@ -24,6 +31,7 @@ class SharedArrayBuffer;
 
 enum class ArrayBufferCreationMode { kInternalized, kExternalized };
 enum class BackingStoreInitializationMode { kZeroInitialized, kUninitialized };
+enum class BackingStoreOnFailureMode { kReturnNull, kOutOfMemory };
 
 /**
  * A wrapper around the backing store (i.e. the raw memory) of an array buffer.
@@ -83,18 +91,6 @@ class V8_EXPORT BackingStore : public v8::internal::BackingStoreBase {
    */
   void operator delete(void* ptr) { ::operator delete(ptr); }
 
-  /**
-   * Wrapper around ArrayBuffer::Allocator::Reallocate that preserves IsShared.
-   * Assumes that the backing_store was allocated by the ArrayBuffer allocator
-   * of the given isolate.
-   */
-  V8_DEPRECATED(
-      "Reallocate is unsafe, please do not use. Please allocate a new "
-      "BackingStore and copy instead.")
-  static std::unique_ptr<BackingStore> Reallocate(
-      v8::Isolate* isolate, std::unique_ptr<BackingStore> backing_store,
-      size_t byte_length);
-
   /**
    * This callback is used only if the memory block for a BackingStore cannot be
    * allocated with an ArrayBuffer::Allocator. In such cases the destructor of
@@ -172,21 +168,13 @@ class V8_EXPORT ArrayBuffer : public Object {
     virtual void Free(void* data, size_t length) = 0;
 
     /**
-     * Reallocate the memory block of size |old_length| to a memory block of
-     * size |new_length| by expanding, contracting, or copying the existing
-     * memory block. If |new_length| > |old_length|, then the new part of
-     * the memory must be initialized to zeros. Return nullptr if reallocation
-     * is not successful.
-     *
-     * The caller guarantees that the memory block was previously allocated
-     * using Allocate or AllocateUninitialized.
-     *
-     * The default implementation allocates a new block and copies data.
+     * Returns a size_t that determines the largest ArrayBuffer that can be
+     * allocated.  Override if your Allocator is more restrictive than the
+     * default.  Will only be called once, and the value returned will be
+     * cached.
+     * Should not return a value that is larger than kMaxByteLength.
      */
-    V8_DEPRECATED(
-        "Reallocate is unsafe, please do not use. Please allocate new memory "
-        "and copy instead.")
-    virtual void* Reallocate(void* data, size_t old_length, size_t new_length);
+    virtual size_t MaxAllocationSize() const { return kMaxByteLength; }
 
     /**
      * ArrayBuffer allocation mode. kNormal is a malloc/free style allocation,
@@ -195,11 +183,37 @@ class V8_EXPORT ArrayBuffer : public Object {
      */
     enum class AllocationMode { kNormal, kReservation };
 
+    /**
+     * Returns page allocator used by this Allocator instance.
+     *
+     * When the sandbox used by Allocator it is expected that this returns
+     * sandbox's page allocator.
+     * Otherwise, it should return system page allocator.
+     */
+    virtual PageAllocator* GetPageAllocator() { return nullptr; }
+
+#if defined(V8_COMPRESS_POINTERS) && \
+    !defined(V8_COMPRESS_POINTERS_IN_SHARED_CAGE)
     /**
      * Convenience allocator.
      *
      * When the sandbox is enabled, this allocator will allocate its backing
-     * memory inside the sandbox. Otherwise, it will rely on malloc/free.
+     * memory inside the sandbox that belongs to passed isolate group.
+     * Otherwise, it will rely on malloc/free.
+     *
+     * Caller takes ownership, i.e. the returned object needs to be freed using
+     * |delete allocator| once it is no longer in use.
+     */
+    static Allocator* NewDefaultAllocator(const IsolateGroup& group);
+#endif  // defined(V8_COMPRESS_POINTERS) &&
+        // !defined(V8_COMPRESS_POINTERS_IN_SHARED_CAGE)
+
+    /**
+     * Convenience allocator.
+     *
+     * When the sandbox is enabled, this allocator will allocate its backing
+     * memory inside the default global sandbox. Otherwise, it will rely on
+     * malloc/free.
      *
      * Caller takes ownership, i.e. the returned object needs to be freed using
      * |delete allocator| once it is no longer in use.
@@ -217,6 +231,18 @@ class V8_EXPORT ArrayBuffer : public Object {
    */
   size_t MaxByteLength() const;
 
+  /**
+   * Attempt to create a new ArrayBuffer. Allocate |byte_length| bytes.
+   * Allocated memory will be owned by a created ArrayBuffer and
+   * will be deallocated when it is garbage-collected,
+   * unless the object is externalized. If allocation fails, the Maybe
+   * returned will be empty.
+   */
+  static MaybeLocal<ArrayBuffer> MaybeNew(
+      Isolate* isolate, size_t byte_length,
+      BackingStoreInitializationMode initialization_mode =
+          BackingStoreInitializationMode::kZeroInitialized);
+
   /**
    * Create a new ArrayBuffer. Allocate |byte_length| bytes, which are either
    * zero-initialized or uninitialized. Allocated memory will be owned by a
@@ -246,17 +272,25 @@ class V8_EXPORT ArrayBuffer : public Object {
   /**
    * Returns a new standalone BackingStore that is allocated using the array
    * buffer allocator of the isolate. The allocation can either be zero
-   * intialized, or uninitialized. The result can be later passed to
+   * initialized, or uninitialized. The result can be later passed to
    * ArrayBuffer::New.
    *
    * If the allocator returns nullptr, then the function may cause GCs in the
-   * given isolate and re-try the allocation. If GCs do not help, then the
+   * given isolate and re-try the allocation.
+   *
+   * If GCs do not help and on_failure is kOutOfMemory, then the
    * function will crash with an out-of-memory error.
+   *
+   * Otherwise if GCs do not help (or the allocation is too large for GCs to
+   * help) and on_failure is kReturnNull, then a null result is returned.
    */
   static std::unique_ptr<BackingStore> NewBackingStore(
       Isolate* isolate, size_t byte_length,
       BackingStoreInitializationMode initialization_mode =
-          BackingStoreInitializationMode::kZeroInitialized);
+          BackingStoreInitializationMode::kZeroInitialized,
+      BackingStoreOnFailureMode on_failure =
+          BackingStoreOnFailureMode::kOutOfMemory);
+
   /**
    * Returns a new standalone BackingStore that takes over the ownership of
    * the given buffer. The destructor of the BackingStore invokes the given
@@ -354,9 +388,21 @@ class V8_EXPORT ArrayBuffer : public Object {
       V8_ARRAY_BUFFER_INTERNAL_FIELD_COUNT;
   static constexpr int kEmbedderFieldCount = kInternalFieldCount;
 
+#if V8_ENABLE_SANDBOX
+  static constexpr size_t kMaxByteLength =
+      internal::kMaxSafeBufferSizeForSandbox;
+#elif V8_HOST_ARCH_32_BIT
+  static constexpr size_t kMaxByteLength = std::numeric_limits<int>::max();
+#else
+  // The maximum safe integer (2^53 - 1).
+  static constexpr size_t kMaxByteLength =
+      static_cast<size_t>((uint64_t{1} << 53) - 1);
+#endif
+
  private:
   ArrayBuffer();
   static void CheckCast(Value* obj);
+  friend class TypedArray;
 };
 
 #ifndef V8_ARRAY_BUFFER_VIEW_INTERNAL_FIELD_COUNT
@@ -394,6 +440,16 @@ class V8_EXPORT ArrayBufferView : public Object {
    */
   size_t CopyContents(void* dest, size_t byte_length);
 
+  /**
+   * Returns the contents of the ArrayBufferView's buffer as a MemorySpan. If
+   * the contents are on the V8 heap, they get copied into `storage`. Otherwise
+   * a view into the off-heap backing store is returned. The provided storage
+   * should be at least as large as the maximum on-heap size of a TypedArray,
+   * was defined in gn with `typed_array_max_size_in_heap`. The default value is
+   * 64 bytes.
+   */
+  v8::MemorySpan<uint8_t> GetContents(v8::MemorySpan<uint8_t> storage);
+
   /**
    * Returns true if ArrayBufferView's backing ArrayBuffer has already been
    * allocated.
@@ -463,6 +519,18 @@ class V8_EXPORT SharedArrayBuffer : public Object {
       BackingStoreInitializationMode initialization_mode =
           BackingStoreInitializationMode::kZeroInitialized);
 
+  /**
+   * Create a new SharedArrayBuffer. Allocate |byte_length| bytes, which are
+   * either zero-initialized or uninitialized. Allocated memory will be owned by
+   * a created SharedArrayBuffer and will be deallocated when it is
+   * garbage-collected, unless the object is externalized.  If allocation
+   * fails, the Maybe returned will be empty.
+   */
+  static MaybeLocal<SharedArrayBuffer> MaybeNew(
+      Isolate* isolate, size_t byte_length,
+      BackingStoreInitializationMode initialization_mode =
+          BackingStoreInitializationMode::kZeroInitialized);
+
   /**
    * Create a new SharedArrayBuffer with an existing backing store.
    * The created array keeps a reference to the backing store until the array
@@ -481,17 +549,26 @@ class V8_EXPORT SharedArrayBuffer : public Object {
   /**
    * Returns a new standalone BackingStore that is allocated using the array
    * buffer allocator of the isolate. The allocation can either be zero
-   * intialized, or uninitialized. The result can be later passed to
+   * initialized, or uninitialized. The result can be later passed to
    * SharedArrayBuffer::New.
    *
    * If the allocator returns nullptr, then the function may cause GCs in the
-   * given isolate and re-try the allocation. If GCs do not help, then the
-   * function will crash with an out-of-memory error.
+   * given isolate and re-try the allocation.
+   *
+   * If on_failure is kOutOfMemory and GCs do not help, then the function will
+   * crash with an out-of-memory error.
+   *
+   * Otherwise, if on_failure is kReturnNull and GCs do not help (or the
+   * byte_length is so large that the allocation cannot succeed), then a null
+   * result is returned.
    */
   static std::unique_ptr<BackingStore> NewBackingStore(
       Isolate* isolate, size_t byte_length,
       BackingStoreInitializationMode initialization_mode =
-          BackingStoreInitializationMode::kZeroInitialized);
+          BackingStoreInitializationMode::kZeroInitialized,
+      BackingStoreOnFailureMode on_failure =
+          BackingStoreOnFailureMode::kOutOfMemory);
+
   /**
    * Returns a new standalone BackingStore that takes over the ownership of
    * the given buffer. The destructor of the BackingStore invokes the given

package/include/node/v8-callbacks.h

@@ -129,7 +129,9 @@ struct JitCodeEvent {
 enum JitCodeEventOptions {
   kJitCodeEventDefault = 0,
   // Generate callbacks for already existent code.
-  kJitCodeEventEnumExisting = 1
+  kJitCodeEventEnumExisting = 1,
+
+  kLastJitCodeEventOption = kJitCodeEventEnumExisting
 };
 
 /**
@@ -188,6 +190,9 @@ using GCCallback = void (*)(GCType type, GCCallbackFlags flags);
 
 using InterruptCallback = void (*)(Isolate* isolate, void* data);
 
+using PrintCurrentStackTraceFilterCallback =
+    bool (*)(Isolate* isolate, Local<String> script_name);
+
 /**
  * This callback is invoked when the heap size is close to the heap limit and
  * V8 is likely to abort with out-of-memory error.
@@ -254,15 +259,7 @@ using AddCrashKeyCallback = void (*)(CrashKeyId id, const std::string& value);
 using BeforeCallEnteredCallback = void (*)(Isolate*);
 using CallCompletedCallback = void (*)(Isolate*);
 
-// --- AllowCodeGenerationFromStrings callbacks ---
-
-/**
- * Callback to check if code generation from strings is allowed. See
- * Context::AllowCodeGenerationFromStrings.
- */
-using AllowCodeGenerationFromStringsCallback = bool (*)(Local<Context> context,
-                                                        Local<String> source);
-
+// --- Modify Code Generation From Strings Callback ---
 struct ModifyCodeGenerationFromStringsResult {
   // If true, proceed with the codegen algorithm. Otherwise, block it.
   bool codegen_allowed = false;
@@ -272,6 +269,20 @@ struct ModifyCodeGenerationFromStringsResult {
   MaybeLocal<String> modified_source;
 };
 
+/**
+ * Callback to check if codegen is allowed from a source object, and convert
+ * the source to string if necessary. See: ModifyCodeGenerationFromStrings.
+ */
+using ModifyCodeGenerationFromStringsCallback =
+    ModifyCodeGenerationFromStringsResult (*)(Local<Context> context,
+                                              Local<Value> source);
+using ModifyCodeGenerationFromStringsCallback2 =
+    ModifyCodeGenerationFromStringsResult (*)(Local<Context> context,
+                                              Local<Value> source,
+                                              bool is_code_like);
+
+// --- Failed Access Check Callback ---
+
 /**
  * Access type specification.
  */
@@ -283,23 +294,9 @@ enum AccessType {
   ACCESS_KEYS
 };
 
-// --- Failed Access Check Callback ---
-
 using FailedAccessCheckCallback = void (*)(Local<Object> target,
                                            AccessType type, Local<Value> data);
 
-/**
- * Callback to check if codegen is allowed from a source object, and convert
- * the source to string if necessary. See: ModifyCodeGenerationFromStrings.
- */
-using ModifyCodeGenerationFromStringsCallback =
-    ModifyCodeGenerationFromStringsResult (*)(Local<Context> context,
-                                              Local<Value> source);
-using ModifyCodeGenerationFromStringsCallback2 =
-    ModifyCodeGenerationFromStringsResult (*)(Local<Context> context,
-                                              Local<Value> source,
-                                              bool is_code_like);
-
 // --- WebAssembly compilation callbacks ---
 using ExtensionCallback = bool (*)(const FunctionCallbackInfo<Value>&);
 
@@ -377,6 +374,47 @@ using HostImportModuleDynamicallyCallback = MaybeLocal<Promise> (*)(
     Local<Value> resource_name, Local<String> specifier,
     Local<FixedArray> import_attributes);
 
+/**
+ * HostImportModuleWithPhaseDynamicallyCallback is called when we
+ * require the embedder to load a module with a specific phase. This is used
+ * as part of the dynamic import syntax.
+ *
+ * The referrer contains metadata about the script/module that calls
+ * import.
+ *
+ * The specifier is the name of the module that should be imported.
+ *
+ * The phase is the phase of the import requested.
+ *
+ * The import_attributes are import attributes for this request in the form:
+ * [key1, value1, key2, value2, ...] where the keys and values are of type
+ * v8::String. Note, unlike the FixedArray passed to ResolveModuleCallback and
+ * returned from ModuleRequest::GetImportAttributes(), this array does not
+ * contain the source Locations of the attributes.
+ *
+ * The Promise returned from this function is forwarded to userland
+ * JavaScript. The embedder must resolve this promise according to the phase
+ * requested:
+ * - For ModuleImportPhase::kSource, the promise must be resolved with a
+ *   compiled ModuleSource object, or rejected with a SyntaxError if the
+ *   module does not support source representation.
+ * - For ModuleImportPhase::kEvaluation, the promise must be resolved with a
+ *   ModuleNamespace object of a module that has been compiled, instantiated,
+ *   and evaluated.
+ *
+ * In case of an exception, the embedder must reject this promise with the
+ * exception. If the promise creation itself fails (e.g. due to stack
+ * overflow), the embedder must propagate that exception by returning an empty
+ * MaybeLocal.
+ *
+ * This callback is still experimental and is only invoked for source phase
+ * imports.
+ */
+using HostImportModuleWithPhaseDynamicallyCallback = MaybeLocal<Promise> (*)(
+    Local<Context> context, Local<Data> host_defined_options,
+    Local<Value> resource_name, Local<String> specifier,
+    ModuleImportPhase phase, Local<FixedArray> import_attributes);
+
 /**
  * Callback for requesting a compile hint for a function from the embedder. The
  * first parameter is the position of the function in source code and the second
@@ -412,6 +450,14 @@ using HostInitializeImportMetaObjectCallback = void (*)(Local<Context> context,
 using HostCreateShadowRealmContextCallback =
     MaybeLocal<Context> (*)(Local<Context> initiator_context);
 
+/**
+ * IsJSApiWrapperNativeErrorCallback is called on an JSApiWrapper object to
+ * determine if Error.isError should return true or false. For instance, in an
+ * HTML embedder, DOMExceptions return true when passed to Error.isError.
+ */
+using IsJSApiWrapperNativeErrorCallback = bool (*)(Isolate* isolate,
+                                                   Local<Object> obj);
+
 /**
  * PrepareStackTraceCallback is called when the stack property of an error is
  * first accessed. The return value will be used as the stack value. If this
@@ -452,14 +498,26 @@ using PrepareStackTraceCallback = MaybeLocal<Value> (*)(Local<Context> context,
  * with a list of regular expressions that should match the document URL
  * in order to enable ETW tracing:
  *   {
- *     "version": "1.0",
+ *     "version": "2.0",
  *     "filtered_urls": [
  *         "https:\/\/.*\.chromium\.org\/.*", "https://v8.dev/";, "..."
- *     ]
+ *     ],
+ *     "trace_interpreter_frames": true
  *  }
  */
+
 using FilterETWSessionByURLCallback =
     bool (*)(Local<Context> context, const std::string& etw_filter_payload);
+
+struct FilterETWSessionByURLResult {
+  // If true, enable ETW tracing for the current isolate.
+  bool enable_etw_tracing;
+
+  // If true, also enables ETW tracing for interpreter stack frames.
+  bool trace_interpreter_frames;
+};
+using FilterETWSessionByURL2Callback = FilterETWSessionByURLResult (*)(
+    Local<Context> context, const std::string& etw_filter_payload);
 #endif  // V8_OS_WIN
 
 }  // namespace v8

package/include/node/v8-context.h

@@ -320,7 +320,7 @@ class V8_EXPORT Context : public Data {
    * 'Function' constructor are used an exception will be thrown.
    *
    * If code generation from strings is not allowed the
-   * V8::AllowCodeGenerationFromStrings callback will be invoked if
+   * V8::ModifyCodeGenerationFromStringsCallback callback will be invoked if
    * set before blocking the call to 'eval' or the 'Function'
    * constructor. If that callback returns true, the call will be
    * allowed, otherwise an exception will be thrown. If no callback is
@@ -427,7 +427,8 @@ class V8_EXPORT Context : public Data {
 
   static void CheckCast(Data* obj);
 
-  internal::Address* GetDataFromSnapshotOnce(size_t index);
+  internal::ValueHelper::InternalRepresentationType GetDataFromSnapshotOnce(
+      size_t index);
   Local<Value> SlowGetEmbedderData(int index);
   void* SlowGetAlignedPointerFromEmbedderData(int index);
 };
@@ -497,10 +498,10 @@ void* Context::GetAlignedPointerFromEmbedderData(int index) {
 
 template <class T>
 MaybeLocal<T> Context::GetDataFromSnapshotOnce(size_t index) {
-  if (auto slot = GetDataFromSnapshotOnce(index); slot) {
-    internal::PerformCastCheck(
-        internal::ValueHelper::SlotAsValue<T, false>(slot));
-    return Local<T>::FromSlot(slot);
+  if (auto repr = GetDataFromSnapshotOnce(index);
+      repr != internal::ValueHelper::kEmpty) {
+    internal::PerformCastCheck(internal::ValueHelper::ReprAsValue<T>(repr));
+    return Local<T>::FromRepr(repr);
   }
   return {};
 }

package/include/node/v8-cppgc.h

@@ -87,6 +87,7 @@ class V8_EXPORT CppHeap {
    *
    * After this call, object allocation is prohibited.
    */
+  V8_DEPRECATED("Terminate gets automatically called in the CppHeap destructor")
   void Terminate();
 
   /**
@@ -101,7 +102,7 @@ class V8_EXPORT CppHeap {
   /**
    * Collects statistics for the given spaces and reports them to the receiver.
    *
-   * \param custom_spaces a collection of custom space indicies.
+   * \param custom_spaces a collection of custom space indices.
    * \param receiver an object that gets the results.
    */
   void CollectCustomSpaceStatisticsAtLastGC(

package/include/node/v8-data.h

@@ -27,6 +27,11 @@ class V8_EXPORT Data {
    */
   bool IsModule() const;
 
+  /**
+   * Returns true if this data is a |v8::ModuleRequest|.
+   */
+  bool IsModuleRequest() const;
+
   /**
    * Returns tru if this data is a |v8::FixedArray|
    */

package/include/node/v8-debug.h

@@ -42,6 +42,12 @@ class V8_EXPORT StackFrame {
    */
   int GetColumn() const { return GetLocation().GetColumnNumber() + 1; }
 
+  /**
+   * Returns zero based source position (character offset) for the associated
+   * function.
+   */
+  int GetSourcePosition() const;
+
   /**
    * Returns the id of the script for the function for this StackFrame.
    * This method will return Message::kNoScriptIdInfo if it is unable to
@@ -130,6 +136,11 @@ class V8_EXPORT StackTrace {
     kDetailed = kOverview | kIsEval | kIsConstructor | kScriptNameOrSourceURL
   };
 
+  /**
+   * Returns the (unique) ID of this stack trace.
+   */
+  int GetID() const;
+
   /**
    * Returns a StackFrame at a particular index.
    */

package/include/node/v8-embedder-heap.h

@@ -21,37 +21,10 @@ class Value;
  */
 class V8_EXPORT EmbedderRootsHandler {
  public:
-  enum class RootHandling {
-    kQueryEmbedderForNonDroppableReferences,
-    kDontQueryEmbedderForAnyReference,
-  };
-
   virtual ~EmbedderRootsHandler() = default;
 
   EmbedderRootsHandler() = default;
 
-  V8_DEPRECATED("Use the default constructor instead.")
-  explicit EmbedderRootsHandler(RootHandling default_traced_reference_handling)
-      : default_traced_reference_handling_(default_traced_reference_handling) {}
-
-  /**
-   * Returns true if the |TracedReference| handle should be considered as root
-   * for the currently running non-tracing garbage collection and false
-   * otherwise. The default implementation will keep all |TracedReference|
-   * references as roots.
-   *
-   * If this returns false, then V8 may decide that the object referred to by
-   * such a handle is reclaimed. In that case, V8 calls |ResetRoot()| for the
-   * |TracedReference|.
-   *
-   * Note that the `handle` is different from the handle that the embedder holds
-   * for retaining the object.
-   *
-   * The concrete implementations must be thread-safe.
-   */
-  V8_DEPRECATED("Use TracedReferenceHandling::kDroppable instead.")
-  virtual bool IsRoot(const v8::TracedReference<v8::Value>& handle) = 0;
-
   /**
    * Used in combination with |IsRoot|. Called by V8 when an
    * object that is backed by a handle is reclaimed by a non-tracing garbage
@@ -69,14 +42,10 @@ class V8_EXPORT EmbedderRootsHandler {
    * |false| is returned, |ResetRoot()| will be recalled for the same handle.
    */
   virtual bool TryResetRoot(const v8::TracedReference<v8::Value>& handle) {
-    ResetRoot(handle);
-    return true;
+    return false;
   }
 
  private:
-  const RootHandling default_traced_reference_handling_ =
-      RootHandling::kDontQueryEmbedderForAnyReference;
-
   friend class internal::TracedHandles;
 };
 

package/include/node/v8-exception.h

@@ -45,6 +45,8 @@ class V8_EXPORT Exception {
                                     Local<Value> options = {});
   static Local<Value> WasmRuntimeError(Local<String> message,
                                        Local<Value> options = {});
+  static Local<Value> WasmSuspendError(Local<String> message,
+                                       Local<Value> options = {});
   static Local<Value> Error(Local<String> message, Local<Value> options = {});
 
   /**

package/include/node/v8-function-callback.h

@@ -126,23 +126,6 @@ class FunctionCallbackInfo {
   V8_INLINE Local<Value> operator[](int i) const;
   /** Returns the receiver. This corresponds to the "this" value. */
   V8_INLINE Local<Object> This() const;
-  /**
-   * If the callback was created without a Signature, this is the same
-   * value as This(). If there is a signature, and the signature didn't match
-   * This() but one of its hidden prototypes, this will be the respective
-   * hidden prototype.
-   *
-   * Note that this is not the prototype of This() on which the accessor
-   * referencing this callback was found (which in V8 internally is often
-   * referred to as holder [sic]).
-   */
-  V8_DEPRECATED(
-      "V8 will stop providing access to hidden prototype (i.e. "
-      "JSGlobalObject). Use This() instead. \n"
-      "DO NOT try to workaround this by accessing JSGlobalObject via "
-      "v8::Object::GetPrototype() - it'll be deprecated soon too. \n"
-      "See http://crbug.com/333672197. ")
-  V8_INLINE Local<Object> Holder() const;
   /** For construct calls, this returns the "new.target" value. */
   V8_INLINE Local<Value> NewTarget() const;
   /** Indicates whether this is a regular call or a construct call. */
@@ -154,18 +137,16 @@ class FunctionCallbackInfo {
   /** The ReturnValue for the call. */
   V8_INLINE ReturnValue<T> GetReturnValue() const;
 
-  // This is a temporary replacement for Holder() added just for the purpose
-  // of testing the deprecated Holder() machinery until it's removed for real.
-  // DO NOT use it.
-  V8_INLINE Local<Object> HolderSoonToBeDeprecated() const;
-
  private:
   friend class internal::FunctionCallbackArguments;
   friend class internal::CustomArguments<FunctionCallbackInfo>;
   friend class debug::ConsoleCallArguments;
   friend void internal::PrintFunctionCallbackInfo(void*);
 
-  static constexpr int kHolderIndex = 0;
+  // TODO(ishell, http://crbug.com/326505377): in case of non-constructor
+  // call, don't pass kNewTarget and kUnused. Add IsConstructCall flag to
+  // kIsolate field.
+  static constexpr int kUnusedIndex = 0;
   static constexpr int kIsolateIndex = 1;
   static constexpr int kContextIndex = 2;
   static constexpr int kReturnValueIndex = 3;
@@ -649,16 +630,6 @@ Local<Object> FunctionCallbackInfo<T>::This() const {
   return Local<Object>::FromSlot(values_ + kThisValuesIndex);
 }
 
-template <typename T>
-Local<Object> FunctionCallbackInfo<T>::HolderSoonToBeDeprecated() const {
-  return Local<Object>::FromSlot(&implicit_args_[kHolderIndex]);
-}
-
-template <typename T>
-Local<Object> FunctionCallbackInfo<T>::Holder() const {
-  return HolderSoonToBeDeprecated();
-}
-
 template <typename T>
 Local<Value> FunctionCallbackInfo<T>::NewTarget() const {
   return Local<Value>::FromSlot(&implicit_args_[kNewTargetIndex]);

package/include/node/v8-function.h

@@ -18,6 +18,7 @@
 namespace v8 {
 
 class Context;
+class Location;
 class UnboundScript;
 
 /**
@@ -88,6 +89,12 @@ class V8_EXPORT Function : public Object {
    */
   int GetScriptColumnNumber() const;
 
+  /**
+   * Returns zero based line and column number of function body, else returns
+   * {-1, -1}.
+   */
+  Location GetScriptLocation() const;
+
   /**
    * Returns zero based start position (character offset) of function body and
    * kLineOffsetNotFound if no information available.