[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

38

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

38

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

38

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

38

* 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

38

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/FreeBSDSignals.h

 //===-- FreeBSDSignals.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_PROCESS_UTILITY_FREEBSDSIGNALS_H
 #define LLDB_SOURCE_PLUGINS_PROCESS_UTILITY_FREEBSDSIGNALS_H
 
 #include "lldb/Target/UnixSignals.h"
 
 namespace lldb_private {
 
 /// FreeBSD specific set of Unix signals.
 class FreeBSDSignals : public UnixSignals {
 public:
   FreeBSDSignals();
 
 private:
   void Reset() override;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_PROCESS_UTILITY_FREEBSDSIGNALS_H

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

 //===-- FreeBSDSignals.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 "FreeBSDSignals.h"
 
 using namespace lldb_private;
 
 FreeBSDSignals::FreeBSDSignals() : UnixSignals() { Reset(); }
 
 void FreeBSDSignals::Reset() {
   UnixSignals::Reset();
 
   //        SIGNO   NAME            SUPPRESS STOP   NOTIFY DESCRIPTION
   //        ======  ============    ======== ====== ======
   //        ===================================================
   AddSignal(32, "SIGTHR", false, false, false, "thread interrupt");
   AddSignal(33, "SIGLIBRT", false, false, false,
             "reserved by real-time library");
   AddSignal(65, "SIGRTMIN", false, false, false, "real time signal 0");
   AddSignal(66, "SIGRTMIN+1", false, false, false, "real time signal 1");
   AddSignal(67, "SIGRTMIN+2", false, false, false, "real time signal 2");
   AddSignal(68, "SIGRTMIN+3", false, false, false, "real time signal 3");
   AddSignal(69, "SIGRTMIN+4", false, false, false, "real time signal 4");
   AddSignal(70, "SIGRTMIN+5", false, false, false, "real time signal 5");
   AddSignal(71, "SIGRTMIN+6", false, false, false, "real time signal 6");
   AddSignal(72, "SIGRTMIN+7", false, false, false, "real time signal 7");
   AddSignal(73, "SIGRTMIN+8", false, false, false, "real time signal 8");
   AddSignal(74, "SIGRTMIN+9", false, false, false, "real time signal 9");
   AddSignal(75, "SIGRTMIN+10", false, false, false, "real time signal 10");
   AddSignal(76, "SIGRTMIN+11", false, false, false, "real time signal 11");
   AddSignal(77, "SIGRTMIN+12", false, false, false, "real time signal 12");
   AddSignal(78, "SIGRTMIN+13", false, false, false, "real time signal 13");
   AddSignal(79, "SIGRTMIN+14", false, false, false, "real time signal 14");
   AddSignal(80, "SIGRTMIN+15", false, false, false, "real time signal 15");
   AddSignal(81, "SIGRTMIN+16", false, false, false, "real time signal 16");
   AddSignal(82, "SIGRTMIN+17", false, false, false, "real time signal 17");
   AddSignal(83, "SIGRTMIN+18", false, false, false, "real time signal 18");
   AddSignal(84, "SIGRTMIN+19", false, false, false, "real time signal 19");
   AddSignal(85, "SIGRTMIN+20", false, false, false, "real time signal 20");
   AddSignal(86, "SIGRTMIN+21", false, false, false, "real time signal 21");
   AddSignal(87, "SIGRTMIN+22", false, false, false, "real time signal 22");
   AddSignal(88, "SIGRTMIN+23", false, false, false, "real time signal 23");
   AddSignal(89, "SIGRTMIN+24", false, false, false, "real time signal 24");
   AddSignal(90, "SIGRTMIN+25", false, false, false, "real time signal 25");
   AddSignal(91, "SIGRTMIN+26", false, false, false, "real time signal 26");
   AddSignal(92, "SIGRTMIN+27", false, false, false, "real time signal 27");
   AddSignal(93, "SIGRTMIN+28", false, false, false, "real time signal 28");
   AddSignal(94, "SIGRTMIN+29", false, false, false, "real time signal 29");
   AddSignal(95, "SIGRTMIN+30", false, false, false, "real time signal 30");
   AddSignal(96, "SIGRTMAX-30", false, false, false, "real time signal 31");
   AddSignal(97, "SIGRTMAX-29", false, false, false, "real time signal 32");
   AddSignal(98, "SIGRTMAX-28", false, false, false, "real time signal 33");
   AddSignal(99, "SIGRTMAX-27", false, false, false, "real time signal 34");
   AddSignal(100, "SIGRTMAX-26", false, false, false, "real time signal 35");
   AddSignal(101, "SIGRTMAX-25", false, false, false, "real time signal 36");
   AddSignal(102, "SIGRTMAX-24", false, false, false, "real time signal 37");
   AddSignal(103, "SIGRTMAX-23", false, false, false, "real time signal 38");
   AddSignal(104, "SIGRTMAX-22", false, false, false, "real time signal 39");
   AddSignal(105, "SIGRTMAX-21", false, false, false, "real time signal 40");
   AddSignal(106, "SIGRTMAX-20", false, false, false, "real time signal 41");
   AddSignal(107, "SIGRTMAX-19", false, false, false, "real time signal 42");
   AddSignal(108, "SIGRTMAX-18", false, false, false, "real time signal 43");
   AddSignal(109, "SIGRTMAX-17", false, false, false, "real time signal 44");
   AddSignal(110, "SIGRTMAX-16", false, false, false, "real time signal 45");
   AddSignal(111, "SIGRTMAX-15", false, false, false, "real time signal 46");
   AddSignal(112, "SIGRTMAX-14", false, false, false, "real time signal 47");
   AddSignal(113, "SIGRTMAX-13", false, false, false, "real time signal 48");
   AddSignal(114, "SIGRTMAX-12", false, false, false, "real time signal 49");
   AddSignal(115, "SIGRTMAX-11", false, false, false, "real time signal 50");
   AddSignal(116, "SIGRTMAX-10", false, false, false, "real time signal 51");
   AddSignal(117, "SIGRTMAX-9", false, false, false, "real time signal 52");
   AddSignal(118, "SIGRTMAX-8", false, false, false, "real time signal 53");
   AddSignal(119, "SIGRTMAX-7", false, false, false, "real time signal 54");
   AddSignal(120, "SIGRTMAX-6", false, false, false, "real time signal 55");
   AddSignal(121, "SIGRTMAX-5", false, false, false, "real time signal 56");
   AddSignal(122, "SIGRTMAX-4", false, false, false, "real time signal 57");
   AddSignal(123, "SIGRTMAX-3", false, false, false, "real time signal 58");
   AddSignal(124, "SIGRTMAX-2", false, false, false, "real time signal 59");
   AddSignal(125, "SIGRTMAX-1", false, false, false, "real time signal 60");
   AddSignal(126, "SIGRTMAX", false, false, false, "real time signal 61");
 }

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/LinuxSignals.h

 //===-- LinuxSignals.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_PROCESS_UTILITY_LINUXSIGNALS_H
 #define LLDB_SOURCE_PLUGINS_PROCESS_UTILITY_LINUXSIGNALS_H
 
 #include "lldb/Target/UnixSignals.h"
 
 namespace lldb_private {
 
 /// Linux specific set of Unix signals.
 class LinuxSignals : public UnixSignals {
 public:
   LinuxSignals();
 
 private:
   void Reset() override;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_PROCESS_UTILITY_LINUXSIGNALS_H

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

 //===-- LinuxSignals.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 "LinuxSignals.h"
 
 using namespace lldb_private;
 
 LinuxSignals::LinuxSignals() : UnixSignals() { Reset(); }
 
 void LinuxSignals::Reset() {
   m_signals.clear();
   // clang-format off
   //        SIGNO   NAME            SUPPRESS  STOP    NOTIFY  DESCRIPTION
   //        ======  ==============  ========  ======  ======  ===================================================
   AddSignal(1,      "SIGHUP",       false,    true,   true,   "hangup");
   AddSignal(2,      "SIGINT",       true,     true,   true,   "interrupt");
   AddSignal(3,      "SIGQUIT",      false,    true,   true,   "quit");
   AddSignal(4,      "SIGILL",       false,    true,   true,   "illegal instruction");
   AddSignal(5,      "SIGTRAP",      true,     true,   true,   "trace trap (not reset when caught)");
   AddSignal(6,      "SIGABRT",      false,    true,   true,   "abort()/IOT trap", "SIGIOT");
   AddSignal(7,      "SIGBUS",       false,    true,   true,   "bus error");
   AddSignal(8,      "SIGFPE",       false,    true,   true,   "floating point exception");
   AddSignal(9,      "SIGKILL",      false,    true,   true,   "kill");
   AddSignal(10,     "SIGUSR1",      false,    true,   true,   "user defined signal 1");
   AddSignal(11,     "SIGSEGV",      false,    true,   true,   "segmentation violation");
   AddSignal(12,     "SIGUSR2",      false,    true,   true,   "user defined signal 2");
   AddSignal(13,     "SIGPIPE",      false,    true,   true,   "write to pipe with reading end closed");
   AddSignal(14,     "SIGALRM",      false,    false,  false,  "alarm");
   AddSignal(15,     "SIGTERM",      false,    true,   true,   "termination requested");
   AddSignal(16,     "SIGSTKFLT",    false,    true,   true,   "stack fault");
   AddSignal(17,     "SIGCHLD",      false,    false,  true,   "child status has changed", "SIGCLD");
   AddSignal(18,     "SIGCONT",      false,    false,  true,   "process continue");
   AddSignal(19,     "SIGSTOP",      true,     true,   true,   "process stop");
   AddSignal(20,     "SIGTSTP",      false,    true,   true,   "tty stop");
   AddSignal(21,     "SIGTTIN",      false,    true,   true,   "background tty read");
   AddSignal(22,     "SIGTTOU",      false,    true,   true,   "background tty write");
   AddSignal(23,     "SIGURG",       false,    true,   true,   "urgent data on socket");
   AddSignal(24,     "SIGXCPU",      false,    true,   true,   "CPU resource exceeded");
   AddSignal(25,     "SIGXFSZ",      false,    true,   true,   "file size limit exceeded");
   AddSignal(26,     "SIGVTALRM",    false,    true,   true,   "virtual time alarm");
   AddSignal(27,     "SIGPROF",      false,    false,  false,  "profiling time alarm");
   AddSignal(28,     "SIGWINCH",     false,    true,   true,   "window size changes");
   AddSignal(29,     "SIGIO",        false,    true,   true,   "input/output ready/Pollable event", "SIGPOLL");
   AddSignal(30,     "SIGPWR",       false,    true,   true,   "power failure");
   AddSignal(31,     "SIGSYS",       false,    true,   true,   "invalid system call");
   AddSignal(32,     "SIG32",        false,    false,  false,  "threading library internal signal 1");
   AddSignal(33,     "SIG33",        false,    false,  false,  "threading library internal signal 2");
   AddSignal(34,     "SIGRTMIN",     false,    false,  false,  "real time signal 0");
   AddSignal(35,     "SIGRTMIN+1",   false,    false,  false,  "real time signal 1");
   AddSignal(36,     "SIGRTMIN+2",   false,    false,  false,  "real time signal 2");
   AddSignal(37,     "SIGRTMIN+3",   false,    false,  false,  "real time signal 3");
   AddSignal(38,     "SIGRTMIN+4",   false,    false,  false,  "real time signal 4");
   AddSignal(39,     "SIGRTMIN+5",   false,    false,  false,  "real time signal 5");
   AddSignal(40,     "SIGRTMIN+6",   false,    false,  false,  "real time signal 6");
   AddSignal(41,     "SIGRTMIN+7",   false,    false,  false,  "real time signal 7");
   AddSignal(42,     "SIGRTMIN+8",   false,    false,  false,  "real time signal 8");
   AddSignal(43,     "SIGRTMIN+9",   false,    false,  false,  "real time signal 9");
   AddSignal(44,     "SIGRTMIN+10",  false,    false,  false,  "real time signal 10");
   AddSignal(45,     "SIGRTMIN+11",  false,    false,  false,  "real time signal 11");
   AddSignal(46,     "SIGRTMIN+12",  false,    false,  false,  "real time signal 12");
   AddSignal(47,     "SIGRTMIN+13",  false,    false,  false,  "real time signal 13");
   AddSignal(48,     "SIGRTMIN+14",  false,    false,  false,  "real time signal 14");
   AddSignal(49,     "SIGRTMIN+15",  false,    false,  false,  "real time signal 15");
   AddSignal(50,     "SIGRTMAX-14",  false,    false,  false,  "real time signal 16"); // switching to SIGRTMAX-xxx to match "kill -l" output
   AddSignal(51,     "SIGRTMAX-13",  false,    false,  false,  "real time signal 17");
   AddSignal(52,     "SIGRTMAX-12",  false,    false,  false,  "real time signal 18");
   AddSignal(53,     "SIGRTMAX-11",  false,    false,  false,  "real time signal 19");
   AddSignal(54,     "SIGRTMAX-10",  false,    false,  false,  "real time signal 20");
   AddSignal(55,     "SIGRTMAX-9",   false,    false,  false,  "real time signal 21");
   AddSignal(56,     "SIGRTMAX-8",   false,    false,  false,  "real time signal 22");
   AddSignal(57,     "SIGRTMAX-7",   false,    false,  false,  "real time signal 23");
   AddSignal(58,     "SIGRTMAX-6",   false,    false,  false,  "real time signal 24");
   AddSignal(59,     "SIGRTMAX-5",   false,    false,  false,  "real time signal 25");
   AddSignal(60,     "SIGRTMAX-4",   false,    false,  false,  "real time signal 26");
   AddSignal(61,     "SIGRTMAX-3",   false,    false,  false,  "real time signal 27");
   AddSignal(62,     "SIGRTMAX-2",   false,    false,  false,  "real time signal 28");
   AddSignal(63,     "SIGRTMAX-1",   false,    false,  false,  "real time signal 29");
   AddSignal(64,     "SIGRTMAX",     false,    false,  false,  "real time signal 30");
   // clang-format on
 }

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/NetBSDSignals.h

 //===-- NetBSDSignals.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_PROCESS_UTILITY_NETBSDSIGNALS_H
 #define LLDB_SOURCE_PLUGINS_PROCESS_UTILITY_NETBSDSIGNALS_H
 
 #include "lldb/Target/UnixSignals.h"
 
 namespace lldb_private {
 
 /// NetBSD specific set of Unix signals.
 class NetBSDSignals : public UnixSignals {
 public:
   NetBSDSignals();
 
 private:
   void Reset() override;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_PROCESS_UTILITY_NETBSDSIGNALS_H

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

 //===-- NetBSDSignals.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 "NetBSDSignals.h"
 
 using namespace lldb_private;
 
 NetBSDSignals::NetBSDSignals() : UnixSignals() { Reset(); }
 
 void NetBSDSignals::Reset() {
   UnixSignals::Reset();
   //        SIGNO  NAME          SUPPRESS STOP   NOTIFY DESCRIPTION
   //        ====== ============  ======== ====== ======
   //        ===================================================
   AddSignal(32, "SIGPWR", false, true, true,
             "power fail/restart (not reset when caught)");
   AddSignal(33, "SIGRTMIN", false, false, false, "real time signal 0");
   AddSignal(34, "SIGRTMIN+1", false, false, false, "real time signal 1");
   AddSignal(35, "SIGRTMIN+2", false, false, false, "real time signal 2");
   AddSignal(36, "SIGRTMIN+3", false, false, false, "real time signal 3");
   AddSignal(37, "SIGRTMIN+4", false, false, false, "real time signal 4");
   AddSignal(38, "SIGRTMIN+5", false, false, false, "real time signal 5");
   AddSignal(39, "SIGRTMIN+6", false, false, false, "real time signal 6");
   AddSignal(40, "SIGRTMIN+7", false, false, false, "real time signal 7");
   AddSignal(41, "SIGRTMIN+8", false, false, false, "real time signal 8");
   AddSignal(42, "SIGRTMIN+9", false, false, false, "real time signal 9");
   AddSignal(43, "SIGRTMIN+10", false, false, false, "real time signal 10");
   AddSignal(44, "SIGRTMIN+11", false, false, false, "real time signal 11");
   AddSignal(45, "SIGRTMIN+12", false, false, false, "real time signal 12");
   AddSignal(46, "SIGRTMIN+13", false, false, false, "real time signal 13");
   AddSignal(47, "SIGRTMIN+14", false, false, false, "real time signal 14");
   AddSignal(48, "SIGRTMIN+15", false, false, false, "real time signal 15");
   AddSignal(49, "SIGRTMIN-14", false, false, false, "real time signal 16");
   AddSignal(50, "SIGRTMAX-13", false, false, false, "real time signal 17");
   AddSignal(51, "SIGRTMAX-12", false, false, false, "real time signal 18");
   AddSignal(52, "SIGRTMAX-11", false, false, false, "real time signal 19");
   AddSignal(53, "SIGRTMAX-10", false, false, false, "real time signal 20");
   AddSignal(54, "SIGRTMAX-9", false, false, false, "real time signal 21");
   AddSignal(55, "SIGRTMAX-8", false, false, false, "real time signal 22");
   AddSignal(56, "SIGRTMAX-7", false, false, false, "real time signal 23");
   AddSignal(57, "SIGRTMAX-6", false, false, false, "real time signal 24");
   AddSignal(58, "SIGRTMAX-5", false, false, false, "real time signal 25");
   AddSignal(59, "SIGRTMAX-4", false, false, false, "real time signal 26");
   AddSignal(60, "SIGRTMAX-3", false, false, false, "real time signal 27");
   AddSignal(61, "SIGRTMAX-2", false, false, false, "real time signal 28");
   AddSignal(62, "SIGRTMAX-1", false, false, false, "real time signal 29");
   AddSignal(63, "SIGRTMAX", false, false, false, "real time signal 30");
 }

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/GDBRemoteSignals.h

 //===-- GDBRemoteSignals.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_PROCESS_UTILITY_GDBREMOTESIGNALS_H
 #define LLDB_SOURCE_PLUGINS_PROCESS_UTILITY_GDBREMOTESIGNALS_H
 
 #include "lldb/Target/UnixSignals.h"
 
 namespace lldb_private {
 
 /// Initially carries signals defined by the GDB Remote Serial Protocol.
 /// Can be filled with platform's signals through PlatformRemoteGDBServer.
 class GDBRemoteSignals : public UnixSignals {
 public:
   GDBRemoteSignals();
 
   GDBRemoteSignals(const lldb::UnixSignalsSP &rhs);
 
 private:
   void Reset() override;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_PROCESS_UTILITY_GDBREMOTESIGNALS_H

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

 //===-- GDBRemoteSignals.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 "GDBRemoteSignals.h"
 
 using namespace lldb_private;
 
 GDBRemoteSignals::GDBRemoteSignals() : UnixSignals() { Reset(); }
 
 GDBRemoteSignals::GDBRemoteSignals(const lldb::UnixSignalsSP &rhs)
     : UnixSignals(*rhs) {}
 
 void GDBRemoteSignals::Reset() {
   m_signals.clear();
   // clang-format off
   //        SIGNO   NAME            SUPPRESS  STOP    NOTIFY  DESCRIPTION
   //        ======  ==============  ========  ======  ======  ===================================================
   AddSignal(1,      "SIGHUP",       false,    true,   true,   "hangup");
   AddSignal(2,      "SIGINT",       true,     true,   true,   "interrupt");
   AddSignal(3,      "SIGQUIT",      false,    true,   true,   "quit");
   AddSignal(4,      "SIGILL",       false,    true,   true,   "illegal instruction");
   AddSignal(5,      "SIGTRAP",      true,     true,   true,   "trace trap (not reset when caught)");
   AddSignal(6,      "SIGABRT",      false,    true,   true,   "abort()/IOT trap", "SIGIOT");
   AddSignal(7,      "SIGEMT",       false,    true,   true,   "emulation trap");
   AddSignal(8,      "SIGFPE",       false,    true,   true,   "floating point exception");
   AddSignal(9,      "SIGKILL",      false,    true,   true,   "kill");
   AddSignal(10,     "SIGBUS",       false,    true,   true,   "bus error");
   AddSignal(11,     "SIGSEGV",      false,    true,   true,   "segmentation violation");
   AddSignal(12,     "SIGSYS",       false,    true,   true,   "invalid system call");
   AddSignal(13,     "SIGPIPE",      false,    true,   true,   "write to pipe with reading end closed");
   AddSignal(14,     "SIGALRM",      false,    false,  false,  "alarm");
   AddSignal(15,     "SIGTERM",      false,    true,   true,   "termination requested");
   AddSignal(16,     "SIGURG",       false,    true,   true,   "urgent data on socket");
   AddSignal(17,     "SIGSTOP",      true,     true,   true,   "process stop");
   AddSignal(18,     "SIGTSTP",      false,    true,   true,   "tty stop");
   AddSignal(19,     "SIGCONT",      false,    false,  true,   "process continue");
   AddSignal(20,     "SIGCHLD",      false,    false,  true,   "child status has changed", "SIGCLD");
   AddSignal(21,     "SIGTTIN",      false,    true,   true,   "background tty read");
   AddSignal(22,     "SIGTTOU",      false,    true,   true,   "background tty write");
   AddSignal(23,     "SIGIO",        false,    true,   true,   "input/output ready/Pollable event");
   AddSignal(24,     "SIGXCPU",      false,    true,   true,   "CPU resource exceeded");
   AddSignal(25,     "SIGXFSZ",      false,    true,   true,   "file size limit exceeded");
   AddSignal(26,     "SIGVTALRM",    false,    true,   true,   "virtual time alarm");
   AddSignal(27,     "SIGPROF",      false,    false,  false,  "profiling time alarm");
   AddSignal(28,     "SIGWINCH",     false,    true,   true,   "window size changes");
   AddSignal(29,     "SIGLOST",      false,    true,   true,   "resource lost");
   AddSignal(30,     "SIGUSR1",      false,    true,   true,   "user defined signal 1");
   AddSignal(31,     "SIGUSR2",      false,    true,   true,   "user defined signal 2");
   AddSignal(32,     "SIGPWR",       false,    true,   true,   "power failure");
   AddSignal(33,     "SIGPOLL",      false,    true,   true,   "pollable event");
   AddSignal(34,     "SIGWIND",      false,    true,   true,   "SIGWIND");
   AddSignal(35,    "SIGPHONE",      false,    true,   true,   "SIGPHONE");
   AddSignal(36,  "SIGWAITING",      false,    true,   true,   "process's LWPs are blocked");
   AddSignal(37,      "SIGLWP",      false,    true,   true,   "signal LWP");
   AddSignal(38,   "SIGDANGER",      false,    true,   true,   "swap space dangerously low");
   AddSignal(39,    "SIGGRANT",      false,    true,   true,   "monitor mode granted");
   AddSignal(40,  "SIGRETRACT",      false,    true,   true,   "need to relinquish monitor mode");
   AddSignal(41,      "SIGMSG",      false,    true,   true,   "monitor mode data available");
   AddSignal(42,    "SIGSOUND",      false,    true,   true,   "sound completed");
   AddSignal(43,      "SIGSAK",      false,    true,   true,   "secure attention");
   AddSignal(44,     "SIGPRIO",      false,    true,   true,   "SIGPRIO");
 
   AddSignal(45,       "SIG33",      false,    false,  false,  "real-time event 33");
   AddSignal(46,       "SIG34",      false,    false,  false,  "real-time event 34");
   AddSignal(47,       "SIG35",      false,    false,  false,  "real-time event 35");
   AddSignal(48,       "SIG36",      false,    false,  false,  "real-time event 36");
   AddSignal(49,       "SIG37",      false,    false,  false,  "real-time event 37");
   AddSignal(50,       "SIG38",      false,    false,  false,  "real-time event 38");
   AddSignal(51,       "SIG39",      false,    false,  false,  "real-time event 39");
   AddSignal(52,       "SIG40",      false,    false,  false,  "real-time event 40");
   AddSignal(53,       "SIG41",      false,    false,  false,  "real-time event 41");
   AddSignal(54,       "SIG42",      false,    false,  false,  "real-time event 42");
   AddSignal(55,       "SIG43",      false,    false,  false,  "real-time event 43");
   AddSignal(56,       "SIG44",      false,    false,  false,  "real-time event 44");
   AddSignal(57,       "SIG45",      false,    false,  false,  "real-time event 45");
   AddSignal(58,       "SIG46",      false,    false,  false,  "real-time event 46");
   AddSignal(59,       "SIG47",      false,    false,  false,  "real-time event 47");
   AddSignal(60,       "SIG48",      false,    false,  false,  "real-time event 48");
   AddSignal(61,       "SIG49",      false,    false,  false,  "real-time event 49");
   AddSignal(62,       "SIG50",      false,    false,  false,  "real-time event 50");
   AddSignal(63,       "SIG51",      false,    false,  false,  "real-time event 51");
   AddSignal(64,       "SIG52",      false,    false,  false,  "real-time event 52");
   AddSignal(65,       "SIG53",      false,    false,  false,  "real-time event 53");
   AddSignal(66,       "SIG54",      false,    false,  false,  "real-time event 54");
   AddSignal(67,       "SIG55",      false,    false,  false,  "real-time event 55");
   AddSignal(68,       "SIG56",      false,    false,  false,  "real-time event 56");
   AddSignal(69,       "SIG57",      false,    false,  false,  "real-time event 57");
   AddSignal(70,       "SIG58",      false,    false,  false,  "real-time event 58");
   AddSignal(71,       "SIG59",      false,    false,  false,  "real-time event 59");
   AddSignal(72,       "SIG60",      false,    false,  false,  "real-time event 60");
   AddSignal(73,       "SIG61",      false,    false,  false,  "real-time event 61");
   AddSignal(74,       "SIG62",      false,    false,  false,  "real-time event 62");
   AddSignal(75,       "SIG63",      false,    false,  false,  "real-time event 63");
 
   AddSignal(76,   "SIGCANCEL",      false,    true,   true,   "LWP internal signal");
 
   AddSignal(77,       "SIG32",      false,    false,  false,  "real-time event 32");
   AddSignal(78,       "SIG64",      false,    false,  false,  "real-time event 64");
   AddSignal(79,       "SIG65",      false,    false,  false,  "real-time event 65");
   AddSignal(80,       "SIG66",      false,    false,  false,  "real-time event 66");
   AddSignal(81,       "SIG67",      false,    false,  false,  "real-time event 67");
   AddSignal(82,       "SIG68",      false,    false,  false,  "real-time event 68");
   AddSignal(83,       "SIG69",      false,    false,  false,  "real-time event 69");
   AddSignal(84,       "SIG70",      false,    false,  false,  "real-time event 70");
   AddSignal(85,       "SIG71",      false,    false,  false,  "real-time event 71");
   AddSignal(86,       "SIG72",      false,    false,  false,  "real-time event 72");
   AddSignal(87,       "SIG73",      false,    false,  false,  "real-time event 73");
   AddSignal(88,       "SIG74",      false,    false,  false,  "real-time event 74");
   AddSignal(89,       "SIG75",      false,    false,  false,  "real-time event 75");
   AddSignal(90,       "SIG76",      false,    false,  false,  "real-time event 76");
   AddSignal(91,       "SIG77",      false,    false,  false,  "real-time event 77");
   AddSignal(92,       "SIG78",      false,    false,  false,  "real-time event 78");
   AddSignal(93,       "SIG79",      false,    false,  false,  "real-time event 79");
   AddSignal(94,       "SIG80",      false,    false,  false,  "real-time event 80");
   AddSignal(95,       "SIG81",      false,    false,  false,  "real-time event 81");
   AddSignal(96,       "SIG82",      false,    false,  false,  "real-time event 82");
   AddSignal(97,       "SIG83",      false,    false,  false,  "real-time event 83");
   AddSignal(98,       "SIG84",      false,    false,  false,  "real-time event 84");
   AddSignal(99,       "SIG85",      false,    false,  false,  "real-time event 85");
   AddSignal(100,      "SIG86",      false,    false,  false,  "real-time event 86");
   AddSignal(101,      "SIG87",      false,    false,  false,  "real-time event 87");
   AddSignal(102,      "SIG88",      false,    false,  false,  "real-time event 88");
   AddSignal(103,      "SIG89",      false,    false,  false,  "real-time event 89");
   AddSignal(104,      "SIG90",      false,    false,  false,  "real-time event 90");
   AddSignal(105,      "SIG91",      false,    false,  false,  "real-time event 91");
   AddSignal(106,      "SIG92",      false,    false,  false,  "real-time event 92");
   AddSignal(107,      "SIG93",      false,    false,  false,  "real-time event 93");
   AddSignal(108,      "SIG94",      false,    false,  false,  "real-time event 94");
   AddSignal(109,      "SIG95",      false,    false,  false,  "real-time event 95");
   AddSignal(110,      "SIG96",      false,    false,  false,  "real-time event 96");
   AddSignal(111,      "SIG97",      false,    false,  false,  "real-time event 97");
   AddSignal(112,      "SIG98",      false,    false,  false,  "real-time event 98");
   AddSignal(113,      "SIG99",      false,    false,  false,  "real-time event 99");
   AddSignal(114,     "SIG100",      false,    false,  false,  "real-time event 100");
   AddSignal(115,     "SIG101",      false,    false,  false,  "real-time event 101");
   AddSignal(116,     "SIG102",      false,    false,  false,  "real-time event 102");
   AddSignal(117,     "SIG103",      false,    false,  false,  "real-time event 103");
   AddSignal(118,     "SIG104",      false,    false,  false,  "real-time event 104");
   AddSignal(119,     "SIG105",      false,    false,  false,  "real-time event 105");
   AddSignal(120,     "SIG106",      false,    false,  false,  "real-time event 106");
   AddSignal(121,     "SIG107",      false,    false,  false,  "real-time event 107");
   AddSignal(122,     "SIG108",      false,    false,  false,  "real-time event 108");
   AddSignal(123,     "SIG109",      false,    false,  false,  "real-time event 109");
   AddSignal(124,     "SIG110",      false,    false,  false,  "real-time event 110");
   AddSignal(125,     "SIG111",      false,    false,  false,  "real-time event 111");
   AddSignal(126,     "SIG112",      false,    false,  false,  "real-time event 112");
   AddSignal(127,     "SIG113",      false,    false,  false,  "real-time event 113");
   AddSignal(128,     "SIG114",      false,    false,  false,  "real-time event 114");
   AddSignal(129,     "SIG115",      false,    false,  false,  "real-time event 115");
   AddSignal(130,     "SIG116",      false,    false,  false,  "real-time event 116");
   AddSignal(131,     "SIG117",      false,    false,  false,  "real-time event 117");
   AddSignal(132,     "SIG118",      false,    false,  false,  "real-time event 118");
   AddSignal(133,     "SIG119",      false,    false,  false,  "real-time event 119");
   AddSignal(134,     "SIG120",      false,    false,  false,  "real-time event 120");
   AddSignal(135,     "SIG121",      false,    false,  false,  "real-time event 121");
   AddSignal(136,     "SIG122",      false,    false,  false,  "real-time event 122");
   AddSignal(137,     "SIG123",      false,    false,  false,  "real-time event 123");
   AddSignal(138,     "SIG124",      false,    false,  false,  "real-time event 124");
   AddSignal(139,     "SIG125",      false,    false,  false,  "real-time event 125");
   AddSignal(140,     "SIG126",      false,    false,  false,  "real-time event 126");
   AddSignal(141,     "SIG127",      false,    false,  false,  "real-time event 127");
 
   AddSignal(142,    "SIGINFO",      false,    true,   true,   "information request");
   AddSignal(143,    "unknown",      false,    true,   true,   "unknown signal");
 
   AddSignal(145,      "EXC_BAD_ACCESS",       false,  true,   true,   "could not access memory");
   AddSignal(146, "EXC_BAD_INSTRUCTION",       false,  true,   true,   "illegal instruction/operand");
   AddSignal(147,      "EXC_ARITHMETIC",       false,  true,   true,   "arithmetic exception");
   AddSignal(148,       "EXC_EMULATION",       false,  true,   true,   "emulation instruction");
   AddSignal(149,        "EXC_SOFTWARE",       false,  true,   true,   "software generated exception");
   AddSignal(150,      "EXC_BREAKPOINT",       false,  true,   true,   "breakpoint");
 
   AddSignal(151,   "SIGLIBRT",      false,    true,   true,   "librt internal signal");
 
   // clang-format on
 }

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>
 
 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(); }
 };