[lldb] [llgs] Implement qXfer:siginfo:read

[mgorny]

Summary

Implement the qXfer:siginfo:read that is used to read the siginfo_t
(extended signal information) for the current thread. This is currently
implemented on FreeBSD and Linux.

[labath]

lldb/include/lldb/Host/common/NativeProcessProtocol.h

195–198

I think it would be more natural/consistent to have this function on a specific NativeThreadProtocol object (and let the user choose whether it wants the siginfo for the current thread, or someone else).

lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp

1987

I'd be better to outright allocate a memory buffer of the right size (getNewUninitMemBuffer), and directly write the data there.

lldb/test/API/tools/lldb-server/TestLldbGdbServer.py

1398

Didn't D117103 fix that?

1437

you want the address width of the debugged binary, not python, right? We already have some utilities to help with that (grep for parse_process_info_response).

[mgorny]

Implemented the requested changes.

lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp

1987

I suppose there's no similar solution for the FreeBSD case where the returned struct is a member of the temporary struct?

lldb/test/API/tools/lldb-server/TestLldbGdbServer.py

1398

Yeah, I left a comment, so I don't forget, then I've forgotten that I've left a comment ;-D.

[labath]

cool

lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp

1987

Not with the current interface (and it's probably not worth changing it for it).

[stella.stamenova]

This does not build correctly with gcc 7.3.1 on CentOS:

/usr/bin/g++ -DGTEST_HAS_RTTI=0 -DHAVE_ROUND -D_DEBUG -D_GNU_SOURCE -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -I/mnt/resource/1/b/llvm/Release/tools/lldb/source/Plugins/Process/Linux -I/mnt/resource/1/s/llvm-project/lldb/source/Plugins/Process/Linux -I/mnt/resource/1/s/llvm-project/lldb/include -I/mnt/resource/1/b/llvm/Release/tools/lldb/include -I/mnt/resource/1/b/llvm/Release/include -I/mnt/resource/1/s/llvm-project/llvm/include -I/mnt/resource/1/s/llvm-project/llvm/../clang/include -I/mnt/resource/1/b/llvm/Release/tools/lldb/../clang/include -I/mnt/resource/1/s/llvm-project/lldb/source -I/mnt/resource/1/b/llvm/Release/tools/lldb/source -fPIC -fno-semantic-interposition -fvisibility-inlines-hidden -Werror=date-time -Wall -Wextra -Wno-unused-parameter -Wwrite-strings -Wcast-qual -Wno-missing-field-initializers -pedantic -Wno-long-long -Wimplicit-fallthrough -Wno-maybe-uninitialized -Wno-noexcept-type -Wdelete-non-virtual-dtor -Wno-comment -Wmisleading-indentation -fdiagnostics-color -ffunction-sections -fdata-sections -Wno-deprecated-declarations -Wno-unknown-pragmas -Wno-strict-aliasing -Wno-deprecated-register -Wno-vla-extension -O3 -DNDEBUG  -fno-exceptions -fno-rtti -UNDEBUG -std=c++14 -MD -MT tools/lldb/source/Plugins/Process/Linux/CMakeFiles/lldbPluginProcessLinux.dir/NativeThreadLinux.cpp.o -MF tools/lldb/source/Plugins/Process/Linux/CMakeFiles/lldbPluginProcessLinux.dir/NativeThreadLinux.cpp.o.d -o tools/lldb/source/Plugins/Process/Linux/CMakeFiles/lldbPluginProcessLinux.dir/NativeThreadLinux.cpp.o -c /mnt/resource/1/s/llvm-project/lldb/source/Plugins/Process/Linux/NativeThreadLinux.cpp
/mnt/resource/1/s/llvm-project/lldb/source/Plugins/Process/Linux/NativeThreadLinux.cpp: In member function ‘virtual llvm::Expected<std::unique_ptr<llvm::MemoryBuffer> > lldb_private::process_linux::NativeThreadLinux::GetSiginfo() const’:
/mnt/resource/1/s/llvm-project/lldb/source/Plugins/Process/Linux/NativeThreadLinux.cpp:552:10: error: could not convert ‘siginfo_buf’ from ‘std::unique_ptr<llvm::WritableMemoryBuffer>’ to ‘llvm::Expected<std::unique_ptr<llvm::MemoryBuffer> >’
   return siginfo_buf;

[labath]

sounds like something that could be fixed by a couple of std::moves

[mgorny]

In D117113#3251838, @stella.stamenova wrote:

This does not build correctly with gcc 7.3.1 on CentOS:

Could you please try adding some std::move()s to the relevant returns? I don't have an access to such an ancient compiler.

lldb/include/lldb/Host/common/NativeProcessProtocol.h

public:
 
   uint32_t GetAddressByteSize() const {
     return GetArchitecture().GetAddressByteSize();
   }
 
   virtual llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>>
   GetAuxvData() const = 0;
 
   // Exit Status
   virtual llvm::Optional<WaitStatus> GetExitStatus();
 
   virtual bool SetExitStatus(WaitStatus status, bool bNotifyStateChange);
 
   // Access to threads
   NativeThreadProtocol *GetThreadAtIndex(uint32_t idx);
 
   NativeThreadProtocol *GetThreadByID(lldb::tid_t tid);
 
   void SetCurrentThreadID(lldb::tid_t tid) { m_current_thread_id = tid; }
 
-  lldb::tid_t GetCurrentThreadID() { return m_current_thread_id; }
+  lldb::tid_t GetCurrentThreadID() const { return m_current_thread_id; }
 
   NativeThreadProtocol *GetCurrentThread() {
     return GetThreadByID(m_current_thread_id);
   }
 
   // Access to inferior stdio
   virtual int GetTerminalFileDescriptor() { return m_terminal_fd; }
 
enum class Extension {
     multiprocess = (1u << 0),
     fork = (1u << 1),
     vfork = (1u << 2),
     pass_signals = (1u << 3),
     auxv = (1u << 4),
     libraries_svr4 = (1u << 5),
     memory_tagging = (1u << 6),
     savecore = (1u << 7),
+    siginfo_read = (1u << 8),
 
-    LLVM_MARK_AS_BITMASK_ENUM(savecore)
+    LLVM_MARK_AS_BITMASK_ENUM(siginfo_read)
   };
 
   class Factory {
   public:
     virtual ~Factory();
     /// Launch a process for debugging.
     ///
     /// \param[in] launch_info

lldb/include/lldb/Host/common/NativeThreadProtocol.h

 //===-- NativeThreadProtocol.h ----------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_HOST_COMMON_NATIVETHREADPROTOCOL_H
 #define LLDB_HOST_COMMON_NATIVETHREADPROTOCOL_H
 
 #include <memory>
 
 #include "lldb/Host/Debug.h"
+#include "lldb/Utility/UnimplementedError.h"
 #include "lldb/lldb-private-forward.h"
 #include "lldb/lldb-types.h"
 
+#include "llvm/Support/Error.h"
+#include "llvm/Support/MemoryBuffer.h"
+
 namespace lldb_private {
 // NativeThreadProtocol
 class NativeThreadProtocol {
 public:
   NativeThreadProtocol(NativeProcessProtocol &process, lldb::tid_t tid);
 
   virtual ~NativeThreadProtocol() = default;
 
public:
 
   virtual Status RemoveWatchpoint(lldb::addr_t addr) = 0;
 
   // Thread-specific Hardware Breakpoint routines
   virtual Status SetHardwareBreakpoint(lldb::addr_t addr, size_t size) = 0;
 
   virtual Status RemoveHardwareBreakpoint(lldb::addr_t addr) = 0;
 
+  virtual llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>>
+  GetSiginfo() const {
+    return llvm::make_error<UnimplementedError>();
+  }
+
 protected:
   NativeProcessProtocol &m_process;
   lldb::tid_t m_tid;
 };
 }
 
 #endif // LLDB_HOST_COMMON_NATIVETHREADPROTOCOL_H

lldb/packages/Python/lldbsuite/test/tools/lldb-server/gdbremote_testcase.py

_KNOWN_QSUPPORTED_STUB_FEATURES = [
         "PacketSize",
         "QStartNoAckMode",
         "QThreadSuffixSupported",
         "QListThreadsInStopReply",
         "qXfer:auxv:read",
         "qXfer:libraries:read",
         "qXfer:libraries-svr4:read",
         "qXfer:features:read",
+        "qXfer:siginfo:read",
         "qEcho",
         "QPassSignals",
         "multiprocess",
         "fork-events",
         "vfork-events",
         "memory-tagging",
         "qSaveCore",
         "native-signals",

lldb/source/Plugins/Process/FreeBSD/NativeProcessFreeBSD.cpp

 
 NativeProcessFreeBSD::Extension
 NativeProcessFreeBSD::Factory::GetSupportedExtensions() const {
   return
 #if defined(PT_COREDUMP)
       Extension::savecore |
 #endif
       Extension::multiprocess | Extension::fork | Extension::vfork |
-      Extension::pass_signals | Extension::auxv | Extension::libraries_svr4;
+      Extension::pass_signals | Extension::auxv | Extension::libraries_svr4 |
+      Extension::siginfo_read;
 }
 
 // Public Instance Methods
 
 NativeProcessFreeBSD::NativeProcessFreeBSD(::pid_t pid, int terminal_fd,
                                            NativeDelegate &delegate,
                                            const ArchSpec &arch,
                                            MainLoop &mainloop)

lldb/source/Plugins/Process/FreeBSD/NativeThreadFreeBSD.h

Status SetWatchpoint(lldb::addr_t addr, size_t size, uint32_t watch_flags,
                        bool hardware) override;
 
   Status RemoveWatchpoint(lldb::addr_t addr) override;
 
   Status SetHardwareBreakpoint(lldb::addr_t addr, size_t size) override;
 
   Status RemoveHardwareBreakpoint(lldb::addr_t addr) override;
 
+  llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>>
+  GetSiginfo() const override;
+
 private:
   // Interface for friend classes
 
   Status Resume();
   Status SingleStep();
   Status Suspend();
 
   void SetStoppedBySignal(uint32_t signo, const siginfo_t *info = nullptr);

lldb/source/Plugins/Process/FreeBSD/NativeThreadFreeBSD.cpp

NativeThreadFreeBSD::CopyWatchpointsFrom(NativeThreadFreeBSD &source) {
   llvm::Error s = GetRegisterContext().CopyHardwareWatchpointsFrom(
       source.GetRegisterContext());
   if (!s) {
     m_watchpoint_index_map = source.m_watchpoint_index_map;
     m_hw_break_index_map = source.m_hw_break_index_map;
   }
   return s;
 }
+
+llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>>
+NativeThreadFreeBSD::GetSiginfo() const {
+  Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
+
+  struct ptrace_lwpinfo info;
+  const auto siginfo_err = NativeProcessFreeBSD::PtraceWrapper(
+      PT_LWPINFO, GetID(), &info, sizeof(info));
+  if (siginfo_err.Fail()) {
+    LLDB_LOG(log, "PT_LWPINFO failed {0}", siginfo_err);
+    return siginfo_err.ToError();
+  }
+
+  if (info.pl_event != PL_EVENT_SIGNAL)
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "Thread not signaled");
+  if (!(info.pl_flags & PL_FLAG_SI))
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "No siginfo for thread");
+
+  return llvm::MemoryBuffer::getMemBufferCopy(
+      llvm::StringRef(reinterpret_cast<const char *>(&info.pl_siginfo),
+                      sizeof(info.pl_siginfo)));
+}

lldb/source/Plugins/Process/Linux/NativeProcessLinux.h

public:
 
   // Interface used by NativeRegisterContext-derived classes.
   static Status PtraceWrapper(int req, lldb::pid_t pid, void *addr = nullptr,
                               void *data = nullptr, size_t data_size = 0,
                               long *result = nullptr);
 
   bool SupportHardwareSingleStepping() const;
 
+  /// Writes a siginfo_t structure corresponding to the given thread ID to the
+  /// memory region pointed to by \p siginfo.
+  Status GetSignalInfo(lldb::tid_t tid, void *siginfo) const;
+
 protected:
   llvm::Expected<llvm::ArrayRef<uint8_t>>
   GetSoftwareBreakpointTrapOpcode(size_t size_hint) override;
 
   llvm::Expected<uint64_t> Syscall(llvm::ArrayRef<uint64_t> args);
 
 private:
   MainLoop::SignalHandleUP m_sigchld_handle;
private:
   Status NotifyTracersOfNewThread(lldb::tid_t tid);
 
   /// Stop tracing threads upon a destroy event.
   ///
   /// Trace mechanisms should modify this method to provide automatic trace
   /// stopping for threads being destroyed.
   Status NotifyTracersOfThreadDestroyed(lldb::tid_t tid);
 
-  /// Writes a siginfo_t structure corresponding to the given thread ID to the
-  /// memory region pointed to by \p siginfo.
-  Status GetSignalInfo(lldb::tid_t tid, void *siginfo);
-
   /// Writes the raw event message code (vis-a-vis PTRACE_GETEVENTMSG)
   /// corresponding to the given thread ID to the memory pointed to by @p
   /// message.
   Status GetEventMessage(lldb::tid_t tid, unsigned long *message);
 
   void NotifyThreadDeath(lldb::tid_t tid);
 
   Status Detach(lldb::tid_t tid);

lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp

NativeProcessLinux::Factory::Attach(
   return std::unique_ptr<NativeProcessLinux>(new NativeProcessLinux(
       pid, -1, native_delegate, Info.GetArchitecture(), mainloop, *tids_or));
 }
 
 NativeProcessLinux::Extension
 NativeProcessLinux::Factory::GetSupportedExtensions() const {
   NativeProcessLinux::Extension supported =
       Extension::multiprocess | Extension::fork | Extension::vfork |
-      Extension::pass_signals | Extension::auxv | Extension::libraries_svr4;
+      Extension::pass_signals | Extension::auxv | Extension::libraries_svr4 |
+      Extension::siginfo_read;
 
 #ifdef __aarch64__
   // At this point we do not have a process so read auxv directly.
   if ((getauxval(AT_HWCAP2) & HWCAP2_MTE))
     supported |= Extension::memory_tagging;
 #endif
 
   return supported;
for (bytes_written = 0; bytes_written < size; bytes_written += remainder) {
     }
 
     addr += k_ptrace_word_size;
     src += k_ptrace_word_size;
   }
   return error;
 }
 
-Status NativeProcessLinux::GetSignalInfo(lldb::tid_t tid, void *siginfo) {
+Status NativeProcessLinux::GetSignalInfo(lldb::tid_t tid, void *siginfo) const {
   return PtraceWrapper(PTRACE_GETSIGINFO, tid, nullptr, siginfo);
 }
 
 Status NativeProcessLinux::GetEventMessage(lldb::tid_t tid,
                                            unsigned long *message) {
   return PtraceWrapper(PTRACE_GETEVENTMSG, tid, nullptr, message);
 }
 
Expected<json::Value> NativeProcessLinux::TraceGetState(StringRef type) {
   return NativeProcessProtocol::TraceGetState(type);
 }
 
 Expected<std::vector<uint8_t>> NativeProcessLinux::TraceGetBinaryData(
     const TraceGetBinaryDataRequest &request) {
   if (request.type == "intel-pt")
     return m_intel_pt_manager.GetBinaryData(request);
   return NativeProcessProtocol::TraceGetBinaryData(request);
 }

lldb/source/Plugins/Process/Linux/NativeThreadLinux.h

public:
   Status RemoveWatchpoint(lldb::addr_t addr) override;
 
   Status SetHardwareBreakpoint(lldb::addr_t addr, size_t size) override;
 
   Status RemoveHardwareBreakpoint(lldb::addr_t addr) override;
 
   NativeProcessLinux &GetProcess();
 
+  const NativeProcessLinux &GetProcess() const;
+
+  llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>>
+  GetSiginfo() const override;
+
 private:
   // Interface for friend classes
 
   /// Resumes the thread.  If \p signo is anything but
   /// LLDB_INVALID_SIGNAL_NUMBER, deliver that signal to the thread.
   Status Resume(uint32_t signo);
 
   /// Single steps the thread.  If \p signo is anything but

lldb/source/Plugins/Process/Linux/NativeThreadLinux.cpp

void NativeThreadLinux::MaybeLogStateChange(lldb::StateType new_state) {
 
   LLDB_LOG(log, "pid={0}, tid={1}: changing from state {2} to {3}",
            m_process.GetID(), GetID(), old_state, new_state);
 }
 
 NativeProcessLinux &NativeThreadLinux::GetProcess() {
   return static_cast<NativeProcessLinux &>(m_process);
 }
+
+const NativeProcessLinux &NativeThreadLinux::GetProcess() const {
+  return static_cast<const NativeProcessLinux &>(m_process);
+}
+
+llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>>
+NativeThreadLinux::GetSiginfo() const {
+  auto siginfo_buf =
+      llvm::WritableMemoryBuffer::getNewUninitMemBuffer(sizeof(siginfo_t));
+  Status error =
+      GetProcess().GetSignalInfo(GetID(), siginfo_buf->getBufferStart());
+  if (!error.Success())
+    return error.ToError();
+  return siginfo_buf;
+}

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp

GDBRemoteCommunicationServerLLGS::ReadXferObject(llvm::StringRef object,
   if (object == "auxv") {
     // Grab the auxv data.
     auto buffer_or_error = m_current_process->GetAuxvData();
     if (!buffer_or_error)
       return llvm::errorCodeToError(buffer_or_error.getError());
     return std::move(*buffer_or_error);
   }
 
+  if (object == "siginfo") {
+    NativeThreadProtocol *thread = m_current_process->GetCurrentThread();
+    if (!thread)
+      return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                     "no current thread");
+
+    auto buffer_or_error = thread->GetSiginfo();
+    if (!buffer_or_error)
+      return buffer_or_error.takeError();
+    return std::move(*buffer_or_error);
+  }
+
   if (object == "libraries-svr4") {
     auto library_list = m_current_process->GetLoadedSVR4Libraries();
     if (!library_list)
       return library_list.takeError();
 
     StreamString response;
     response.Printf("<library-list-svr4 version=\"1.0\">");
     for (auto const &library : *library_list) {
std::vector<std::string> GDBRemoteCommunicationServerLLGS::HandleFeatures(
   using Extension = NativeProcessProtocol::Extension;
   Extension plugin_features = m_process_factory.GetSupportedExtensions();
   if (bool(plugin_features & Extension::pass_signals))
     ret.push_back("QPassSignals+");
   if (bool(plugin_features & Extension::auxv))
     ret.push_back("qXfer:auxv:read+");
   if (bool(plugin_features & Extension::libraries_svr4))
     ret.push_back("qXfer:libraries-svr4:read+");
+  if (bool(plugin_features & Extension::siginfo_read))
+    ret.push_back("qXfer:siginfo:read+");
   if (bool(plugin_features & Extension::memory_tagging))
     ret.push_back("memory-tagging+");
   if (bool(plugin_features & Extension::savecore))
     ret.push_back("qSaveCore+");
 
   // check for client features
   m_extensions_supported = {};
   for (llvm::StringRef x : client_features)

lldb/test/API/tools/lldb-server/TestLldbGdbServer.py

 """
 Test case for testing the gdbremote protocol.
 
 Tests run against debugserver and lldb-server (llgs).
 lldb-server tests run where the lldb-server exe is
 available.
 
 This class will be broken into smaller test case classes by
 gdb remote packet functional areas.  For now it contains
 the initial set of tests implemented.
 """
 
 import binascii
 import itertools
+import struct
 
 import unittest2
 import gdbremote_testcase
 import lldbgdbserverutils
 from lldbsuite.support import seven
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.lldbdwarf import *
class LldbGdbServerTestCase(gdbremote_testcase.GdbRemoteTestCaseBase, DwarfOpcodeParser):
 
     def test_qSupported_libraries_svr4(self):
         expected = ('+' if lldbplatformutil.getPlatform()
                     in ["freebsd", "linux", "netbsd"] else '-')
         supported_dict = self.get_qSupported_dict()
         self.assertEqual(supported_dict.get('qXfer:libraries-svr4:read', '-'),
                          expected)
 
+    def test_qSupported_siginfo_read(self):
+        expected = ('+' if lldbplatformutil.getPlatform()
+                    in ["freebsd", "linux"] else '-')
+        supported_dict = self.get_qSupported_dict()
+        self.assertEqual(supported_dict.get('qXfer:siginfo:read', '-'),
+                         expected)
+
     def test_qSupported_QPassSignals(self):
         expected = ('+' if lldbplatformutil.getPlatform()
                     in ["freebsd", "linux", "netbsd"] else '-')
         supported_dict = self.get_qSupported_dict()
         self.assertEqual(supported_dict.get('QPassSignals', '-'), expected)
 
     @add_test_categories(["fork"])
     def test_qSupported_fork_events(self):
def test_QEnvironmentHexEncoded(self):
             ["read packet: $vRun;%s#00" % (";".join(hex_args),),
              {"direction": "send",
               "regex": r"^\$T([0-9a-fA-F]+)"},
              "read packet: $c#00",
              "send packet: $W00#00"],
             True)
         context = self.expect_gdbremote_sequence()
         self.assertEqual(context["O_content"], b"test\r\na=z\r\na*}#z\r\n")
+
+    @skipUnlessPlatform(oslist=["freebsd", "linux"])
+    @add_test_categories(["llgs"])
+    def test_qXfer_siginfo_read(self):
+        self.build()
+        self.set_inferior_startup_launch()
+        procs = self.prep_debug_monitor_and_inferior(
+                inferior_args=["thread:segfault", "thread:new", "sleep:10"])
+        self.test_sequence.add_log_lines(["read packet: $c#63"], True)
+        self.expect_gdbremote_sequence()
+
+        # Run until SIGSEGV comes in.
+        self.reset_test_sequence()
+        self.test_sequence.add_log_lines(
+            [{"direction": "send",
+              "regex": r"^\$T([0-9a-fA-F]{2})thread:([0-9a-fA-F]+);",
+              "capture": {1: "signo", 2: "thread_id"},
+              }], True)
+
+        # Figure out which thread crashed.
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+        self.assertEqual(int(context["signo"], 16),
+                         lldbutil.get_signal_number('SIGSEGV'))
+        crashing_thread = int(context["thread_id"], 16)
+
+        # Grab siginfo for the crashing thread.
+        self.reset_test_sequence()
+        self.add_process_info_collection_packets()
+        self.test_sequence.add_log_lines(
+            ["read packet: $Hg{:x}#00".format(crashing_thread),
+             "send packet: $OK#00",
+             "read packet: $qXfer:siginfo:read::0,80:#00",
+             {"direction": "send",
+              "regex": re.compile(r"^\$([^E])(.*)#[0-9a-fA-F]{2}$",
+                                  re.MULTILINE | re.DOTALL),
+              "capture": {1: "response_type", 2: "content_raw"},
+              }], True)
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+
+        # Ensure we end up with all data in one packet.
+        self.assertEqual(context.get("response_type"), "l")
+
+        # Decode binary data.
+        content_raw = context.get("content_raw")
+        self.assertIsNotNone(content_raw)
+        content = self.decode_gdbremote_binary(content_raw).encode("latin1")
+
+        # Decode siginfo_t.
+        process_info = self.parse_process_info_response(context)
+        pad = ""
+        if process_info["ptrsize"] == "8":
+            pad = "i"
+        signo_idx = 0
+        errno_idx = 1
+        code_idx = 2
+        addr_idx = -1
+        SEGV_MAPERR = 1
+        if process_info["ostype"] == "linux":
+            # si_signo, si_errno, si_code, [pad], _sifields._sigfault.si_addr
+            format_str = "iii{}P".format(pad)
+        elif process_info["ostype"].startswith("freebsd"):
+            # si_signo, si_errno, si_code, si_pid, si_uid, si_status, si_addr
+            format_str = "iiiiiiP"
+        elif process_info["ostype"].startswith("netbsd"):
+            # _signo, _code, _errno, [pad], _reason._fault._addr
+            format_str = "iii{}P".format(pad)
+            errno_idx = 2
+            code_idx = 1
+        else:
+            assert False, "unknown ostype"
+
+        decoder = struct.Struct(format_str)
+        decoded = decoder.unpack(content[:decoder.size])
+        self.assertEqual(decoded[signo_idx],
+                         lldbutil.get_signal_number('SIGSEGV'))
+        self.assertEqual(decoded[errno_idx], 0)  # si_errno
+        self.assertEqual(decoded[code_idx], SEGV_MAPERR)  # si_code
+        self.assertEqual(decoded[addr_idx], 0)  # si_addr