Refactor Unix signals.

[chaoren]

Summary

• Consolidate Unix signals selection in UnixSignals.
• Make Unix signals available from platform.
• Add jSignalsInfo packet to retrieve Unix signals from remote platform.
• Get a copy of the platform signal for each remote process.
• Update SB API for signals.
• Update signal utility in test suite.

[chaoren]

Tested on Linux (local and remote). Very likely broken on other platform (will test later).

Some thoughts:

1. Is it worth the effort to make Platform::GetUnixSignals const? Same thing with most (all?) of the Get* methods in PlatformRemoteGDBServer. I don't know if we should bother with const-correctness of remote protocols.
2. *Signals.{h,cpp} should probably be moved out of Process/Utility. But where?
3. Are Should{Suppress,Stop,Notify} per process properties or general properties of the signals. If it's per process, each process will need its own copy (which we didn't have before).

[chaoren]

• UnixSignals::Reset should be virtual.

[labath]

include/lldb/API/SBUnixSignals.h

68 ↗

(On Diff #29418)

You are changing the public API here. We are maintaining binary compatibility wrt. SBAPI. You can see http://lldb.llvm.org/SB-api-coding-rules.html for details, but the short version is that you can add signatures, but not modfy or remove existing ones.

78 ↗

(On Diff #29418)

Modifying the members ( = size of the object) is also a no-no.

source/Commands/CommandObjectProcess.cpp

1833 ↗

(On Diff #29418)

Please rename to signals_sp, per coding conventions.

source/Host/common/Host.cpp

1078 ↗

(On Diff #29418)

I am not sure this function belongs to the Host layer anymore (which I understand as providing information about the host lldb is running on), since it now provides signals for any platform. Perhaps if we move this function to process/Utility then we wouldn't have the host layer calling back into other stuff (was this the reason for your question #2?). What do you think?

[chaoren]

include/lldb/API/SBUnixSignals.h

68 ↗

(On Diff #29418)

This is protected: so it's not part of the public API. Actually, now that you mention it, it should probably be private: instead, since there's no inheritance.

78 ↗

(On Diff #29418)

We can probably do without the process pointer (depending on the answer to my 3rd question). But I'm not sure it makes sense to use a WP for UnixSignals.

source/Host/common/Host.cpp

1078 ↗

(On Diff #29418)

We can probably move this function to UnixSignals itself. The signals are usually platform specific rather than process specific, so I thought it was a little weird to still have them in Process/Utility.

[clayborg]

So what is the overall goal of this patch? I am assuming the jist of this patch is to just get the JSON packet to get unix signals from the remote GDB server.

The following things MUST be true:

• Each process must have its own unix signals, i.e. they must be separate UnixSignals instances. Different processes might setup which signals to ignore and pass along and notify differently and this shouldn't change.
• You can't add ivars to lldb::SB classes there must be one shared_ptr, unique_ptr or raw pointer and its size must match what was there before for API compatability

I would rather not see SBPlatform get UnixSignals if we can help it. It would be nice from the standpoint that you might be able to grab a copy of them and modify them before any processes are launched, but I don't see us doing any of this anywhere so I would rather avoid it until we do. The theory is you can modify a platforms unix signals, and then each process will get a copy of the current platforms signals when the process is created, but each process needs to have its own instance of UnixSignals so each process can set which signals to stop/notify/continue from separately, all processes can't use the same instance otherwise you make other processes stop when they didn't want to for specified signals. We have lldb.util.get_signal_number() that is trying to take advantage of the platform having unix signals but I would argue that we should have a lldb.SBProcess available anytime we need this information, so the platform doesn't really need signals right now. So I believe Process should still have a m_unix_signals object that is owned by it just like it used to and it can be seeded with startup values if needed.

So what I don't like about the platform having unix signals and this patch:

• Each platform might be able to guess what signals it has by making a constant copy of some signals from some version of the their previous OS's but this can get out of date
• Each platform could provide the correct signals if it is connected to a remote platform, but connection to a platform isn't required (for iOS we don't connect to a remote platform) and the lldb-server on the other side might not support the JSON signal packet, and if not then we are back to guessing as in the above step
• We can't share unix signals between multiple processes, they each need to have their own instance

What I do like about the platform having unix signals:

• We can get ahold of SBUnixSignals before we run and set up signals so each process that gets launched can init itself with a copy of one set of settings (but this patch doesn't do that).

A quick not about public API stuff:

• Any changes in the public API must be additions only and no changes to previous API can be made
• no ivar size changes
• Don't bother with any "const" specifications on ANY methods as they are useless. The only thing it does it makes sure the shared_ptr, unique_ptr or pointer can't be changed. We have some functions that people put "const" on erroneously, but we are stuck with it now since we can't change public API. We shouldn't add more.

So let me know what you think after reading my above comments. I would almost rather this patch just do the following:

• introduce the new JSON unix signal packet and use it for ProcessGDBRemote
• Don't do any of the SBPlatform stuff, the only thing we are using it for is lldbutil.get_signal_number() and we should be able to use the current process for this
• Backout all public API changes
• Backout all host changes

include/lldb/API/SBUnixSignals.h

77–78 ↗

(On Diff #29418)

All objects in the public API must never change size so you can't add one here. If clients update LLDB they should still be able to link against the LLDB public interface without anything changing, adding an ivar changes the byte size, anyone that might have inherited from or use a SBUnixSignal as an ivar, will now crash.

include/lldb/Host/Host.h

248–249 ↗

(On Diff #29418)

I am confused as to why this change was made. In the host layer there should only be 1 host set of unix signals. If you are trying to make a grab bag for any kind of canned unix signals, please make a static function in the lldb_private::UnixSignals class.

[chaoren]

It would be nice from the standpoint that you might be able to grab a copy of them and modify them before any processes are launched, but I don't see us doing any of this anywhere so I would rather avoid it until we do.

We do this in the gdb remote tests. I added the kill -l workaround, but that doesn't work on prehistoric shells.

Each platform might be able to guess what signals it has by making a constant copy of some signals from some version of the their previous OS's but this can get out of date

Yes, that's the fall back. Doesn't Process do this currently? If so, I don't see how this is worse.

[chaoren]

Address reviews.

• Moved signal selection out of Host and into UnixSignals itself.
• Single UnixSignalsWP in SBUnixSignals for API compatibility.
• Each process gets its own instance of UnixSignals.
• ProcessGDBRemote gets a copy from PlatformRemoteGDBServer.

[jingham]

Note, there is a document that describes the rules for coding the SB API's:

http://lldb.llvm.org/SB-api-coding-rules.html

if there's something there that isn't clear, feel free to clarify the text there...

Jim

[ovyalov]

source/API/SBUnixSignals.cpp

111 ↗

(On Diff #29488)

Please add check for not-null signals_sp

144 ↗

(On Diff #29488)

ditto.

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

978 ↗

(On Diff #29488)

Should it be Host::GetUnixSignals?

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerPlatform.cpp

263 ↗

(On Diff #29488)

Could you store result of Host::GetUnixSignals() as local variable?

source/Target/UnixSignals.cpp

343 ↗

(On Diff #29488)

Please add a check that index < m_signals.size()

[chaoren]

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

978 ↗

(On Diff #29488)

I think it's better to use the default Unix signal set without any assumptions about the remote platform, than to assume that the remote platform would be the same as the host.

[chaoren]

source/API/SBUnixSignals.cpp

111 ↗

(On Diff #29488)

Do we not want to log if it's null?

I think SBUnixSignals(<null>)::SetShouldSuppress is still good to see.

[clayborg]

Looks fine, just some possible cleanup with respect to calling "get_signal_number(signal_name, process):" as mentioned in inlined comments.

test/lldbutil.py

935–939 ↗

(On Diff #29488)

We should be getting this info from the current process if we can. This seems like it can introduce test suite errors if our const cached notion of what signals are that are retrieved from the static UnixSignals function doesn't actually match the real current process that might have fetched the info from the remote GDB server. Can you check on all of the callsites that use this get_signal_number() function and see if any have a live process they can supply?

I would like to see this function changed to:

def get_signal_number(signal_name, process):
    signals = None
    if process:
       signals = process.GetUnixSignals()
    else:
        platform = lldb.remote_platform
        if platform and platform.IsValid():
            signals = platform.GetUnixSignals()
    if signals and signals.IsValid():

[chaoren]

test/lldbutil.py

935–939 ↗

(On Diff #29488)

I don't think it's possible for the signals to be different between the platform and a process, since I followed your advice and each process gets a copy of the signals that the platform fetched remotely.

[clayborg]

So what happens if we are not connected to a remote platform? Do we get UnixSignal that are empty? Do we fall back to some constant notion of what we think the signal should be?

[chaoren]

We use local signals.

return getattr(signal, signal_name)

[chaoren]

I was under the assumption that, in general, you need a remote platform to
have a remote process. Is the iOS thing not a special case? Even in that
specific case, the local host signals should suffice (since that's what we
had before I added the get_signal_number utility).

[chaoren]

• Properly defer RemoteUnixSignals through the platform chain.
• Also address ovyalov's reviews.

[clayborg]

That is fine, lets start with this and we can iterate on it if when we need to do so.

[ovyalov]

LGTM

[chaoren]

Minor fixups and rebase.

[chaoren]

• Update xcode project file.
• Remove unused include.

lldb/trunk/include/lldb/API/SBPlatform.h

public:
         MakeDirectory (const char *path, uint32_t file_permissions = eFilePermissionsDirectoryDefault);
 
         uint32_t
         GetFilePermissions (const char *path);
         
         SBError
         SetFilePermissions (const char *path, uint32_t file_permissions);
 
+        SBUnixSignals
+        GetUnixSignals() const;
+
     protected:
         
         friend class SBDebugger;
         friend class SBTarget;
 
         lldb::PlatformSP
         GetSP () const;
         

lldb/trunk/include/lldb/API/SBUnixSignals.h

public:
     int32_t
     GetNumSignals () const;
 
     int32_t
     GetSignalAtIndex (int32_t index) const;
 
 protected:
     friend class SBProcess;
+    friend class SBPlatform;
 
-    SBUnixSignals (lldb::ProcessSP &process_sp);
+    SBUnixSignals(lldb::ProcessSP &process_sp);
 
-    lldb::ProcessSP
+    SBUnixSignals(lldb::PlatformSP &platform_sp);
+
+    lldb::UnixSignalsSP
     GetSP() const;
 
     void
-    SetSP (const lldb::ProcessSP &process_sp);
+    SetSP(const lldb::UnixSignalsSP &signals_sp);
 
 private:
-    lldb::ProcessWP m_opaque_wp;
+    lldb::UnixSignalsWP m_opaque_wp;
 };
 
 
 } // namespace lldb
 
 #endif // LLDB_SBUnixSignals_h_

lldb/trunk/include/lldb/Core/StructuredData.h

public:
         {
         }
 
         virtual
         ~Array()
         {
         }
 
-        void
+        bool
         ForEach (std::function <bool(Object* object)> const &foreach_callback) const
         {
             for (const auto &object_sp : m_items)
             {
                 if (foreach_callback(object_sp.get()) == false)
-                    break;
+                    return false;
             }
+            return true;
         }
 
 
         size_t
         GetSize() const
         {
             return m_items.size();
         }

lldb/trunk/include/lldb/Host/Host.h

#if !defined(__ANDROID__) && !defined(__ANDROID_NDK__)
 
     static Error LaunchProcessPosixSpawn(const char *exe_path, const ProcessLaunchInfo &launch_info, lldb::pid_t &pid);
 
     static bool AddPosixSpawnFileAction(void *file_actions, const FileAction *info, Log *log, Error &error);
 
 #endif // !defined(__ANDROID__) && !defined(__ANDROID_NDK__)
 #endif // defined (__APPLE__) || defined (__linux__) || defined (__FreeBSD__) || defined (__GLIBC__) || defined(__NetBSD__)
 
-    static const lldb_private::UnixSignalsSP&
-    GetUnixSignals ();
+    static const lldb::UnixSignalsSP &
+    GetUnixSignals();
 
     static Error
     LaunchProcess (ProcessLaunchInfo &launch_info);
 
     //------------------------------------------------------------------
     /// Perform expansion of the command-line for this launch info
     /// This can potentially involve wildcard expansion
     //  environment variable replacement, and whatever other

lldb/trunk/include/lldb/Target/Platform.h

//                Error &error) = 0;
                       uint64_t &high);
         
         virtual int32_t
         GetResumeCountForLaunchInfo (ProcessLaunchInfo &launch_info)
         {
             return 1;
         }
 
+        virtual const lldb::UnixSignalsSP &
+        GetRemoteUnixSignals();
+
+        const lldb::UnixSignalsSP &
+        GetUnixSignals();
+
         //------------------------------------------------------------------
         /// 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

lldb/trunk/include/lldb/Target/Process.h

#endif
     /// Uses the Host UnixSignalsSP by default.
     //------------------------------------------------------------------
     Process(Target &target, Listener &listener);
 
     //------------------------------------------------------------------
     /// Construct with a shared pointer to a target, the Process listener,
     /// and the appropriate UnixSignalsSP for the process.
     //------------------------------------------------------------------
-    Process(Target &target, Listener &listener, const UnixSignalsSP &unix_signals_sp);
+    Process(Target &target, Listener &listener, const lldb::UnixSignalsSP &unix_signals_sp);
 
     //------------------------------------------------------------------
     /// Destructor.
     ///
     /// The destructor is virtual since this class is designed to be
     /// inherited from by the plug-in instance.
     //------------------------------------------------------------------
     virtual
#endif
     ///
     /// @return
     ///     Returns an error object.
     //------------------------------------------------------------------
     Error
     Signal (int signal);
 
     void
-    SetUnixSignals (const UnixSignalsSP &signals_sp);
+    SetUnixSignals(const lldb::UnixSignalsSP &signals_sp);
 
-    UnixSignals &
-    GetUnixSignals ();
+    const lldb::UnixSignalsSP &
+    GetUnixSignals();
 
     //==================================================================
     // Plug-in Process Control Overrides
     //==================================================================
 
     //------------------------------------------------------------------
     /// Called before attaching to a process.
     ///
protected:
     std::vector<lldb::addr_t>   m_image_tokens;
     Listener                    &m_listener;
     BreakpointSiteList          m_breakpoint_site_list; ///< This is the list of breakpoint locations we intend to insert in the target.
     lldb::DynamicLoaderUP       m_dyld_ap;
     lldb::JITLoaderListUP       m_jit_loaders_ap;
     lldb::DynamicCheckerFunctionsUP m_dynamic_checkers_ap; ///< The functions used by the expression parser to validate data that expressions use.
     lldb::OperatingSystemUP     m_os_ap;
     lldb::SystemRuntimeUP       m_system_runtime_ap;
-    UnixSignalsSP               m_unix_signals_sp;         /// This is the current signal set for this process.
+    lldb::UnixSignalsSP         m_unix_signals_sp;         /// This is the current signal set for this process.
     lldb::ABISP                 m_abi_sp;
     lldb::IOHandlerSP           m_process_input_reader;
     Communication               m_stdio_communication;
     Mutex                       m_stdio_communication_mutex;
     bool                        m_stdin_forward;           /// Remember if stdin must be forwarded to remote debug server
     std::string                 m_stdout_data;
     std::string                 m_stderr_data;
     Mutex                       m_profile_data_comm_mutex;

lldb/trunk/include/lldb/Target/UnixSignals.h

 #include "lldb/Core/ConstString.h"
 
 namespace lldb_private
 {
 
 class UnixSignals
 {
 public:
+    static lldb::UnixSignalsSP
+    Create(const ArchSpec &arch);
+
     //------------------------------------------------------------------
     // Constructors and Destructors
     //------------------------------------------------------------------
     UnixSignals();
 
     virtual
     ~UnixSignals();
 
public:
     // Call GetFirstSignalNumber to get the first entry, then iterate on GetNextSignalNumber
     // till you get back LLDB_INVALID_SIGNAL_NUMBER.
     int32_t
     GetFirstSignalNumber () const;
 
     int32_t
     GetNextSignalNumber (int32_t current_signal) const;
 
+    int32_t
+    GetNumSignals() const;
+
+    int32_t
+    GetSignalAtIndex(int32_t index) const;
+
     // We assume that the elements of this object are constant once it is constructed,
     // since a process should never need to add or remove symbols as it runs.  So don't
     // call these functions anywhere but the constructor of your subclass of UnixSignals or in
     // your Process Plugin's GetUnixSignals method before you return the UnixSignal object.
 
     void
     AddSignal (int signo,
                const char *name,
struct Signal
                 bool default_suppress,
                 bool default_stop,
                 bool default_notify,
                 const char *description);
 
         ~Signal () {}
     };
 
-    void
+    virtual void
     Reset ();
 
     typedef std::map <int32_t, Signal> collection;
 
     collection m_signals;
 
-    DISALLOW_COPY_AND_ASSIGN (UnixSignals);
+    // GDBRemote signals need to be copyable.
+    UnixSignals(const UnixSignals &rhs);
+
+    const UnixSignals &
+    operator=(const UnixSignals &rhs) = delete;
 };
 
 } // Namespace lldb
 #endif  // lldb_UnixSignals_h_

lldb/trunk/include/lldb/lldb-forward.h

#endif // #ifndef LLDB_DISABLE_PYTHON
     typedef std::shared_ptr<lldb_private::TypeFormatImpl> TypeFormatImplSP;
     typedef std::shared_ptr<lldb_private::TypeNameSpecifierImpl> TypeNameSpecifierImplSP;
     typedef std::shared_ptr<lldb_private::TypeSummaryImpl> TypeSummaryImplSP;
     typedef std::shared_ptr<lldb_private::TypeSummaryOptions> TypeSummaryOptionsSP;
     typedef std::shared_ptr<lldb_private::TypeValidatorImpl> TypeValidatorImplSP;
 #ifndef LLDB_DISABLE_PYTHON
     typedef std::shared_ptr<lldb_private::ScriptedSyntheticChildren> ScriptedSyntheticChildrenSP;
 #endif
+    typedef std::shared_ptr<lldb_private::UnixSignals> UnixSignalsSP;
+    typedef std::weak_ptr<lldb_private::UnixSignals> UnixSignalsWP;
     typedef std::shared_ptr<lldb_private::UnwindAssembly> UnwindAssemblySP;
     typedef std::shared_ptr<lldb_private::UnwindPlan> UnwindPlanSP;
     typedef lldb_private::SharingPtr<lldb_private::ValueObject> ValueObjectSP;
     typedef std::shared_ptr<lldb_private::Value> ValueSP;
     typedef std::shared_ptr<lldb_private::ValueList> ValueListSP;
     typedef std::shared_ptr<lldb_private::Variable> VariableSP;
     typedef std::shared_ptr<lldb_private::VariableList> VariableListSP;
     typedef std::shared_ptr<lldb_private::ValueObjectList> ValueObjectListSP;
     typedef std::shared_ptr<lldb_private::Watchpoint> WatchpointSP;
 
 } // namespace lldb
 
 
 #endif  // #if defined(__cplusplus)
 #endif  // LLDB_lldb_forward_h_

lldb/trunk/include/lldb/lldb-private-forward.h

namespace lldb_private
     // ---------------------------------------------------------------
     // SP/WP decls.
     // ---------------------------------------------------------------
     typedef std::shared_ptr<NativeBreakpoint> NativeBreakpointSP;
     typedef std::shared_ptr<lldb_private::NativeProcessProtocol> NativeProcessProtocolSP;
     typedef std::weak_ptr<lldb_private::NativeProcessProtocol> NativeProcessProtocolWP;
     typedef std::shared_ptr<lldb_private::NativeRegisterContext> NativeRegisterContextSP;
     typedef std::shared_ptr<lldb_private::NativeThreadProtocol> NativeThreadProtocolSP;
-    typedef std::shared_ptr<lldb_private::UnixSignals> UnixSignalsSP;
 }
 
 #endif // #if defined(__cplusplus)
 #endif // #ifndef LLDB_lldb_private_forward_h_

lldb/trunk/lldb.xcodeproj/project.pbxproj

/* Begin PBXBuildFile section */
     B2B7CCF015D1C20F00EEFB57 /* WatchpointOptions.cpp in Sources */ = {isa = PBXBuildFile; fileRef = B2B7CCEF15D1C20F00EEFB57 /* WatchpointOptions.cpp */; };
     B5EFAE861AE53B1D007059F3 /* RegisterContextFreeBSD_arm.cpp in Sources */ = {isa = PBXBuildFile; fileRef = B5EFAE841AE53B1D007059F3 /* RegisterContextFreeBSD_arm.cpp */; };
     E769331C1A94D15400C73337 /* lldb-gdbserver.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 26D6F3F4183E7F9300194858 /* lldb-gdbserver.cpp */; };
     E769331E1A94D18100C73337 /* lldb-server.cpp in Sources */ = {isa = PBXBuildFile; fileRef = E769331D1A94D18100C73337 /* lldb-server.cpp */; };
     E7723D441AC4A7FB002BA082 /* RegisterContextPOSIXCore_arm64.cpp in Sources */ = {isa = PBXBuildFile; fileRef = E7723D421AC4A7FB002BA082 /* RegisterContextPOSIXCore_arm64.cpp */; };
     E7723D481AC4A8C8002BA082 /* RegisterContextFreeBSD_arm64.cpp in Sources */ = {isa = PBXBuildFile; fileRef = E7723D461AC4A8C8002BA082 /* RegisterContextFreeBSD_arm64.cpp */; };
     E7723D4C1AC4A944002BA082 /* RegisterContextPOSIX_arm64.cpp in Sources */ = {isa = PBXBuildFile; fileRef = E7723D4A1AC4A944002BA082 /* RegisterContextPOSIX_arm64.cpp */; };
     E778E9A21B062D1700247609 /* EmulateInstructionMIPS.cpp in Sources */ = {isa = PBXBuildFile; fileRef = E778E99F1B062D1700247609 /* EmulateInstructionMIPS.cpp */; };
+    E7E94ABC1B54961F00D0AE30 /* GDBRemoteSignals.cpp in Sources */ = {isa = PBXBuildFile; fileRef = E73A15A41B548EC500786197 /* GDBRemoteSignals.cpp */; };
     ED88244E15114A9200BC98B9 /* Security.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = EDB919B414F6F10D008FF64B /* Security.framework */; };
     ED88245015114CA200BC98B9 /* main.mm in Sources */ = {isa = PBXBuildFile; fileRef = ED88244F15114CA200BC98B9 /* main.mm */; };
     ED88245115114CA200BC98B9 /* main.mm in Sources */ = {isa = PBXBuildFile; fileRef = ED88244F15114CA200BC98B9 /* main.mm */; };
     ED88245315114CFC00BC98B9 /* LauncherRootXPCService.mm in Sources */ = {isa = PBXBuildFile; fileRef = ED88245215114CFC00BC98B9 /* LauncherRootXPCService.mm */; };
     EDC6D4AA14E5C49E001B75F8 /* LauncherXPCService.mm in Sources */ = {isa = PBXBuildFile; fileRef = EDC6D49414E5C15C001B75F8 /* LauncherXPCService.mm */; };
 /* End PBXBuildFile section */
 
 /* Begin PBXContainerItemProxy section */

     B2A5872514313B480092BFBA /* SBWatchpoint.i */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.h; path = SBWatchpoint.i; sourceTree = "<group>"; };
     B2B7CCEA15D1BD6600EEFB57 /* CommandObjectWatchpointCommand.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = CommandObjectWatchpointCommand.cpp; path = source/Commands/CommandObjectWatchpointCommand.cpp; sourceTree = "<group>"; };
     B2B7CCEC15D1BD9600EEFB57 /* CommandObjectWatchpointCommand.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = CommandObjectWatchpointCommand.h; path = source/Commands/CommandObjectWatchpointCommand.h; sourceTree = "<group>"; };
     B2B7CCED15D1BFB700EEFB57 /* WatchpointOptions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = WatchpointOptions.h; path = include/lldb/Breakpoint/WatchpointOptions.h; sourceTree = "<group>"; };
     B2B7CCEF15D1C20F00EEFB57 /* WatchpointOptions.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = WatchpointOptions.cpp; path = source/Breakpoint/WatchpointOptions.cpp; sourceTree = "<group>"; };
     B2D3033612EFA5C500F84EB3 /* InstructionUtils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = InstructionUtils.h; path = Utility/InstructionUtils.h; sourceTree = "<group>"; };
     B5EFAE841AE53B1D007059F3 /* RegisterContextFreeBSD_arm.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = RegisterContextFreeBSD_arm.cpp; path = Utility/RegisterContextFreeBSD_arm.cpp; sourceTree = "<group>"; };
     B5EFAE851AE53B1D007059F3 /* RegisterContextFreeBSD_arm.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = RegisterContextFreeBSD_arm.h; path = Utility/RegisterContextFreeBSD_arm.h; sourceTree = "<group>"; };
+    E73A15A41B548EC500786197 /* GDBRemoteSignals.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = GDBRemoteSignals.cpp; path = Utility/GDBRemoteSignals.cpp; sourceTree = "<group>"; };
+    E73A15A51B548EC500786197 /* GDBRemoteSignals.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = GDBRemoteSignals.h; path = Utility/GDBRemoteSignals.h; sourceTree = "<group>"; };
     E769331D1A94D18100C73337 /* lldb-server.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = "lldb-server.cpp"; path = "tools/lldb-server/lldb-server.cpp"; sourceTree = "<group>"; };
     E7723D421AC4A7FB002BA082 /* RegisterContextPOSIXCore_arm64.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = RegisterContextPOSIXCore_arm64.cpp; sourceTree = "<group>"; };
     E7723D431AC4A7FB002BA082 /* RegisterContextPOSIXCore_arm64.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RegisterContextPOSIXCore_arm64.h; sourceTree = "<group>"; };
     E7723D461AC4A8C8002BA082 /* RegisterContextFreeBSD_arm64.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = RegisterContextFreeBSD_arm64.cpp; path = Utility/RegisterContextFreeBSD_arm64.cpp; sourceTree = "<group>"; };
     E7723D471AC4A8C8002BA082 /* RegisterContextFreeBSD_arm64.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = RegisterContextFreeBSD_arm64.h; path = Utility/RegisterContextFreeBSD_arm64.h; sourceTree = "<group>"; };
     E7723D4A1AC4A944002BA082 /* RegisterContextPOSIX_arm64.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = RegisterContextPOSIX_arm64.cpp; path = Utility/RegisterContextPOSIX_arm64.cpp; sourceTree = "<group>"; };
     E7723D4B1AC4A944002BA082 /* RegisterContextPOSIX_arm64.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = RegisterContextPOSIX_arm64.h; path = Utility/RegisterContextPOSIX_arm64.h; sourceTree = "<group>"; };
     E778E99F1B062D1700247609 /* EmulateInstructionMIPS.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = EmulateInstructionMIPS.cpp; sourceTree = "<group>"; };
26AC3F441365F40E0065C7EF /* UnwindAssembly */ = {
         2692BA17136611CD00F9E14D /* x86 */,
       );
       path = UnwindAssembly;
       sourceTree = "<group>";
     };
     26B4666E11A2080F00CF6220 /* Utility */ = {
       isa = PBXGroup;
       children = (
+        E73A15A41B548EC500786197 /* GDBRemoteSignals.cpp */,
+        E73A15A51B548EC500786197 /* GDBRemoteSignals.h */,
         B5EFAE841AE53B1D007059F3 /* RegisterContextFreeBSD_arm.cpp */,
         B5EFAE851AE53B1D007059F3 /* RegisterContextFreeBSD_arm.h */,
         256CBDBE1ADD11C000BC6CDC /* RegisterContextPOSIX_arm.cpp */,
         256CBDBF1ADD11C000BC6CDC /* RegisterContextPOSIX_arm.h */,
         256CBDB61ADD107200BC6CDC /* RegisterContextLinux_arm.cpp */,
         256CBDB71ADD107200BC6CDC /* RegisterContextLinux_arm.h */,
         AF20F76E1AF1902900751A6E /* RegisterContextLinux_arm64.cpp */,
         AF20F76F1AF1902900751A6E /* RegisterContextLinux_arm64.h */,
2689FFC613353D7A00698AC0 /* Sources */ = {
         260CC65115D0440D002BF2E0 /* OptionValueSInt64.cpp in Sources */,
         260CC65215D0440D002BF2E0 /* OptionValueString.cpp in Sources */,
         6D55B2911A8A806200A70529 /* GDBRemoteCommunicationServerLLGS.cpp in Sources */,
         260CC65315D0440D002BF2E0 /* OptionValueUInt64.cpp in Sources */,
         260CC65415D0440D002BF2E0 /* OptionValueUUID.cpp in Sources */,
         94BA8B6D176F8C9B005A91B5 /* Range.cpp in Sources */,
         26DAED6315D327C200E15819 /* OptionValuePathMappings.cpp in Sources */,
         B2B7CCEB15D1BD6700EEFB57 /* CommandObjectWatchpointCommand.cpp in Sources */,
+        E7E94ABC1B54961F00D0AE30 /* GDBRemoteSignals.cpp in Sources */,
         AF25AB26188F685C0030DEC3 /* AppleGetQueuesHandler.cpp in Sources */,
         B2B7CCF015D1C20F00EEFB57 /* WatchpointOptions.cpp in Sources */,
         2640E19F15DC78FD00F23B50 /* Property.cpp in Sources */,
         26491E3E15E1DB9F00CBFFC2 /* OptionValueRegex.cpp in Sources */,
         2697A39315E404B1003E682C /* OptionValueArch.cpp in Sources */,
         6D55B2921A8A806200A70529 /* GDBRemoteCommunicationServerPlatform.cpp in Sources */,
         94EA1D5C15E6C9B400D4171A /* PythonDataObjects.cpp in Sources */,
         94D6A0AC16CEB55F00833B6E /* NSSet.cpp in Sources */,

lldb/trunk/scripts/interface/SBPlatform.i

public:
     MakeDirectory (const char *path, uint32_t file_permissions = lldb::eFilePermissionsDirectoryDefault);
     
     uint32_t
     GetFilePermissions (const char *path);
     
     lldb::SBError
     SetFilePermissions (const char *path, uint32_t file_permissions);
 
+    lldb::SBUnixSignals
+    GetUnixSignals();
+
 };
 
 } // namespace lldb

lldb/trunk/source/API/SBPlatform.cpp

 //===-- SBPlatform.cpp ------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBPlatform.h"
 #include "lldb/API/SBError.h"
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/API/SBLaunchInfo.h"
+#include "lldb/API/SBUnixSignals.h"
 #include "lldb/Core/ArchSpec.h"
 #include "lldb/Core/Error.h"
 #include "lldb/Host/File.h"
 #include "lldb/Interpreter/Args.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Platform.h"
 
 #include <functional>
SBPlatform::SetFilePermissions (const char *path, uint32_t file_permissions)
     else
     {
         sb_error.SetErrorString("invalid platform");
     }
     return sb_error;
     
 }
 
+SBUnixSignals
+SBPlatform::GetUnixSignals() const
+{
+    if (auto platform_sp = GetSP())
+        return SBUnixSignals{platform_sp};
+
+    return {};
+}

lldb/trunk/source/API/SBProcess.cpp

if (log)
                      static_cast<void*>(sb_error.get()), sstr.GetData());
     }
     return sb_error;
 }
 
 SBUnixSignals
 SBProcess::GetUnixSignals()
 {
-    SBUnixSignals sb_unix_signals;
-    ProcessSP process_sp(GetSP());
-    if (process_sp)
-    {
-        sb_unix_signals.SetSP(process_sp);
-    }
+    if (auto process_sp = GetSP())
+        return SBUnixSignals{process_sp};
 
-    return sb_unix_signals;
+    return {};
 }
 
 void
 SBProcess::SendAsyncInterrupt ()
 {
     ProcessSP process_sp(GetSP());
     if (process_sp)
     {

lldb/trunk/source/API/SBThread.cpp

if (exe_ctx.HasThreadScope())
                             static char wp_desc[] = "watchpoint hit";
                             stop_desc = wp_desc;
                             stop_desc_len = sizeof(wp_desc); // Include the NULL byte for size
                         }
                         break;
 
                     case eStopReasonSignal:
                         {
-                            stop_desc = exe_ctx.GetProcessPtr()->GetUnixSignals ().GetSignalAsCString (stop_info_sp->GetValue());
+                            stop_desc = exe_ctx.GetProcessPtr()->GetUnixSignals()->GetSignalAsCString(stop_info_sp->GetValue());
                             if (stop_desc == NULL || stop_desc[0] == '\0')
                             {
                                 static char signal_desc[] = "signal";
                                 stop_desc = signal_desc;
                                 stop_desc_len = sizeof(signal_desc); // Include the NULL byte for size
                             }
                         }
                         break;

lldb/trunk/source/API/SBUnixSignals.cpp

 //===-- SBUnixSignals.cpp -------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/lldb-defines.h"
 #include "lldb/Target/Process.h"
+#include "lldb/Target/Platform.h"
 #include "lldb/Target/UnixSignals.h"
 #include "lldb/Core/Log.h"
 
 #include "lldb/API/SBUnixSignals.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 SBUnixSignals::SBUnixSignals ()
 {}
 
 SBUnixSignals::SBUnixSignals (const SBUnixSignals &rhs) :
     m_opaque_wp(rhs.m_opaque_wp)
 {
 }
 
-SBUnixSignals::SBUnixSignals (ProcessSP &process_sp) :
-    m_opaque_wp(process_sp)
+SBUnixSignals::SBUnixSignals(ProcessSP &process_sp) :
+    m_opaque_wp(process_sp ? process_sp->GetUnixSignals() : nullptr)
+{
+}
+
+SBUnixSignals::SBUnixSignals(PlatformSP &platform_sp) :
+    m_opaque_wp(platform_sp ? platform_sp->GetUnixSignals() : nullptr)
 {
 }
 
 const SBUnixSignals&
 SBUnixSignals::operator = (const SBUnixSignals& rhs)
 {
     if (this != &rhs)
         m_opaque_wp = rhs.m_opaque_wp;
     return *this;
 }
 
 SBUnixSignals::~SBUnixSignals()
 {
 }
 
-ProcessSP
+UnixSignalsSP
 SBUnixSignals::GetSP() const
 {
     return m_opaque_wp.lock();
 }
 
 void
-SBUnixSignals::SetSP (const ProcessSP &process_sp)
+SBUnixSignals::SetSP(const UnixSignalsSP &signals_sp)
 {
-    m_opaque_wp = process_sp;
+    m_opaque_wp = signals_sp;
 }
 
 void
 SBUnixSignals::Clear ()
 {
     m_opaque_wp.reset();
 }
 
 bool
 SBUnixSignals::IsValid() const
 {
-    return (bool) GetSP();
+    return static_cast<bool>(GetSP());
 }
 
 const char *
 SBUnixSignals::GetSignalAsCString (int32_t signo) const
 {
-    ProcessSP process_sp(GetSP());
-    if (process_sp) return process_sp->GetUnixSignals().GetSignalAsCString(signo);
-    return NULL;
+    if (auto signals_sp = GetSP())
+        return signals_sp->GetSignalAsCString(signo);
+
+    return nullptr;
 }
 
 int32_t
 SBUnixSignals::GetSignalNumberFromName (const char *name) const
 {
-    ProcessSP process_sp(GetSP());
-    if (process_sp) return process_sp->GetUnixSignals().GetSignalNumberFromName(name);
-    return -1;
+    if (auto signals_sp = GetSP())
+        return signals_sp->GetSignalNumberFromName(name);
+
+    return LLDB_INVALID_SIGNAL_NUMBER;
 }
 
 bool
 SBUnixSignals::GetShouldSuppress (int32_t signo) const
 {
-    ProcessSP process_sp(GetSP());
-    if (process_sp) return process_sp->GetUnixSignals().GetShouldSuppress(signo);
+    if (auto signals_sp = GetSP())
+        return signals_sp->GetShouldSuppress(signo);
+
     return false;
 }
 
 bool
 SBUnixSignals::SetShouldSuppress (int32_t signo, bool value)
 {
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-    ProcessSP process_sp(GetSP());
+    auto signals_sp = GetSP();
 
     if (log)
     {
         log->Printf ("SBUnixSignals(%p)::SetShouldSuppress (signo=%d, value=%d)",
-                     static_cast<void*>(process_sp.get()),
+                     static_cast<void*>(signals_sp.get()),
                      signo,
                      value);
     }
 
-    if (process_sp) return process_sp->GetUnixSignals().SetShouldSuppress(signo, value);
+    if (signals_sp)
+        return signals_sp->SetShouldSuppress(signo, value);
+
     return false;
 }
 
 bool
 SBUnixSignals::GetShouldStop (int32_t signo) const
 {
-    ProcessSP process_sp(GetSP());
-    if (process_sp) return process_sp->GetUnixSignals().GetShouldStop(signo);
+    if (auto signals_sp = GetSP())
+        return signals_sp->GetShouldStop(signo);
+
     return false;
 }
 
 bool
 SBUnixSignals::SetShouldStop (int32_t signo, bool value)
 {
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-    ProcessSP process_sp(GetSP());
+    auto signals_sp = GetSP();
 
     if (log)
     {
         log->Printf ("SBUnixSignals(%p)::SetShouldStop (signo=%d, value=%d)",
-                     static_cast<void*>(process_sp.get()),
+                     static_cast<void*>(signals_sp.get()),
                      signo,
                      value);
     }
 
-    if (process_sp) return process_sp->GetUnixSignals().SetShouldStop(signo, value);
+    if (signals_sp)
+        return signals_sp->SetShouldStop(signo, value);
+
     return false;
 }
 
 bool
 SBUnixSignals::GetShouldNotify (int32_t signo) const
 {
-    ProcessSP process_sp(GetSP());
-    if (process_sp) return process_sp->GetUnixSignals().GetShouldNotify(signo);
+    if (auto signals_sp = GetSP())
+        return signals_sp->GetShouldNotify(signo);
+
     return false;
 }
 
 bool
 SBUnixSignals::SetShouldNotify (int32_t signo, bool value)
 {
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-    ProcessSP process_sp(GetSP());
+    auto signals_sp = GetSP();
 
     if (log)
     {
         log->Printf ("SBUnixSignals(%p)::SetShouldNotify (signo=%d, value=%d)",
-                     static_cast<void*>(process_sp.get()),
+                     static_cast<void*>(signals_sp.get()),
                      signo,
                      value);
     }
 
-    if (process_sp) return process_sp->GetUnixSignals().SetShouldNotify(signo, value);
+    if (signals_sp)
+        return signals_sp->SetShouldNotify(signo, value);
+
     return false;
 }
 
 int32_t
 SBUnixSignals::GetNumSignals () const
 {
-    if (auto process_sp = GetSP())
-    {
-        // only valid while we hold process_sp
-        UnixSignals *unix_signals_ptr = &process_sp->GetUnixSignals();
-        int32_t num_signals = 0;
-        for (int32_t signo = unix_signals_ptr->GetFirstSignalNumber();
-             signo != LLDB_INVALID_SIGNAL_NUMBER;
-             signo = unix_signals_ptr->GetNextSignalNumber(signo))
-        {
-            num_signals++;
-        }
-        return num_signals;
-    }
-    return LLDB_INVALID_SIGNAL_NUMBER;
+    if (auto signals_sp = GetSP())
+        return signals_sp->GetNumSignals();
+
+    return -1;
 }
 
 int32_t
 SBUnixSignals::GetSignalAtIndex (int32_t index) const
 {
-    if (auto process_sp = GetSP())
-    {
-        // only valid while we hold process_sp
-        UnixSignals *unix_signals_ptr = &process_sp->GetUnixSignals();
-        int32_t idx = 0;
-        for (int32_t signo = unix_signals_ptr->GetFirstSignalNumber();
-             signo != LLDB_INVALID_SIGNAL_NUMBER;
-             signo = unix_signals_ptr->GetNextSignalNumber(signo))
-        {
-            if (index == idx) return signo;
-            idx++;
-        }
-    }
+    if (auto signals_sp = GetSP())
+        return signals_sp->GetSignalAtIndex(index);
+
     return LLDB_INVALID_SIGNAL_NUMBER;
 }

lldb/trunk/source/Commands/CommandObjectProcess.cpp

DoExecute (Args& command,
         if (command.GetArgumentCount() == 1)
         {
             int signo = LLDB_INVALID_SIGNAL_NUMBER;
             
             const char *signal_name = command.GetArgumentAtIndex(0);
             if (::isxdigit (signal_name[0]))
                 signo = StringConvert::ToSInt32(signal_name, LLDB_INVALID_SIGNAL_NUMBER, 0);
             else
-                signo = process->GetUnixSignals().GetSignalNumberFromName (signal_name);
+                signo = process->GetUnixSignals()->GetSignalNumberFromName(signal_name);
             
             if (signo == LLDB_INVALID_SIGNAL_NUMBER)
             {
                 result.AppendErrorWithFormat ("Invalid signal argument '%s'.\n", command.GetArgumentAtIndex(0));
                 result.SetStatus (eReturnStatusFailed);
             }
             else
             {
public:
     void
     PrintSignalHeader (Stream &str)
     {
         str.Printf ("NAME         PASS   STOP   NOTIFY\n");
         str.Printf ("===========  =====  =====  ======\n");
     }  
 
     void
-    PrintSignal (Stream &str, int32_t signo, const char *sig_name, UnixSignals &signals)
+    PrintSignal(Stream &str, int32_t signo, const char *sig_name, const UnixSignalsSP &signals_sp)
     {
         bool stop;
         bool suppress;
         bool notify;
 
         str.Printf ("%-11s  ", sig_name);
-        if (signals.GetSignalInfo (signo, suppress, stop, notify))
+        if (signals_sp->GetSignalInfo(signo, suppress, stop, notify))
         {
             bool pass = !suppress;
             str.Printf ("%s  %s  %s", 
                         (pass ? "true " : "false"), 
                         (stop ? "true " : "false"), 
                         (notify ? "true " : "false"));
         }
         str.Printf ("\n");
     }
 
     void
-    PrintSignalInformation (Stream &str, Args &signal_args, int num_valid_signals, UnixSignals &signals)
+    PrintSignalInformation(Stream &str, Args &signal_args, int num_valid_signals, const UnixSignalsSP &signals_sp)
     {
         PrintSignalHeader (str);
 
         if (num_valid_signals > 0)
         {
             size_t num_args = signal_args.GetArgumentCount();
             for (size_t i = 0; i < num_args; ++i)
             {
-                int32_t signo = signals.GetSignalNumberFromName (signal_args.GetArgumentAtIndex (i));
+                int32_t signo = signals_sp->GetSignalNumberFromName(signal_args.GetArgumentAtIndex(i));
                 if (signo != LLDB_INVALID_SIGNAL_NUMBER)
-                    PrintSignal (str, signo, signal_args.GetArgumentAtIndex (i), signals);
+                    PrintSignal (str, signo, signal_args.GetArgumentAtIndex (i), signals_sp);
             }
         }
         else // Print info for ALL signals
         {
-            int32_t signo = signals.GetFirstSignalNumber(); 
+            int32_t signo = signals_sp->GetFirstSignalNumber();
             while (signo != LLDB_INVALID_SIGNAL_NUMBER)
             {
-                PrintSignal (str, signo, signals.GetSignalAsCString (signo), signals);
-                signo = signals.GetNextSignalNumber (signo);
+                PrintSignal(str, signo, signals_sp->GetSignalAsCString(signo), signals_sp);
+                signo = signals_sp->GetNextSignalNumber(signo);
             }
         }
     }
 
 protected:
     bool
     DoExecute (Args &signal_args, CommandReturnObject &result)
     {
DoExecute (Args &signal_args, CommandReturnObject &result)
             && ! VerifyCommandOptionValue (m_options.pass, pass_action))
         {
             result.AppendError ("Invalid argument for command option --pass; must be true or false.\n");
             result.SetStatus (eReturnStatusFailed);
             return false;
         }
 
         size_t num_args = signal_args.GetArgumentCount();
-        UnixSignals &signals = process_sp->GetUnixSignals();
+        UnixSignalsSP signals_sp = process_sp->GetUnixSignals();
         int num_signals_set = 0;
 
         if (num_args > 0)
         {
             for (size_t i = 0; i < num_args; ++i)
             {
-                int32_t signo = signals.GetSignalNumberFromName (signal_args.GetArgumentAtIndex (i));
+                int32_t signo = signals_sp->GetSignalNumberFromName(signal_args.GetArgumentAtIndex(i));
                 if (signo != LLDB_INVALID_SIGNAL_NUMBER)
                 {
                     // Casting the actions as bools here should be okay, because VerifyCommandOptionValue guarantees
                     // the value is either 0 or 1.
                     if (stop_action != -1)
-                        signals.SetShouldStop (signo, (bool) stop_action);
+                        signals_sp->SetShouldStop(signo, stop_action);
                     if (pass_action != -1)
                     {
-                        bool suppress = ! ((bool) pass_action);
-                        signals.SetShouldSuppress (signo, suppress);
+                        bool suppress = !pass_action;
+                        signals_sp->SetShouldSuppress(signo, suppress);
                     }
                     if (notify_action != -1)
-                        signals.SetShouldNotify (signo, (bool) notify_action);
+                        signals_sp->SetShouldNotify(signo, notify_action);
                     ++num_signals_set;
                 }
                 else
                 {
                     result.AppendErrorWithFormat ("Invalid signal name '%s'\n", signal_args.GetArgumentAtIndex (i));
                 }
             }
         }
         else
         {
             // No signal specified, if any command options were specified, update ALL signals.
             if ((notify_action != -1) || (stop_action != -1) || (pass_action != -1))
             {
                 if (m_interpreter.Confirm ("Do you really want to update all the signals?", false))
                 {
-                    int32_t signo = signals.GetFirstSignalNumber();
+                    int32_t signo = signals_sp->GetFirstSignalNumber();
                     while (signo != LLDB_INVALID_SIGNAL_NUMBER)
                     {
                         if (notify_action != -1)
-                            signals.SetShouldNotify (signo, (bool) notify_action);
+                            signals_sp->SetShouldNotify(signo, notify_action);
                         if (stop_action != -1)
-                            signals.SetShouldStop (signo, (bool) stop_action);
+                            signals_sp->SetShouldStop(signo, stop_action);
                         if (pass_action != -1)
                         {
-                            bool suppress = ! ((bool) pass_action);
-                            signals.SetShouldSuppress (signo, suppress);
+                            bool suppress = !pass_action;
+                            signals_sp->SetShouldSuppress(signo, suppress);
                         }
-                        signo = signals.GetNextSignalNumber (signo);
+                        signo = signals_sp->GetNextSignalNumber(signo);
                     }
                 }
             }
         }
 
-        PrintSignalInformation (result.GetOutputStream(), signal_args, num_signals_set, signals);
+        PrintSignalInformation (result.GetOutputStream(), signal_args, num_signals_set, signals_sp);
 
         if (num_signals_set > 0)
             result.SetStatus (eReturnStatusSuccessFinishNoResult);
         else
             result.SetStatus (eReturnStatusFailed);
 
         return result.Succeeded();
     }

lldb/trunk/source/Host/common/Host.cpp

 
 void
 Host::SetCrashDescription (const char *description)
 {
 }
 
 #endif
 
-#if !defined (__linux__) && !defined (__FreeBSD__) && !defined(__FreeBSD_kernel__) && !defined (__NetBSD__)
-
-const lldb_private::UnixSignalsSP&
-Host::GetUnixSignals ()
+const UnixSignalsSP &
+Host::GetUnixSignals()
 {
-    static UnixSignalsSP s_unix_signals_sp (new UnixSignals ());
+    static const auto s_unix_signals_sp = UnixSignals::Create(HostInfo::GetArchitecture());
     return s_unix_signals_sp;
 }
-
-#endif

lldb/trunk/source/Host/freebsd/Host.cpp

 #include "lldb/Target/Process.h"
 #include "lldb/Target/Platform.h"
 
 #include "lldb/Core/DataBufferHeap.h"
 #include "lldb/Core/DataExtractor.h"
 #include "lldb/Utility/CleanUp.h"
 #include "lldb/Utility/NameMatches.h"
 
-#include "Plugins/Process/Utility/FreeBSDSignals.h"
-
 #include "llvm/Support/Host.h"
 
 extern "C" {
     extern char **environ;
 }
 
 using namespace lldb;
 using namespace lldb_private;
if (::sysctl(mib, 4, buf_ap->GetBytes(), &auxv_size, NULL, 0) == 0) {
            buf_sp.reset(buf_ap.release());
    } else {
            perror("sysctl failed on auxv");
    }
 
    return buf_sp;
 }
 
-const UnixSignalsSP&
-Host::GetUnixSignals ()
-{
-    static const lldb_private::UnixSignalsSP s_unix_signals_sp (new FreeBSDSignals ());
-    return s_unix_signals_sp;
-}
-
 Error
 Host::ShellExpandArguments (ProcessLaunchInfo &launch_info)
 {
     return Error("unimplemented");
 }
 

lldb/trunk/source/Host/linux/Host.cpp

 #include "lldb/Host/android/Android.h"
 #endif
 #include "lldb/Core/DataBufferHeap.h"
 #include "lldb/Core/DataExtractor.h"
 
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "Plugins/Process/Linux/ProcFileReader.h"
-#include "Plugins/Process/Utility/LinuxSignals.h"
-#include "Plugins/Process/Utility/MipsLinuxSignals.h"
+
 using namespace lldb;
 using namespace lldb_private;
 
 typedef enum ProcessStateFlags
 {
     eProcessStateRunning           = (1u << 0), // Running
     eProcessStateSleeping          = (1u << 1), // Sleeping in an interruptible wait
     eProcessStateWaiting           = (1u << 2), // Waiting in an uninterruptible disk sleep
Host::GetEnvironment (StringList &env)
     char **host_env = environ;
     char *env_entry;
     size_t i;
     for (i=0; (env_entry = host_env[i]) != NULL; ++i)
         env.AppendString(env_entry);
     return i;
 }
 
-// TODO: Generalize this with a function Host::GetSignals() as discussed at http://reviews.llvm.org/D10180 
-const lldb_private::UnixSignalsSP&
-Host::GetUnixSignals ()
-{
-    ArchSpec target_arch = HostInfoBase::GetArchitecture();
-    if(target_arch.GetTriple ().getArch () == llvm::Triple::mips64 ||
-       target_arch.GetTriple ().getArch () == llvm::Triple::mips64el ||
-       target_arch.GetTriple ().getArch () == llvm::Triple::mips ||
-       target_arch.GetTriple ().getArch () == llvm::Triple::mipsel) {
-        static const lldb_private::UnixSignalsSP s_unix_signals_sp (new process_linux::MipsLinuxSignals ());
-        return s_unix_signals_sp;
-    }
-    else
-    {
-        static const lldb_private::UnixSignalsSP s_unix_signals_sp (new process_linux::LinuxSignals ());
-        return s_unix_signals_sp;
-    }
-
-}
-
 Error
 Host::ShellExpandArguments (ProcessLaunchInfo &launch_info)
 {
     return Error("unimplemented");
 }

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

if (!process_sp)
         return process_sp;
     }
     else
     {
         if (log)
             log->Printf ("PlatformLinux::%s successfully created process", __FUNCTION__);
     }
 
-    // Set the unix signals properly.
-    process_sp->SetUnixSignals (Host::GetUnixSignals ());
-
     // Adjust launch for a hijacker.
     ListenerSP listener_sp;
     if (!launch_info.GetHijackListener ())
     {
         if (log)
             log->Printf ("PlatformLinux::%s setting up hijacker", __FUNCTION__);
 
         listener_sp.reset (new Listener("lldb.PlatformLinux.DebugProcess.hijack"));

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

public:
     GetRemoteOSBuildString (std::string &s) override;
 
     bool
     GetRemoteOSKernelDescription (std::string &s) override;
 
     lldb_private::ArchSpec
     GetRemoteSystemArchitecture () override;
 
+    const lldb::UnixSignalsSP &
+    GetRemoteUnixSignals() override;
+
     size_t
     GetEnvironment (lldb_private::StringList &environment) override;
 
     bool
     IsConnected () const override;
 
     lldb_private::Error
     RunShellCommand(const char *command,                       // Shouldn't be NULL

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

 {
     if (IsHost())
         return Platform::CalculateMD5 (file_spec, low, high);
     if (m_remote_platform_sp)
         return m_remote_platform_sp->CalculateMD5(file_spec, low, high);
     return false;
 }
 
+const lldb::UnixSignalsSP &
+PlatformPOSIX::GetRemoteUnixSignals() {
+    if (IsRemote() && m_remote_platform_sp)
+        return m_remote_platform_sp->GetRemoteUnixSignals();
+    return Platform::GetRemoteUnixSignals();
+}
+
+
 FileSpec
 PlatformPOSIX::GetRemoteWorkingDirectory()
 {
     if (IsRemote() && m_remote_platform_sp)
         return m_remote_platform_sp->GetRemoteWorkingDirectory();
     else
         return Platform::GetRemoteWorkingDirectory();
 }
if (IsHost())
                             exe_module_sp ? exe_module_sp->GetFileSpec().GetPath().c_str() : "<null>");
             }
 
 
             process_sp = target->CreateProcess (attach_info.GetListenerForProcess(debugger), attach_info.GetProcessPluginName(), NULL);
 
             if (process_sp)
             {
-                // Set UnixSignals appropriately.
-                process_sp->SetUnixSignals (Host::GetUnixSignals ());
-
                 auto listener_sp = attach_info.GetHijackListener();
                 if (listener_sp == nullptr)
                 {
                     listener_sp.reset(new Listener("lldb.PlatformPOSIX.attach.hijack"));
                     attach_info.SetHijackListener(listener_sp);
                 }
                 process_sp->HijackProcessEvents(listener_sp.get());
                 error = process_sp->Attach (attach_info);

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

 // C Includes
 // C++ Includes
 #include <string>
 
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Target/Platform.h"
 #include "../../Process/gdb-remote/GDBRemoteCommunicationClient.h"
+#include "Plugins/Process/Utility/GDBRemoteSignals.h"
 
 namespace lldb_private {
 namespace platform_gdb_server {
 
 class PlatformRemoteGDBServer : public Platform
 {
 public:
 
RunShellCommand(const char *command,            // Shouldn't be NULL
                     int *status_ptr,                // Pass NULL if you don't want the process exit status
                     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
                     uint32_t timeout_sec) override; // Timeout in seconds to wait for shell program to finish
 
     void
     CalculateTrapHandlerSymbolNames () override;
 
+    const lldb::UnixSignalsSP &
+    GetRemoteUnixSignals() override;
+
 protected:
     process_gdb_remote::GDBRemoteCommunicationClient m_gdb_client;
     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::UnixSignalsSP m_remote_signals_sp;
+
     // Launch the lldb-gdbserver on the remote host and return the port it is listening on or 0 on
     // failure. Subclasses should override this method if they want to do extra actions before or
     // after launching the lldb-gdbserver.
     virtual uint16_t
     LaunchGDBserverAndGetPort (lldb::pid_t &pid);
 
     virtual bool
     KillSpawnedProcess (lldb::pid_t pid);

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

 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Host/StringConvert.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 
 #include "Utility/UriParser.h"
 
+#include "Plugins/Process/Utility/GDBRemoteSignals.h"
+
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::platform_gdb_server;
 
 static bool g_initialized = false;
 
 static std::string MakeGdbServerUrl(
         const std::string &platform_scheme,
PlatformRemoteGDBServer::ConnectRemote (Args& args)
     return error;
 }
 
 Error
 PlatformRemoteGDBServer::DisconnectRemote ()
 {
     Error error;
     m_gdb_client.Disconnect(&error);
+    m_remote_signals_sp.reset();
     return error;
 }
 
 const char *
 PlatformRemoteGDBServer::GetHostname ()
 {
     m_gdb_client.GetHostname (m_name);
     if (m_name.empty())
PlatformRemoteGDBServer::RunShellCommand(const char *command,           // Shouldn't be NULL
                                          std::string *command_output,   // Pass NULL if you don't want the command output
                                          uint32_t timeout_sec)          // Timeout in seconds to wait for shell program to finish
 {
     return m_gdb_client.RunShellCommand(command, working_dir, status_ptr, signo_ptr, command_output, timeout_sec);
 }
 
 void
 PlatformRemoteGDBServer::CalculateTrapHandlerSymbolNames ()
-{   
+{
     m_trap_handlers.push_back (ConstString ("_sigtramp"));
 }
+
+const UnixSignalsSP &
+PlatformRemoteGDBServer::GetRemoteUnixSignals()
+{
+    if (!IsConnected())
+        return Platform::GetRemoteUnixSignals();
+
+    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());
+
+    const char packet[] = "jSignalsInfo";
+    StringExtractorGDBRemote response;
+    auto result = m_gdb_client.SendPacketAndWaitForResponse(
+            packet, strlen(packet), response, false);
+
+    if (result != decltype(result)::Success ||
+            response.GetResponseType() != response.eResponse)
+        return m_remote_signals_sp;
+
+    auto object_sp = StructuredData::ParseJSON(response.GetStringRef());
+    if (!object_sp || !object_sp->IsValid())
+        return m_remote_signals_sp;
+
+    auto array_sp = object_sp->GetAsArray();
+    if (!array_sp || !array_sp->IsValid())
+        return m_remote_signals_sp;
+
+    auto remote_signals_sp = std::make_shared<lldb_private::GDBRemoteSignals>();
+
+    bool done = array_sp->ForEach(
+        [&remote_signals_sp](StructuredData::Object *object) -> bool
+        {
+            if (!object || !object->IsValid())
+                return false;
+
+            auto dict = object->GetAsDictionary();
+            if (!dict || !dict->IsValid())
+                return false;
+
+            // Signal number and signal name are required.
+            int signo;
+            if (!dict->GetValueForKeyAsInteger("signo", signo))
+                return false;
+
+            std::string name;
+            if (!dict->GetValueForKeyAsString("name", name))
+                return false;
+
+            // We can live without short_name, description, etc.
+            std::string short_name{""};
+            auto object_sp = dict->GetValueForKey("short_name");
+            if (object_sp && object_sp->IsValid())
+                short_name = object_sp->GetStringValue();
+
+            bool suppress{false};
+            object_sp = dict->GetValueForKey("suppress");
+            if (object_sp && object_sp->IsValid())
+                suppress = object_sp->GetBooleanValue();
+
+            bool stop{false};
+            object_sp = dict->GetValueForKey("stop");
+            if (object_sp && object_sp->IsValid())
+                stop = object_sp->GetBooleanValue();
+
+            bool notify{false};
+            object_sp = dict->GetValueForKey("notify");
+            if (object_sp && object_sp->IsValid())
+                notify = object_sp->GetBooleanValue();
+
+            std::string description{""};
+            object_sp = dict->GetValueForKey("description");
+            if (object_sp && object_sp->IsValid())
+                description = object_sp->GetStringValue();
+
+            remote_signals_sp->AddSignal(signo,
+                                         name.c_str(),
+                                         short_name.c_str(),
+                                         suppress, stop, notify,
+                                         description.c_str());
+            return true;
+        });
+
+    if (done)
+        m_remote_signals_sp = std::move(remote_signals_sp);
+
+    return m_remote_signals_sp;
+}

lldb/trunk/source/Plugins/Process/Linux/NativeProcessLinux.cpp

 #include "lldb/Target/Process.h"
 #include "lldb/Target/ProcessLaunchInfo.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/Utility/PseudoTerminal.h"
 #include "lldb/Utility/StringExtractor.h"
 
 #include "Plugins/Process/POSIX/ProcessPOSIXLog.h"
-#include "Plugins/Process/Utility/LinuxSignals.h"
 #include "NativeThreadLinux.h"
 #include "ProcFileReader.h"
 #include "Procfs.h"
 
 // System includes - They have to be included after framework includes because they define some
 // macros which collide with variable names in other modules
 #include <linux/unistd.h>
 #include <sys/socket.h>
std::call_once(flag, [] {
         }
     });
 
     return is_supported;
 }
 
 namespace
 {
-    const UnixSignals&
-    GetUnixSignals ()
-    {
-        static process_linux::LinuxSignals signals;
-        return signals;
-    }
-
     Error
     ResolveProcessArchitecture (lldb::pid_t pid, Platform &platform, ArchSpec &arch)
     {
         // Grab process info for the running process.
         ProcessInstanceInfo process_info;
         if (!platform.GetProcessInfo (pid, process_info))
             return Error("failed to get process info");
 
NativeProcessLinux::MonitorSignal(const siginfo_t *info, lldb::pid_t pid, bool exited)
     }
 
     // Handle the signal.
     if (info->si_code == SI_TKILL || info->si_code == SI_USER)
     {
         if (log)
             log->Printf ("NativeProcessLinux::%s() received signal %s (%d) with code %s, (siginfo pid = %d (%s), waitpid pid = %" PRIu64 ")",
                             __FUNCTION__,
-                            GetUnixSignals ().GetSignalAsCString (signo),
+                            Host::GetSignalAsCString(signo),
                             signo,
                             (info->si_code == SI_TKILL ? "SI_TKILL" : "SI_USER"),
                             info->si_pid,
                             is_from_llgs ? "from llgs" : "not from llgs",
                             pid);
     }
 
     // Check for new thread notification.
if (is_from_llgs && (info->si_code == SI_TKILL) && (signo == SIGSTOP))
             }
             else
             {
                 if (log)
                 {
                     // Retrieve the signal name if the thread was stopped by a signal.
                     int stop_signo = 0;
                     const bool stopped_by_signal = linux_thread_sp->IsStopped (&stop_signo);
-                    const char *signal_name = stopped_by_signal ? GetUnixSignals ().GetSignalAsCString (stop_signo) : "<not stopped by signal>";
+                    const char *signal_name = stopped_by_signal ? Host::GetSignalAsCString(stop_signo) : "<not stopped by signal>";
                     if (!signal_name)
                         signal_name = "<no-signal-name>";
 
                     log->Printf ("NativeProcessLinux::%s() pid %" PRIu64 " tid %" PRIu64 ", thread was already marked as a stopped state (state=%s, signal=%d (%s)), leaving stop signal as is",
                                  __FUNCTION__,
                                  GetID (),
                                  linux_thread_sp->GetID (),
                                  StateAsCString (thread_state),
                                  stop_signo,
                                  signal_name);
                 }
                 ThreadDidStop (thread_sp->GetID (), false);
             }
         }
 
         // Done handling.
         return;
     }
 
     if (log)
-        log->Printf ("NativeProcessLinux::%s() received signal %s", __FUNCTION__, GetUnixSignals ().GetSignalAsCString (signo));
+        log->Printf ("NativeProcessLinux::%s() received signal %s", __FUNCTION__, Host::GetSignalAsCString(signo));
 
     // This thread is stopped.
     ThreadDidStop (pid, false);
 
     if (thread_sp)
         std::static_pointer_cast<NativeThreadLinux> (thread_sp)->SetStoppedBySignal(signo, info);
 
     // Send a stop to the debugger after we get all other threads to stop.

 
 Error
 NativeProcessLinux::Signal (int signo)
 {
     Error error;
 
     Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
     if (log)
-        log->Printf ("NativeProcessLinux::%s: sending signal %d (%s) to pid %" PRIu64, 
-                __FUNCTION__, signo,  GetUnixSignals ().GetSignalAsCString (signo), GetID ());
+        log->Printf ("NativeProcessLinux::%s: sending signal %d (%s) to pid %" PRIu64,
+                __FUNCTION__, signo, Host::GetSignalAsCString(signo), GetID());
 
     if (kill(GetID(), signo))
         error.SetErrorToErrno();
 
     return error;
 }
 
 Error

 
 Error
 NativeProcessLinux::Resume (lldb::tid_t tid, uint32_t signo)
 {
     Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
 
     if (log)
         log->Printf ("NativeProcessLinux::%s() resuming thread = %"  PRIu64 " with signal %s", __FUNCTION__, tid,
-                                 GetUnixSignals().GetSignalAsCString (signo));
+                                 Host::GetSignalAsCString(signo));
 
 
 
     intptr_t data = 0;
 
     if (signo != LLDB_INVALID_SIGNAL_NUMBER)
         data = signo;
 

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

 include_directories(../../../Utility/)
 
 set(LLVM_NO_RTTI 1)
 
 add_lldb_library(lldbPluginProcessUtility
   DynamicRegisterInfo.cpp
   FreeBSDSignals.cpp
+  GDBRemoteSignals.cpp
   HistoryThread.cpp
   HistoryUnwind.cpp
   InferiorCallPOSIX.cpp
   LinuxSignals.cpp
   MipsLinuxSignals.cpp
   RegisterContextDarwin_arm.cpp
   RegisterContextDarwin_arm64.cpp
   RegisterContextDarwin_i386.cpp

lldb/trunk/source/Plugins/Process/Utility/FreeBSDSignals.h

 //===-- FreeBSDSignals.h ----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_FreeBSDSignals_H_
 #define liblldb_FreeBSDSignals_H_
 
 // Project includes
 #include "lldb/Target/UnixSignals.h"
 
+namespace lldb_private {
+
 /// FreeBSD specific set of Unix signals.
-class FreeBSDSignals
-    : public lldb_private::UnixSignals
+class FreeBSDSignals : public UnixSignals
 {
 public:
     FreeBSDSignals();
 
 private:
     void
-    Reset();
+    Reset() override;
 };
 
+} // namespace lldb_private
+
 #endif // liblldb_FreeBSDSignals_H_

lldb/trunk/source/Plugins/Process/Utility/FreeBSDSignals.cpp

 //===-- FreeBSDSignals.cpp --------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "FreeBSDSignals.h"
 
+using namespace lldb_private;
+
 FreeBSDSignals::FreeBSDSignals()
     : UnixSignals()
 {
     Reset();
 }
 
 void
 FreeBSDSignals::Reset()

lldb/trunk/source/Plugins/Process/Utility/GDBRemoteSignals.h

+//===-- GDBRemoteSignals.h --------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_GDBRemoteSignals_H_
+#define liblldb_GDBRemoteSignals_H_
+
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
+#include "lldb/Target/UnixSignals.h"
+
+namespace lldb_private {
+
+/// Empty set of Unix signals to be filled by PlatformRemoteGDBServer
+class GDBRemoteSignals : public UnixSignals
+{
+public:
+    GDBRemoteSignals();
+
+    GDBRemoteSignals(const lldb::UnixSignalsSP &rhs);
+
+private:
+    void
+    Reset() override;
+};
+
+} // namespace lldb_private
+
+#endif // liblldb_GDBRemoteSignals_H_

lldb/trunk/source/Plugins/Process/Utility/GDBRemoteSignals.cpp

+//===-- GDBRemoteSignals.cpp ------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
+#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();
+}

lldb/trunk/source/Plugins/Process/Utility/LinuxSignals.h

 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Target/UnixSignals.h"
 
 namespace lldb_private {
-namespace process_linux {
 
-    /// Linux specific set of Unix signals.
-    class LinuxSignals
-        : public lldb_private::UnixSignals
-    {
-    public:
-        LinuxSignals();
+class LinuxSignals : public UnixSignals
 
-    private:
-        void
-        Reset();
-    };
+    Reset() override;
 
 } // namespace lldb_private
-} // namespace process_linux
 
-#endif
+#endif // liblldb_LinuxSignals_H_

lldb/trunk/source/Plugins/Process/Utility/LinuxSignals.cpp

 //===-- LinuxSignals.cpp ----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "LinuxSignals.h"
 
-using namespace lldb_private::process_linux;
+using namespace lldb_private;
 
 LinuxSignals::LinuxSignals()
     : UnixSignals()
 {
     Reset();
 }
 
 void

lldb/trunk/source/Plugins/Process/Utility/MipsLinuxSignals.h

 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Target/UnixSignals.h"
 
 namespace lldb_private {
-namespace process_linux {
 
-    /// Linux specific set of Unix signals.
-    class MipsLinuxSignals
-        : public lldb_private::UnixSignals
-    {
-    public:
-        MipsLinuxSignals();
+class MipsLinuxSignals : public UnixSignals
 
-    private:
-        void
-        Reset();
-    };
+    Reset() override;
 
 } // namespace lldb_private
-} // namespace process_linux
 
-#endif
+#endif // liblldb_MipsLinuxSignals_H_

lldb/trunk/source/Plugins/Process/Utility/MipsLinuxSignals.cpp

 //===-- MipsLinuxSignals.cpp ----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "MipsLinuxSignals.h"
 
-using namespace lldb_private::process_linux;
+using namespace lldb_private;
 
 MipsLinuxSignals::MipsLinuxSignals()
     : UnixSignals()
 {
     Reset();
 }
 
 void

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

 #include "lldb/Target/Target.h"
 #include "lldb/Target/DynamicLoader.h"
 #include "lldb/Target/UnixSignals.h"
 
 #include "llvm/Support/ELF.h"
 
 #include "Plugins/ObjectFile/ELF/ObjectFileELF.h"
 #include "Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.h"
-#include "Plugins/Process/Utility/FreeBSDSignals.h"
-#include "Plugins/Process/Utility/LinuxSignals.h"
 
 // Project includes
 #include "ProcessElfCore.h"
 #include "ThreadElfCore.h"
 
 using namespace lldb_private;
 
 ConstString
if (!ranges_are_sorted)
         m_core_aranges.Sort();
 
     // 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());
     if (arch.IsValid())
         m_target.SetArchitecture(arch);
 
-    switch (m_os)
-    {
-        case llvm::Triple::FreeBSD:
-        {
-            static UnixSignalsSP s_freebsd_signals_sp(new FreeBSDSignals ());
-            SetUnixSignals(s_freebsd_signals_sp);
-            break;
-        }
-        case llvm::Triple::Linux:
-        {
-            static UnixSignalsSP s_linux_signals_sp(new process_linux::LinuxSignals ());
-            SetUnixSignals(s_linux_signals_sp);
-            break;
-        }
-        default:
-            break;
-    }
+    SetUnixSignals(UnixSignals::Create(GetArchitecture()));
 
     return error;
 }
 
 lldb_private::DynamicLoader *
 ProcessElfCore::GetDynamicLoader ()
 {
     if (m_dyld_ap.get() == NULL)

 }
 
 void
 ProcessElfCore::Clear()
 {
     m_thread_list.Clear();
     m_os = llvm::Triple::UnknownOS;
 
-    static UnixSignalsSP s_default_unix_signals_sp(new UnixSignals());
+    static const auto s_default_unix_signals_sp = std::make_shared<UnixSignals>();
     SetUnixSignals(s_default_unix_signals_sp);
 }
 
 void
 ProcessElfCore::Initialize()
 {
     static std::once_flag g_once_flag;
 

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

)
     StateType state = eStateRunning;
 
     BroadcastEvent(eBroadcastBitRunPacketSent, NULL);
     m_public_is_running.SetValue (true, eBroadcastNever);
     // Set the starting continue packet into "continue_packet". This packet
     // may change if we are interrupted and we continue after an async packet...
     std::string continue_packet(payload, packet_length);
 
-    const auto sigstop_signo = process->GetUnixSignals().GetSignalNumberFromName("SIGSTOP");
-    const auto sigint_signo = process->GetUnixSignals().GetSignalNumberFromName("SIGINT");
+    const auto sigstop_signo = process->GetUnixSignals()->GetSignalNumberFromName("SIGSTOP");
+    const auto sigint_signo = process->GetUnixSignals()->GetSignalNumberFromName("SIGINT");
 
     bool got_async_packet = false;
     
     while (state == eStateRunning)
     {
         if (!got_async_packet)
         {
             if (log)

lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerPlatform.h

protected:
     Handle_qGetWorkingDir (StringExtractorGDBRemote &packet);
 
     PacketResult
     Handle_QSetWorkingDir (StringExtractorGDBRemote &packet);
 
     PacketResult
     Handle_qC (StringExtractorGDBRemote &packet);
 
+    PacketResult
+    Handle_jSignalsInfo(StringExtractorGDBRemote &packet);
+
 private:
     bool
     DebugserverProcessReaped (lldb::pid_t pid);
 
     static bool
     ReapDebugserverProcess (void *callback_baton,
                             lldb::pid_t pid,
                             bool exited,

lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerPlatform.cpp

 // C Includes
 // C++ Includes
 #include <cstring>
 #include <chrono>
 
 // Other libraries and framework includes
 #include "lldb/Core/Log.h"
 #include "lldb/Core/StreamString.h"
+#include "lldb/Core/StructuredData.h"
 #include "lldb/Host/Config.h"
 #include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/StringConvert.h"
 #include "lldb/Target/FileAction.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
+#include "lldb/Target/UnixSignals.h"
 
 // Project includes
 #include "Utility/StringExtractorGDBRemote.h"
 #include "Utility/UriParser.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::process_gdb_remote;
GDBRemoteCommunicationServerPlatform::GDBRemoteCommunicationServerPlatform() :
     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qGetWorkingDir,
                                   &GDBRemoteCommunicationServerPlatform::Handle_qGetWorkingDir);
     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qLaunchGDBServer,
                                   &GDBRemoteCommunicationServerPlatform::Handle_qLaunchGDBServer);
     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qProcessInfo,
                                   &GDBRemoteCommunicationServerPlatform::Handle_qProcessInfo);
     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_QSetWorkingDir,
                                   &GDBRemoteCommunicationServerPlatform::Handle_QSetWorkingDir);
+    RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_jSignalsInfo,
+                                  &GDBRemoteCommunicationServerPlatform::Handle_jSignalsInfo);
 
     RegisterPacketHandler(StringExtractorGDBRemote::eServerPacketType_interrupt,
                           [this](StringExtractorGDBRemote packet,
                                  Error &error,
                                  bool &interrupt,
                                  bool &quit)
                           {
                               error.SetErrorString("interrupt received");
GDBRemoteCommunicationServerPlatform::Handle_qC (StringExtractorGDBRemote &packet)
     if (pid != LLDB_INVALID_PROCESS_ID)
     {
         m_process_launch_info.Clear();
     }
 
     return SendPacketNoLock (response.GetData(), response.GetSize());
 }
 
+GDBRemoteCommunication::PacketResult
+GDBRemoteCommunicationServerPlatform::Handle_jSignalsInfo(StringExtractorGDBRemote &packet)
+{
+    StructuredData::Array signal_array;
+
+    const auto &signals = Host::GetUnixSignals();
+    for (auto signo = signals->GetFirstSignalNumber();
+         signo != LLDB_INVALID_SIGNAL_NUMBER;
+         signo = signals->GetNextSignalNumber(signo))
+    {
+        auto dictionary = std::make_shared<StructuredData::Dictionary>();
+
+        dictionary->AddIntegerItem("signo", signo);
+        dictionary->AddStringItem("name", signals->GetSignalAsCString(signo));
+
+        bool suppress, stop, notify;
+        signals->GetSignalInfo(signo, suppress, stop, notify);
+        dictionary->AddBooleanItem("suppress", suppress);
+        dictionary->AddBooleanItem("stop", stop);
+        dictionary->AddBooleanItem("notify", notify);
+
+        signal_array.Push(dictionary);
+    }
+
+    StreamString response;
+    signal_array.Dump(response);
+    return SendPacketNoLock(response.GetData(), response.GetSize());
+}
+
 bool
 GDBRemoteCommunicationServerPlatform::DebugserverProcessReaped (lldb::pid_t pid)
 {
     Mutex::Locker locker (m_spawned_pids_mutex);
     FreePortForProcess(pid);
     return m_spawned_pids.erase(pid) > 0;
 }
 

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

 #include "lldb/Target/Target.h"
 #include "lldb/Target/TargetList.h"
 #include "lldb/Target/ThreadPlanCallFunction.h"
 #include "lldb/Target/SystemRuntime.h"
 #include "lldb/Utility/PseudoTerminal.h"
 
 // Project includes
 #include "lldb/Host/Host.h"
-#include "Plugins/Process/Utility/FreeBSDSignals.h"
+#include "Plugins/Process/Utility/GDBRemoteSignals.h"
 #include "Plugins/Process/Utility/InferiorCallPOSIX.h"
-#include "Plugins/Process/Utility/LinuxSignals.h"
-#include "Plugins/Process/Utility/MipsLinuxSignals.h"
 #include "Plugins/Process/Utility/StopInfoMachException.h"
 #include "Plugins/Platform/MacOSX/PlatformRemoteiOS.h"
 #include "Utility/StringExtractorGDBRemote.h"
 #include "GDBRemoteRegisterContext.h"
 #include "ProcessGDBRemote.h"
 #include "ProcessGDBRemoteLog.h"
 #include "ThreadGDBRemote.h"
 
if (error.Success()
             GetTarget().SetArchitecture(m_gdb_comm.GetProcessArchitecture());
         else
             GetTarget().SetArchitecture(m_gdb_comm.GetHostArchitecture());
     }
 
     if (log)
         log->Printf ("ProcessGDBRemote::%s pid %" PRIu64 ": normalized target architecture triple: %s", __FUNCTION__, GetID (), GetTarget ().GetArchitecture ().GetTriple ().getTriple ().c_str ());
 
-    // Set the Unix signals properly for the target.
-    // FIXME Add a gdb-remote packet to discover dynamically.
-    if (error.Success ())
-    {
-        const ArchSpec arch_spec = m_gdb_comm.GetHostArchitecture();
-        if (arch_spec.IsValid ())
-        {
-            if (log)
-                log->Printf ("ProcessGDBRemote::%s pid %" PRIu64 ": determining unix signals type based on architecture %s, triple %s", __FUNCTION__, GetID (), arch_spec.GetArchitectureName () ? arch_spec.GetArchitectureName () : "<null>", arch_spec.GetTriple ().getTriple ().c_str ());
-
-            switch (arch_spec.GetTriple ().getOS ())
-            {
-            case llvm::Triple::Linux:
-                if (arch_spec.GetTriple ().getArch () == llvm::Triple::mips64 || arch_spec.GetTriple ().getArch () == llvm::Triple::mips64el)
-                    SetUnixSignals (UnixSignalsSP (new process_linux::MipsLinuxSignals ()));
-                else
-                    SetUnixSignals (UnixSignalsSP (new process_linux::LinuxSignals ()));
-                if (log)
-                    log->Printf ("ProcessGDBRemote::%s using Linux unix signals type for pid %" PRIu64, __FUNCTION__, GetID ());
-                break;
-            case llvm::Triple::OpenBSD:
-            case llvm::Triple::FreeBSD:
-            case llvm::Triple::NetBSD:
-                SetUnixSignals (UnixSignalsSP (new FreeBSDSignals ()));
-                if (log)
-                    log->Printf ("ProcessGDBRemote::%s using *BSD unix signals type for pid %" PRIu64, __FUNCTION__, GetID ());
-                break;
-            default:
-                SetUnixSignals (UnixSignalsSP (new UnixSignals ()));
-                if (log)
-                    log->Printf ("ProcessGDBRemote::%s using generic unix signals type for pid %" PRIu64, __FUNCTION__, GetID ());
-                break;
-            }
-        }
-    }
+    if (error.Success())
+        SetUnixSignals(std::make_shared<GDBRemoteSignals>(GetTarget().GetPlatform()->GetUnixSignals()));
 
     return error;
 }
 
 Error
 ProcessGDBRemote::WillLaunchOrAttach ()
 {
     Error error;
if (target_sp)
                 state != eStateInvalid &&
                 state != eStateUnloaded &&
                 state != eStateExited &&
                 state != eStateDetached)
             {
                 char error_str[1024];
                 if (signo)
                 {
-                    const char *signal_cstr = process->GetUnixSignals().GetSignalAsCString (signo);
+                    const char *signal_cstr = process->GetUnixSignals()->GetSignalAsCString(signo);
                     if (signal_cstr)
                         ::snprintf (error_str, sizeof (error_str), DEBUGSERVER_BASENAME " died with signal %s", signal_cstr);
                     else
                         ::snprintf (error_str, sizeof (error_str), DEBUGSERVER_BASENAME " died with signal %i", signo);
                 }
                 else
                 {
                     ::snprintf (error_str, sizeof (error_str), DEBUGSERVER_BASENAME " died with an exit status of 0x%8.8x", exit_status);

lldb/trunk/source/Plugins/Process/gdb-remote/ThreadGDBRemote.cpp

if (process_sp)
         switch (resume_state)
         {
         case eStateSuspended:
         case eStateStopped:
             // Don't append anything for threads that should stay stopped.
             break;
 
         case eStateRunning:
-            if (gdb_process->GetUnixSignals().SignalIsValid (signo))
+            if (gdb_process->GetUnixSignals()->SignalIsValid(signo))
                 gdb_process->m_continue_C_tids.push_back(std::make_pair(tid, signo));
             else
                 gdb_process->m_continue_c_tids.push_back(tid);
             break;
 
         case eStateStepping:
-            if (gdb_process->GetUnixSignals().SignalIsValid (signo))
+            if (gdb_process->GetUnixSignals()->SignalIsValid(signo))
                 gdb_process->m_continue_S_tids.push_back(std::make_pair(tid, signo));
             else
                 gdb_process->m_continue_s_tids.push_back(tid);
             break;
 
         default:
             break;
         }

lldb/trunk/source/Target/Platform.cpp

 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Interpreter/OptionValueProperties.h"
 #include "lldb/Interpreter/Property.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
+#include "lldb/Target/UnixSignals.h"
 #include "lldb/Utility/Utils.h"
 #include "llvm/Support/FileSystem.h"
 
 #include "Utility/ModuleCache.h"
 
 // Define these constants from POSIX mman.h rather than include the file
 // so that they will be correct even when compiled on Linux.
 #define MAP_PRIVATE 2
Platform::GetModuleCacheRoot ()
     return dir_spec;
 }
 
 const char *
 Platform::GetCacheHostname ()
 {
     return GetHostname ();
 }
+
+const UnixSignalsSP &
+Platform::GetRemoteUnixSignals()
+{
+    static const auto s_default_unix_signals_sp = std::make_shared<UnixSignals>();
+    return s_default_unix_signals_sp;
+}
+
+const UnixSignalsSP &
+Platform::GetUnixSignals()
+{
+    if (IsHost())
+        return Host::GetUnixSignals();
+    return GetRemoteUnixSignals();
+}

lldb/trunk/source/Target/Process.cpp

Process::GetStaticBroadcasterClass ()
     static ConstString class_name ("lldb.process");
     return class_name;
 }
 
 //----------------------------------------------------------------------
 // Process constructor
 //----------------------------------------------------------------------
 Process::Process(Target &target, Listener &listener) :
-    Process(target, listener, Host::GetUnixSignals ())
+    Process(target, listener, UnixSignals::Create(HostInfo::GetArchitecture()))
 {
     // This constructor just delegates to the full Process constructor,
     // defaulting to using the Host's UnixSignals.
 }
 
 Process::Process(Target &target, Listener &listener, const UnixSignalsSP &unix_signals_sp) :
     ProcessProperties (this),
     UserID (LLDB_INVALID_PROCESS_ID),

 {
     CheckInWithManager ();
 
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT));
     if (log)
         log->Printf ("%p Process::Process()", static_cast<void*>(this));
 
     if (!m_unix_signals_sp)
-        m_unix_signals_sp.reset (new UnixSignals ());
+        m_unix_signals_sp = std::make_shared<UnixSignals>();
 
     SetEventName (eBroadcastBitStateChanged, "state-changed");
     SetEventName (eBroadcastBitInterrupt, "interrupt");
     SetEventName (eBroadcastBitSTDOUT, "stdout-available");
     SetEventName (eBroadcastBitSTDERR, "stderr-available");
     SetEventName (eBroadcastBitProfileData, "profile-data-available");
-    
     m_private_state_control_broadcaster.SetEventName (eBroadcastInternalStateControlStop  , "control-stop"  );
     m_private_state_control_broadcaster.SetEventName (eBroadcastInternalStateControlPause , "control-pause" );
     m_private_state_control_broadcaster.SetEventName (eBroadcastInternalStateControlResume, "control-resume");
 
     listener.StartListeningForEvents (this,
                                       eBroadcastBitStateChanged |
                                       eBroadcastBitInterrupt |
                                       eBroadcastBitSTDOUT |
switch (event_state)
                                     break;
 
                                  case eStopReasonSignal:
                                 {
                                     // Don't select a signal thread if we weren't going to stop at that
                                     // signal.  We have to have had another reason for stopping here, and
                                     // the user doesn't want to see this thread.
                                     uint64_t signo = thread->GetStopInfo()->GetValue();
-                                    if (process_sp->GetUnixSignals().GetShouldStop(signo))
+                                    if (process_sp->GetUnixSignals()->GetShouldStop(signo))
                                     {
                                         if (!other_thread)
                                             other_thread = thread;
                                     }
                                     break;
                                 }
                                 case eStopReasonTrace:
                                 case eStopReasonBreakpoint:
if (exited)
         TargetSP target_sp(Debugger::FindTargetWithProcessID (pid));
         if (target_sp)
         {
             ProcessSP process_sp (target_sp->GetProcessSP());
             if (process_sp)
             {
                 const char *signal_cstr = NULL;
                 if (signo)
-                    signal_cstr = process_sp->GetUnixSignals().GetSignalAsCString (signo);
+                    signal_cstr = process_sp->GetUnixSignals()->GetSignalAsCString(signo);
 
                 process_sp->SetExitStatus (exit_status, signal_cstr);
             }
         }
         return true;
     }
     return false;
 }

 
 void
 Process::SetUnixSignals (const UnixSignalsSP &signals_sp)
 {
     assert (signals_sp && "null signals_sp");
     m_unix_signals_sp = signals_sp;
 }
 
-UnixSignals &
+const lldb::UnixSignalsSP &
 Process::GetUnixSignals ()
 {
     assert (m_unix_signals_sp && "null m_unix_signals_sp");
-    return *m_unix_signals_sp;
+    return m_unix_signals_sp;
 }
 
 lldb::ByteOrder
 Process::GetByteOrder () const
 {
     return m_target.GetArchitecture().GetByteOrder();
 }
 

lldb/trunk/source/Target/StopInfo.cpp

GetStopReason () const
         return eStopReasonSignal;
     }
 
     virtual bool
     ShouldStopSynchronous (Event *event_ptr)
     {
         ThreadSP thread_sp (m_thread_wp.lock());
         if (thread_sp)
-            return thread_sp->GetProcess()->GetUnixSignals().GetShouldStop (m_value);
+            return thread_sp->GetProcess()->GetUnixSignals()->GetShouldStop(m_value);
         return false;
     }
 
     virtual bool
     ShouldStop (Event *event_ptr)
     {
         ThreadSP thread_sp (m_thread_wp.lock());
         if (thread_sp)
-            return thread_sp->GetProcess()->GetUnixSignals().GetShouldStop (m_value);
+            return thread_sp->GetProcess()->GetUnixSignals()->GetShouldStop(m_value);
         return false;
     }
     
     
     // If should stop returns false, check if we should notify of this event
     virtual bool
     DoShouldNotify (Event *event_ptr)
     {
         ThreadSP thread_sp (m_thread_wp.lock());
         if (thread_sp)
         {
-            bool should_notify = thread_sp->GetProcess()->GetUnixSignals().GetShouldNotify (m_value);
+            bool should_notify = thread_sp->GetProcess()->GetUnixSignals()->GetShouldNotify(m_value);
             if (should_notify)
             {
                 StreamString strm;
                 strm.Printf ("thread %d received signal: %s",
                              thread_sp->GetIndexID(),
-                             thread_sp->GetProcess()->GetUnixSignals().GetSignalAsCString (m_value));
+                             thread_sp->GetProcess()->GetUnixSignals()->GetSignalAsCString(m_value));
                 Process::ProcessEventData::AddRestartedReason(event_ptr, strm.GetData());
             }
             return should_notify;
         }
         return true;
     }
 
     
     virtual void
     WillResume (lldb::StateType resume_state)
     {
         ThreadSP thread_sp (m_thread_wp.lock());
         if (thread_sp)
         {
-            if (thread_sp->GetProcess()->GetUnixSignals().GetShouldSuppress(m_value) == false)
+            if (thread_sp->GetProcess()->GetUnixSignals()->GetShouldSuppress(m_value) == false)
                 thread_sp->SetResumeSignal(m_value);
         }
     }
 
     virtual const char *
     GetDescription ()
     {
         if (m_description.empty())
         {
             ThreadSP thread_sp (m_thread_wp.lock());
             if (thread_sp)
             {
                 StreamString strm;
-                const char *signal_name = thread_sp->GetProcess()->GetUnixSignals().GetSignalAsCString (m_value);
+                const char *signal_name = thread_sp->GetProcess()->GetUnixSignals()->GetSignalAsCString(m_value);
                 if (signal_name)
                     strm.Printf("signal %s", signal_name);
                 else
                     strm.Printf("signal %" PRIi64, m_value);
                 m_description.swap (strm.GetString());
             }
         }
         return m_description.c_str();

lldb/trunk/source/Target/UnixSignals.cpp

 //===-- UnixSignals.cpp -----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Target/UnixSignals.h"
 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
+#include "lldb/Core/ArchSpec.h"
 #include "lldb/Host/StringConvert.h"
 
+#include "Plugins/Process/Utility/FreeBSDSignals.h"
+#include "Plugins/Process/Utility/LinuxSignals.h"
+#include "Plugins/Process/Utility/MipsLinuxSignals.h"
+
 using namespace lldb_private;
 
-UnixSignals::Signal::Signal 
+UnixSignals::Signal::Signal
 (
-    const char *name, 
-    const char *short_name, 
-    bool default_suppress, 
-    bool default_stop, 
+    const char *name,
+    const char *short_name,
+    bool default_suppress,
+    bool default_stop,
     bool default_notify,
     const char *description
 ) :
     m_name (name),
     m_short_name (short_name),
     m_description (),
     m_suppress (default_suppress),
     m_stop (default_stop),
     m_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:
+        {
+            switch (triple.getArch())
+            {
+                case llvm::Triple::mips:
+                case llvm::Triple::mipsel:
+                case llvm::Triple::mips64:
+                case llvm::Triple::mips64el:
+                    return std::make_shared<MipsLinuxSignals>();
+                default:
+                    return std::make_shared<LinuxSignals>();
+            }
+        }
+        case llvm::Triple::FreeBSD:
+        case llvm::Triple::OpenBSD:
+        case llvm::Triple::NetBSD:
+            return std::make_shared<FreeBSDSignals>();
+        default:
+            return std::make_shared<UnixSignals>();
+    }
+}
+
 //----------------------------------------------------------------------
 // UnixSignals constructor
 //----------------------------------------------------------------------
 UnixSignals::UnixSignals ()
 {
     Reset ();
 }
 
+UnixSignals::UnixSignals(const UnixSignals &rhs)
+    : m_signals(rhs.m_signals)
+{
+}
+
 //----------------------------------------------------------------------
 // Destructor
 //----------------------------------------------------------------------
 UnixSignals::~UnixSignals ()
 {
 }
 
 void

 bool
 UnixSignals::SetShouldNotify (const char *signal_name, bool value)
 {
     const int32_t signo = GetSignalNumberFromName (signal_name);
     if (signo != LLDB_INVALID_SIGNAL_NUMBER)
         return SetShouldNotify (signo, value);
     return false;
 }
+
+int32_t
+UnixSignals::GetNumSignals() const
+{
+    return m_signals.size();
+}
+
+int32_t
+UnixSignals::GetSignalAtIndex(int32_t index) const
+{
+    if (index < 0 || m_signals.size() <= static_cast<size_t>(index))
+        return LLDB_INVALID_SIGNAL_NUMBER;
+    auto it = m_signals.begin();
+    std::advance(it, index);
+    return it->first;
+}

lldb/trunk/source/Utility/StringExtractorGDBRemote.h

enum ServerPacketType
         eServerPacketType_qSyncThreadStateSupported,
         eServerPacketType_qThreadExtraInfo,
         eServerPacketType_qThreadStopInfo,
         eServerPacketType_qVAttachOrWaitSupported,
         eServerPacketType_qWatchpointSupportInfo,
         eServerPacketType_qWatchpointSupportInfoSupported,
         eServerPacketType_qXfer_auxv_read,
 
+        eServerPacketType_jSignalsInfo,
+
         eServerPacketType_vAttach,
         eServerPacketType_vAttachWait,
         eServerPacketType_vAttachOrWait,
         eServerPacketType_vAttachName,
         eServerPacketType_vCont,
         eServerPacketType_vCont_actions, // vCont?
 
         eServerPacketType_stop_reason, // '?'

lldb/trunk/source/Utility/StringExtractorGDBRemote.cpp

case '-':
         break;
 
     case '+':
         if (packet_size == 1) return eServerPacketType_ack;
         break;
 
     case 'A':
         return eServerPacketType_A;
-            
     case 'Q':
 
         switch (packet_cstr[1])
         {
         case 'E':
             if (PACKET_STARTS_WITH ("QEnvironment:"))           return eServerPacketType_QEnvironment;
             if (PACKET_STARTS_WITH ("QEnvironmentHexEncoded:")) return eServerPacketType_QEnvironmentHexEncoded;
             break;
case 'Q':
             if (PACKET_STARTS_WITH ("QRestoreRegisterState:"))    return eServerPacketType_QRestoreRegisterState;
             break;
 
         case 'T':
             if (PACKET_MATCHES ("QThreadSuffixSupported"))        return eServerPacketType_QThreadSuffixSupported;
             break;
         }
         break;
-            
     case 'q':
         switch (packet_cstr[1])
         {
         case 's':
             if (PACKET_MATCHES ("qsProcessInfo"))               return eServerPacketType_qsProcessInfo;
             if (PACKET_MATCHES ("qsThreadInfo"))                return eServerPacketType_qsThreadInfo;
             break;
 
case 'q':
             if (PACKET_MATCHES ("qWatchpointSupportInfo"))      return eServerPacketType_qWatchpointSupportInfoSupported;
             break;
 
         case 'X':
             if (PACKET_STARTS_WITH ("qXfer:auxv:read::"))       return eServerPacketType_qXfer_auxv_read;
             break;
         }
         break;
+
+    case 'j':
+        if (PACKET_MATCHES("jSignalInfo")) return eServerPacketType_jSignalsInfo;
+
     case 'v':
             if (PACKET_STARTS_WITH("vFile:"))
             {
                 if (PACKET_STARTS_WITH("vFile:open:"))          return eServerPacketType_vFile_open;
                 else if (PACKET_STARTS_WITH("vFile:close:"))    return eServerPacketType_vFile_close;
                 else if (PACKET_STARTS_WITH("vFile:pread"))     return eServerPacketType_vFile_pread;
                 else if (PACKET_STARTS_WITH("vFile:pwrite"))    return eServerPacketType_vFile_pwrite;
                 else if (PACKET_STARTS_WITH("vFile:size"))      return eServerPacketType_vFile_size;

lldb/trunk/test/lldbutil.py

 # ==================================================
 # Utility functions to get the correct signal number
 # ==================================================
 
 import signal
 
 def get_signal_number(signal_name):
     platform = lldb.remote_platform
-    if platform:
-        if platform.GetName() == 'remote-linux':
-            command = lldb.SBPlatformShellCommand('kill -l %d' % signal_name)
-            if platform.Run(command).Success() and command.GetStatus() == 0:
-                try:
-                    return int(command.GetOutput())
-                except ValueError:
-                    pass
-        elif platform.GetName() == 'remote-android':
-            for signal_number in range(1, 65):
-                command = lldb.SBPlatformShellCommand('kill -l %d' % signal_number)
-                if platform.Run(command).Fail() or command.GetStatus() != 0:
-                    continue
-                output = command.GetOutput().strip().upper()
-                if not output.startswith('SIG'):
-                    output = 'SIG' + output
-                if output == signal_name:
-                    return signal_number
-    if lldb.debugger:
-        for target_index in range(lldb.debugger.GetNumTargets()):
-            target = lldb.debugger.GetTargetAtIndex(target_index)
-            if not target.IsValid():
-                continue
-            process = target.GetProcess()
-            if not process.IsValid():
-                continue
-            signals = process.GetUnixSignals()
-            if not signals.IsValid():
-                continue
+    if platform and platform.IsValid():
+        signals = platform.GetUnixSignals()
+        if signals.IsValid():
             signal_number = signals.GetSignalNumberFromName(signal_name)
             if signal_number > 0:
                 return signal_number
+    # No remote platform; fall back to using local python signals.
     return getattr(signal, signal_name)