[lldb] Support gdbserver signals

[mgorny]

Summary

GDB and LLDB use different signal models. GDB uses a predefined set
of signal codes, and maps platform's signos to them. On the other hand,
LLDB has historically simply passed native signos.

In order to improve compatibility between LLDB and gdbserver, the GDB
signal model should be used. However, GDB does not provide a mapping
for all existing signals on Linux and unsupported signals are passed
as 'unknown'. Limiting LLDB to this behavior could be considered
a regression.

To get the best of both worlds, use the LLDB signal model when talking
to lldb-server, and the GDB signal model otherwise. For this purpose,
new versions of lldb-server indicate "native-signals+" via qSupported.
At the same time, we also detect older versions of lldb-server
via QThreadSuffixSupported for backwards compatibility. If neither test
succeeds, we assume gdbserver or another implementation using GDB model.

[mgorny]

Added client tests for GDB and LLDB signal variants. Moved signal init into DidLaunchOrAttach, in order to have normalized target triple already (needed for correct os-name in test).

[mgorny]

Included all signals from include/gdb/signals.def.

[JDevlieghere]

LGTM

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

1349

What about debugserver, I assume that would need to be updated as well?

[JDevlieghere]

Didn't mean to accept yet (originally I thought the native-signals check was inverted)

[mgorny]

Advertise native-signals+ in debugserver too.

[mgorny]

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

1349

I've attempted doing that. Please lemme know if that's ok.

[mgorny]

Rebased.

[labath]

It would be nice if the commit message/summary included more details about the differences in signal handling (the things we talked about on irc), but generally, I think this patch looks good.

The only thing that's missing is interoperability with older lldb-compatible stubs (debugservers mainly). I believe we already have some "standard" solution for that, like checking for QThreadSuffixSupported or some similar lldb-only packet (?)

[mgorny]

Add fallback to QThreadSuffixSupported and a respective test. Improve the summary.

[labath]

lldb/test/API/functionalities/gdb_remote_client/TestGDBRemoteClient.py

486

I believe this will always use remote-linux (or something), as the platform is determined by the binary. And even in case it isn't , it would probably be better to hardcode the platform by using the appropriate CreateTarget overload

lldb/packages/Python/lldbsuite/test/tools/lldb-server/gdbremote_testcase.py

_KNOWN_QSUPPORTED_STUB_FEATURES = [
         "qXfer:features:read",
         "qEcho",
         "QPassSignals",
         "multiprocess",
         "fork-events",
         "vfork-events",
         "memory-tagging",
         "qSaveCore",
+        "native-signals",
     ]
 
     def parse_qSupported_response(self, context):
         self.assertIsNotNone(context)
 
         raw_response = context.get("qSupported_response")
         self.assertIsNotNone(raw_response)
 

lldb/source/Plugins/Process/Utility/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 {
 
-/// Empty set of Unix signals to be filled by PlatformRemoteGDBServer
+/// 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/Process/Utility/GDBRemoteSignals.cpp

 
 using namespace lldb_private;
 
 GDBRemoteSignals::GDBRemoteSignals() : UnixSignals() { Reset(); }
 
 GDBRemoteSignals::GDBRemoteSignals(const lldb::UnixSignalsSP &rhs)
     : UnixSignals(*rhs) {}
 
-void GDBRemoteSignals::Reset() { m_signals.clear(); }
+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/Process/gdb-remote/GDBRemoteCommunicationClient.h

public:
   bool GetThreadExtendedInfoSupported();
 
   bool GetLoadedDynamicLibrariesInfosSupported();
 
   bool GetSharedCacheInfoSupported();
 
   bool GetMemoryTaggingSupported();
 
+  bool UsesNativeSignals();
+
   lldb::DataBufferSP ReadMemoryTags(lldb::addr_t addr, size_t len,
                                     int32_t type);
 
   Status WriteMemoryTags(lldb::addr_t addr, size_t len, int32_t type,
                          const std::vector<uint8_t> &tags);
 
   /// Use qOffsets to query the offset used when relocating the target
   /// executable. If successful, the returned structure will contain at least
protected:
   LazyBool m_supports_jThreadExtendedInfo = eLazyBoolCalculate;
   LazyBool m_supports_jLoadedDynamicLibrariesInfos = eLazyBoolCalculate;
   LazyBool m_supports_jGetSharedCacheInfo = eLazyBoolCalculate;
   LazyBool m_supports_QPassSignals = eLazyBoolCalculate;
   LazyBool m_supports_error_string_reply = eLazyBoolCalculate;
   LazyBool m_supports_multiprocess = eLazyBoolCalculate;
   LazyBool m_supports_memory_tagging = eLazyBoolCalculate;
   LazyBool m_supports_qSaveCore = eLazyBoolCalculate;
+  LazyBool m_uses_native_signals = eLazyBoolCalculate;
 
   bool m_supports_qProcessInfoPID : 1, m_supports_qfProcessInfo : 1,
       m_supports_qUserName : 1, m_supports_qGroupName : 1,
       m_supports_qThreadStopInfo : 1, m_supports_z0 : 1, m_supports_z1 : 1,
       m_supports_z2 : 1, m_supports_z3 : 1, m_supports_z4 : 1,
       m_supports_QEnvironment : 1, m_supports_QEnvironmentHexEncoded : 1,
       m_supports_qSymbol : 1, m_qSymbol_requests_done : 1,
       m_supports_qModuleInfo : 1, m_supports_jThreadsInfo : 1,

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

if (!did_exec) {
     m_supports_multiprocess = eLazyBoolCalculate;
     m_supports_qSaveCore = eLazyBoolCalculate;
     m_supports_qXfer_auxv_read = eLazyBoolCalculate;
     m_supports_qXfer_libraries_read = eLazyBoolCalculate;
     m_supports_qXfer_libraries_svr4_read = eLazyBoolCalculate;
     m_supports_qXfer_features_read = eLazyBoolCalculate;
     m_supports_qXfer_memory_map_read = eLazyBoolCalculate;
     m_supports_augmented_libraries_svr4_read = eLazyBoolCalculate;
+    m_uses_native_signals = eLazyBoolCalculate;
     m_supports_qProcessInfoPID = true;
     m_supports_qfProcessInfo = true;
     m_supports_qUserName = true;
     m_supports_qGroupName = true;
     m_supports_qThreadStopInfo = true;
     m_supports_z0 = true;
     m_supports_z1 = true;
     m_supports_z2 = true;
void GDBRemoteCommunicationClient::GetRemoteQSupported() {
   m_supports_augmented_libraries_svr4_read = eLazyBoolNo;
   m_supports_qXfer_features_read = eLazyBoolNo;
   m_supports_qXfer_memory_map_read = eLazyBoolNo;
   m_supports_multiprocess = eLazyBoolNo;
   m_supports_qEcho = eLazyBoolNo;
   m_supports_QPassSignals = eLazyBoolNo;
   m_supports_memory_tagging = eLazyBoolNo;
   m_supports_qSaveCore = eLazyBoolNo;
+  m_uses_native_signals = eLazyBoolNo;
 
   m_max_packet_size = UINT64_MAX; // It's supposed to always be there, but if
                                   // not, we assume no limit
 
   // build the qSupported packet
   std::vector<std::string> features = {"xmlRegisters=i386,arm,mips,arc",
                                        "multiprocess+", "fork-events+",
                                        "vfork-events+"};
for (llvm::StringRef x : llvm::split(response.GetStringRef(), ';')) {
       else if (x == "QPassSignals+")
         m_supports_QPassSignals = eLazyBoolYes;
       else if (x == "multiprocess+")
         m_supports_multiprocess = eLazyBoolYes;
       else if (x == "memory-tagging+")
         m_supports_memory_tagging = eLazyBoolYes;
       else if (x == "qSaveCore+")
         m_supports_qSaveCore = eLazyBoolYes;
+      else if (x == "native-signals+")
+        m_uses_native_signals = eLazyBoolYes;
       // Look for a list of compressions in the features list e.g.
       // qXfer:features:read+;PacketSize=20000;qEcho+;SupportedCompressions=zlib-
       // deflate,lzma
       else if (x.consume_front("SupportedCompressions=")) {
         llvm::SmallVector<llvm::StringRef, 4> compressions;
         x.split(compressions, ',');
         if (!compressions.empty())
           MaybeEnableCompression(compressions);
Status GDBRemoteCommunicationClient::ConfigureRemoteStructuredData(
   }
   return error;
 }
 
 void GDBRemoteCommunicationClient::OnRunPacketSent(bool first) {
   GDBRemoteClientBase::OnRunPacketSent(first);
   m_curr_tid = LLDB_INVALID_THREAD_ID;
 }
+
+bool GDBRemoteCommunicationClient::UsesNativeSignals() {
+  if (m_uses_native_signals == eLazyBoolCalculate)
+    GetRemoteQSupported();
+  if (m_uses_native_signals == eLazyBoolYes)
+    return true;
+
+  // If the remote didn't indicate native-signal support explicitly,
+  // check whether it is an old version of lldb-server.
+  return GetThreadSuffixSupported();
+}

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

std::vector<std::string> GDBRemoteCommunicationServerCommon::HandleFeatures(
   // 128KBytes is a reasonable max packet size--debugger can always use less.
   constexpr uint32_t max_packet_size = 128 * 1024;
 
   // Features common to platform server and llgs.
   return {
       llvm::formatv("PacketSize={0}", max_packet_size),
       "QStartNoAckMode+",
       "qEcho+",
+      "native-signals+",
   };
 }

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

Status ProcessGDBRemote::DoConnectRemote(llvm::StringRef remote_url) {
   }
 
   LLDB_LOGF(log,
             "ProcessGDBRemote::%s pid %" PRIu64
             ": normalized target architecture triple: %s",
             __FUNCTION__, GetID(),
             GetTarget().GetArchitecture().GetTriple().getTriple().c_str());
 
-  if (error.Success()) {
-    PlatformSP platform_sp = GetTarget().GetPlatform();
-    if (platform_sp && platform_sp->IsConnected())
-      SetUnixSignals(platform_sp->GetUnixSignals());
-    else
-      SetUnixSignals(UnixSignals::Create(GetTarget().GetArchitecture()));
-  }
-
   return error;
 }
 
 Status ProcessGDBRemote::WillLaunchOrAttach() {
   Status error;
   m_stdio_communication.Clear();
   return error;
 }
void ProcessGDBRemote::DidLaunchOrAttach(ArchSpec &process_arch) {
 
   MaybeLoadExecutableModule();
 
   // 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()) {
+    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()));
+  }
 }
 
 void ProcessGDBRemote::MaybeLoadExecutableModule() {
   ModuleSP module_sp = GetTarget().GetExecutableModule();
   if (!module_sp)
     return;
 
   llvm::Optional<QOffsets> offsets = m_gdb_comm.GetQOffsets();

lldb/test/API/functionalities/gdb_remote_client/TestGDBRemoteClient.py

def test_detach_pid(self):
                 self.detached = packet
                 return "OK"
 
         self.server.responder = MyResponder(self)
         target = self.dbg.CreateTarget('')
         process = self.connect(target)
         process.Detach()
         self.assertRegex(self.server.responder.detached, r"D;0*400")
+
+    def test_signal_gdb(self):
+        class MyResponder(MockGDBServerResponder):
+            def qSupported(self, client_supported):
+                return "PacketSize=3fff;QStartNoAckMode+"
+
+            def haltReason(self):
+                return "S0a"
+
+            def cont(self):
+                return self.haltReason()
+
+        self.server.responder = MyResponder()
+
+        target = self.createTarget("a.yaml")
+        process = self.connect(target)
+
+        self.assertEqual(process.threads[0].GetStopReason(),
+                         lldb.eStopReasonSignal)
+        self.assertEqual(process.threads[0].GetStopDescription(100),
+                         'signal SIGBUS')
+
+    def test_signal_lldb_old(self):
+        class MyResponder(MockGDBServerResponder):
+            def qSupported(self, client_supported):
+                return "PacketSize=3fff;QStartNoAckMode+"
+
+            def qHostInfo(self):
+                return "triple:61726d76372d756e6b6e6f776e2d6c696e75782d676e75;"
+
+            def QThreadSuffixSupported(self):
+                return "OK"
+
+            def haltReason(self):
+                return "S0a"
+
+            def cont(self):
+                return self.haltReason()
+
+        self.server.responder = MyResponder()
+
+        target = self.createTarget("a.yaml")
+        process = self.connect(target)
+
+        self.assertEqual(process.threads[0].GetStopReason(),
+                         lldb.eStopReasonSignal)
+        self.assertEqual(process.threads[0].GetStopDescription(100),
+                         'signal SIGUSR1')
+
+    def test_signal_lldb(self):
+        class MyResponder(MockGDBServerResponder):
+            def qSupported(self, client_supported):
+                return "PacketSize=3fff;QStartNoAckMode+;native-signals+"
+
+            def qHostInfo(self):
+                return "triple:61726d76372d756e6b6e6f776e2d6c696e75782d676e75;"
+
+            def haltReason(self):
+                return "S0a"
+
+            def cont(self):
+                return self.haltReason()
+
+        self.server.responder = MyResponder()
+
+        target = self.createTarget("a.yaml")
+        process = self.connect(target)
+
+        self.assertEqual(process.threads[0].GetStopReason(),
+                         lldb.eStopReasonSignal)
+        self.assertEqual(process.threads[0].GetStopDescription(100),
+                         'signal SIGUSR1')

lldb/tools/debugserver/source/RNBRemote.cpp

static bool GetProcessNameFrom_vAttach(const char *&p,
   }
   return return_val;
 }
 
 rnb_err_t RNBRemote::HandlePacket_qSupported(const char *p) {
   uint32_t max_packet_size = 128 * 1024; // 128KBytes is a reasonable max packet
                                          // size--debugger can always use less
   char buf[256];
-  snprintf(buf, sizeof(buf), "qXfer:features:read+;PacketSize=%x;qEcho+",
+  snprintf(buf, sizeof(buf),
+           "qXfer:features:read+;PacketSize=%x;qEcho+;native-signals+",
            max_packet_size);
 
   bool enable_compression = false;
   (void)enable_compression;
 
 #if (defined (TARGET_OS_WATCH) && TARGET_OS_WATCH == 1) \
     || (defined (TARGET_OS_IOS) && TARGET_OS_IOS == 1) \
     || (defined (TARGET_OS_TV) && TARGET_OS_TV == 1) \