Consolidate UnixSignals setting/getting in Process.

[tfiala]

Summary

This change does the following:

• eliminates the Process::GetUnixSignals() virtual method and replaces with a fixed getter.
• replaces the Process UnixSignals storage with a shared pointer.
• guarantees that Process::GetUnixSignals() can always return a UnixSignals reference.
• adds a Process constructor variant that can be passed the UnixSignalsSP. When the constructor without the UnixSignalsSP is specified, the Host's default UnixSignals is used.
• adds a host-specific version of GetUnixSignals() that is used when we need the host's appropriate UnixSignals variant.
• replaces GetUnixSignals() overrides in PlatformElfCore, ProcessGDBRemote, ProcessFreeBSD and ProcessLinux with code that appropriately sets the Process::UnixSignals for the process.

This change also enables some future patches that will enable llgs to be used for local Linux debugging.

Note I'm not currently using HostInfo for GetUnixSignals. I am happy to do that in a follow-up patch, but right now I want to minimize the number of changes vs. other branches and keep that other change separate.

[tfiala]

Small tweak - a flag from another branch snuck in. Harmless for the change but still not intended to be there.

[tfiala]

Any feedback on this? If not, I'll go ahead and get this in later today.

[tfiala]

The modification to source/Plugins/Process/gdb-remote/GDBRemoteCommunication.cpp is not appropriate in this patch. It already went in as a separate change (llvm.org svn r216745 here: http://lists.cs.uiuc.edu/pipermail/lldb-commits/Week-of-Mon-20140825/012685.html).

[tfiala]

Put it up here:
svn commit
Sending include/lldb/Host/Host.h
Sending include/lldb/Target/Process.h
Sending include/lldb/lldb-private-forward.h
Sending lldb.xcodeproj/project.pbxproj
Sending source/Host/common/Host.cpp
Sending source/Host/freebsd/Host.cpp
Sending source/Host/linux/Host.cpp
Sending source/Plugins/Process/FreeBSD/ProcessFreeBSD.cpp
Sending source/Plugins/Process/FreeBSD/ProcessFreeBSD.h
Sending source/Plugins/Process/Linux/ProcessLinux.cpp
Sending source/Plugins/Process/Linux/ProcessLinux.h
Sending source/Plugins/Process/POSIX/ProcessPOSIX.cpp
Sending source/Plugins/Process/POSIX/ProcessPOSIX.h
Sending source/Plugins/Process/elf-core/ProcessElfCore.cpp
Sending source/Plugins/Process/elf-core/ProcessElfCore.h
Sending source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
Sending source/Plugins/Process/gdb-remote/ProcessGDBRemote.h
Sending source/Target/Process.cpp
Transmitting file data ..................
Committed revision 216748.

include/lldb/Host/Host.h

 #include <string>
 
 #include "lldb/lldb-private.h"
+#include "lldb/lldb-private-forward.h"
 #include "lldb/Core/StringList.h"
 #include "lldb/Host/File.h"
 #include "lldb/Host/FileSpec.h"

     static bool AddPosixSpawnFileAction(void *file_actions, const FileAction *info, Log *log, Error &error);
 #endif
 
+    static const lldb_private::UnixSignalsSP&
+    GetUnixSignals ();
+
     static lldb::pid_t
     LaunchApplication (const FileSpec &app_file_spec);
 

include/lldb/Target/Process.h

 
     //------------------------------------------------------------------
     /// Construct with a shared pointer to a target, and the Process listener.
+    /// 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);
+
+    //------------------------------------------------------------------
     /// Destructor.
     ///
     /// The destructor is virtual since this class is designed to be

     Error
     Signal (int signal);
 
-    virtual UnixSignals &
+    void
+    SetUnixSignals (const UnixSignalsSP &signals_sp)
+    {
+        assert (signals_sp && "null signals_sp");
+        m_unix_signals_sp = signals_sp;
+    }
+
+    UnixSignals &
     GetUnixSignals ()
     {
-        return m_unix_signals;
+        assert (m_unix_signals_sp && "null m_unix_signals_sp");
+        return *m_unix_signals_sp;
     }
 
     //==================================================================

     std::unique_ptr<DynamicCheckerFunctions> m_dynamic_checkers_ap; ///< The functions used by the expression parser to validate data that expressions use.
     std::unique_ptr<OperatingSystem> m_os_ap;
     std::unique_ptr<SystemRuntime> m_system_runtime_ap;
-    UnixSignals                 m_unix_signals;         /// This is the current signal set for this process.
+    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;

include/lldb/lldb-private-forward.h

     class NativeProcessProtocol;
     class NativeRegisterContext;
     class NativeThreadProtocol;
+    class UnixSignals;
 
     // ---------------------------------------------------------------
     // SP/WP decls.

     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)

lldb.xcodeproj/project.pbxproj

     236124A31986B4E2004EFC37 /* Socket.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Socket.cpp; sourceTree = "<group>"; };
     236124A61986B50E004EFC37 /* IOObject.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = IOObject.h; path = include/lldb/Host/IOObject.h; sourceTree = "<group>"; };
     236124A71986B50E004EFC37 /* Socket.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = Socket.h; path = include/lldb/Host/Socket.h; sourceTree = "<group>"; };
+    237C577A19AF9D9F00213D59 /* HostInfoLinux.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = HostInfoLinux.h; path = include/lldb/Host/linux/HostInfoLinux.h; sourceTree = SOURCE_ROOT; };
     23AB052D199FF639003B8084 /* FreeBSDThread.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = FreeBSDThread.cpp; sourceTree = "<group>"; };
     23AB052E199FF639003B8084 /* FreeBSDThread.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = FreeBSDThread.h; sourceTree = "<group>"; };
     23AB052F199FF639003B8084 /* ProcessFreeBSD.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = ProcessFreeBSD.cpp; sourceTree = "<group>"; };

       isa = PBXGroup;
       children = (
         233B009D19610D6B0090E598 /* Host.cpp */,
+        237C577A19AF9D9F00213D59 /* HostInfoLinux.h */,
         3FDFE53619A2933E009756A7 /* HostInfoLinux.cpp */,
       );
       name = linux;

source/Host/common/Host.cpp

 #include "lldb/Host/FileSpec.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Mutex.h"
+#include "lldb/lldb-private-forward.h"
 #include "lldb/Target/FileAction.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/ProcessLaunchInfo.h"

 }
 
 #endif
+
+#if !defined (__linux__) && !defined (__FreeBSD__) && !defined (__NetBSD__)
+
+const lldb_private::UnixSignalsSP&
+Host::GetUnixSignals ()
+{
+    static UnixSignalsSP s_unix_signals_sp (new UnixSignals ());
+    return s_unix_signals_sp;
+}
+
+#endif

source/Host/freebsd/Host.cpp

 #include "lldb/Core/DataExtractor.h"
 #include "lldb/Utility/CleanUp.h"
 
+#include "Plugins/Process/Utility/FreeBSDSignals.h"
+
 #include "llvm/Support/Host.h"
 
-
 extern "C" {
     extern char **environ;
 }

    done:
    return buf_sp;
 }
+
+const UnixSignalsSP&
+Host::GetUnixSignals ()
+{
+    static const lldb_private::UnixSignalsSP s_unix_signals_sp (new FreeBSDSignals ());
+    return s_unix_signals_sp;
+}
+

source/Host/linux/Host.cpp

 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "Plugins/Process/Linux/ProcFileReader.h"
+#include "Plugins/Process/Utility/LinuxSignals.h"
 
 using namespace lldb;
 using namespace lldb_private;

         env.AppendString(env_entry);
     return i;
 }
+
+const lldb_private::UnixSignalsSP&
+Host::GetUnixSignals ()
+{
+    static const lldb_private::UnixSignalsSP s_unix_signals_sp (new process_linux::LinuxSignals ());
+    return s_unix_signals_sp;
+}
+

source/Plugins/Process/FreeBSD/ProcessFreeBSD.h

 // Other libraries and framework includes
 #include "lldb/Target/Process.h"
 #include "lldb/Target/ThreadList.h"
-#include "Plugins/Process/Utility/FreeBSDSignals.h"
 #include "ProcessMessage.h"
 #include "ProcessPOSIX.h"
 

     EnablePluginLogging(lldb_private::Stream *strm,
                         lldb_private::Args &command);
 
-    //------------------------------------------------------------------
-    // Plugin process overrides
-    //------------------------------------------------------------------
-    virtual lldb_private::UnixSignals &
-    GetUnixSignals()
-    {
-        return m_freebsd_signals;
-    }
-
 protected:
     friend class FreeBSDThread;
 
-    // FreeBSD-specific signal set.
-    FreeBSDSignals m_freebsd_signals;
-
     typedef std::vector<lldb::tid_t> tid_collection;
     tid_collection m_suspend_tids;
     tid_collection m_run_tids;

source/Plugins/Process/FreeBSD/ProcessFreeBSD.cpp

 #include "ProcessFreeBSD.h"
 #include "ProcessPOSIXLog.h"
 #include "Plugins/Process/Utility/InferiorCallPOSIX.h"
+#include "Plugins/Process/Utility/FreeBSDSignals.h"
 #include "ProcessMonitor.h"
 #include "FreeBSDThread.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
+namespace
+{
+    UnixSignalsSP&
+    GetFreeBSDSignals ()
+    {
+        static UnixSignalsSP s_freebsd_signals_sp (new FreeBSDSignals ());
+        return s_freebsd_signals_sp;
+    }
+}
+
 //------------------------------------------------------------------------------
 // Static functions.
 

 // Constructors and destructors.
 
 ProcessFreeBSD::ProcessFreeBSD(Target& target, Listener &listener)
-    : ProcessPOSIX(target, listener),
+    : ProcessPOSIX(target, listener, GetFreeBSDSignals ()),
       m_resume_signo(0)
 {
 }

 
     m_message_queue.push(message);
 }
-

source/Plugins/Process/Linux/ProcessLinux.h

 #include "ProcessMessage.h"
 #include "ProcessPOSIX.h"
 
-#include "Plugins/Process/Utility/LinuxSignals.h"
-
 class ProcessMonitor;
 
 class ProcessLinux :

     EnablePluginLogging(lldb_private::Stream *strm,
                         lldb_private::Args &command);
 
-    //------------------------------------------------------------------
-    // Plug-in process overrides
-    //------------------------------------------------------------------
-    virtual lldb_private::UnixSignals &
-    GetUnixSignals ()
-    {
-        return m_linux_signals;
-    }
-
     virtual bool
     CanDebug(lldb_private::Target &target, bool plugin_specified_by_name);
 

 
 private:
 
-    /// Linux-specific signal set.
-    process_linux::LinuxSignals m_linux_signals;
-
     lldb_private::FileSpec *m_core_file;
 
     // Flag to avoid recursion when stopping all threads.

source/Plugins/Process/Linux/ProcessLinux.cpp

 #include "ProcessLinux.h"
 #include "ProcessPOSIXLog.h"
 #include "Plugins/Process/Utility/InferiorCallPOSIX.h"
+#include "Plugins/Process/Utility/LinuxSignals.h"
 #include "ProcessMonitor.h"
 #include "LinuxThread.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
+namespace
+{
+    UnixSignalsSP&
+    GetStaticLinuxSignalsSP ()
+    {
+        static UnixSignalsSP s_unix_signals_sp (new process_linux::LinuxSignals ());
+        return s_unix_signals_sp;
+    }
+}
+
 //------------------------------------------------------------------------------
 // Static functions.
 

 // Constructors and destructors.
 
 ProcessLinux::ProcessLinux(Target& target, Listener &listener, FileSpec *core_file)
-    : ProcessPOSIX(target, listener), m_core_file(core_file), m_stopping_threads(false)
+    : ProcessPOSIX(target, listener, GetStaticLinuxSignalsSP ()), m_core_file(core_file), m_stopping_threads(false)
 {
 #if 0
     // FIXME: Putting this code in the ctor and saving the byte order in a

source/Plugins/Process/POSIX/ProcessPOSIX.h

 
 // Other libraries and framework includes
 #include "lldb/Target/Process.h"
-#include "lldb/Target/UnixSignals.h"
 #include "ProcessMessage.h"
 
 class ProcessMonitor;

     // Constructors and destructors
     //------------------------------------------------------------------
     ProcessPOSIX(lldb_private::Target& target,
-                 lldb_private::Listener &listener);
+                 lldb_private::Listener &listener,
+                 lldb_private::UnixSignalsSP &unix_signals_sp);
 
     virtual
     ~ProcessPOSIX();

     ProcessMonitor &
     GetMonitor() { assert(m_monitor); return *m_monitor; }
 
-    lldb_private::UnixSignals &
-    GetUnixSignals();
-
     const char *GetFilePath(const lldb_private::FileAction *file_action, const char *default_path);
 
     /// Stops all threads in the process.

     /// Drive any exit events to completion.
     bool m_exit_now;
 
-    /// OS-specific signal set.
-    lldb_private::UnixSignals m_signals;
-
     /// Returns true if the process has exited.
     bool HasExited();
 

source/Plugins/Process/POSIX/ProcessPOSIX.cpp

 //------------------------------------------------------------------------------
 // Constructors and destructors.
 
-ProcessPOSIX::ProcessPOSIX(Target& target, Listener &listener)
-    : Process(target, listener),
+ProcessPOSIX::ProcessPOSIX(Target& target, Listener &listener, UnixSignalsSP &unix_signals_sp)
+    : Process(target, listener, unix_signals_sp),
       m_byte_order(lldb::endian::InlHostByteOrder()),
       m_monitor(NULL),
       m_module(NULL),

     return status;
 }
 
-UnixSignals &
-ProcessPOSIX::GetUnixSignals()
-{
-    return m_signals;
-}
-
 //------------------------------------------------------------------------------
 // Utility functions.
 

source/Plugins/Process/elf-core/ProcessElfCore.h

     IsAlive ();
 
     //------------------------------------------------------------------
-    // Process Signals
-    //------------------------------------------------------------------
-    virtual lldb_private::UnixSignals &
-    GetUnixSignals()
-    {
-        if (m_signals_sp)
-            return *m_signals_sp;
-        else
-            return Process::GetUnixSignals();
-    }
-
-    //------------------------------------------------------------------
     // Process Memory
     //------------------------------------------------------------------
     virtual size_t

     DISALLOW_COPY_AND_ASSIGN (ProcessElfCore);
 
     llvm::Triple::OSType m_os;
-    std::shared_ptr<lldb_private::UnixSignals> m_signals_sp;
 
     // True if m_thread_contexts contains valid entries
     bool m_thread_data_valid;

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

 #include "lldb/Core/Log.h"
 #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"

     m_core_file (core_file),
     m_dyld_plugin_name (),
     m_os(llvm::Triple::UnknownOS),
-    m_signals_sp (),
     m_thread_data_valid(false),
     m_thread_data(),
     m_core_aranges ()

     switch (m_os)
     {
         case llvm::Triple::FreeBSD:
-            m_signals_sp.reset(new FreeBSDSignals());
+        {
+            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;
     }

 {
     m_thread_list.Clear();
     m_os = llvm::Triple::UnknownOS;
-    m_signals_sp.reset();
+
+    static UnixSignalsSP s_default_unix_signals_sp(new UnixSignals());
+    SetUnixSignals(s_default_unix_signals_sp);
 }
 
 void

     lldb::DataBufferSP buffer(new lldb_private::DataBufferHeap(start, len));
     return buffer;
 }
-

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

             ::snprintf (arg_cstr, sizeof(arg_cstr), "--log-flags=%s", env_debugserver_log_flags);
             debugserver_args.AppendArgument(arg_cstr);
         }
-        
+        // Add additional args, starting with LLDB_DEBUGSERVER_EXTRA_ARG_1 until an env var doesn't come back.
+        uint32_t env_var_index = 1;
+        bool has_env_var;
+        do
+        {
+            char env_var_name[64];
+            snprintf (env_var_name, sizeof (env_var_name), "LLDB_DEBUGSERVER_EXTRA_ARG_%" PRIu32, env_var_index++);
+            const char *extra_arg = getenv(env_var_name);
+            has_env_var = extra_arg != nullptr;
+
+            if (has_env_var)
+            {
+                debugserver_args.AppendArgument (extra_arg);
+                if (log)
+                    log->Printf ("GDBRemoteCommunication::%s adding env var %s contents to stub command line (%s)", __FUNCTION__, env_var_name, extra_arg);
+            }
+        } while (has_env_var);
+
         // Close STDIN, STDOUT and STDERR. We might need to redirect them
         // to "/dev/null" if we run into any problems.
         launch_info.AppendCloseFileAction (STDIN_FILENO);

source/Plugins/Process/gdb-remote/ProcessGDBRemote.h

 #include "lldb/Core/StringList.h"
 #include "lldb/Core/StructuredData.h"
 #include "lldb/Core/ThreadSafeValue.h"
+#include "lldb/lldb-private-forward.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Thread.h"
 

     virtual void
     DidLaunch ();
 
-    lldb_private::UnixSignals&
-    GetUnixSignals () override;
-
     virtual lldb_private::Error
     WillAttachToProcessWithID (lldb::pid_t pid);
 

     bool m_destroy_tried_resuming;
     lldb::CommandObjectSP m_command_sp;
     int64_t m_breakpoint_pc_offset;
-    std::shared_ptr<lldb_private::UnixSignals> m_unix_signals_sp;
 
-
     bool
     StartAsyncThread ();
 

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

     m_waiting_for_attach (false),
     m_destroy_tried_resuming (false),
     m_command_sp (),
-    m_breakpoint_pc_offset (0),
-    m_unix_signals_sp (new UnixSignals ())
+    m_breakpoint_pc_offset (0)
 {
     m_async_broadcaster.SetEventName (eBroadcastBitAsyncThreadShouldExit,   "async thread should exit");
     m_async_broadcaster.SetEventName (eBroadcastBitAsyncContinue,           "async thread continue");

             switch (arch_spec.GetTriple ().getOS ())
             {
             case llvm::Triple::Linux:
-                m_unix_signals_sp.reset (new process_linux::LinuxSignals ());
+                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:
-                m_unix_signals_sp.reset (new FreeBSDSignals ());
+                SetUnixSignals (UnixSignalsSP (new FreeBSDSignals ()));
                 if (log)
                     log->Printf ("ProcessGDBRemote::%s using *BSD unix signals type for pid %" PRIu64, __FUNCTION__, GetID ());
                 break;
             default:
-                m_unix_signals_sp.reset (new UnixSignals ());
+                SetUnixSignals (UnixSignalsSP (new UnixSignals ()));
                 if (log)
                     log->Printf ("ProcessGDBRemote::%s using generic unix signals type for pid %" PRIu64, __FUNCTION__, GetID ());
                 break;

     DidLaunchOrAttach (process_arch);
 }
 
-UnixSignals&
-ProcessGDBRemote::GetUnixSignals ()
-{
-    assert (m_unix_signals_sp && "m_unix_signals_sp is null");
-    return *m_unix_signals_sp;
-}
-
 Error
 ProcessGDBRemote::DoAttachToProcessWithID (lldb::pid_t attach_pid)
 {

source/Target/Process.cpp

 // Process constructor
 //----------------------------------------------------------------------
 Process::Process(Target &target, Listener &listener) :
+    Process(target, listener, Host::GetUnixSignals ())
+{
+    // 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 (false),
     UserID (LLDB_INVALID_PROCESS_ID),
     Broadcaster (&(target.GetDebugger()), "lldb.process"),

     m_listener (listener),
     m_breakpoint_site_list (),
     m_dynamic_checkers_ap (),
-    m_unix_signals (),
+    m_unix_signals_sp (unix_signals_sp),
     m_abi_sp (),
     m_process_input_reader (),
     m_stdio_communication ("process.stdio"),

     if (log)
         log->Printf ("%p Process::Process()", static_cast<void*>(this));
 
+    if (!m_unix_signals_sp)
+        m_unix_signals_sp.reset (new UnixSignals ());
+
     SetEventName (eBroadcastBitStateChanged, "state-changed");
     SetEventName (eBroadcastBitInterrupt, "interrupt");
     SetEventName (eBroadcastBitSTDOUT, "stdout-available");

                                                      eBroadcastInternalStateControlStop |
                                                      eBroadcastInternalStateControlPause |
                                                      eBroadcastInternalStateControlResume);
+    // We need something valid here, even if just the default UnixSignalsSP.
+    assert (m_unix_signals_sp && "null m_unix_signals_sp after initialization");
 }
 
 //----------------------------------------------------------------------