mgorny updated this revision to Diff 402110. mgorny added a comment. Turn `PlatformLinuxTest` into a more generic `PlatformSiginfoTest`, to improve code reuse between platforms. Start preparing for testing FreeBSD.
CHANGES SINCE LAST ACTION https://reviews.llvm.org/D117707/new/ https://reviews.llvm.org/D117707 Files: lldb/bindings/interface/SBPlatform.i lldb/include/lldb/API/SBPlatform.h lldb/include/lldb/API/SBType.h lldb/include/lldb/Target/Platform.h lldb/source/API/SBPlatform.cpp lldb/source/Plugins/Platform/Linux/PlatformLinux.cpp lldb/source/Plugins/Platform/Linux/PlatformLinux.h lldb/source/Target/Platform.cpp lldb/unittests/Platform/CMakeLists.txt lldb/unittests/Platform/PlatformSiginfoTest.cpp lldb/unittests/Platform/tools/generate_siginfo.c
Index: lldb/unittests/Platform/tools/generate_siginfo.c =================================================================== --- /dev/null +++ lldb/unittests/Platform/tools/generate_siginfo.c @@ -0,0 +1,63 @@ +//===-- 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 glibc 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"); + P(si_signo); + P(si_errno); + P(si_code); + 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); + printf(" });\n"); + + return 0; +} Index: lldb/unittests/Platform/PlatformSiginfoTest.cpp =================================================================== --- /dev/null +++ lldb/unittests/Platform/PlatformSiginfoTest.cpp @@ -0,0 +1,281 @@ +//===-- 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/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(); + } + + void TearDown() override { + 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 char *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; + 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(*target_sp); + } +}; + +} // namespace + +TEST_F(PlatformSiginfoTest, TestLinux_x86_64) { + InitializeSiginfo("x86_64-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", 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_i386) { + InitializeSiginfo("i386-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, TestLinux_aarch64) { + InitializeSiginfo("aarch64-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", 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_arm) { + InitializeSiginfo("armv7-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, TestLinux_ppc64le) { + InitializeSiginfo("powerpc64le-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", 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}, + }); +} Index: lldb/unittests/Platform/CMakeLists.txt =================================================================== --- lldb/unittests/Platform/CMakeLists.txt +++ lldb/unittests/Platform/CMakeLists.txt @@ -1,8 +1,11 @@ add_lldb_unittest(LLDBPlatformTests PlatformAppleSimulatorTest.cpp PlatformDarwinTest.cpp + PlatformSiginfoTest.cpp LINK_LIBS + lldbPluginPlatformFreeBSD + lldbPluginPlatformLinux lldbPluginPlatformMacOSX LINK_COMPONENTS Support Index: lldb/source/Target/Platform.cpp =================================================================== --- lldb/source/Target/Platform.cpp +++ lldb/source/Target/Platform.cpp @@ -2003,3 +2003,7 @@ return 0; } + +CompilerType Platform::GetSiginfoType(lldb_private::Target &target) { + return CompilerType(); +} Index: lldb/source/Plugins/Platform/Linux/PlatformLinux.h =================================================================== --- lldb/source/Plugins/Platform/Linux/PlatformLinux.h +++ lldb/source/Plugins/Platform/Linux/PlatformLinux.h @@ -58,6 +58,8 @@ unsigned flags, lldb::addr_t fd, lldb::addr_t offset) override; + CompilerType GetSiginfoType(lldb_private::Target &target) override; + std::vector<ArchSpec> m_supported_architectures; }; Index: lldb/source/Plugins/Platform/Linux/PlatformLinux.cpp =================================================================== --- lldb/source/Plugins/Platform/Linux/PlatformLinux.cpp +++ lldb/source/Plugins/Platform/Linux/PlatformLinux.cpp @@ -14,6 +14,7 @@ #include <sys/utsname.h> #endif +#include "Plugins/TypeSystem/Clang/TypeSystemClang.h" #include "Utility/ARM64_DWARF_Registers.h" #include "lldb/Core/Debugger.h" #include "lldb/Core/PluginManager.h" @@ -309,3 +310,183 @@ return args; } +CompilerType PlatformLinux::GetSiginfoType(lldb_private::Target &target) { + CompilerType type; + TypeSystemClang *ast = ScratchTypeSystemClang::GetForTarget(target); + if (!ast) + return type; + + const ArchSpec &arch = target.GetArchitecture(); + bool is_64bit = arch.GetAddressByteSize() == 8; + bool si_errno_then_code = true; + bool si_band_type_is_int = false; + + // TODO: do we actually care about sparc here? lldb doesn't seem to have + // any sparc support + switch (arch.GetMachine()) { + 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; + case llvm::Triple::sparc: + case llvm::Triple::sparcel: + case llvm::Triple::sparcv9: + // sparc64 uses int for __SI_BAND_TYPE + if (is_64bit) + si_band_type_is_int = true; + 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 = si_band_type_is_int ? int_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 (is_64bit) + 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}, + // NB: sparc has extra _si_trapno here + {"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; +} Index: lldb/source/API/SBPlatform.cpp =================================================================== --- lldb/source/API/SBPlatform.cpp +++ lldb/source/API/SBPlatform.cpp @@ -12,6 +12,8 @@ #include "lldb/API/SBFileSpec.h" #include "lldb/API/SBLaunchInfo.h" #include "lldb/API/SBPlatform.h" +#include "lldb/API/SBTarget.h" +#include "lldb/API/SBType.h" #include "lldb/API/SBUnixSignals.h" #include "lldb/Host/File.h" #include "lldb/Target/Platform.h" @@ -657,3 +659,16 @@ return SBEnvironment(); } + +SBType SBPlatform::GetSiginfoType(const lldb::SBTarget &target) { + LLDB_INSTRUMENT_VA(this, target); + + PlatformSP platform_sp(GetSP()); + TargetSP target_sp(target.GetSP()); + + if (platform_sp && target_sp) + return SBType(platform_sp->GetSiginfoType(*target_sp)); + + assert(target_sp); + return SBType(); +} Index: lldb/include/lldb/Target/Platform.h =================================================================== --- lldb/include/lldb/Target/Platform.h +++ lldb/include/lldb/Target/Platform.h @@ -863,6 +863,8 @@ return nullptr; } + virtual CompilerType GetSiginfoType(lldb_private::Target &target); + protected: /// Create a list of ArchSpecs with the given OS and a architectures. The /// vendor field is left as an "unspecified unknown". Index: lldb/include/lldb/API/SBType.h =================================================================== --- lldb/include/lldb/API/SBType.h +++ lldb/include/lldb/API/SBType.h @@ -224,6 +224,7 @@ friend class SBFunction; friend class SBModule; + friend class SBPlatform; friend class SBTarget; friend class SBTypeEnumMember; friend class SBTypeEnumMemberList; Index: lldb/include/lldb/API/SBPlatform.h =================================================================== --- lldb/include/lldb/API/SBPlatform.h +++ lldb/include/lldb/API/SBPlatform.h @@ -169,6 +169,8 @@ /// environment. SBEnvironment GetEnvironment(); + SBType GetSiginfoType(const lldb::SBTarget &target); + protected: friend class SBDebugger; friend class SBTarget; Index: lldb/bindings/interface/SBPlatform.i =================================================================== --- lldb/bindings/interface/SBPlatform.i +++ lldb/bindings/interface/SBPlatform.i @@ -213,6 +213,9 @@ lldb::SBEnvironment GetEnvironment(); + lldb::SBType + GetSiginfoType(lldb::SBTarget &target); + }; } // namespace lldb
_______________________________________________ lldb-commits mailing list lldb-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/lldb-commits
