[lldb] [Platform] Support synthesizing siginfo_t

[mgorny]

Summary

Support synthesizing the siginfo_t type from the Platform plugin.
This type is going to be used by LLDB client to process the raw siginfo
data received from lldb-server without the necessity of relying
on target's debug info being present.

[mgorny]

My current test program is:

#!/usr/bin/env python

import lldb

raw_data = b'\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00up\n\x00\xe8\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'

lldb.SBDebugger.Initialize()
try:
    dbg = lldb.SBDebugger.Create()
    try:
        t = dbg.CreateTarget("/home/mgorny/git/llvm-project/build/a.out")
        assert t
        typ = list(t.FindTypes("siginfo_t"))[0]
        assert typ
        typ2 = t.GetPlatform().GetSiginfoType(t)
        assert typ2
        data = lldb.SBData()
        data2 = lldb.SBData()
        error = lldb.SBError()
        data.SetData(error, raw_data, lldb.eByteOrderLittle, 8)
        print(t.CreateValueFromData("siginfo", data, typ))
        print(t.CreateValueFromData("siginfo2", data, typ2))
    finally:
        lldb.SBDebugger.Destroy(dbg)
finally:
    lldb.SBDebugger.Terminate()

[mgorny]

Cover more union members.

[mgorny]

Hmm, maybe for the sub-structs, it'd be better to use TypeSystemClang::CreateStructForIdentifier().

[mgorny]

Use CreateStructForIdentifier() whenever possible. Describe the remaining union members.

Open question: do we care for 100% correct SPARC support? Given that it has different _sigfault layout, it adds some complexity while LLDB doesn't seem to support SPARC at all.

[mgorny]

Initial PoC unit test — the idea is to verify field offsets and sizes against known values taken from real siginfo_t.

[mgorny]

Cover all fields with tests and add a test input generator.

[mgorny]

Put the common test code into a common init function, add tests for armv7, arm64, i386, ppc64le.

[mgorny]

Simplify the tests to use dotted member notation for field lookup. Make the test utility generate exact test code.

[mgorny]

Update following instrumentation changes.

[mgorny]

Turn PlatformLinuxTest into a more generic PlatformSiginfoTest, to improve code reuse between platforms. Start preparing for testing FreeBSD.

[mgorny]

Add tests for FreeBSD (no implementation yet).

[mgorny]

Implemented FreeBSD.

[mgorny]

Combine the tests for various 32-bit and 64-bit arches, as they have the same offset-size pairs. Instead of repeating them, just iterate over the list of arches.

[mgorny]

Add NetBSD.

[labath]

Adding Alex for the plugin dependency aspect. I don't think this dep is wrong (it's pretty hard to pretend we don't at least have a C language), but he may want to say something about this.

The patch itself is somewhat repetitive, but otherwise seems ok.

I am a bit curious about the __lldb prefix. I'm wondering if there's a way to avoid having it, while still maintaining isolation from any type with the same name coming from the debug info. I'm thinking about putting it in some kind of an anonymous namespace or something... Does anyone know if that works?

lldb/source/API/SBPlatform.cpp

672 ↗

(On Diff #402208)

??

lldb/source/Plugins/Platform/Linux/PlatformLinux.cpp

323

we don't

lldb/unittests/Platform/PlatformSiginfoTest.cpp

84

drop c_str()

110

Other platform APIs seem to take an ArchSpec or even a Triple, so doing that would be more consistent *and* make your job here easier.

[jingham]

The GetSiginfoType API seems awkward to me. It requires I get the data itself from some other source and then cast it to this type myself. I'm assuming in the fullness of time, there will be a GetSiginfoData call, and then I have to put the two together? The only reason I can see to have separate "GetType" and "GetData" calls is if there's some useful way to get the data blob that doesn't go through lldb.

After all, if we had:

SBValue SBThread::GetSiginfoValue();

API you can still get the type and data back out of the SBValue if you needed them. But I am pretty sure most uses will be to query the values of its child members, which makes the value returning API more convenient.

At the lldb_private layer, it's fine to separate the two, but when you go to present this to the outside world through commands or API's we try to keep the API set more compact.

[jingham]

In D117707#3269214, @labath wrote:

Adding Alex for the plugin dependency aspect. I don't think this dep is wrong (it's pretty hard to pretend we don't at least have a C language), but he may want to say something about this.

I think we need to have a way to express types that the base platform has so we can present them in a structured way to users. Formally, you could express this by saying that we need a "platform language" reflecting how that platform vends it's API's at the lowest level. This would have been Pascal for classic MacOS way back in the day, and maybe Lisp for Lisp machines. But IRL all the platforms we are likely to deal with express their lowest level system API's in C, so it seems okay to have that be an implicit assumption till we come across a system that we want to support and for which C isn't one of the low level system languages.

The patch itself is somewhat repetitive, but otherwise seems ok.

I am a bit curious about the __lldb prefix. I'm wondering if there's a way to avoid having it, while still maintaining isolation from any type with the same name coming from the debug info. I'm thinking about putting it in some kind of an anonymous namespace or something... Does anyone know if that works?

This will be the actual type of an SBValue, as is the case in other instances where we've made up types, so users will see this type if they look closely. So it should be clear from the name that this is just an artificial type lldb made up. __lldb_whatever expresses that pretty clearly, but I'm worried some reasonable looking name in an anonymous namespace would send users off on a wild goose chase.

[mgorny]

lldb/source/API/SBPlatform.cpp

672 ↗

(On Diff #402208)

Sorry, debug leftover ;-).

[mgorny]

Implemented the requested changes.

[mgorny]

Hmm, I think I've exposed it via SBPlatform because originally I planned on writing the tests in Python. However, it ended up being tested through unittests after all, so I think I can remove that part. Lemme try.

[mgorny]

Remove the unnecessary API part.

[jingham]

In D117707#3270323, @mgorny wrote:

Remove the unnecessary API part.

In the end, you will want some SB API exposing this information so users can do something with it. I think returning the SBValue for the Thread is the right way to go. I see you're doing that in https://reviews.llvm.org/D118055.

[jingham]

This looks fine to me.

[labath]

In D117707#3270072, @jingham wrote:

I am a bit curious about the __lldb prefix. I'm wondering if there's a way to avoid having it, while still maintaining isolation from any type with the same name coming from the debug info. I'm thinking about putting it in some kind of an anonymous namespace or something... Does anyone know if that works?

This will be the actual type of an SBValue, as is the case in other instances where we've made up types, so users will see this type if they look closely. So it should be clear from the name that this is just an artificial type lldb made up. __lldb_whatever expresses that pretty clearly, but I'm worried some reasonable looking name in an anonymous namespace would send users off on a wild goose chase.

Yeah, that makes sense.

[mgorny]

Thanks for the review. I'm going to wait with the merging until the other patch is reviewed, in case there are any API changes required here.

lldb/include/lldb/Target/Platform.h

public:
   ///     information type as the entry key and the matching  an array as the
   ///     entry value. \b nullptr if not implemented or  if the process has no
   ///     crash information entry. \b error if an error occured.
   virtual llvm::Expected<StructuredData::DictionarySP>
   FetchExtendedCrashInformation(lldb_private::Process &process) {
     return nullptr;
   }
 
+  virtual CompilerType GetSiginfoType(const llvm::Triple &triple);
+
 protected:
   /// Create a list of ArchSpecs with the given OS and a architectures. The
   /// vendor field is left as an "unspecified unknown".
   static std::vector<ArchSpec>
   CreateArchList(llvm::ArrayRef<llvm::Triple::ArchType> archs,
                  llvm::Triple::OSType os);
 
   /// Private implementation of connecting to a process. If the stream is set

lldb/source/Plugins/Platform/FreeBSD/PlatformFreeBSD.h

 //===-- PlatformFreeBSD.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_SOURCE_PLUGINS_PLATFORM_FREEBSD_PLATFORMFREEBSD_H
 #define LLDB_SOURCE_PLUGINS_PLATFORM_FREEBSD_PLATFORMFREEBSD_H
 
 #include "Plugins/Platform/POSIX/PlatformPOSIX.h"
+#include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
 
 namespace lldb_private {
 namespace platform_freebsd {
 
 class PlatformFreeBSD : public PlatformPOSIX {
 public:
   PlatformFreeBSD(bool is_host);
 
public:
 
   void CalculateTrapHandlerSymbolNames() override;
 
   MmapArgList GetMmapArgumentList(const ArchSpec &arch, lldb::addr_t addr,
                                   lldb::addr_t length, unsigned prot,
                                   unsigned flags, lldb::addr_t fd,
                                   lldb::addr_t offset) override;
 
+  CompilerType GetSiginfoType(const llvm::Triple &triple) override;
+
   std::vector<ArchSpec> m_supported_architectures;
+
+private:
+  std::unique_ptr<TypeSystemClang> m_type_system_up;
 };
 
 } // namespace platform_freebsd
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_PLATFORM_FREEBSD_PLATFORMFREEBSD_H

lldb/source/Plugins/Platform/FreeBSD/PlatformFreeBSD.cpp

MmapArgList PlatformFreeBSD::GetMmapArgumentList(const ArchSpec &arch,
   if (flags & eMmapFlagsAnon)
     flags_platform |= MAP_ANON;
 
   MmapArgList args({addr, length, prot, flags_platform, fd, offset});
   if (arch.GetTriple().getArch() == llvm::Triple::x86)
     args.push_back(0);
   return args;
 }
+
+CompilerType PlatformFreeBSD::GetSiginfoType(const llvm::Triple &triple) {
+  if (!m_type_system_up)
+    m_type_system_up.reset(new TypeSystemClang("siginfo", triple));
+  TypeSystemClang *ast = m_type_system_up.get();
+
+  // generic types
+  CompilerType int_type = ast->GetBasicType(eBasicTypeInt);
+  CompilerType uint_type = ast->GetBasicType(eBasicTypeUnsignedInt);
+  CompilerType long_type = ast->GetBasicType(eBasicTypeLong);
+  CompilerType voidp_type = ast->GetBasicType(eBasicTypeVoid).GetPointerType();
+
+  // platform-specific types
+  CompilerType &pid_type = int_type;
+  CompilerType &uid_type = uint_type;
+
+  CompilerType sigval_type = ast->CreateRecordType(
+      nullptr, OptionalClangModuleID(), lldb::eAccessPublic, "__lldb_sigval_t",
+      clang::TTK_Union, lldb::eLanguageTypeC);
+  ast->StartTagDeclarationDefinition(sigval_type);
+  ast->AddFieldToRecordType(sigval_type, "sival_int", int_type,
+                            lldb::eAccessPublic, 0);
+  ast->AddFieldToRecordType(sigval_type, "sival_ptr", voidp_type,
+                            lldb::eAccessPublic, 0);
+  ast->CompleteTagDeclarationDefinition(sigval_type);
+
+  // siginfo_t
+  CompilerType siginfo_type = ast->CreateRecordType(
+      nullptr, OptionalClangModuleID(), lldb::eAccessPublic, "__lldb_siginfo_t",
+      clang::TTK_Struct, lldb::eLanguageTypeC);
+  ast->StartTagDeclarationDefinition(siginfo_type);
+  ast->AddFieldToRecordType(siginfo_type, "si_signo", int_type,
+                            lldb::eAccessPublic, 0);
+  ast->AddFieldToRecordType(siginfo_type, "si_errno", int_type,
+                            lldb::eAccessPublic, 0);
+  ast->AddFieldToRecordType(siginfo_type, "si_code", int_type,
+                            lldb::eAccessPublic, 0);
+  ast->AddFieldToRecordType(siginfo_type, "si_pid", pid_type,
+                            lldb::eAccessPublic, 0);
+  ast->AddFieldToRecordType(siginfo_type, "si_uid", uid_type,
+                            lldb::eAccessPublic, 0);
+  ast->AddFieldToRecordType(siginfo_type, "si_status", int_type,
+                            lldb::eAccessPublic, 0);
+  ast->AddFieldToRecordType(siginfo_type, "si_addr", voidp_type,
+                            lldb::eAccessPublic, 0);
+  ast->AddFieldToRecordType(siginfo_type, "si_value", sigval_type,
+                            lldb::eAccessPublic, 0);
+
+  // union used to hold the signal data
+  CompilerType union_type = ast->CreateRecordType(
+      nullptr, OptionalClangModuleID(), lldb::eAccessPublic, "",
+      clang::TTK_Union, lldb::eLanguageTypeC);
+  ast->StartTagDeclarationDefinition(union_type);
+
+  ast->AddFieldToRecordType(
+      union_type, "_fault",
+      ast->CreateStructForIdentifier(ConstString(),
+                                     {
+                                         {"_trapno", int_type},
+                                     }),
+      lldb::eAccessPublic, 0);
+
+  ast->AddFieldToRecordType(
+      union_type, "_timer",
+      ast->CreateStructForIdentifier(ConstString(),
+                                     {
+                                         {"_timerid", int_type},
+                                         {"_overrun", int_type},
+                                     }),
+      lldb::eAccessPublic, 0);
+
+  ast->AddFieldToRecordType(
+      union_type, "_mesgq",
+      ast->CreateStructForIdentifier(ConstString(),
+                                     {
+                                         {"_mqd", int_type},
+                                     }),
+      lldb::eAccessPublic, 0);
+
+  ast->AddFieldToRecordType(
+      union_type, "_poll",
+      ast->CreateStructForIdentifier(ConstString(),
+                                     {
+                                         {"_band", long_type},
+                                     }),
+      lldb::eAccessPublic, 0);
+
+  ast->CompleteTagDeclarationDefinition(union_type);
+  ast->AddFieldToRecordType(siginfo_type, "_reason", union_type,
+                            lldb::eAccessPublic, 0);
+
+  ast->CompleteTagDeclarationDefinition(siginfo_type);
+  return siginfo_type;
+}

lldb/source/Plugins/Platform/Linux/PlatformLinux.h

 //===-- PlatformLinux.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_SOURCE_PLUGINS_PLATFORM_LINUX_PLATFORMLINUX_H
 #define LLDB_SOURCE_PLUGINS_PLATFORM_LINUX_PLATFORMLINUX_H
 
 #include "Plugins/Platform/POSIX/PlatformPOSIX.h"
+#include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
 
 namespace lldb_private {
 namespace platform_linux {
 
 class PlatformLinux : public PlatformPOSIX {
 public:
   PlatformLinux(bool is_host);
 
public:
   lldb::UnwindPlanSP GetTrapHandlerUnwindPlan(const llvm::Triple &triple,
                                               ConstString name) override;
 
   MmapArgList GetMmapArgumentList(const ArchSpec &arch, lldb::addr_t addr,
                                   lldb::addr_t length, unsigned prot,
                                   unsigned flags, lldb::addr_t fd,
                                   lldb::addr_t offset) override;
 
+  CompilerType GetSiginfoType(const llvm::Triple &triple) override;
+
   std::vector<ArchSpec> m_supported_architectures;
+
+private:
+  std::unique_ptr<TypeSystemClang> m_type_system_up;
 };
 
 } // namespace platform_linux
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_PLATFORM_LINUX_PLATFORMLINUX_H

lldb/source/Plugins/Platform/Linux/PlatformLinux.cpp

if (flags & eMmapFlagsPrivate)
     flags_platform |= MAP_PRIVATE;
   if (flags & eMmapFlagsAnon)
     flags_platform |= map_anon;
 
   MmapArgList args({addr, length, prot, flags_platform, fd, offset});
   return args;
 }
 
+CompilerType PlatformLinux::GetSiginfoType(const llvm::Triple &triple) {
+  if (!m_type_system_up)
+    m_type_system_up.reset(new TypeSystemClang("siginfo", triple));
+  TypeSystemClang *ast = m_type_system_up.get();
+
+  bool si_errno_then_code = true;
+
+  switch (triple.getArch()) {
+  case llvm::Triple::mips:
+  case llvm::Triple::mipsel:
+  case llvm::Triple::mips64:
+  case llvm::Triple::mips64el:
+    // mips has si_code and si_errno swapped
+    si_errno_then_code = false;
+    break;
+  default:
+    break;
+  }
+
+  // generic types
+  CompilerType int_type = ast->GetBasicType(eBasicTypeInt);
+  CompilerType uint_type = ast->GetBasicType(eBasicTypeUnsignedInt);
+  CompilerType short_type = ast->GetBasicType(eBasicTypeShort);
+  CompilerType long_type = ast->GetBasicType(eBasicTypeLong);
+  CompilerType voidp_type = ast->GetBasicType(eBasicTypeVoid).GetPointerType();
+
+  // platform-specific types
+  CompilerType &pid_type = int_type;
+  CompilerType &uid_type = uint_type;
+  CompilerType &clock_type = long_type;
+  CompilerType &band_type = long_type;
+
+  CompilerType sigval_type = ast->CreateRecordType(
+      nullptr, OptionalClangModuleID(), lldb::eAccessPublic, "__lldb_sigval_t",
+      clang::TTK_Union, lldb::eLanguageTypeC);
+  ast->StartTagDeclarationDefinition(sigval_type);
+  ast->AddFieldToRecordType(sigval_type, "sival_int", int_type,
+                            lldb::eAccessPublic, 0);
+  ast->AddFieldToRecordType(sigval_type, "sival_ptr", voidp_type,
+                            lldb::eAccessPublic, 0);
+  ast->CompleteTagDeclarationDefinition(sigval_type);
+
+  CompilerType sigfault_bounds_type = ast->CreateRecordType(
+      nullptr, OptionalClangModuleID(), lldb::eAccessPublic, "",
+      clang::TTK_Union, lldb::eLanguageTypeC);
+  ast->StartTagDeclarationDefinition(sigfault_bounds_type);
+  ast->AddFieldToRecordType(sigfault_bounds_type, "_addr_bnd",
+      ast->CreateStructForIdentifier(ConstString(),
+                                     {
+                                         {"_lower", voidp_type},
+                                         {"_upper", voidp_type},
+                                     }),
+                            lldb::eAccessPublic, 0);
+  ast->AddFieldToRecordType(sigfault_bounds_type, "_pkey", uint_type,
+                            lldb::eAccessPublic, 0);
+  ast->CompleteTagDeclarationDefinition(sigfault_bounds_type);
+
+  // siginfo_t
+  CompilerType siginfo_type = ast->CreateRecordType(
+      nullptr, OptionalClangModuleID(), lldb::eAccessPublic, "__lldb_siginfo_t",
+      clang::TTK_Struct, lldb::eLanguageTypeC);
+  ast->StartTagDeclarationDefinition(siginfo_type);
+  ast->AddFieldToRecordType(siginfo_type, "si_signo", int_type,
+                            lldb::eAccessPublic, 0);
+
+  if (si_errno_then_code) {
+    ast->AddFieldToRecordType(siginfo_type, "si_errno", int_type,
+                              lldb::eAccessPublic, 0);
+    ast->AddFieldToRecordType(siginfo_type, "si_code", int_type,
+                              lldb::eAccessPublic, 0);
+  } else {
+    ast->AddFieldToRecordType(siginfo_type, "si_code", int_type,
+                              lldb::eAccessPublic, 0);
+    ast->AddFieldToRecordType(siginfo_type, "si_errno", int_type,
+                              lldb::eAccessPublic, 0);
+  }
+
+  // the structure is padded on 64-bit arches to fix alignment
+  if (triple.isArch64Bit())
+    ast->AddFieldToRecordType(siginfo_type, "__pad0", int_type,
+                              lldb::eAccessPublic, 0);
+
+  // union used to hold the signal data
+  CompilerType union_type = ast->CreateRecordType(
+      nullptr, OptionalClangModuleID(), lldb::eAccessPublic, "",
+      clang::TTK_Union, lldb::eLanguageTypeC);
+  ast->StartTagDeclarationDefinition(union_type);
+
+  ast->AddFieldToRecordType(
+      union_type, "_kill",
+      ast->CreateStructForIdentifier(ConstString(),
+                                     {
+                                         {"si_pid", pid_type},
+                                         {"si_uid", uid_type},
+                                     }),
+      lldb::eAccessPublic, 0);
+
+  ast->AddFieldToRecordType(
+      union_type, "_timer",
+      ast->CreateStructForIdentifier(ConstString(),
+                                     {
+                                         {"si_tid", int_type},
+                                         {"si_overrun", int_type},
+                                         {"si_sigval", sigval_type},
+                                     }),
+      lldb::eAccessPublic, 0);
+
+  ast->AddFieldToRecordType(
+      union_type, "_rt",
+      ast->CreateStructForIdentifier(ConstString(),
+                                     {
+                                         {"si_pid", pid_type},
+                                         {"si_uid", uid_type},
+                                         {"si_sigval", sigval_type},
+                                     }),
+      lldb::eAccessPublic, 0);
+
+  ast->AddFieldToRecordType(
+      union_type, "_sigchld",
+      ast->CreateStructForIdentifier(ConstString(),
+                                     {
+                                         {"si_pid", pid_type},
+                                         {"si_uid", uid_type},
+                                         {"si_status", int_type},
+                                         {"si_utime", clock_type},
+                                         {"si_stime", clock_type},
+                                     }),
+      lldb::eAccessPublic, 0);
+
+  ast->AddFieldToRecordType(
+      union_type, "_sigfault",
+      ast->CreateStructForIdentifier(ConstString(),
+                                     {
+                                         {"si_addr", voidp_type},
+                                         {"si_addr_lsb", short_type},
+                                         {"_bounds", sigfault_bounds_type},
+                                     }),
+      lldb::eAccessPublic, 0);
+
+  ast->AddFieldToRecordType(
+      union_type, "_sigpoll",
+      ast->CreateStructForIdentifier(ConstString(),
+                                     {
+                                         {"si_band", band_type},
+                                         {"si_fd", int_type},
+                                     }),
+      lldb::eAccessPublic, 0);
+
+  // NB: SIGSYS is not present on ia64 but we don't seem to support that
+  ast->AddFieldToRecordType(
+      union_type, "_sigsys",
+      ast->CreateStructForIdentifier(ConstString(),
+                                     {
+                                         {"_call_addr", voidp_type},
+                                         {"_syscall", int_type},
+                                         {"_arch", uint_type},
+                                     }),
+      lldb::eAccessPublic, 0);
+
+  ast->CompleteTagDeclarationDefinition(union_type);
+  ast->AddFieldToRecordType(siginfo_type, "_sifields", union_type,
+                            lldb::eAccessPublic, 0);
+
+  ast->CompleteTagDeclarationDefinition(siginfo_type);
+  return siginfo_type;
+}

lldb/source/Plugins/Platform/NetBSD/PlatformNetBSD.h

 //===-- PlatformNetBSD.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_SOURCE_PLUGINS_PLATFORM_NETBSD_PLATFORMNETBSD_H
 #define LLDB_SOURCE_PLUGINS_PLATFORM_NETBSD_PLATFORMNETBSD_H
 
 #include "Plugins/Platform/POSIX/PlatformPOSIX.h"
+#include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
 
 namespace lldb_private {
 namespace platform_netbsd {
 
 class PlatformNetBSD : public PlatformPOSIX {
 public:
   PlatformNetBSD(bool is_host);
 
public:
 
   void CalculateTrapHandlerSymbolNames() override;
 
   MmapArgList GetMmapArgumentList(const ArchSpec &arch, lldb::addr_t addr,
                                   lldb::addr_t length, unsigned prot,
                                   unsigned flags, lldb::addr_t fd,
                                   lldb::addr_t offset) override;
 
+  CompilerType GetSiginfoType(const llvm::Triple &triple) override;
+
   std::vector<ArchSpec> m_supported_architectures;
+
+private:
+  std::unique_ptr<TypeSystemClang> m_type_system_up;
 };
 
 } // namespace platform_netbsd
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_PLATFORM_NETBSD_PLATFORMNETBSD_H

lldb/source/Plugins/Platform/NetBSD/PlatformNetBSD.cpp

MmapArgList PlatformNetBSD::GetMmapArgumentList(const ArchSpec &arch,
   if (flags & eMmapFlagsPrivate)
     flags_platform |= MAP_PRIVATE;
   if (flags & eMmapFlagsAnon)
     flags_platform |= MAP_ANON;
 
   MmapArgList args({addr, length, prot, flags_platform, fd, offset});
   return args;
 }
+
+CompilerType PlatformNetBSD::GetSiginfoType(const llvm::Triple &triple) {
+  if (!m_type_system_up)
+    m_type_system_up.reset(new TypeSystemClang("siginfo", triple));
+  TypeSystemClang *ast = m_type_system_up.get();
+
+  // generic types
+  CompilerType int_type = ast->GetBasicType(eBasicTypeInt);
+  CompilerType uint_type = ast->GetBasicType(eBasicTypeUnsignedInt);
+  CompilerType long_type = ast->GetBasicType(eBasicTypeLong);
+  CompilerType long_long_type = ast->GetBasicType(eBasicTypeLongLong);
+  CompilerType voidp_type = ast->GetBasicType(eBasicTypeVoid).GetPointerType();
+
+  // platform-specific types
+  CompilerType &pid_type = int_type;
+  CompilerType &uid_type = uint_type;
+  CompilerType &clock_type = uint_type;
+  CompilerType &lwpid_type = int_type;
+
+  CompilerType sigval_type = ast->CreateRecordType(
+      nullptr, OptionalClangModuleID(), lldb::eAccessPublic, "__lldb_sigval_t",
+      clang::TTK_Union, lldb::eLanguageTypeC);
+  ast->StartTagDeclarationDefinition(sigval_type);
+  ast->AddFieldToRecordType(sigval_type, "sival_int", int_type,
+                            lldb::eAccessPublic, 0);
+  ast->AddFieldToRecordType(sigval_type, "sival_ptr", voidp_type,
+                            lldb::eAccessPublic, 0);
+  ast->CompleteTagDeclarationDefinition(sigval_type);
+
+  CompilerType ptrace_option_type = ast->CreateRecordType(
+      nullptr, OptionalClangModuleID(), lldb::eAccessPublic, "",
+      clang::TTK_Union, lldb::eLanguageTypeC);
+  ast->StartTagDeclarationDefinition(ptrace_option_type);
+  ast->AddFieldToRecordType(ptrace_option_type, "_pe_other_pid", pid_type,
+                            lldb::eAccessPublic, 0);
+  ast->AddFieldToRecordType(ptrace_option_type, "_pe_lwp", lwpid_type,
+                            lldb::eAccessPublic, 0);
+  ast->CompleteTagDeclarationDefinition(ptrace_option_type);
+
+  // siginfo_t
+  CompilerType siginfo_type = ast->CreateRecordType(
+      nullptr, OptionalClangModuleID(), lldb::eAccessPublic, "__lldb_siginfo_t",
+      clang::TTK_Union, lldb::eLanguageTypeC);
+  ast->StartTagDeclarationDefinition(siginfo_type);
+
+  // struct _ksiginfo
+  CompilerType ksiginfo_type = ast->CreateRecordType(
+      nullptr, OptionalClangModuleID(), lldb::eAccessPublic, "",
+      clang::TTK_Struct, lldb::eLanguageTypeC);
+  ast->StartTagDeclarationDefinition(ksiginfo_type);
+  ast->AddFieldToRecordType(ksiginfo_type, "_signo", int_type,
+                            lldb::eAccessPublic, 0);
+  ast->AddFieldToRecordType(ksiginfo_type, "_code", int_type,
+                            lldb::eAccessPublic, 0);
+  ast->AddFieldToRecordType(ksiginfo_type, "_errno", int_type,
+                            lldb::eAccessPublic, 0);
+
+  // the structure is padded on 64-bit arches to fix alignment
+  if (triple.isArch64Bit())
+    ast->AddFieldToRecordType(ksiginfo_type, "__pad0", int_type,
+                              lldb::eAccessPublic, 0);
+
+  // union used to hold the signal data
+  CompilerType union_type = ast->CreateRecordType(
+      nullptr, OptionalClangModuleID(), lldb::eAccessPublic, "",
+      clang::TTK_Union, lldb::eLanguageTypeC);
+  ast->StartTagDeclarationDefinition(union_type);
+
+  ast->AddFieldToRecordType(
+      union_type, "_rt",
+      ast->CreateStructForIdentifier(ConstString(),
+                                     {
+                                         {"_pid", pid_type},
+                                         {"_uid", uid_type},
+                                         {"_value", sigval_type},
+                                     }),
+      lldb::eAccessPublic, 0);
+
+  ast->AddFieldToRecordType(
+      union_type, "_child",
+      ast->CreateStructForIdentifier(ConstString(),
+                                     {
+                                         {"_pid", pid_type},
+                                         {"_uid", uid_type},
+                                         {"_status", int_type},
+                                         {"_utime", clock_type},
+                                         {"_stime", clock_type},
+                                     }),
+      lldb::eAccessPublic, 0);
+
+  ast->AddFieldToRecordType(
+      union_type, "_fault",
+      ast->CreateStructForIdentifier(ConstString(),
+                                     {
+                                         {"_addr", voidp_type},
+                                         {"_trap", int_type},
+                                         {"_trap2", int_type},
+                                         {"_trap3", int_type},
+                                     }),
+      lldb::eAccessPublic, 0);
+
+  ast->AddFieldToRecordType(
+      union_type, "_poll",
+      ast->CreateStructForIdentifier(ConstString(),
+                                     {
+                                         {"_band", long_type},
+                                         {"_fd", int_type},
+                                     }),
+      lldb::eAccessPublic, 0);
+
+  ast->AddFieldToRecordType(union_type, "_syscall",
+                            ast->CreateStructForIdentifier(
+                                ConstString(),
+                                {
+                                    {"_sysnum", int_type},
+                                    {"_retval", int_type.GetArrayType(2)},
+                                    {"_error", int_type},
+                                    {"_args", long_long_type.GetArrayType(8)},
+                                }),
+                            lldb::eAccessPublic, 0);
+
+  ast->AddFieldToRecordType(
+      union_type, "_ptrace_state",
+      ast->CreateStructForIdentifier(ConstString(),
+                                     {
+                                         {"_pe_report_event", int_type},
+                                         {"_option", ptrace_option_type},
+                                     }),
+      lldb::eAccessPublic, 0);
+
+  ast->CompleteTagDeclarationDefinition(union_type);
+  ast->AddFieldToRecordType(ksiginfo_type, "_reason", union_type,
+                            lldb::eAccessPublic, 0);
+
+  ast->CompleteTagDeclarationDefinition(ksiginfo_type);
+  ast->AddFieldToRecordType(siginfo_type, "_info", ksiginfo_type,
+                            lldb::eAccessPublic, 0);
+
+  ast->CompleteTagDeclarationDefinition(siginfo_type);
+  return siginfo_type;
+}

lldb/source/Target/Platform.cpp

size_t Platform::GetSoftwareBreakpointTrapOpcode(Target &target,
   }
 
   assert(bp_site);
   if (bp_site->SetTrapOpcode(trap_opcode, trap_opcode_size))
     return trap_opcode_size;
 
   return 0;
 }
+
+CompilerType Platform::GetSiginfoType(const llvm::Triple& triple) {
+  return CompilerType();
+}

lldb/unittests/Platform/CMakeLists.txt

 add_lldb_unittest(LLDBPlatformTests
   PlatformAppleSimulatorTest.cpp
   PlatformDarwinTest.cpp
+  PlatformSiginfoTest.cpp
 
   LINK_LIBS
+    lldbPluginPlatformFreeBSD
+    lldbPluginPlatformLinux
     lldbPluginPlatformMacOSX
+    lldbPluginPlatformNetBSD
   LINK_COMPONENTS
     Support
   )
 
 add_subdirectory(Android)

lldb/unittests/Platform/PlatformSiginfoTest.cpp

+//===-- PlatformSiginfoTest.cpp -------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "gtest/gtest.h"
+
+#include <initializer_list>
+#include <tuple>
+
+#include "Plugins/Platform/FreeBSD/PlatformFreeBSD.h"
+#include "Plugins/Platform/Linux/PlatformLinux.h"
+#include "Plugins/Platform/NetBSD/PlatformNetBSD.h"
+#include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
+
+#include "TestingSupport/SubsystemRAII.h"
+#include "lldb/Core/Debugger.h"
+#include "lldb/Host/FileSystem.h"
+#include "lldb/Host/HostInfo.h"
+#include "lldb/Utility/ArchSpec.h"
+#include "lldb/Utility/Reproducer.h"
+
+using namespace lldb;
+using namespace lldb_private;
+using namespace lldb_private::repro;
+
+namespace {
+class PlatformSiginfoTest : public ::testing::Test {
+  SubsystemRAII<FileSystem, HostInfo, TypeSystemClang> subsystems;
+  PlatformSP platform_sp;
+  DebuggerSP debugger_sp;
+  TargetSP target_sp;
+
+public:
+  CompilerType siginfo_type;
+
+  void SetUp() override {
+    llvm::cantFail(Reproducer::Initialize(ReproducerMode::Off, llvm::None));
+    platform_freebsd::PlatformFreeBSD::Initialize();
+    platform_linux::PlatformLinux::Initialize();
+    platform_netbsd::PlatformNetBSD::Initialize();
+  }
+
+  void TearDown() override {
+    platform_netbsd::PlatformNetBSD::Terminate();
+    platform_linux::PlatformLinux::Terminate();
+    platform_freebsd::PlatformFreeBSD::Terminate();
+    Reproducer::Terminate();
+  }
+
+  typedef std::tuple<const char *, uint64_t, uint64_t> field_tuple;
+
+  void ExpectField(const CompilerType &siginfo_type, field_tuple field) {
+    const char *path;
+    uint64_t offset, size;
+    std::tie(path, offset, size) = field;
+
+    SCOPED_TRACE(path);
+    CompilerType field_type = siginfo_type;
+    uint64_t total_offset = 0;
+    for (auto field_name : llvm::split(path, '.')) {
+      uint64_t bit_offset;
+      ASSERT_NE(field_type.GetIndexOfFieldWithName(field_name.str().c_str(),
+                                                   &field_type, &bit_offset),
+                UINT32_MAX);
+      total_offset += bit_offset;
+    }
+
+    EXPECT_EQ(total_offset, offset * 8);
+    EXPECT_EQ(field_type.GetByteSize(nullptr), llvm::Optional<uint64_t>(size));
+  }
+
+  void ExpectFields(const CompilerType &container,
+                    std::initializer_list<field_tuple> fields) {
+    for (auto x : fields)
+      ExpectField(container, x);
+  }
+
+  void InitializeSiginfo(const std::string &triple) {
+    ArchSpec arch(triple);
+
+    switch (arch.GetTriple().getOS()) {
+    case llvm::Triple::FreeBSD:
+      platform_sp =
+          platform_freebsd::PlatformFreeBSD::CreateInstance(true, &arch);
+      break;
+    case llvm::Triple::Linux:
+      platform_sp = platform_linux::PlatformLinux::CreateInstance(true, &arch);
+      break;
+    case llvm::Triple::NetBSD:
+      platform_sp =
+          platform_netbsd::PlatformNetBSD::CreateInstance(true, &arch);
+      break;
+    default:
+      llvm_unreachable("unknown ostype in triple");
+    }
+    Platform::SetHostPlatform(platform_sp);
+
+    debugger_sp = Debugger::CreateInstance();
+    ASSERT_TRUE(debugger_sp);
+
+    debugger_sp->GetTargetList().CreateTarget(
+        *debugger_sp, "", arch, eLoadDependentsNo, platform_sp, target_sp);
+    ASSERT_TRUE(target_sp);
+
+    siginfo_type = platform_sp->GetSiginfoType(arch.GetTriple());
+  }
+};
+
+} // namespace
+
+TEST_F(PlatformSiginfoTest, TestLinux_64bit) {
+  for (std::string arch : {"x86_64", "aarch64", "powerpc64le"}) {
+    SCOPED_TRACE(arch);
+    InitializeSiginfo(arch + "-pc-linux-gnu");
+    ASSERT_TRUE(siginfo_type);
+
+    ExpectFields(siginfo_type,
+                 {
+                     {"si_signo", 0, 4},
+                     {"si_errno", 4, 4},
+                     {"si_code", 8, 4},
+                     {"_sifields._kill.si_pid", 16, 4},
+                     {"_sifields._kill.si_uid", 20, 4},
+                     {"_sifields._timer.si_tid", 16, 4},
+                     {"_sifields._timer.si_overrun", 20, 4},
+                     {"_sifields._timer.si_sigval", 24, 8},
+                     {"_sifields._rt.si_pid", 16, 4},
+                     {"_sifields._rt.si_uid", 20, 4},
+                     {"_sifields._rt.si_sigval", 24, 8},
+                     {"_sifields._sigchld.si_pid", 16, 4},
+                     {"_sifields._sigchld.si_uid", 20, 4},
+                     {"_sifields._sigchld.si_status", 24, 4},
+                     {"_sifields._sigchld.si_utime", 32, 8},
+                     {"_sifields._sigchld.si_stime", 40, 8},
+                     {"_sifields._sigfault.si_addr", 16, 8},
+                     {"_sifields._sigfault.si_addr_lsb", 24, 2},
+                     {"_sifields._sigfault._bounds._addr_bnd._lower", 32, 8},
+                     {"_sifields._sigfault._bounds._addr_bnd._upper", 40, 8},
+                     {"_sifields._sigfault._bounds._pkey", 32, 4},
+                     {"_sifields._sigpoll.si_band", 16, 8},
+                     {"_sifields._sigpoll.si_fd", 24, 4},
+                     {"_sifields._sigsys._call_addr", 16, 8},
+                     {"_sifields._sigsys._syscall", 24, 4},
+                     {"_sifields._sigsys._arch", 28, 4},
+                 });
+  }
+}
+
+TEST_F(PlatformSiginfoTest, TestLinux_32bit) {
+  for (std::string arch : {"i386", "armv7"}) {
+    SCOPED_TRACE(arch);
+    InitializeSiginfo(arch + "-pc-linux");
+    ASSERT_TRUE(siginfo_type);
+
+    ExpectFields(siginfo_type,
+                 {
+                     {"si_signo", 0, 4},
+                     {"si_errno", 4, 4},
+                     {"si_code", 8, 4},
+                     {"_sifields._kill.si_pid", 12, 4},
+                     {"_sifields._kill.si_uid", 16, 4},
+                     {"_sifields._timer.si_tid", 12, 4},
+                     {"_sifields._timer.si_overrun", 16, 4},
+                     {"_sifields._timer.si_sigval", 20, 4},
+                     {"_sifields._rt.si_pid", 12, 4},
+                     {"_sifields._rt.si_uid", 16, 4},
+                     {"_sifields._rt.si_sigval", 20, 4},
+                     {"_sifields._sigchld.si_pid", 12, 4},
+                     {"_sifields._sigchld.si_uid", 16, 4},
+                     {"_sifields._sigchld.si_status", 20, 4},
+                     {"_sifields._sigchld.si_utime", 24, 4},
+                     {"_sifields._sigchld.si_stime", 28, 4},
+                     {"_sifields._sigfault.si_addr", 12, 4},
+                     {"_sifields._sigfault.si_addr_lsb", 16, 2},
+                     {"_sifields._sigfault._bounds._addr_bnd._lower", 20, 4},
+                     {"_sifields._sigfault._bounds._addr_bnd._upper", 24, 4},
+                     {"_sifields._sigfault._bounds._pkey", 20, 4},
+                     {"_sifields._sigpoll.si_band", 12, 4},
+                     {"_sifields._sigpoll.si_fd", 16, 4},
+                     {"_sifields._sigsys._call_addr", 12, 4},
+                     {"_sifields._sigsys._syscall", 16, 4},
+                     {"_sifields._sigsys._arch", 20, 4},
+                 });
+  }
+}
+
+TEST_F(PlatformSiginfoTest, TestFreeBSD_64bit) {
+  for (std::string arch : {"x86_64", "aarch64"}) {
+    SCOPED_TRACE(arch);
+    InitializeSiginfo("x86_64-unknown-freebsd13.0");
+    ASSERT_TRUE(siginfo_type);
+
+    ExpectFields(siginfo_type, {
+                                   {"si_signo", 0, 4},
+                                   {"si_errno", 4, 4},
+                                   {"si_code", 8, 4},
+                                   {"si_pid", 12, 4},
+                                   {"si_uid", 16, 4},
+                                   {"si_status", 20, 4},
+                                   {"si_addr", 24, 8},
+                                   {"si_value", 32, 8},
+                                   {"_reason._fault._trapno", 40, 4},
+                                   {"_reason._timer._timerid", 40, 4},
+                                   {"_reason._timer._overrun", 44, 4},
+                                   {"_reason._mesgq._mqd", 40, 4},
+                                   {"_reason._poll._band", 40, 8},
+                               });
+  }
+}
+
+TEST_F(PlatformSiginfoTest, TestFreeBSD_32bit) {
+  for (std::string arch : {"i386"}) {
+    SCOPED_TRACE(arch);
+    InitializeSiginfo(arch + "-unknown-freebsd13.0");
+    ASSERT_TRUE(siginfo_type);
+
+    ExpectFields(siginfo_type, {
+                                   {"si_signo", 0, 4},
+                                   {"si_errno", 4, 4},
+                                   {"si_code", 8, 4},
+                                   {"si_pid", 12, 4},
+                                   {"si_uid", 16, 4},
+                                   {"si_status", 20, 4},
+                                   {"si_addr", 24, 4},
+                                   {"si_value", 28, 4},
+                                   {"_reason._fault._trapno", 32, 4},
+                                   {"_reason._timer._timerid", 32, 4},
+                                   {"_reason._timer._overrun", 36, 4},
+                                   {"_reason._mesgq._mqd", 32, 4},
+                                   {"_reason._poll._band", 32, 4},
+                               });
+  }
+}
+
+TEST_F(PlatformSiginfoTest, TestNetBSD_64bit) {
+  for (std::string arch : {"x86_64"}) {
+    SCOPED_TRACE(arch);
+    InitializeSiginfo(arch + "-unknown-netbsd9.0");
+    ASSERT_TRUE(siginfo_type);
+
+    ExpectFields(
+        siginfo_type,
+        {
+            {"_info._signo", 0, 4},
+            {"_info._code", 4, 4},
+            {"_info._errno", 8, 4},
+            {"_info._reason._rt._pid", 16, 4},
+            {"_info._reason._rt._uid", 20, 4},
+            {"_info._reason._rt._value", 24, 8},
+            {"_info._reason._child._pid", 16, 4},
+            {"_info._reason._child._uid", 20, 4},
+            {"_info._reason._child._status", 24, 4},
+            {"_info._reason._child._utime", 28, 4},
+            {"_info._reason._child._stime", 32, 4},
+            {"_info._reason._fault._addr", 16, 8},
+            {"_info._reason._fault._trap", 24, 4},
+            {"_info._reason._fault._trap2", 28, 4},
+            {"_info._reason._fault._trap3", 32, 4},
+            {"_info._reason._poll._band", 16, 8},
+            {"_info._reason._poll._fd", 24, 4},
+            {"_info._reason._syscall._sysnum", 16, 4},
+            {"_info._reason._syscall._retval", 20, 8},
+            {"_info._reason._syscall._error", 28, 4},
+            {"_info._reason._syscall._args", 32, 64},
+            {"_info._reason._ptrace_state._pe_report_event", 16, 4},
+            {"_info._reason._ptrace_state._option._pe_other_pid", 20, 4},
+            {"_info._reason._ptrace_state._option._pe_lwp", 20, 4},
+        });
+  }
+}
+
+TEST_F(PlatformSiginfoTest, TestNetBSD_32bit) {
+  for (std::string arch : {"i386"}) {
+    SCOPED_TRACE(arch);
+    InitializeSiginfo(arch + "-unknown-netbsd9.0");
+    ASSERT_TRUE(siginfo_type);
+
+    ExpectFields(
+        siginfo_type,
+        {
+            {"_info._signo", 0, 4},
+            {"_info._code", 4, 4},
+            {"_info._errno", 8, 4},
+            {"_info._reason._rt._pid", 12, 4},
+            {"_info._reason._rt._uid", 16, 4},
+            {"_info._reason._rt._value", 20, 4},
+            {"_info._reason._child._pid", 12, 4},
+            {"_info._reason._child._uid", 16, 4},
+            {"_info._reason._child._status", 20, 4},
+            {"_info._reason._child._utime", 24, 4},
+            {"_info._reason._child._stime", 28, 4},
+            {"_info._reason._fault._addr", 12, 4},
+            {"_info._reason._fault._trap", 16, 4},
+            {"_info._reason._fault._trap2", 20, 4},
+            {"_info._reason._fault._trap3", 24, 4},
+            {"_info._reason._poll._band", 12, 4},
+            {"_info._reason._poll._fd", 16, 4},
+            {"_info._reason._syscall._sysnum", 12, 4},
+            {"_info._reason._syscall._retval", 16, 8},
+            {"_info._reason._syscall._error", 24, 4},
+            {"_info._reason._syscall._args", 28, 64},
+            {"_info._reason._ptrace_state._pe_report_event", 12, 4},
+            {"_info._reason._ptrace_state._option._pe_other_pid", 16, 4},
+            {"_info._reason._ptrace_state._option._pe_lwp", 16, 4},
+        });
+  }
+}

lldb/unittests/Platform/tools/generate_siginfo.c

+//===-- generate_siginfo_linux.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
+//
+//===----------------------------------------------------------------------===//
+
+#include <signal.h>
+#include <stddef.h>
+#include <stdio.h>
+
+siginfo_t siginfo;
+
+#define P(member)                                                              \
+  printf("                   {\"%s\", %zd, %zd},\n", #member,   \
+         offsetof(siginfo_t, member), sizeof(siginfo.member));
+
+// undef annoying "POSIX friendliness" macros
+#undef si_pid
+#undef si_uid
+#undef si_overrun
+#undef si_status
+#undef si_utime
+#undef si_stime
+#undef si_addr
+#undef si_addr_lsb
+#undef si_band
+#undef si_fd
+
+int main() {
+  printf("  ExpectFields(siginfo_type,\n");
+  printf("               {\n");
+
+#if !defined(__NetBSD__)
+  P(si_signo);
+  P(si_errno);
+  P(si_code);
+
+#if defined(__GLIBC__)
+  P(_sifields._kill.si_pid);
+  P(_sifields._kill.si_uid);
+  P(_sifields._timer.si_tid);
+  P(_sifields._timer.si_overrun);
+  P(_sifields._timer.si_sigval);
+  P(_sifields._rt.si_pid);
+  P(_sifields._rt.si_uid);
+  P(_sifields._rt.si_sigval);
+  P(_sifields._sigchld.si_pid);
+  P(_sifields._sigchld.si_uid);
+  P(_sifields._sigchld.si_status);
+  P(_sifields._sigchld.si_utime);
+  P(_sifields._sigchld.si_stime);
+  P(_sifields._sigfault.si_addr);
+  P(_sifields._sigfault.si_addr_lsb);
+  P(_sifields._sigfault._bounds._addr_bnd._lower);
+  P(_sifields._sigfault._bounds._addr_bnd._upper);
+  P(_sifields._sigfault._bounds._pkey);
+  P(_sifields._sigpoll.si_band);
+  P(_sifields._sigpoll.si_fd);
+  P(_sifields._sigsys._call_addr);
+  P(_sifields._sigsys._syscall);
+  P(_sifields._sigsys._arch);
+#endif // defined(__GLIBC__)
+
+#if defined(__FreeBSD__)
+  // these are top-level fields on FreeBSD
+  P(si_pid);
+  P(si_uid);
+  P(si_status);
+  P(si_addr);
+  P(si_value);
+  P(_reason._fault._trapno);
+  P(_reason._timer._timerid);
+  P(_reason._timer._overrun);
+  P(_reason._mesgq._mqd);
+  P(_reason._poll._band);
+#endif // defined(__FreeBSD__)
+
+#else // defined(__NetBSD__)
+
+  P(_info._signo);
+  P(_info._code);
+  P(_info._errno);
+  P(_info._reason._rt._pid);
+  P(_info._reason._rt._uid);
+  P(_info._reason._rt._value);
+  P(_info._reason._child._pid);
+  P(_info._reason._child._uid);
+  P(_info._reason._child._status);
+  P(_info._reason._child._utime);
+  P(_info._reason._child._stime);
+  P(_info._reason._fault._addr);
+  P(_info._reason._fault._trap);
+  P(_info._reason._fault._trap2);
+  P(_info._reason._fault._trap3);
+  P(_info._reason._poll._band);
+  P(_info._reason._poll._fd);
+  P(_info._reason._syscall._sysnum);
+  P(_info._reason._syscall._retval);
+  P(_info._reason._syscall._error);
+  P(_info._reason._syscall._args);
+  P(_info._reason._ptrace_state._pe_report_event);
+  P(_info._reason._ptrace_state._option._pe_other_pid);
+  P(_info._reason._ptrace_state._option._pe_lwp);
+
+#endif // defined(__NetBSD__)
+
+  printf("               });\n");
+
+  return 0;
+}