node-linux-arm64 20.8.0 → 21.0.0

package/share/doc/node/gdbinit

@@ -21,14 +21,51 @@ Usage: jh internal_handle
 end
 
 # Print content of v8::Local handle.
-define jlh
-call (void) _v8_internal_Print_Object(*((v8::internal::Object**)($arg0).val_))
-end
-document jlh
-Print content of a v8::Local handle
-Usage: jlh local_handle
+python
+import gdb
+
+class PrintV8LocalCommand(gdb.Command):
+  """Print content of v8::Local handle."""
+
+  PRINT_CMD = "call (void) _v8_internal_Print_Object(*(v8::internal::Address**)({0}))"
+
+  def __init__ (self):
+    super(PrintV8LocalCommand, self).__init__ ("print-v8-local", gdb.COMMAND_DATA)
+
+  @staticmethod
+  def get_address_from_local(value):
+    if gdb.types.get_basic_type(value.type).code != gdb.TYPE_CODE_STRUCT:
+      return None
+    # After https://crrev.com/c/4335544, v8::MaybeLocal contains a local_.
+    if gdb.types.has_field(value.type, "local_"):
+      value = value["local_"]
+    # After https://crrev.com/c/4335544, v8::Local contains a location_.
+    if gdb.types.has_field(value.type, "location_"):
+      return value["location_"].format_string()
+    # Before https://crrev.com/c/4335544, v8::Local contained a val_.
+    if gdb.types.has_field(value.type, "val_"):
+      return value["val_"].format_string()
+    # We don't know how to print this...
+    return None
+
+  def invoke (self, arg, from_tty):
+    argv = gdb.string_to_argv(arg)
+    if len(argv) != 1:
+      raise gdb.GdbError("print-local takes exactly one argument.")
+    value = gdb.parse_and_eval(argv[0])
+    indirect_pointer = self.get_address_from_local(value)
+    if indirect_pointer is not None:
+      gdb.execute(self.PRINT_CMD.format(indirect_pointer), from_tty)
+    else:
+      raise gdb.GdbError("print-local cannot print a value of type {}".format(
+        value.type))
+
+PrintV8LocalCommand()
 end
 
+alias jlh = print-v8-local
+alias jl = print-v8-local
+
 # Print Code objects containing given PC.
 define jco
   if $argc == 0
@@ -42,6 +79,23 @@ Print a v8 Code object from an internal code address
 Usage: jco pc
 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
+      call (void) _v8_internal_Print_OnlyCode((void*)($arg0), 30)
+    else
+      call (void) _v8_internal_Print_OnlyCode((void*)($arg0), (size_t)($arg1))
+    end
+  end
+end
+document jco
+Print a v8 Code object from an internal code address
+Usage: jco pc
+end
+
 # Print TransitionTree.
 define jtt
 call (void) _v8_internal_Print_TransitionTree((void*)($arg0))

package/share/doc/node/lldb_commands.py

@@ -22,53 +22,114 @@ def current_thread(debugger):
 def current_frame(debugger):
   return current_thread(debugger).GetSelectedFrame()
 
-def no_arg_cmd(debugger, cmd):
+
+def no_arg_cmd(debugger, cmd, print_error=True):
   cast_to_void_expr = '(void) {}'.format(cmd)
   evaluate_result = current_frame(debugger).EvaluateExpression(cast_to_void_expr)
   # When a void function is called the return value type is 0x1001 which
   # is specified in http://tiny.cc/bigskz. This does not indicate
   # an error so we check for that value below.
   kNoResult = 0x1001
-  error = evaluate_result.GetError()
-  if error.fail and error.value != kNoResult:
+  result = evaluate_result.GetError()
+  is_success = not result.fail or result.value == kNoResult
+  if not is_success:
+    if print_error:
       print("Failed to evaluate command {} :".format(cmd))
-      print(error.description)
+      print(result.description)
   else:
     print("")
+  return (is_success, result, cmd)
+
 
-def ptr_arg_cmd(debugger, name, param, cmd):
+def ptr_arg_cmd(debugger, name, param, cmd, print_error=True):
   if not param:
     print("'{}' requires an argument".format(name))
-    return
+    return (False, None, "")
   param = '(void*)({})'.format(param)
-  no_arg_cmd(debugger, cmd.format(param))
+  return no_arg_cmd(debugger, cmd.format(param), print_error)
+
+
+V8_LLDB_COMMANDS = []
+
+
+def lldbCommand(fn):
+  V8_LLDB_COMMANDS.append(fn.__name__)
+  return fn
 
 #####################
 # lldb commands.    #
 #####################
+
+
+@lldbCommand
 def job(debugger, param, *args):
   """Print a v8 heap object"""
   ptr_arg_cmd(debugger, 'job', param, "_v8_internal_Print_Object({})")
 
+
+@lldbCommand
+def jh(debugger, param, *args):
+  """Print v8::internal::Handle value"""
+  V8_PRINT_CMD = "_v8_internal_Print_Object(*(v8::internal::Object**)({}.%s))"
+  ptr_arg_cmd(debugger, 'jh', param, V8_PRINT_CMD % "location_")
+
+
+def get_address_from_local(value):
+  # After https://crrev.com/c/4335544, v8::MaybeLocal contains a local_.
+  field = value.GetValueForExpressionPath(".local_")
+  if field.IsValid():
+    value = field
+  # After https://crrev.com/c/4335544, v8::Local contains a location_.
+  field = value.GetValueForExpressionPath(".location_")
+  if field.IsValid():
+    return field.value
+  # Before https://crrev.com/c/4335544, v8::Local contained a val_.
+  field = value.GetValueForExpressionPath(".val_")
+  if field.IsValid():
+    return field.value
+  # We don't know how to print this...
+  return None
+
+
+@lldbCommand
 def jlh(debugger, param, *args):
   """Print v8::Local handle value"""
-  ptr_arg_cmd(debugger, 'jlh', param,
-              "_v8_internal_Print_Object(*(v8::internal::Object**)({}.val_))")
+  V8_PRINT_CMD = "_v8_internal_Print_Object(*(v8::internal::Address**)({0}))"
+  value = current_frame(debugger).EvaluateExpression(param)
+  indirect_pointer = get_address_from_local(value)
+  if indirect_pointer is not None:
+    ptr_arg_cmd(debugger, 'jlh', param, V8_PRINT_CMD.format(indirect_pointer))
+  else:
+    print("Failed to print value of type {}".format(value.type.name))
+
+
+@lldbCommand
+def jl(debugger, param, *args):
+  """Print v8::Local handle value"""
+  return jlh(debugger, param, *args)
 
+
+@lldbCommand
 def jco(debugger, param, *args):
   """Print the code object at the given pc (default: current pc)"""
   if not param:
     param = str(current_frame(debugger).FindRegister("pc").value)
   ptr_arg_cmd(debugger, 'jco', param, "_v8_internal_Print_Code({})")
 
+
+@lldbCommand
 def jtt(debugger, param, *args):
   """Print the transition tree of a v8 Map"""
   ptr_arg_cmd(debugger, 'jtt', param, "_v8_internal_Print_TransitionTree({})")
 
+
+@lldbCommand
 def jst(debugger, *args):
   """Print the current JavaScript stack trace"""
   no_arg_cmd(debugger, "_v8_internal_Print_StackTrace()")
 
+
+@lldbCommand
 def jss(debugger, *args):
   """Skip the jitted stack on x64 to where we entered JS last"""
   frame = current_frame(debugger)
@@ -83,6 +144,8 @@ def jss(debugger, *args):
   rsp = js_entry_sp + 2 *sizeof_void
   pc.value = js_entry_sp + sizeof_void
 
+
+@lldbCommand
 def bta(debugger, *args):
   """Print stack trace with assertion scopes"""
   func_name_re = re.compile("([^(<]+)(?:\(.+\))?")
@@ -129,6 +192,6 @@ def setup_source_map_for_relative_paths(debugger):
 def __lldb_init_module(debugger, dict):
   setup_source_map_for_relative_paths(debugger)
   debugger.HandleCommand('settings set target.x86-disassembly-flavor intel')
-  for cmd in ('job', 'jlh', 'jco', 'jld', 'jtt', 'jst', 'jss', 'bta'):
+  for cmd in V8_LLDB_COMMANDS:
     debugger.HandleCommand(
       'command script add -f lldb_commands.{} {}'.format(cmd, cmd))

package/share/man/man1/node.1

@@ -152,6 +152,11 @@ Requires Node.js to be built with
 .It Fl -enable-source-maps
 Enable Source Map V3 support for stack traces.
 .
+.It Fl -experimental-default-type Ns = Ns Ar type
+Interpret as either ES modules or CommonJS modules input via --eval or STDIN, when --input-type is unspecified;
+.js or extensionless files with no sibling or parent package.json;
+.js or extensionless files whose nearest parent package.json lacks a "type" field, unless under node_modules.
+.
 .It Fl -experimental-global-webcrypto
 Expose the Web Crypto API on the global scope.
 .
@@ -178,6 +183,9 @@ Use this flag to enable ShadowRealm support.
 .It Fl -experimental-test-coverage
 Enable code coverage in the test runner.
 .
+.It Fl -experimental-websocket
+Enable experimental support for the WebSocket API.
+.
 .It Fl -no-experimental-fetch
 Disable experimental support for the Fetch API.
 .
@@ -410,6 +418,10 @@ Specify the minimum allocation from the OpenSSL secure heap. The default is 2. T
 .It Fl -test
 Starts the Node.js command line test runner.
 .
+.It Fl -test-concurrency
+The maximum number of test files that the test runner CLI will execute
+concurrently.
+.
 .It Fl -test-name-pattern
 A regular expression that configures the test runner to only execute tests
 whose name matches the provided pattern.