[lldb] Move UnixSignals creation into Platform plugins

[bulbazord]

Summary

The high level goal of this change is to remove lldbTarget's dependency
on lldbPluginProcessUtility. The reason for this existing dependency is
so that we can create the appropriate UnixSignals object based on an
ArchSpec. Instead of using the ArchSpec, we can instead take advantage
of the Platform associated with the current Target.

This is accomplished by adding a new method to Platform,
CreateUnixSignals, which will create the correct UnixSignals object for
us. We then can use Platform::GetUnixSignals and rely on that to give
us the correct signals as needed.

[JDevlieghere]

We're only using the OS part of the triple/ArchSpec so there should be a 1:1 mapping with the platform. I don't see any issue with this. LGTM.

[rupprecht]

This seems to cause a regression on Linux where we no longer get the signal details.

Given an intentionally-crashy test binary, such as:

void crash() {
  // Allocate valid but non-accessible memory and attempt to write to it,
  // triggering a Segmentation Fault.
  int *ptr = static_cast<int *>(
      mmap(nullptr, sizeof(int), PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, 0, 0));
  *ptr = 0x12345678;
  munmap(ptr, sizeof(int));
}

we used to see this:

$ bin/lldb crashy
(lldb) target create "crashy"
Current executable set to 'crashy' (x86_64).
(lldb) r
Process 2317185 launched: 'crashy' (x86_64)
Process 2317185 stopped
* thread #1, name = 'crashy', stop reason = signal SIGSEGV: invalid permissions for mapped object (fault address: 0x7ffff7fc5000)

but now the stop reason is just: stop reason = signal SIGSEGV (no details about the fault address)

Unrelated to the bug above: this also creates a circular dependency between gdb-server <-> gdb-remote packages (https://llvm.org/docs/CodingStandards.html#library-layering)

[bulbazord]

In D146263#4214336, @rupprecht wrote:

This seems to cause a regression on Linux where we no longer get the signal details.

Given an intentionally-crashy test binary, such as:

void crash() {
  // Allocate valid but non-accessible memory and attempt to write to it,
  // triggering a Segmentation Fault.
  int *ptr = static_cast<int *>(
      mmap(nullptr, sizeof(int), PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, 0, 0));
  *ptr = 0x12345678;
  munmap(ptr, sizeof(int));
}

we used to see this:

$ bin/lldb crashy
(lldb) target create "crashy"
Current executable set to 'crashy' (x86_64).
(lldb) r
Process 2317185 launched: 'crashy' (x86_64)
Process 2317185 stopped
* thread #1, name = 'crashy', stop reason = signal SIGSEGV: invalid permissions for mapped object (fault address: 0x7ffff7fc5000)

but now the stop reason is just: stop reason = signal SIGSEGV (no details about the fault address)

Yep, definitely a regression... I suspect we're not creating the correct UnixSignals object anymore in this case. It would be nice if we had more testing here... I'll try to fix this, thanks for pointing it out.

Unrelated to the bug above: this also creates a circular dependency between gdb-server <-> gdb-remote packages (https://llvm.org/docs/CodingStandards.html#library-layering)

Ah, yeah that does happen too, doesn't it? Maybe the Signals should live in the Process plugins instead of the Platform plugins? I'm not married to this specific implementation.

[rupprecht]

lldb/source/Target/UnixSignals.cpp

39

I think the divergence might be happening here -- the host platform is null here, so we get UnixSignals instead of the subcode from LinuxSignals.

[bulbazord]

lldb/source/Target/UnixSignals.cpp

39

Why might the HostPlatform be nullptr? I assume you're debugging a binary built for some Linux distro on some Linux machine.

[rupprecht]

lldb/source/Target/UnixSignals.cpp

39

Yes, this is a local debugging session of a linux binary running on a linux machine. But it seems from my prodding around that lldb calls Platform::SetHostPlatform() (via PlatformLinux::Initialize(), but lldb-server isn't, and lldb-server is the thing that supposed to be returning the subcode details.

[bulbazord]

lldb/source/Target/UnixSignals.cpp

39

* frame #0: 0x0000aaaaab72dfe0 lldb-server`lldb_private::Platform::GetHostPlatform() at Platform.cpp:137:49
   frame #1: 0x0000aaaaab83f6e8 lldb-server`lldb_private::UnixSignals::CreateForHost() at UnixSignals.cpp:36:27
   frame #2: 0x0000aaaaab569590 lldb-server`GetCrashReasonString[abi:cxx11](info=0x0000ffffffffd9e0) at CrashReason.cpp:25:7
   frame #3: 0x0000aaaaab48e084 lldb-server`lldb_private::process_linux::NativeThreadLinux::SetStoppedBySignal(this=0x0000aaaab5255180, signo=11, info=0x0000ffffffffd9e0) at NativeThreadLinux.cpp:297:28

Yep, that makes sense to me. I'll work on this, thanks for letting me know about this.

[bulbazord]

lldb/source/Target/UnixSignals.cpp

39

D146668

lldb/include/lldb/Target/Platform.h

public:
 
   virtual bool CalculateMD5(const FileSpec &file_spec, uint64_t &low,
                             uint64_t &high);
 
   virtual uint32_t GetResumeCountForLaunchInfo(ProcessLaunchInfo &launch_info) {
     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
   /// thread may be associated with a GCD queue or not, and a queue may be
   /// associated with multiple threads. The process/thread must provide a way
   /// to find the "dispatch_qaddr" for each thread, and from that
   /// dispatch_qaddr this Platform method will locate the queue name and
   /// provide that.

lldb/include/lldb/Target/UnixSignals.h

 #include "lldb/Utility/ConstString.h"
 #include "lldb/lldb-private.h"
 #include "llvm/Support/JSON.h"
 
 namespace lldb_private {
 
 class UnixSignals {
 public:
-  static lldb::UnixSignalsSP Create(const ArchSpec &arch);
   static lldb::UnixSignalsSP CreateForHost();
 
   // Constructors and Destructors
   UnixSignals();
 
   virtual ~UnixSignals();
 
   const char *GetSignalAsCString(int32_t signo) const;

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/CMakeLists.txt

LINK_LIBS
     lldbExpression
     lldbHost
     lldbInterpreter
     lldbSymbol
     lldbTarget
     lldbUtility
     lldbPluginExpressionParserClang
     lldbPluginCPPRuntime
+    lldbPluginProcessUtility
     lldbPluginTypeSystemClang
   CLANG_LIBS
     clangAST
   LINK_COMPONENTS
     Support
   )

lldb/source/Plugins/Platform/FreeBSD/CMakeLists.txt

 add_lldb_library(lldbPluginPlatformFreeBSD PLUGIN
+  FreeBSDSignals.cpp
   PlatformFreeBSD.cpp
 
    LINK_LIBS
     lldbBreakpoint
     lldbCore
     lldbHost
     lldbTarget
 
   LINK_COMPONENTS
     TargetParser
   )

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

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;
 
+  lldb::UnixSignalsSP CreateUnixSignals() override;
+
 private:
   std::mutex m_mutex;
   std::shared_ptr<TypeSystemClang> m_type_system;
 };
 
 } // namespace platform_freebsd
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_PLATFORM_FREEBSD_PLATFORMFREEBSD_H

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

 //===-- PlatformFreeBSD.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 "PlatformFreeBSD.h"
+#include "FreeBSDSignals.h"
 #include "lldb/Host/Config.h"
 
 #include <cstdio>
 #if LLDB_ENABLE_POSIX
 #include <sys/utsname.h>
 #endif
 
 #include "lldb/Breakpoint/BreakpointLocation.h"
CompilerType PlatformFreeBSD::GetSiginfoType(const llvm::Triple &triple) {
 
   ast->CompleteTagDeclarationDefinition(union_type);
   ast->AddFieldToRecordType(siginfo_type, "_reason", union_type,
                             lldb::eAccessPublic, 0);
 
   ast->CompleteTagDeclarationDefinition(siginfo_type);
   return siginfo_type;
 }
+
+lldb::UnixSignalsSP PlatformFreeBSD::CreateUnixSignals() {
+  return std::make_shared<FreeBSDSignals>();
+}

lldb/source/Plugins/Platform/Linux/CMakeLists.txt

 add_lldb_library(lldbPluginPlatformLinux PLUGIN
+  LinuxSignals.cpp
   PlatformLinux.cpp
 
    LINK_LIBS
     lldbBreakpoint
     lldbCore
     lldbHost
     lldbInterpreter
     lldbTarget
     lldbPluginPlatformPOSIX
   )

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

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;
 
+  lldb::UnixSignalsSP CreateUnixSignals() override;
+
 private:
   std::mutex m_mutex;
   std::shared_ptr<TypeSystemClang> m_type_system;
 };
 
 } // namespace platform_linux
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_PLATFORM_LINUX_PLATFORMLINUX_H

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

 //===-- PlatformLinux.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 "PlatformLinux.h"
+#include "LinuxSignals.h"
 #include "lldb/Host/Config.h"
 
 #include <cstdio>
 #if LLDB_ENABLE_POSIX
 #include <sys/utsname.h>
 #endif
 
 #include "Utility/ARM64_DWARF_Registers.h"
CompilerType PlatformLinux::GetSiginfoType(const llvm::Triple &triple) {
 
   ast->CompleteTagDeclarationDefinition(union_type);
   ast->AddFieldToRecordType(siginfo_type, "_sifields", union_type,
                             lldb::eAccessPublic, 0);
 
   ast->CompleteTagDeclarationDefinition(siginfo_type);
   return siginfo_type;
 }
+
+lldb::UnixSignalsSP PlatformLinux::CreateUnixSignals() {
+  return std::make_shared<LinuxSignals>();
+}

lldb/source/Plugins/Platform/NetBSD/CMakeLists.txt

 add_lldb_library(lldbPluginPlatformNetBSD PLUGIN
+  NetBSDSignals.cpp
   PlatformNetBSD.cpp
 
    LINK_LIBS
     lldbBreakpoint
     lldbCore
     lldbHost
     lldbTarget
   )

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

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;
 
+  lldb::UnixSignalsSP CreateUnixSignals() override;
+
 private:
   std::mutex m_mutex;
   std::shared_ptr<TypeSystemClang> m_type_system;
 };
 
 } // namespace platform_netbsd
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_PLATFORM_NETBSD_PLATFORMNETBSD_H

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

 //===-- PlatformNetBSD.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 "PlatformNetBSD.h"
+#include "NetBSDSignals.h"
 #include "lldb/Host/Config.h"
 
 #include <cstdio>
 #if LLDB_ENABLE_POSIX
 #include <sys/utsname.h>
 #endif
 
 #include "lldb/Core/Debugger.h"
CompilerType PlatformNetBSD::GetSiginfoType(const llvm::Triple &triple) {
 
   ast->CompleteTagDeclarationDefinition(ksiginfo_type);
   ast->AddFieldToRecordType(siginfo_type, "_info", ksiginfo_type,
                             lldb::eAccessPublic, 0);
 
   ast->CompleteTagDeclarationDefinition(siginfo_type);
   return siginfo_type;
 }
+
+lldb::UnixSignalsSP PlatformNetBSD::CreateUnixSignals() {
+  return std::make_shared<NetBSDSignals>();
+}

lldb/source/Plugins/Platform/POSIX/PlatformPOSIX.h

lldb_private::Status PutFile(const lldb_private::FileSpec &source,
                                const lldb_private::FileSpec &destination,
                                uint32_t uid = UINT32_MAX,
                                uint32_t gid = UINT32_MAX) override;
 
   lldb_private::Status
   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::Target *target, // Can be nullptr, if
                                                        // nullptr create a new
                                                        // target, else use
                                                        // existing one
                          lldb_private::Status &error) override;
uint32_t DoLoadImage(lldb_private::Process *process,
                        lldb_private::Status &error,
                        lldb_private::FileSpec *loaded_image) override;
 
   lldb_private::Status UnloadImage(lldb_private::Process *process,
                                    uint32_t image_token) override;
 
   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;
   std::unique_ptr<lldb_private::OptionGroupPlatformSSH>
       m_option_group_platform_ssh;
   std::unique_ptr<lldb_private::OptionGroupPlatformCaching>
       m_option_group_platform_caching;
 

lldb/source/Plugins/Platform/POSIX/PlatformPOSIX.cpp

 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Host/ProcessLaunchInfo.h"
 #include "lldb/Target/DynamicLoader.h"
 #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"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/StreamString.h"
 #include "llvm/ADT/ScopeExit.h"
 #include <optional>
 
std::string PlatformPOSIX::GetPlatformSpecificConnectionInformation() {
   if (GetLocalCacheDirectory() && *GetLocalCacheDirectory())
     stream.Printf("cache dir: %s", GetLocalCacheDirectory());
   if (stream.GetSize())
     return std::string(stream.GetString());
   else
     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();
 }
 
 Status PlatformPOSIX::ConnectRemote(Args &args) {
   Status error;
   if (IsHost()) {
     error.SetErrorStringWithFormatv(
         "can't connect to the host platform '{0}', always connected",

 ConstString PlatformPOSIX::GetFullNameForDylib(ConstString basename) {
   if (basename.IsEmpty())
     return basename;
 
   StreamString stream;
   stream.Printf("lib%s.so", basename.GetCString());
   return ConstString(stream.GetString());
 }
+
+lldb::UnixSignalsSP PlatformPOSIX::CreateUnixSignals() {
+  return std::make_shared<UnixSignals>();
+}

lldb/source/Plugins/Platform/QemuUser/PlatformQemuUser.h

public:
   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 {
     return Platform::GetHostPlatform()->GetMmapArgumentList(
         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);
 
   PlatformQemuUser() : Platform(/*is_host=*/true) {}
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_PLATFORM_QEMUUSER_PLATFORMQEMUUSER_H

lldb/source/Plugins/Platform/Windows/PlatformWindows.h

public:
 
   ConstString GetFullNameForDylib(ConstString basename) override;
 
   size_t GetSoftwareBreakpointTrapOpcode(Target &target,
                                          BreakpointSite *bp_site) override;
 
   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,
                                lldb_private::Status &status);
 
   lldb_private::Status EvaluateLoaderExpression(lldb_private::Process *process,
                                                 const char *expression,
                                                 lldb::ValueObjectSP &value);
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_PLATFORM_WINDOWS_PLATFORMWINDOWS_H

lldb/source/Plugins/Platform/gdb-server/CMakeLists.txt

 add_lldb_library(lldbPluginPlatformGDB PLUGIN
+  GDBRemoteSignals.cpp
   PlatformRemoteGDBServer.cpp
 
    LINK_LIBS
     lldbBreakpoint
     lldbCore
     lldbHost
     lldbTarget
-    lldbPluginProcessUtility
     lldbPluginProcessGDBRemote
   )

lldb/source/Plugins/Platform/gdb-server/PlatformRemoteGDBServer.h

 //===-- PlatformRemoteGDBServer.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_GDB_SERVER_PLATFORMREMOTEGDBSERVER_H
 #define LLDB_SOURCE_PLUGINS_PLATFORM_GDB_SERVER_PLATFORMREMOTEGDBSERVER_H
 
 #include <optional>
 #include <string>
 
-#include "Plugins/Process/Utility/GDBRemoteSignals.h"
 #include "Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h"
 #include "lldb/Target/Platform.h"
 
 namespace lldb_private {
 namespace platform_gdb_server {
 
 class PlatformRemoteGDBServer : public Platform, private UserIDResolver {
 public:
Status RunShellCommand(
       int *signo_ptr,  // Pass NULL if you don't want the signal that caused the
                        // process to exit
       std::string
           *command_output, // Pass NULL if you don't want the command output
       const lldb_private::Timeout<std::micro> &timeout) override;
 
   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;
   std::string m_platform_description; // After we connect we can get a more
                                       // complete description of what we are
                                       // connected to
   std::string m_platform_scheme;
   std::string m_platform_hostname;

lldb/source/Plugins/Platform/gdb-server/PlatformRemoteGDBServer.cpp

 //===-- PlatformRemoteGDBServer.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 "PlatformRemoteGDBServer.h"
+#include "GDBRemoteSignals.h"
 #include "lldb/Host/Config.h"
 
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Host/PosixApi.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/LLDBLog.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/ProcessInfo.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StreamString.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>
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::platform_gdb_server;
 
 LLDB_PLUGIN_DEFINE_ADV(PlatformRemoteGDBServer, PlatformGDB)
Status PlatformRemoteGDBServer::RunShellCommand(
   return m_gdb_client_up->RunShellCommand(command, working_dir, status_ptr,
                                           signo_ptr, command_output, timeout);
 }
 
 void PlatformRemoteGDBServer::CalculateTrapHandlerSymbolNames() {
   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);
 
   if (result != decltype(result)::Success ||
       response.GetResponseType() != response.eResponse)
     return m_remote_signals_sp;
 

lldb/source/Plugins/Process/Utility/CMakeLists.txt

 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
   RegisterContextDarwin_i386.cpp
   RegisterContextDarwin_x86_64.cpp
   RegisterContextDummy.cpp
   RegisterContextFreeBSD_i386.cpp
   RegisterContextFreeBSD_mips64.cpp

lldb/source/Plugins/Process/elf-core/ProcessElfCore.cpp

 
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Section.h"
 #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"
 #include "lldb/Utility/LLDBLog.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/State.h"
 
 #include "llvm/BinaryFormat/ELF.h"
Status ProcessElfCore::DoLoadCore() {
 
   // Even if the architecture is set in the target, we need to override it to
   // match the core file which is always single arch.
   ArchSpec arch(m_core_module_sp->GetArchitecture());
 
   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;
   bool prstatus_signal_found = false;
   // Check we found a signal in a SIGINFO note.
   for (const auto &thread_data : m_thread_data) {
     if (thread_data.signo != 0)
       siginfo_signal_found = true;

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

 #include <memory>
 #include <mutex>
 #include <optional>
 #include <sstream>
 #include <thread>
 
 #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"
 #include "ProcessGDBRemoteLog.h"
 #include "ThreadGDBRemote.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Utility/StringExtractorGDBRemote.h"
 
void ProcessGDBRemote::DidLaunchOrAttach(ArchSpec &process_arch) {
 
   // Find out which StructuredDataPlugins are supported by the debug monitor.
   // These plugins transmit data over async $J packets.
   if (StructuredData::Array *supported_packets =
           m_gdb_comm.GetSupportedStructuredDataPlugins())
     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 {
   }
 }
 
 void ProcessGDBRemote::LoadStubBinaries() {
   // The remote stub may know about the "main binary" in
   // the context of a firmware debug session, and can
   // give us a UUID and an address/slide of where the
   // binary is loaded in memory.

lldb/source/Plugins/Process/minidump/ProcessMinidump.cpp

case llvm::Triple::aarch64:
     // Any supported architectures must be listed here and also supported in
     // ThreadMinidump::CreateRegisterContextForFrame().
     break;
   default:
     error.SetErrorStringWithFormat("unsupported minidump architecture: %s",
                                    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())
     GetTarget().MergeArchitecture(module->GetArchitecture());
   std::optional<lldb::pid_t> pid = m_minidump_parser->GetPid();
   if (!pid) {
     Debugger::ReportWarning("unable to retrieve process ID from minidump file, "
                             "setting process ID to 1",

lldb/source/Target/CMakeLists.txt

add_lldb_library(lldbTarget
   LINK_LIBS
     lldbBreakpoint
     lldbCore
     lldbExpression
     lldbHost
     lldbInterpreter
     lldbSymbol
     lldbUtility
-    lldbPluginProcessUtility
 
   LINK_COMPONENTS
     Support
     MC
   )
 
 add_dependencies(lldbTarget
   LLDBTargetPropertiesGen
   LLDBTargetPropertiesEnumGen)

lldb/source/Target/Platform.cpp

 FileSpec Platform::GetModuleCacheRoot() {
   auto dir_spec = GetGlobalPlatformProperties().GetModuleCacheDirectory();
   dir_spec.AppendPathComponent(GetPluginName());
   return dir_spec;
 }
 
 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;
 }
 
 UnixSignalsSP Platform::GetUnixSignals() {
   if (IsHost())
     return UnixSignals::CreateForHost();
   return GetRemoteUnixSignals();

lldb/source/Target/UnixSignals.cpp

 //===-- UnixSignals.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 "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>
 
 using namespace lldb_private;
 using namespace llvm;
 
 UnixSignals::Signal::Signal(const char *name, bool default_suppress,
                             bool default_stop, bool default_notify,
                             const char *description, const char *alias)
     : m_name(name), m_alias(alias), m_description(),
       m_suppress(default_suppress), m_stop(default_stop),
       m_notify(default_notify),
       m_default_suppress(default_suppress), m_default_stop(default_stop),
       m_default_notify(default_notify) {
   if (description)
     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;
 }
 
 // UnixSignals constructor
 UnixSignals::UnixSignals() { Reset(); }
 
 UnixSignals::UnixSignals(const UnixSignals &rhs) : m_signals(rhs.m_signals) {}
 

lldb/unittests/Process/gdb-remote/CMakeLists.txt

 add_lldb_unittest(ProcessGdbRemoteTests
   GDBRemoteClientBaseTest.cpp
   GDBRemoteCommunicationClientTest.cpp
   GDBRemoteCommunicationServerLLGSTest.cpp
   GDBRemoteCommunicationServerTest.cpp
   GDBRemoteCommunicationTest.cpp
   GDBRemoteTestUtils.cpp
   PortMapTest.cpp
 
   LINK_LIBS
     lldbCore
     lldbHost
     lldbPluginPlatformMacOSX
-    lldbPluginProcessUtility
+    lldbPluginPlatformLinux
     lldbPluginProcessGDBRemote
 
     LLVMTestingSupport
 
   LINK_COMPONENTS
     Support
   )

lldb/unittests/Process/gdb-remote/GDBRemoteClientBaseTest.cpp

 //===-- GDBRemoteClientBaseTest.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 <future>
 
 #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"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Testing/Support/Error.h"
 
 using namespace lldb_private::process_gdb_remote;
 using namespace lldb_private;

lldb/unittests/Target/RemoteAwarePlatformTest.cpp

MOCK_METHOD1(GetSupportedArchitectures,
                std::vector<ArchSpec>(const ArchSpec &process_host_arch));
   MOCK_METHOD4(Attach,
                ProcessSP(ProcessAttachInfo &, Debugger &, Target *, Status &));
   MOCK_METHOD0(CalculateTrapHandlerSymbolNames, void());
 
   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*/
   { // NOLINT(modernize-use-override)
     auto pair = ResolveRemoteExecutable(module_spec, module_search_paths_ptr);
     exe_module_sp = pair.second;
     return pair.first;
   }
public:
   MOCK_METHOD0(GetDescription, llvm::StringRef());
   MOCK_METHOD0(GetPluginName, llvm::StringRef());
   MOCK_METHOD1(GetSupportedArchitectures,
                std::vector<ArchSpec>(const ArchSpec &process_host_arch));
   MOCK_METHOD4(Attach,
                ProcessSP(ProcessAttachInfo &, Debugger &, Target *, Status &));
   MOCK_METHOD0(CalculateTrapHandlerSymbolNames, void());
   MOCK_METHOD0(GetUserIDResolver, UserIDResolver &());
+  MOCK_METHOD0(CreateUnixSignals, lldb::UnixSignalsSP());
 };
 
 namespace {
 class RemoteAwarePlatformTest : public testing::Test {
 public:
   static void SetUpTestCase() { FileSystem::Initialize(); }
   static void TearDownTestCase() { FileSystem::Terminate(); }
 };