node-linux-arm64 23.11.0 → 24.0.0

package/include/node/v8-version.h

@@ -8,10 +8,10 @@
 // These macros define the version number for the current version.
 // NOTE these macros are used by some of the tool scripts and the build
 // system so their names cannot be changed without changing the scripts.
-#define V8_MAJOR_VERSION 12
-#define V8_MINOR_VERSION 9
-#define V8_BUILD_NUMBER 202
-#define V8_PATCH_LEVEL 28
+#define V8_MAJOR_VERSION 13
+#define V8_MINOR_VERSION 6
+#define V8_BUILD_NUMBER 233
+#define V8_PATCH_LEVEL 8
 
 // Use 1 for candidates and 0 otherwise.
 // (Boolean macro values are not supported by all preprocessors.)

package/include/node/v8-wasm.h

@@ -199,6 +199,30 @@ class V8_EXPORT WasmStreaming final {
   std::unique_ptr<WasmStreamingImpl> impl_;
 };
 
+/**
+ * The V8 interface for a WebAssembly memory map descriptor. This is an
+ * experimental feature that may change and be removed without further
+ * communication.
+ */
+class V8_EXPORT WasmMemoryMapDescriptor : public Object {
+ public:
+  WasmMemoryMapDescriptor() = delete;
+
+  V8_INLINE static WasmMemoryMapDescriptor* Cast(Value* value) {
+#ifdef V8_ENABLE_CHECKS
+    CheckCast(value);
+#endif
+    return static_cast<WasmMemoryMapDescriptor*>(value);
+  }
+
+  using WasmFileDescriptor = int32_t;
+
+  static Local<WasmMemoryMapDescriptor> New(Isolate* isolate,
+                                            WasmFileDescriptor fd);
+
+ private:
+  static void CheckCast(Value* object);
+};
 }  // namespace v8
 
 #endif  // INCLUDE_V8_WASM_H_

package/include/node/v8-weak-callback-info.h

@@ -5,6 +5,9 @@
 #ifndef INCLUDE_V8_WEAK_CALLBACK_INFO_H_
 #define INCLUDE_V8_WEAK_CALLBACK_INFO_H_
 
+#include <cstring>
+
+#include "cppgc/internal/conditional-stack-allocated.h"  // NOLINT(build/include_directory)
 #include "v8config.h"  // NOLINT(build/include_directory)
 
 namespace v8 {
@@ -15,11 +18,12 @@ namespace api_internal {
 V8_EXPORT void InternalFieldOutOfBounds(int index);
 }  // namespace api_internal
 
-static const int kInternalFieldsInWeakCallback = 2;
-static const int kEmbedderFieldsInWeakCallback = 2;
+static constexpr int kInternalFieldsInWeakCallback = 2;
+static constexpr int kEmbedderFieldsInWeakCallback = 2;
 
 template <typename T>
-class WeakCallbackInfo {
+class WeakCallbackInfo
+    : public cppgc::internal::ConditionalStackAllocatedBase<T> {
  public:
   using Callback = void (*)(const WeakCallbackInfo<T>& data);
 
@@ -27,21 +31,25 @@ class WeakCallbackInfo {
                    void* embedder_fields[kEmbedderFieldsInWeakCallback],
                    Callback* callback)
       : isolate_(isolate), parameter_(parameter), callback_(callback) {
-    for (int i = 0; i < kEmbedderFieldsInWeakCallback; ++i) {
-      embedder_fields_[i] = embedder_fields[i];
-    }
+    memcpy(embedder_fields_, embedder_fields,
+           sizeof(embedder_fields[0]) * kEmbedderFieldsInWeakCallback);
   }
 
   V8_INLINE Isolate* GetIsolate() const { return isolate_; }
   V8_INLINE T* GetParameter() const { return parameter_; }
   V8_INLINE void* GetInternalField(int index) const;
 
-  // When first called, the embedder MUST Reset() the Global which triggered the
-  // callback. The Global itself is unusable for anything else. No v8 other api
-  // calls may be called in the first callback. Should additional work be
-  // required, the embedder must set a second pass callback, which will be
-  // called after all the initial callbacks are processed.
-  // Calling SetSecondPassCallback on the second pass will immediately crash.
+  /**
+   * When a weak callback is first invoked the embedders _must_ Reset() the
+   * handle which triggered the callback. The handle itself is unusable for
+   * anything else. No other V8 API calls may be called in the first callback.
+   * Additional work requires scheduling a second invocation via
+   * `SetSecondPassCallback()` which will be called some time after all the
+   * initial callbacks are processed.
+   *
+   * The second pass callback is prohibited from executing JavaScript. Embedders
+   * should schedule another callback in case this is required.
+   */
   void SetSecondPassCallback(Callback callback) const { *callback_ = callback; }
 
  private:

package/include/node/v8.h

@@ -2,6 +2,9 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#ifndef INCLUDE_V8_H_
+#define INCLUDE_V8_H_
+
 /** \mainpage V8 API Reference Guide
  *
  * V8 is Google's open source JavaScript engine.
@@ -12,9 +15,6 @@
  * For other documentation see https://v8.dev/.
  */
 
-#ifndef INCLUDE_V8_H_
-#define INCLUDE_V8_H_
-
 #include <stddef.h>
 #include <stdint.h>
 

package/include/node/v8config.h

@@ -371,6 +371,7 @@ path. Add it with -I<path> to the command line
 # define V8_HAS_ATTRIBUTE_UNUSED (__has_attribute(unused))
 # define V8_HAS_ATTRIBUTE_USED (__has_attribute(used))
 # define V8_HAS_ATTRIBUTE_RETAIN (__has_attribute(retain))
+# define V8_HAS_ATTRIBUTE_OPTNONE (__has_attribute(optnone))
 // Support for the "preserve_most" attribute is limited:
 // - 32-bit platforms do not implement it,
 // - component builds fail because _dl_runtime_resolve clobbers registers,
@@ -499,6 +500,16 @@ path. Add it with -I<path> to the command line
 # define V8_INLINE inline
 #endif
 
+// A macro to force better inlining of calls in a statement. Don't bother for
+// debug builds.
+// Use like:
+//   V8_INLINE_STATEMENT foo = bar(); // Will force inlining the bar() call.
+#if !defined(DEBUG) && defined(__clang__) && V8_HAS_ATTRIBUTE_ALWAYS_INLINE
+# define V8_INLINE_STATEMENT [[clang::always_inline]]
+#else
+# define V8_INLINE_STATEMENT
+#endif
+
 #if V8_HAS_BUILTIN_ASSUME
 #ifdef DEBUG
 // In debug mode, check assumptions in addition to adding annotations.
@@ -681,7 +692,7 @@ path. Add it with -I<path> to the command line
 //   V8_NODISCARD Foo() { ... };
 // [[nodiscard]] comes in C++17 but supported in clang with -std >= c++11.
 #if V8_HAS_CPP_ATTRIBUTE_NODISCARD
-#define V8_NODISCARD
+#define V8_NODISCARD [[nodiscard]]
 #else
 #define V8_NODISCARD /* NOT SUPPORTED */
 #endif
@@ -787,15 +798,11 @@ V8 shared library set USING_V8_SHARED.
 #else  // V8_OS_WIN
 
 // Setup for Linux shared library export.
-#if V8_HAS_ATTRIBUTE_VISIBILITY
-# ifdef BUILDING_V8_SHARED
-#  define V8_EXPORT __attribute__ ((visibility("default")))
-# else
-#  define V8_EXPORT
-# endif
+#if V8_HAS_ATTRIBUTE_VISIBILITY && (defined(BUILDING_V8_SHARED) || USING_V8_SHARED)
+# define V8_EXPORT __attribute__((visibility("default")))
 #else
 # define V8_EXPORT
-#endif
+# endif  // V8_HAS_ATTRIBUTE_VISIBILITY && ...
 
 #endif  // V8_OS_WIN
 
@@ -833,16 +840,9 @@ V8 shared library set USING_V8_SHARED.
 #elif defined(__PPC64__) || defined(_ARCH_PPC64)
 #define V8_HOST_ARCH_PPC64 1
 #define V8_HOST_ARCH_64_BIT 1
-#elif defined(__PPC__) || defined(_ARCH_PPC)
-#define V8_HOST_ARCH_PPC 1
-#define V8_HOST_ARCH_32_BIT 1
-#elif defined(__s390__) || defined(__s390x__)
-#define V8_HOST_ARCH_S390 1
-#if defined(__s390x__)
+#elif defined(__s390x__)
+#define V8_HOST_ARCH_S390X 1
 #define V8_HOST_ARCH_64_BIT 1
-#else
-#define V8_HOST_ARCH_32_BIT 1
-#endif
 #elif defined(__riscv) || defined(__riscv__)
 #if __riscv_xlen == 64
 #define V8_HOST_ARCH_RISCV64 1
@@ -862,10 +862,10 @@ V8 shared library set USING_V8_SHARED.
 // The macros may be set externally. If not, detect in the same way as the host
 // architecture, that is, target the native environment as presented by the
 // compiler.
-#if !V8_TARGET_ARCH_X64 && !V8_TARGET_ARCH_IA32 && !V8_TARGET_ARCH_ARM &&     \
-    !V8_TARGET_ARCH_ARM64 && !V8_TARGET_ARCH_MIPS64 && !V8_TARGET_ARCH_PPC && \
-    !V8_TARGET_ARCH_PPC64 && !V8_TARGET_ARCH_S390 &&                          \
-    !V8_TARGET_ARCH_RISCV64 && !V8_TARGET_ARCH_LOONG64 &&                     \
+#if !V8_TARGET_ARCH_X64 && !V8_TARGET_ARCH_IA32 && !V8_TARGET_ARCH_ARM && \
+    !V8_TARGET_ARCH_ARM64 && !V8_TARGET_ARCH_MIPS64 &&                    \
+    !V8_TARGET_ARCH_PPC64 && !V8_TARGET_ARCH_S390X &&                     \
+    !V8_TARGET_ARCH_RISCV64 && !V8_TARGET_ARCH_LOONG64 &&                 \
     !V8_TARGET_ARCH_RISCV32
 #if defined(_M_X64) || defined(__x86_64__)
 #define V8_TARGET_ARCH_X64 1
@@ -881,13 +881,8 @@ V8 shared library set USING_V8_SHARED.
 #define V8_TARGET_ARCH_LOONG64 1
 #elif defined(_ARCH_PPC64)
 #define V8_TARGET_ARCH_PPC64 1
-#elif defined(_ARCH_PPC)
-#define V8_TARGET_ARCH_PPC 1
-#elif defined(__s390__)
-#define V8_TARGET_ARCH_S390 1
-#if defined(__s390x__)
+#elif defined(__s390x__)
 #define V8_TARGET_ARCH_S390X 1
-#endif
 #elif defined(__riscv) || defined(__riscv__)
 #if __riscv_xlen == 64
 #define V8_TARGET_ARCH_RISCV64 1
@@ -920,16 +915,10 @@ V8 shared library set USING_V8_SHARED.
 #define V8_TARGET_ARCH_64_BIT 1
 #elif V8_TARGET_ARCH_LOONG64
 #define V8_TARGET_ARCH_64_BIT 1
-#elif V8_TARGET_ARCH_PPC
-#define V8_TARGET_ARCH_32_BIT 1
 #elif V8_TARGET_ARCH_PPC64
 #define V8_TARGET_ARCH_64_BIT 1
-#elif V8_TARGET_ARCH_S390
-#if V8_TARGET_ARCH_S390X
+#elif V8_TARGET_ARCH_S390X
 #define V8_TARGET_ARCH_64_BIT 1
-#else
-#define V8_TARGET_ARCH_32_BIT 1
-#endif
 #elif V8_TARGET_ARCH_RISCV64
 #define V8_TARGET_ARCH_64_BIT 1
 #elif V8_TARGET_ARCH_RISCV32
@@ -986,14 +975,14 @@ V8 shared library set USING_V8_SHARED.
 #else
 #define V8_TARGET_LITTLE_ENDIAN 1
 #endif
-#elif defined(__BIG_ENDIAN__)  // FOR PPCGR on AIX
+#elif V8_TARGET_ARCH_PPC64
+#if V8_OS_AIX
 #define V8_TARGET_BIG_ENDIAN 1
-#elif V8_TARGET_ARCH_PPC_LE
+#else
 #define V8_TARGET_LITTLE_ENDIAN 1
-#elif V8_TARGET_ARCH_PPC_BE
-#define V8_TARGET_BIG_ENDIAN 1
-#elif V8_TARGET_ARCH_S390
-#if V8_TARGET_ARCH_S390_LE_SIM
+#endif
+#elif V8_TARGET_ARCH_S390X
+#if V8_TARGET_ARCH_S390X_LE_SIM
 #define V8_TARGET_LITTLE_ENDIAN 1
 #else
 #define V8_TARGET_BIG_ENDIAN 1
@@ -1017,5 +1006,10 @@ V8 shared library set USING_V8_SHARED.
 #else
 #define V8_STATIC_ROOTS_BOOL true
 #endif
+#ifdef V8_TARGET_BIG_ENDIAN
+#define V8_TARGET_BIG_ENDIAN_BOOL true
+#else
+#define V8_TARGET_BIG_ENDIAN_BOOL false
+#endif
 
 #endif  // V8CONFIG_H_

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-linux-arm64",
-  "version": "v23.11.0",
+  "version": "v24.0.0",
   "description": "node",
   "bin": {
     "node": "bin/node"

package/share/doc/node/gdbinit

@@ -81,9 +81,12 @@ class PrintV8InternalHandleCommand(PrintV8HandleCommand):
     # Indirect handles contain a location_.
     if gdb.types.has_field(value.type, "location_"):
       return self.print_indirect(value["location_"], from_tty)
-    # Direct handles contain a obj_.
+    # With v8_enable_direct_handle=true, direct handles contain a obj_.
     if gdb.types.has_field(value.type, "obj_"):
       return self.print_direct(value["obj_"], from_tty)
+    # Without v8_enable_direct_handle=true, direct handles contain a handle_.
+    if gdb.types.has_field(value.type, "handle_"):
+      return self.print_handle(value["handle_"], from_tty)
     # We don't know how to print this...
     return False
 
@@ -108,12 +111,21 @@ Print a v8 Code object from an internal code address
 Usage: jco pc
 end
 
+# Print JSDispatchEntry object in the JSDispatchTable with the given dispatch handle
+define jdh
+  call (void) _v8_internal_Print_Dispatch_Handle((uint32_t)($arg0))
+end
+document jdh
+Print JSDispatchEntry object in the JSDispatchTable with the given dispatch handle
+Usage: jdh dispatch_handle
+end
+
 # Print Code objects assembly code surrounding given PC.
 define jca
   if $argc == 0
     call (void) _v8_internal_Print_OnlyCode((void*)($pc), 30)
   else
-    if $argc == 0
+    if $argc == 1
       call (void) _v8_internal_Print_OnlyCode((void*)($arg0), 30)
     else
       call (void) _v8_internal_Print_OnlyCode((void*)($arg0), (size_t)($arg1))
@@ -282,7 +294,7 @@ except gdb.error:
 end
 
 # Configuring ASLR may not be possible on some platforms, such running via the
-# `rr` debuggger.
+# `rr` debugger.
 python
 try:
   gdb.execute("set disable-randomization off")
@@ -309,15 +321,26 @@ def v8_stop_handler(event):
     # walk if we see this frame.
     if frame.type() == gdb.DUMMY_FRAME: break
 
-    if frame.name() == 'V8_Dcheck':
-      frame_message = gdb.lookup_symbol('message', frame.block())[0]
-      if frame_message:
-        message = frame_message.value(frame).string()
+    frame_name = frame.name()
+    if frame_name is None:
+      frame = frame.older()
+      continue
+    if frame_name == 'V8_Dcheck' or frame_name.endswith('::DefaultDcheckHandler'):
+      try:
+        frame_message = gdb.lookup_symbol('message', frame.block())[0]
+        if frame_message:
+          message = frame_message.value(frame).string()
+      except:
+        pass
       select_frame = frame.older()
-      break
-    if frame.name() is not None and frame.name().startswith('V8_Fatal'):
-      select_frame = frame.older()
-    if frame.name() == 'v8::base::OS::DebugBreak':
+    if any([
+        frame_name.startswith('V8_Fatal'),
+        frame_name == 'v8::base::OS::DebugBreak',
+        frame_name == '__GI_abort',
+        frame_name == '__GI_raise',
+        frame_name == 'v8::base::OS::Abort',
+        frame_name == 'v8::Utils::ApiCheck',
+      ]):
       select_frame = frame.older()
     frame = frame.older()
 
@@ -325,7 +348,7 @@ def v8_stop_handler(event):
     select_frame.select()
     gdb.execute('frame')
     if message:
-      print('DCHECK error: {}'.format(message))
+      print('==> DCHECK error: {}'.format(message))
 
 gdb.events.stop.connect(v8_stop_handler)
 end
@@ -384,24 +407,6 @@ end
 
 ### CppGC helpers.
 
-# Print compressed pointer.
-define cpcp
-call _cppgc_internal_Decompress_Compressed_Pointer((unsigned)($arg0))
-end
-document cpcp
-Prints compressed pointer (raw value) after decompression.
-Usage: cpcp compressed_pointer
-end
-
-# Print member.
-define cpm
-call _cppgc_internal_Print_Member((cppgc::internal::MemberBase*)(&$arg0))
-end
-document cpm
-Prints member, compressed or not.
-Usage: cpm member
-end
-
 # Pretty printer for cppgc::Member.
 python
 
@@ -450,5 +455,64 @@ def cppgc_pretty_printers(val):
 
 
 gdb.pretty_printers.append(cppgc_pretty_printers)
+class TaggedPrintCommand(gdb.Command):
+    """
+    The equivalent of the print command that deals with tagged objects
+
+    Usage: tp <expression>
+    Example: tp Isolate::Current()->context()->get(3)
+    """
+
+    def __init__(self):
+        super(TaggedPrintCommand, self).__init__("tp", gdb.COMMAND_DATA, gdb.COMPLETE_EXPRESSION)
+
+    def invoke(self, arg, from_tty):
+        """Called when the 'tp' command is invoked."""
+        try:
+            # Split the expression by '->' to handle chained calls.
+            parts = arg.split("->")
+            if not parts:
+                print("Error: No expression provided.")
+                return
+
+            if len(parts) == 1:
+              gdb.execute(f"print {parts[0]}")
+            else:
+              current_val = gdb.parse_and_eval(parts[0])
+              for part in parts[1:-1]:
+                  current_val = self._evaluate_part(current_val, part, False)
+                  if current_val is None:  # Early exit if an evaluation fails.
+                      return
+
+              self._evaluate_part(current_val, parts[-1], True)
+
+        except gdb.error as e:
+            print(f"Error: {e}")
+
+    def _evaluate_part(self, current_val, part, last):
+        """Evaluates a single part of the expression (method call or member access)."""
+
+        storage = None
+        target = f"(({current_val.type}){current_val})"
+
+        type = current_val.type
+        if type.tag and type.tag.startswith("v8::internal::Tagged<"):
+          storage = gdb.parse_and_eval(f"malloc({type.sizeof})").cast(type.pointer())
+          command = f"(({storage.type}){storage})->ptr_ = {current_val['ptr_']}"
+          gdb.parse_and_eval(command)
+          target = f"(({storage.type}){storage})->ToRawPtr()"
+
+        # Check for a method call (ends with parentheses).
+        command = f"{target}->{part}"
+        result = None
+        if last:
+          gdb.execute(f"print {command}")
+        else:
+          result = gdb.parse_and_eval(command)
+        if storage:
+          gdb.parse_and_eval(f"free({storage})")
+        return result
+
+TaggedPrintCommand()
 
 end

package/share/doc/node/lldb_commands.py

@@ -10,6 +10,7 @@ from __future__ import print_function
 
 import os
 import re
+import shlex
 
 import lldb
 
@@ -42,12 +43,27 @@ def no_arg_cmd(debugger, cmd, print_error=True):
   return (is_success, result, cmd)
 
 
-def ptr_arg_cmd(debugger, name, param, cmd, print_error=True):
+def ptr_arg_cmd(debugger, name, param, cmd, fields=[], print_error=True):
   if not param:
     print("'{}' requires an argument".format(name))
     return (False, None, "")
-  param = '(void*)({})'.format(param)
-  return no_arg_cmd(debugger, cmd.format(param), print_error)
+  value = current_frame(debugger).EvaluateExpression(param)
+  error = value.GetError()
+  if error.fail:
+    print("Error evaluating {}\n{}".format(param, error))
+    return (False, error, "")
+  # Proceed, ignoring visualizers if they are enabled.
+  value = value.GetNonSyntheticValue()
+  # Process interesting fields, if this is a structure.
+  while True:
+    for f in fields:
+      field = value.GetValueForExpressionPath(f)
+      if field.IsValid():
+        value = field
+        break
+    else:
+      break
+  return no_arg_cmd(debugger, cmd.format(value.GetValue()), print_error)
 
 
 def print_handle(debugger, command_name, param, print_func):
@@ -66,12 +82,12 @@ def print_handle(debugger, command_name, param, print_func):
 
 def print_direct(debugger, command_name, value):
   CMD = "_v8_internal_Print_Object((v8::internal::Address*)({}))"
-  return ptr_arg_cmd(debugger, command_name, value, CMD.format(value))
+  return no_arg_cmd(debugger, CMD.format(value))
 
 
 def print_indirect(debugger, command_name, value):
-  CMD = "_v8_internal_Print_Object(*(v8::internal::Object**)({}))"
-  return ptr_arg_cmd(debugger, command_name, value, CMD.format(value))
+  CMD = "_v8_internal_Print_Object(*(v8::internal::Address**)({}))"
+  return no_arg_cmd(debugger, CMD.format(value))
 
 
 V8_LLDB_COMMANDS = []
@@ -89,7 +105,9 @@ def lldbCommand(fn):
 @lldbCommand
 def job(debugger, param, *args):
   """Print a v8 heap object"""
-  ptr_arg_cmd(debugger, 'job', param, "_v8_internal_Print_Object({})")
+  CMD = "_v8_internal_Print_Object((void*)({}))"
+  # Allow for Tagged<T>, containing a ptr_.
+  ptr_arg_cmd(debugger, 'job', param, CMD, [".ptr_"])
 
 
 @lldbCommand
@@ -101,10 +119,14 @@ def jh(debugger, param, *args):
     field = value.GetValueForExpressionPath(".location_")
     if field.IsValid():
       return print_indirect(debugger, 'jh', field.value)
-    # Direct handles contain a obj_.
+    # With v8_enable_direct_handle=true, direct handles contain a obj_.
     field = value.GetValueForExpressionPath(".obj_")
     if field.IsValid():
-      return print_indirect(debugger, 'jh', field.value)
+      return print_direct(debugger, 'jh', field.value)
+    # Without v8_enable_direct_handle=true, direct handles contain a handle_.
+    field = value.GetValueForExpressionPath(".handle_")
+    if field.IsValid():
+      return print_func(field)
     # We don't know how to print this...
     return (False, None, "")
 
@@ -147,15 +169,47 @@ def jl(debugger, param, *args):
 @lldbCommand
 def jco(debugger, param, *args):
   """Print the code object at the given pc (default: current pc)"""
+  CMD = "_v8_internal_Print_Code((void*)({}))"
   if not param:
     param = str(current_frame(debugger).FindRegister("pc").value)
-  ptr_arg_cmd(debugger, 'jco', param, "_v8_internal_Print_Code({})")
+  no_arg_cmd(debugger, CMD.format(param))
+
+
+@lldbCommand
+def jdh(debugger, param, *args):
+  """Print JSDispatchEntry object in the JSDispatchTable with the given dispatch handle"""
+  CMD = "_v8_internal_Print_Dispatch_Handle((uint32_t)({}))"
+  # Allow for JSDispatchHandle, containing a value_.
+  ptr_arg_cmd(debugger, 'jdh', param, CMD, [".value_"])
+
+
+@lldbCommand
+def jca(debugger, param, *args):
+  """Print a v8 Code object assembly code from an internal code address"""
+  param = shlex.split(param)
+  if not param:
+    obj = str(current_frame(debugger).FindRegister("pc").value)
+  else:
+    obj = param[0]
+  range_limit = param[1] if len(param) > 1 else 30
+  CMD = "_v8_internal_Print_OnlyCode((void*)({}), (size_t)({}))"
+  no_arg_cmd(debugger, CMD.format(obj, range_limit))
 
 
 @lldbCommand
 def jtt(debugger, param, *args):
-  """Print the transition tree of a v8 Map"""
-  ptr_arg_cmd(debugger, 'jtt', param, "_v8_internal_Print_TransitionTree({})")
+  """Print the complete transition tree starting at the given v8 map"""
+  CMD = "_v8_internal_Print_TransitionTree((void*)({}), false)"
+  # Allow for Tagged<T>, containing a ptr_.
+  ptr_arg_cmd(debugger, 'jtt', param, CMD, [".ptr_"])
+
+
+@lldbCommand
+def jttr(debugger, param, *args):
+  """Print the complete transition tree starting at the root map of the given v8 map"""
+  CMD = "_v8_internal_Print_TransitionTree((void*)({}), true)"
+  # Allow for Tagged<T>, containing a ptr_.
+  ptr_arg_cmd(debugger, 'jttr', param, CMD, [".ptr_"])
 
 
 @lldbCommand
@@ -164,6 +218,14 @@ def jst(debugger, *args):
   no_arg_cmd(debugger, "_v8_internal_Print_StackTrace()")
 
 
+@lldbCommand
+def pn(debugger, param, *args):
+  """Print a v8 TurboFan graph node"""
+  CMD = "_v8_internal_Node_Print((void*)({}))"
+  # Allow for Tagged<T>, containing a ptr_.
+  ptr_arg_cmd(debugger, 'pn', param, CMD, [".ptr_"])
+
+
 @lldbCommand
 def jss(debugger, *args):
   """Skip the jitted stack on x64 to where we entered JS last"""
@@ -180,6 +242,37 @@ def jss(debugger, *args):
   pc.value = js_entry_sp + sizeof_void
 
 
+@lldbCommand
+def jfci(debugger, param, *args):
+  """Print v8::FunctionCallbackInfo<T>& info"""
+  CMD = "_v8_internal_Print_FunctionCallbackInfo((void*)(&{}))"
+  if not param:
+    print("'jfci' requires an argument")
+  else:
+    no_arg_cmd(debugger, CMD.format(param))
+
+
+@lldbCommand
+def jpci(debugger, param, *args):
+  """Print v8::PropertyCallbackInfo<T>& info"""
+  CMD = "_v8_internal_Print_PropertyCallbackInfo((void*)(&{}))"
+  if not param:
+    print("'jpci' requires an argument")
+  else:
+    no_arg_cmd(debugger, CMD.format(param))
+
+
+# Print whether the object is marked, the mark-bit cell and index. The address
+# of the cell is handy for reverse debugging to check when the object was
+# marked/unmarked.
+@lldbCommand
+def jomb(debugger, param, *args):
+  """Print whether the object is marked, the markbit cell and index"""
+  CMD = "_v8_internal_Print_Object_MarkBit((void*)({}))"
+  # Allow for Tagged<T>, containing a ptr_.
+  ptr_arg_cmd(debugger, 'jomb', param, CMD, [".ptr_"])
+
+
 @lldbCommand
 def bta(debugger, *args):
   """Print stack trace with assertion scopes"""
@@ -194,7 +287,7 @@ def bta(debugger, *args):
     functionName = func_name_re.match(functionSignature)
     line = frame.GetLineEntry().GetLine()
     sourceFile = frame.GetLineEntry().GetFileSpec().GetFilename()
-    if line:
+    if sourceFile and line:
       sourceFile = sourceFile + ":" + str(line)
 
     if sourceFile is None:
@@ -213,6 +306,7 @@ def bta(debugger, *args):
       print("%s -> %s %s (%s)\033[0m" % (
           color, prefix, match.group(2), match.group(1)))
 
+
 def setup_source_map_for_relative_paths(debugger):
   # Copied from Chromium's tools/lldb/lldbinit.py.
   # When relative paths are used for debug symbols, lldb cannot find source

package/share/man/man1/node.1

@@ -464,6 +464,9 @@ Require a minimum threshold for line coverage (0 - 100).
 Configures the test runner to exit the process once all known tests have
 finished executing even if the event loop would otherwise remain active.
 .
+.It Fl -test-global-setup
+Specifies a module containing global setup and teardown functions for the test runner.
+.
 .It Fl -test-isolation Ns = Ns Ar mode
 Configures the type of test isolation used in the test runner.
 .
@@ -616,7 +619,7 @@ If set to 0 then V8 will choose an appropriate size of the thread pool based on
 If the value provided is larger than V8's maximum, then the largest value will be chosen.
 .
 .It Fl -zero-fill-buffers
-Automatically zero-fills all newly allocated Buffer and SlowBuffer instances.
+Automatically zero-fills all newly allocated Buffer instances.
 .
 .It Fl c , Fl -check
 Check the script's syntax without executing it.