[lldb] [Commands] Implement "thread siginfo"

[labath]

Seems reasonable to me, but let's get Jim's opinion too.

[jingham]

I think it would help readability if you put the thread ID for the signinfo before printing the siginfo value, otherwise if I list multiple threads (or use "all") I have to count instances to figure out which thread goes with which siginfo.

Otherwise this looks fine.

lldb/source/Commands/CommandObjectThread.cpp

1355

The CommandObjectIterateOverThreads class doesn't itself print which thread the output of each HandleOneThread is for, so if I did:

(lldb) thread siginfo all

Then I would just get a bunch of undifferentiated siginfo's and wouldn't have a way to figure out which thread went with which output. I think it would help to repeat the thread name before the siginfo output.

[JDevlieghere]

lldb/source/Commands/CommandObjectThread.cpp

1323

I know you're just being consistent with the rest of this file, but we've been slowly phasing out these kind of comments.

[mgorny]

lldb/source/Commands/CommandObjectThread.cpp

1323

I'm all for it ;-).

[mgorny]

Removed the comment and added thread info-style status above siginfos.

[jingham]

This looks fine to me.

[mgorny]

Thanks for all the reviews and helpful suggestions!

lldb/source/Commands/CommandObjectThread.cpp

if (exception_thread_sp && exception_thread_sp->IsValid()) {
       exception_thread_sp->GetStatus(strm, 0, UINT32_MAX,
                                      num_frames_with_source, stop_format);
     }
 
     return true;
   }
 };
 
+class CommandObjectThreadSiginfo : public CommandObjectIterateOverThreads {
+public:
+  CommandObjectThreadSiginfo(CommandInterpreter &interpreter)
+      : CommandObjectIterateOverThreads(
+            interpreter, "thread siginfo",
+            "Display the current siginfo object for a thread. Defaults to "
+            "the current thread.",
+            "thread siginfo",
+            eCommandRequiresProcess | eCommandTryTargetAPILock |
+                eCommandProcessMustBeLaunched | eCommandProcessMustBePaused) {}
+
+  ~CommandObjectThreadSiginfo() override = default;
+
+  void
+  HandleArgumentCompletion(CompletionRequest &request,
+                           OptionElementVector &opt_element_vector) override {
+    CommandCompletions::InvokeCommonCompletionCallbacks(
+        GetCommandInterpreter(), CommandCompletions::eThreadIndexCompletion,
+        request, nullptr);
+  }
+
+  bool HandleOneThread(lldb::tid_t tid, CommandReturnObject &result) override {
+    ThreadSP thread_sp =
+        m_exe_ctx.GetProcessPtr()->GetThreadList().FindThreadByID(tid);
+    if (!thread_sp) {
+      result.AppendErrorWithFormat("thread no longer exists: 0x%" PRIx64 "\n",
+                                   tid);
+      return false;
+    }
+
+    Stream &strm = result.GetOutputStream();
+    if (!thread_sp->GetDescription(strm, eDescriptionLevelFull, false, false)) {
+      result.AppendErrorWithFormat("error displaying info for thread: \"%d\"\n",
+                                   thread_sp->GetIndexID());
+      return false;
+    }
+    ValueObjectSP exception_object_sp = thread_sp->GetSiginfoValue();
+    if (exception_object_sp)
+      exception_object_sp->Dump(strm);
+    else
+      strm.Printf("(no siginfo)\n");
+    strm.PutChar('\n');
+
+    return true;
+  }
+};
+
 // CommandObjectThreadReturn
 #define LLDB_OPTIONS_thread_return
 #include "CommandOptions.inc"
 
 class CommandObjectThreadReturn : public CommandObjectRaw {
 public:
   class CommandOptions : public Options {
   public:
CommandObjectMultiwordThread::CommandObjectMultiwordThread(
   LoadSubCommand("select",
                  CommandObjectSP(new CommandObjectThreadSelect(interpreter)));
   LoadSubCommand("until",
                  CommandObjectSP(new CommandObjectThreadUntil(interpreter)));
   LoadSubCommand("info",
                  CommandObjectSP(new CommandObjectThreadInfo(interpreter)));
   LoadSubCommand("exception", CommandObjectSP(new CommandObjectThreadException(
                                   interpreter)));
+  LoadSubCommand("siginfo",
+                 CommandObjectSP(new CommandObjectThreadSiginfo(interpreter)));
   LoadSubCommand("step-in",
                  CommandObjectSP(new CommandObjectThreadStepWithTypeAndScope(
                      interpreter, "thread step-in",
                      "Source level single step, stepping into calls.  Defaults "
                      "to current thread unless specified.",
                      nullptr, eStepTypeInto, eStepScopeSource)));
 
   LoadSubCommand("step-out",

lldb/test/Shell/Commands/Inputs/sigchld.c

+#include <assert.h>
+#include <signal.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <sys/wait.h>
+
+void handler(int signo) {
+  printf("SIGCHLD\n");
+}
+
+int main() {
+  void *ret = signal(SIGINT, handler);
+  assert (ret != SIG_ERR);
+
+  pid_t child_pid = fork();
+  assert (child_pid != -1);
+
+  if (child_pid == 0) {
+    sleep(1);
+    _exit(14);
+  }
+
+  printf("signo = %d\n", SIGCHLD);
+  printf("code = %d\n", CLD_EXITED);
+  printf("child_pid = %d\n", child_pid);
+  printf("uid = %d\n", getuid());
+  pid_t waited = wait(NULL);
+  assert(waited == child_pid);
+
+  return 0;
+}

lldb/test/Shell/Commands/command-thread-siginfo.test

+# REQUIRES: system-linux
+# RUN: %clang_host -g %S/Inputs/sigchld.c -o %t
+# RUN: %lldb %t -b -s %s | FileCheck %s
+
+process launch -s
+process handle SIGCHLD -s true
+process continue
+# CHECK: signo = [[SIGNO:[0-9]+]]
+# CHECK: code = [[CODE:[0-9]+]]
+# CHECK: child_pid = [[PID:[0-9]+]]
+# CHECK: uid = [[UID:[0-9]+]]
+# CHECK: stop reason = signal SIGCHLD
+thread siginfo
+# CHECK-DAG: si_signo = [[SIGNO]]
+# CHECK-DAG: si_errno = 0
+# CHECK-DAG: si_code = [[CODE]]
+# CHECK-DAG: si_pid = [[PID]]
+# CHECK-DAG: si_uid = [[UID]]
+# CHECK-DAG: si_status = 14