return 1;
}
- virtual const lldb::UnixSignalsSP &GetRemoteUnixSignals();
+ virtual lldb::UnixSignalsSP GetRemoteUnixSignals();
lldb::UnixSignalsSP GetUnixSignals();
+ virtual lldb::UnixSignalsSP CreateUnixSignals() = 0;
+
/// Locate a queue name given a thread's qaddr
///
/// On a system using libdispatch ("Grand Central Dispatch") style queues, a
class UnixSignals {
public:
- static lldb::UnixSignalsSP Create(const ArchSpec &arch);
static lldb::UnixSignalsSP CreateForHost();
// Constructors and Destructors
lldbUtility
lldbPluginExpressionParserClang
lldbPluginCPPRuntime
+ lldbPluginProcessUtility
lldbPluginTypeSystemClang
CLANG_LIBS
clangAST
add_lldb_library(lldbPluginPlatformFreeBSD PLUGIN
+ FreeBSDSignals.cpp
PlatformFreeBSD.cpp
LINK_LIBS
//===----------------------------------------------------------------------===//
#include "PlatformFreeBSD.h"
+#include "FreeBSDSignals.h"
#include "lldb/Host/Config.h"
#include <cstdio>
ast->CompleteTagDeclarationDefinition(siginfo_type);
return siginfo_type;
}
+
+lldb::UnixSignalsSP PlatformFreeBSD::CreateUnixSignals() {
+ return std::make_shared<FreeBSDSignals>();
+}
std::vector<ArchSpec> m_supported_architectures;
+ lldb::UnixSignalsSP CreateUnixSignals() override;
+
private:
std::mutex m_mutex;
std::shared_ptr<TypeSystemClang> m_type_system;
add_lldb_library(lldbPluginPlatformLinux PLUGIN
+ LinuxSignals.cpp
PlatformLinux.cpp
LINK_LIBS
//===----------------------------------------------------------------------===//
#include "PlatformLinux.h"
+#include "LinuxSignals.h"
#include "lldb/Host/Config.h"
#include <cstdio>
ast->CompleteTagDeclarationDefinition(siginfo_type);
return siginfo_type;
}
+
+lldb::UnixSignalsSP PlatformLinux::CreateUnixSignals() {
+ return std::make_shared<LinuxSignals>();
+}
std::vector<ArchSpec> m_supported_architectures;
+ lldb::UnixSignalsSP CreateUnixSignals() override;
+
private:
std::mutex m_mutex;
std::shared_ptr<TypeSystemClang> m_type_system;
add_lldb_library(lldbPluginPlatformNetBSD PLUGIN
+ NetBSDSignals.cpp
PlatformNetBSD.cpp
LINK_LIBS
//===----------------------------------------------------------------------===//
#include "PlatformNetBSD.h"
+#include "NetBSDSignals.h"
#include "lldb/Host/Config.h"
#include <cstdio>
ast->CompleteTagDeclarationDefinition(siginfo_type);
return siginfo_type;
}
+
+lldb::UnixSignalsSP PlatformNetBSD::CreateUnixSignals() {
+ return std::make_shared<NetBSDSignals>();
+}
std::vector<ArchSpec> m_supported_architectures;
+ lldb::UnixSignalsSP CreateUnixSignals() override;
+
private:
std::mutex m_mutex;
std::shared_ptr<TypeSystemClang> m_type_system;
#include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/Thread.h"
+#include "lldb/Target/UnixSignals.h"
#include "lldb/Utility/DataBufferHeap.h"
#include "lldb/Utility/FileSpec.h"
#include "lldb/Utility/LLDBLog.h"
return "";
}
-const lldb::UnixSignalsSP &PlatformPOSIX::GetRemoteUnixSignals() {
- if (IsRemote() && m_remote_platform_sp)
- return m_remote_platform_sp->GetRemoteUnixSignals();
+lldb::UnixSignalsSP PlatformPOSIX::GetRemoteUnixSignals() {
+ if (IsRemote() && m_remote_platform_sp) {
+ if (auto unix_signals_sp = m_remote_platform_sp->GetRemoteUnixSignals())
+ return unix_signals_sp;
+ }
+ if (auto unix_signals_sp = CreateUnixSignals())
+ return unix_signals_sp;
return Platform::GetRemoteUnixSignals();
}
stream.Printf("lib%s.so", basename.GetCString());
return ConstString(stream.GetString());
}
+
+lldb::UnixSignalsSP PlatformPOSIX::CreateUnixSignals() {
+ return std::make_shared<UnixSignals>();
+}
GetFile(const lldb_private::FileSpec &source,
const lldb_private::FileSpec &destination) override;
- const lldb::UnixSignalsSP &GetRemoteUnixSignals() override;
+ lldb::UnixSignalsSP GetRemoteUnixSignals() override;
lldb::ProcessSP Attach(lldb_private::ProcessAttachInfo &attach_info,
lldb_private::Debugger &debugger,
lldb_private::ConstString GetFullNameForDylib(lldb_private::ConstString basename) override;
+ lldb::UnixSignalsSP CreateUnixSignals() override;
+
protected:
std::unique_ptr<lldb_private::OptionGroupPlatformRSync>
m_option_group_platform_rsync;
arch, addr, length, prot, flags, fd, offset);
}
+ lldb::UnixSignalsSP CreateUnixSignals() override {
+ // PlatformQemuUser shouldn't create its own UnixSignals. It should defer to
+ // other platforms.
+ return lldb::UnixSignalsSP();
+ }
+
private:
static lldb::PlatformSP CreateInstance(bool force, const ArchSpec *arch);
static void DebuggerInitialize(Debugger &debugger);
std::vector<ArchSpec> m_supported_architectures;
+ lldb::UnixSignalsSP CreateUnixSignals() override {
+ return lldb::UnixSignalsSP();
+ }
+
private:
std::unique_ptr<lldb_private::UtilityFunction>
MakeLoadImageUtilityFunction(lldb_private::ExecutionContext &context,
add_lldb_library(lldbPluginPlatformGDB PLUGIN
+ GDBRemoteSignals.cpp
PlatformRemoteGDBServer.cpp
LINK_LIBS
lldbCore
lldbHost
lldbTarget
- lldbPluginProcessUtility
lldbPluginProcessGDBRemote
)
//===----------------------------------------------------------------------===//
#include "PlatformRemoteGDBServer.h"
+#include "GDBRemoteSignals.h"
#include "lldb/Host/Config.h"
#include "lldb/Breakpoint/BreakpointLocation.h"
#include "lldb/Utility/UriParser.h"
#include "llvm/Support/FormatAdapters.h"
-#include "Plugins/Process/Utility/GDBRemoteSignals.h"
#include "Plugins/Process/gdb-remote/ProcessGDBRemote.h"
#include <optional>
m_trap_handlers.push_back(ConstString("_sigtramp"));
}
-const UnixSignalsSP &PlatformRemoteGDBServer::GetRemoteUnixSignals() {
+UnixSignalsSP PlatformRemoteGDBServer::GetRemoteUnixSignals() {
if (!IsConnected())
- return Platform::GetRemoteUnixSignals();
+ return UnixSignalsSP();
if (m_remote_signals_sp)
return m_remote_signals_sp;
- // If packet not implemented or JSON failed to parse, we'll guess the signal
- // set based on the remote architecture.
- m_remote_signals_sp = UnixSignals::Create(GetRemoteSystemArchitecture());
-
StringExtractorGDBRemote response;
auto result =
m_gdb_client_up->SendPacketAndWaitForResponse("jSignalsInfo", response);
#include <optional>
#include <string>
-#include "Plugins/Process/Utility/GDBRemoteSignals.h"
#include "Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h"
#include "lldb/Target/Platform.h"
void CalculateTrapHandlerSymbolNames() override;
- const lldb::UnixSignalsSP &GetRemoteUnixSignals() override;
+ lldb::UnixSignalsSP GetRemoteUnixSignals() override;
size_t ConnectToWaitingProcesses(lldb_private::Debugger &debugger,
lldb_private::Status &error) override;
virtual size_t
GetPendingGdbServerList(std::vector<std::string> &connection_urls);
+ lldb::UnixSignalsSP CreateUnixSignals() override {
+ // PlatformRemoteGDBServer should defer to other platforms.
+ return lldb::UnixSignalsSP();
+ }
+
protected:
std::unique_ptr<process_gdb_remote::GDBRemoteCommunicationClient>
m_gdb_client_up;
add_lldb_library(lldbPluginProcessUtility
AuxVector.cpp
- FreeBSDSignals.cpp
- GDBRemoteSignals.cpp
HistoryThread.cpp
HistoryUnwind.cpp
InferiorCallPOSIX.cpp
LinuxProcMaps.cpp
- LinuxSignals.cpp
MemoryTagManagerAArch64MTE.cpp
NativeProcessSoftwareSingleStep.cpp
NativeRegisterContextDBReg_arm64.cpp
NativeRegisterContextDBReg_x86.cpp
NativeRegisterContextRegisterInfo.cpp
- NetBSDSignals.cpp
RegisterContext_x86.cpp
RegisterContextDarwin_arm.cpp
RegisterContextDarwin_arm64.cpp
#include "lldb/Target/ABI.h"
#include "lldb/Target/DynamicLoader.h"
#include "lldb/Target/MemoryRegionInfo.h"
+#include "lldb/Target/Platform.h"
#include "lldb/Target/Target.h"
#include "lldb/Target/UnixSignals.h"
#include "lldb/Utility/DataBufferHeap.h"
ArchSpec target_arch = GetTarget().GetArchitecture();
ArchSpec core_arch(m_core_module_sp->GetArchitecture());
target_arch.MergeFrom(core_arch);
- GetTarget().SetArchitecture(target_arch);
-
- SetUnixSignals(UnixSignals::Create(GetArchitecture()));
+ GetTarget().SetArchitecture(target_arch, /* set_platform = */ true);
+
+ if (auto platform_sp = GetTarget().GetPlatform())
+ SetUnixSignals(platform_sp->GetUnixSignals());
// Ensure we found at least one thread that was stopped on a signal.
bool siginfo_signal_found = false;
#include "GDBRemoteRegisterContext.h"
#include "GDBRemoteRegisterFallback.h"
-#include "Plugins/Process/Utility/GDBRemoteSignals.h"
+#include "Plugins/Platform/gdb-server/GDBRemoteSignals.h"
#include "Plugins/Process/Utility/InferiorCallPOSIX.h"
#include "Plugins/Process/Utility/StopInfoMachException.h"
#include "ProcessGDBRemote.h"
MapSupportedStructuredDataPlugins(*supported_packets);
// If connected to LLDB ("native-signals+"), use signal defs for
- // the remote platform. If connected to GDB, just use the standard set.
- if (!m_gdb_comm.UsesNativeSignals()) {
+ // the remote platform (assuming it's available). If connected to GDB, just
+ // use the standard set.
+ auto platform_sp = GetTarget().GetPlatform();
+ if (!platform_sp || !m_gdb_comm.UsesNativeSignals())
SetUnixSignals(std::make_shared<GDBRemoteSignals>());
- } else {
- PlatformSP platform_sp = GetTarget().GetPlatform();
- if (platform_sp && platform_sp->IsConnected())
- SetUnixSignals(platform_sp->GetUnixSignals());
- else
- SetUnixSignals(UnixSignals::Create(GetTarget().GetArchitecture()));
+ else {
+ SetUnixSignals(platform_sp->GetUnixSignals());
}
}
arch.GetArchitectureName());
return error;
}
- GetTarget().SetArchitecture(arch, true /*set_platform*/);
+ GetTarget().SetArchitecture(arch, /*set_platform = */ true);
m_thread_list = m_minidump_parser->GetThreads();
m_active_exception = m_minidump_parser->GetExceptionStream();
- SetUnixSignals(UnixSignals::Create(GetArchitecture()));
+ auto platform_sp = GetTarget().GetPlatform();
+ if (platform_sp)
+ SetUnixSignals(platform_sp->GetUnixSignals());
ReadModuleList();
if (ModuleSP module = GetTarget().GetExecutableModule())
lldbInterpreter
lldbSymbol
lldbUtility
- lldbPluginProcessUtility
LINK_COMPONENTS
Support
const char *Platform::GetCacheHostname() { return GetHostname(); }
-const UnixSignalsSP &Platform::GetRemoteUnixSignals() {
+UnixSignalsSP Platform::GetRemoteUnixSignals() {
static const auto s_default_unix_signals_sp = std::make_shared<UnixSignals>();
return s_default_unix_signals_sp;
}
//===----------------------------------------------------------------------===//
#include "lldb/Target/UnixSignals.h"
-#include "Plugins/Process/Utility/FreeBSDSignals.h"
-#include "Plugins/Process/Utility/LinuxSignals.h"
-#include "Plugins/Process/Utility/NetBSDSignals.h"
#include "lldb/Host/HostInfo.h"
+#include "lldb/Target/Platform.h"
#include "lldb/Utility/ArchSpec.h"
#include <optional>
#include <sstream>
m_description.assign(description);
}
-lldb::UnixSignalsSP UnixSignals::Create(const ArchSpec &arch) {
- const auto &triple = arch.GetTriple();
- switch (triple.getOS()) {
- case llvm::Triple::Linux:
- return std::make_shared<LinuxSignals>();
- case llvm::Triple::FreeBSD:
- case llvm::Triple::OpenBSD:
- return std::make_shared<FreeBSDSignals>();
- case llvm::Triple::NetBSD:
- return std::make_shared<NetBSDSignals>();
- default:
- return std::make_shared<UnixSignals>();
+lldb::UnixSignalsSP UnixSignals::CreateForHost() {
+ static lldb::UnixSignalsSP s_unix_signals_sp;
+ if (s_unix_signals_sp)
+ return s_unix_signals_sp;
+
+ auto host_platform_sp = Platform::GetHostPlatform();
+
+ // If we have no host platform, be resilient and use default UnixSignals.
+ if (!host_platform_sp)
+ s_unix_signals_sp = std::make_shared<UnixSignals>();
+ else {
+ s_unix_signals_sp = host_platform_sp->CreateUnixSignals();
+ // If the Host platform cannot create a UnixSignals object, fall back to the
+ // default UnixSignals. This may happen on platforms without a
+ // UnixSignals implementation (e.g. Windows).
+ if (!s_unix_signals_sp)
+ s_unix_signals_sp = std::make_shared<UnixSignals>();
}
-}
-lldb::UnixSignalsSP UnixSignals::CreateForHost() {
- static lldb::UnixSignalsSP s_unix_signals_sp =
- Create(HostInfo::GetArchitecture());
return s_unix_signals_sp;
}
lldbCore
lldbHost
lldbPluginPlatformMacOSX
- lldbPluginProcessUtility
+ lldbPluginPlatformLinux
lldbPluginProcessGDBRemote
LLVMTestingSupport
#include "GDBRemoteTestUtils.h"
-#include "Plugins/Process/Utility/LinuxSignals.h"
+#include "Plugins/Platform/Linux/LinuxSignals.h"
#include "Plugins/Process/gdb-remote/GDBRemoteClientBase.h"
#include "Plugins/Process/gdb-remote/GDBRemoteCommunicationServer.h"
#include "lldb/Utility/GDBRemote.h"
MOCK_METHOD2(ResolveRemoteExecutable,
std::pair<Status, ModuleSP>(const ModuleSpec &,
const FileSpecList *));
+ MOCK_METHOD0(CreateUnixSignals, lldb::UnixSignalsSP());
+
Status ResolveRemoteExecutable(
const ModuleSpec &module_spec, lldb::ModuleSP &exe_module_sp,
const FileSpecList *module_search_paths_ptr) /*override*/
ProcessSP(ProcessAttachInfo &, Debugger &, Target *, Status &));
MOCK_METHOD0(CalculateTrapHandlerSymbolNames, void());
MOCK_METHOD0(GetUserIDResolver, UserIDResolver &());
+ MOCK_METHOD0(CreateUnixSignals, lldb::UnixSignalsSP());
};
namespace {
projects / platform / upstream / llvm.git / commitdiff