Extend SBPlatform with capability to launch/terminate a process remotely. Integrate this change into test framework in order to spawn processes on a remote target.

[ovyalov]

Summary

1. Added Platform::Kill call which raises SIGTERM signal in its base implementation and sends qKillSpawnedProcess request in case of PlatformRemoteGDBServer.
2. Extended SBPLatform with Launch and Kill methods.
3. A few fixes within GDBRemoteCommunicationClient and GDBRemoteCommunicationServer in order to properly deliver qProcessInfo response (disabling default PID caching).
4. Small utility class hierarchy in lldbtest - _BaseProcess, _LocalProcess and _RemoteProcess to manage process launch/termination depending on test mode.

[vharron]

test/functionalities/process_attach/TestProcessAttach.py

59 ↗

(On Diff #18981)

Hi Greg,

In lldb, when I create a target, it is created in the context of the selected platform. Currently, when I launch a process, it is launched in the context of the selected target.

I would prefer 'process attach' to be done in the context of the currently selected platform. That way, whether you don't need to remember attaching to local/remote processes.

[ovyalov]

test/functionalities/process_attach/TestProcessAttach.py

59 ↗

(On Diff #18981)

It makes sense since "process launch " allows to launch remote process in case of connected platform.
I hacked a quick change for CommandObjectProcess to make it use platform:

if (platform_sp->CanDebugProcess())
 {
     process_sp = platform_sp->Attach(m_options.attach_info, m_interpreter.GetDebugger(), nullptr, error); // PlatformRemoteGDBServer needs to call HijackProcessEvents on process.
 }
 else
 {
     const char *plugin_name = m_options.attach_info.GetProcessPluginName();
     process_sp = target->CreateProcess (m_interpreter.GetDebugger().GetListener(), plugin_name, NULL);
     if (process_sp)
     {
         process_sp->HijackProcessEvents(listener_sp.get());
         error = process_sp->Attach (m_options.attach_info);
     }
 }

It's working remotely but crashing locally for me.
So, I can revert TestProcessAttach.py in this CL and then follow-up with CL for CommandObjectProcess.

[ovyalov]

I reverted TestProcessAttach changes and merged with http://reviews.llvm.org/D7358 - no regressions noticed for local test runs on Ubuntu and OSX, remote Linux->Linux execution of TestProcessAttach works fine.
Please take another look.

Thank you!

[ovyalov]

Friendly ping.

[clayborg]

See comments in the code and let me know what you think.

include/lldb/API/SBPlatform.h

107–135

Can't we just use SBLaunchInfo instead of this?

Also one thing to note: if you add anything to the lldb::SB API, you can only have one member variable: a pointer, an std::unique_ptr<> or a std::shared_pointer<>. Why? Because we are vending a C++ interface and you can't change the size of the class. When people link against the lldb.so, they need a consistent API and layout of classes in case they make classes that inherit from or use a lldb::SB class so the layout can never change. So to work around this we have rules:

1 - lldb::SB classes have one ivar (ptr, unique_ptr, or shared_ptr) which abstracts you from your implementation and makes sure the size of the lldb::SB object never changes
2 - no virtual functions so that all function lookups are based off of a pure name lookup by the dynamic linkers (no vtable that can change on you)
3 - No inheritance, or only inheritance based on other lldb::SB classes that obey the same rules

177–184

Can't this just be a SBLaunchInfo?

source/API/SBPlatform.cpp

261–303

Hopefully this class doesn't need to exist, and we can just use SBLaunchInfo. If not, then all ivars (m_command, m_working_dir, m_arch and m_pid will need to go into a Impl class and the SBPlatformLaunchCommand class will need to have a std::unique_ptr<> to the imp class.

[ovyalov]

Please see my comments.

include/lldb/API/SBPlatform.h

107–135

Thanks for suggestions and context.

I think it makes sense to use SBLaunchInfo instead of SBPlatformLaunchCommand since SBLaunchInfo is a wrapper around ProcessLaunchInfo which Platform::LaunchProcess takes as a parameter. A few follow-up questions:

• Is it ok to remove friendship between SBLaunchInfo and SBTarget and make SBLaunchInfo::ref public since it will be used by SBPlatform and SBTarget? Or we can make SBPlatform its friend as well..
• I'm going to add SBLaunchInfo::GetProcessID that will delegate to ProcessLaunchInfo::SBLaunchInfo - so, I can grab pid of launched process.
• Does it sound okay to extract SBLaunchInfo into separate SBLaunchInfo.h(cpp) files?

[ki.stfu]

include/lldb/API/SBPlatform.h

107–135

Is it ok to remove friendship between SBLaunchInfo and SBTarget and make SBLaunchInfo::ref public since it will be used by SBPlatform and SBTarget? Or we can make SBPlatform its friend as well..

I think we can make its friend. The ref() must be a private.

Does it sound okay to extract SBLaunchInfo into separate SBLaunchInfo.h(cpp) files?

Yes.

[clayborg]

Is it ok to remove friendship between SBLaunchInfo and SBTarget and make SBLaunchInfo::ref public since it will be used by SBPlatform and SBTarget? Or we can make SBPlatform its friend as well..

Make SBPlatform a friend as well

I'm going to add SBLaunchInfo::GetProcessID that will delegate to ProcessLaunchInfo::SBLaunchInfo - so, I can grab pid of launched process.

sounds good

Does it sound okay to extract SBLaunchInfo into separate SBLaunchInfo.h(cpp) files?

Sure thing. Feel free to do the same for SBAttachInfo if you have time. I can deal with the fallout in the Xcode project if you don't have a Mac once you get those in.

[ovyalov]

Extracted SBLaunchInfo (with added GetProcessID method) into a separate file and updated all build dependencies - checked on Ubuntu and OSX, didn't spot any regressions.
The CL's already become pretty big - let me extract SBAttachInfo with another CL.

Please take another look.
Thank you.

[clayborg]

Changes inlined into code as comments.

include/lldb/API/SBPlatform.h

14–15

We shouldn't need these in the header file. Only a reference to SBLaunchInfo is used below. Put them in the .cpp file.

source/API/SBPlatform.cpp

218

Remove this line so there are no diffs generated here.

[ovyalov]

Fixed according to suggestions.

[clayborg]

lgtm

[ovyalov]

Committed as http://reviews.llvm.org/rL228230

include/lldb/API/SBPlatform.h

14–15

Fixed.

source/API/SBPlatform.cpp

218

Done.

include/lldb/API/SBLaunchInfo.h

+//===-- SBLaunchInfo.h ------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_SBLaunchInfo_h_
+#define LLDB_SBLaunchInfo_h_
+
+#include "lldb/API/SBDefines.h"
+
+namespace lldb {
+
+class SBPlatform;
+class SBTarget;
+
+class SBLaunchInfo
+{
+public:
+    SBLaunchInfo (const char **argv);
+
+    ~SBLaunchInfo();
+
+    lldb::pid_t
+    GetProcessID();
+
+    uint32_t
+    GetUserID();
+
+    uint32_t
+    GetGroupID();
+
+    bool
+    UserIDIsValid ();
+
+    bool
+    GroupIDIsValid ();
+
+    void
+    SetUserID (uint32_t uid);
+
+    void
+    SetGroupID (uint32_t gid);
+
+    SBFileSpec
+    GetExecutableFile ();
+
+    //----------------------------------------------------------------------
+    /// Set the executable file that will be used to launch the process and
+    /// optionally set it as the first argument in the argument vector.
+    ///
+    /// This only needs to be specified if clients wish to carefully control
+    /// the exact path will be used to launch a binary. If you create a
+    /// target with a symlink, that symlink will get resolved in the target
+    /// and the resolved path will get used to launch the process. Calling
+    /// this function can help you still launch your process using the
+    /// path of your choice.
+    ///
+    /// If this function is not called prior to launching with
+    /// SBTarget::Launch(...), the target will use the resolved executable
+    /// path that was used to create the target.
+    ///
+    /// @param[in] exe_file
+    ///     The override path to use when launching the executable.
+    ///
+    /// @param[in] add_as_first_arg
+    ///     If true, then the path will be inserted into the argument vector
+    ///     prior to launching. Otherwise the argument vector will be left
+    ///     alone.
+    //----------------------------------------------------------------------
+    void
+    SetExecutableFile (SBFileSpec exe_file, bool add_as_first_arg);
+
+
+    //----------------------------------------------------------------------
+    /// Get the listener that will be used to receive process events.
+    ///
+    /// If no listener has been set via a call to
+    /// SBLaunchInfo::SetListener(), then an invalid SBListener will be
+    /// returned (SBListener::IsValid() will return false). If a listener
+    /// has been set, then the valid listener object will be returned.
+    //----------------------------------------------------------------------
+    SBListener
+    GetListener ();
+
+    //----------------------------------------------------------------------
+    /// Set the listener that will be used to receive process events.
+    ///
+    /// By default the SBDebugger, which has a listener, that the SBTarget
+    /// belongs to will listen for the process events. Calling this function
+    /// allows a different listener to be used to listen for process events.
+    //----------------------------------------------------------------------
+    void
+    SetListener (SBListener &listener);
+
+    uint32_t
+    GetNumArguments ();
+
+    const char *
+    GetArgumentAtIndex (uint32_t idx);
+
+    void
+    SetArguments (const char **argv, bool append);
+
+    uint32_t
+    GetNumEnvironmentEntries ();
+
+    const char *
+    GetEnvironmentEntryAtIndex (uint32_t idx);
+
+    void
+    SetEnvironmentEntries (const char **envp, bool append);
+
+    void
+    Clear ();
+
+    const char *
+    GetWorkingDirectory () const;
+
+    void
+    SetWorkingDirectory (const char *working_dir);
+
+    uint32_t
+    GetLaunchFlags ();
+
+    void
+    SetLaunchFlags (uint32_t flags);
+
+    const char *
+    GetProcessPluginName ();
+
+    void
+    SetProcessPluginName (const char *plugin_name);
+
+    const char *
+    GetShell ();
+
+    void
+    SetShell (const char * path);
+
+    uint32_t
+    GetResumeCount ();
+
+    void
+    SetResumeCount (uint32_t c);
+
+    bool
+    AddCloseFileAction (int fd);
+
+    bool
+    AddDuplicateFileAction (int fd, int dup_fd);
+
+    bool
+    AddOpenFileAction (int fd, const char *path, bool read, bool write);
+
+    bool
+    AddSuppressFileAction (int fd, bool read, bool write);
+
+    void
+    SetLaunchEventData (const char *data);
+
+    const char *
+    GetLaunchEventData () const;
+
+    bool
+    GetDetachOnError() const;
+
+    void
+    SetDetachOnError(bool enable);
+
+protected:
+    friend class SBPlatform;
+    friend class SBTarget;
+
+    lldb_private::ProcessLaunchInfo &
+    ref ();
+
+    ProcessLaunchInfoSP m_opaque_sp;
+};
+
+} // namespace lldb
+
+#endif  // LLDB_SBLaunchInfo_h_

include/lldb/API/SBPlatform.h

 //===-- SBPlatform.h --------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_SBPlatform_h_
 #define LLDB_SBPlatform_h_
 
 #include "lldb/API/SBDefines.h"
+#include "lldb/API/SBLaunchInfo.h"
+#include "lldb/API/SBTarget.h"
+
+#include <functional>
 
 struct PlatformConnectOptions;
 struct PlatformShellCommand;
 
 namespace lldb {
 
     class SBPlatformConnectOptions
     {
public:
         GetOutput ();
 
     protected:
         friend class SBPlatform;
 
         PlatformShellCommand *m_opaque_ptr;
     };
 
     class SBPlatform
     {
     public:
         
         SBPlatform ();
         
         SBPlatform (const char *platform_name);
         
         ~SBPlatform();
         
         bool
         IsValid () const;
         
         void
         Clear ();
 
         const char *
         GetWorkingDirectory();
 
         bool
         SetWorkingDirectory(const char *path);
 
         const char *
         GetName ();
 
         SBError
         ConnectRemote (SBPlatformConnectOptions &connect_options);
 
         void
         DisconnectRemote ();
         
         bool
         IsConnected();
 
         //----------------------------------------------------------------------
         // The following functions will work if the platform is connected
         //----------------------------------------------------------------------
public:
         Get (SBFileSpec &src, SBFileSpec &dst);
 
         SBError
         Install (SBFileSpec& src, SBFileSpec& dst);
 
         SBError
         Run (SBPlatformShellCommand &shell_command);
 
         SBError
+        Launch (SBLaunchInfo &launch_info);
+
+        SBError
+        Kill (const lldb::pid_t pid);
+
+        SBError
         MakeDirectory (const char *path, uint32_t file_permissions = eFilePermissionsDirectoryDefault);
 
         uint32_t
         GetFilePermissions (const char *path);
         
         SBError
         SetFilePermissions (const char *path, uint32_t file_permissions);
 
     protected:
         
         friend class SBDebugger;
         friend class SBTarget;
 
         lldb::PlatformSP
         GetSP () const;
         
         void
         SetSP (const lldb::PlatformSP& platform_sp);
 
+        SBError
+        ExecuteConnected (const std::function<lldb_private::Error(const lldb::PlatformSP&)>& func);
+
         lldb::PlatformSP m_opaque_sp;
     };
 
 } // namespace lldb
 
 #endif // LLDB_SBPlatform_h_

include/lldb/API/SBTarget.h

 #ifndef LLDB_SBTarget_h_
 #define LLDB_SBTarget_h_
 
 #include "lldb/API/SBDefines.h"
 #include "lldb/API/SBAddress.h"
 #include "lldb/API/SBBroadcaster.h"
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/API/SBFileSpecList.h"
+#include "lldb/API/SBLaunchInfo.h"
 #include "lldb/API/SBSymbolContextList.h"
 #include "lldb/API/SBType.h"
 #include "lldb/API/SBValue.h"
 #include "lldb/API/SBWatchpoint.h"
 
 namespace lldb {
 
 class SBPlatform;
 
-class SBLaunchInfo
-{
-public:
-    SBLaunchInfo (const char **argv);
-    
-    ~SBLaunchInfo();
-
-    uint32_t
-    GetUserID();
-    
-    uint32_t
-    GetGroupID();
-    
-    bool
-    UserIDIsValid ();
-    
-    bool
-    GroupIDIsValid ();
-    
-    void
-    SetUserID (uint32_t uid);
-    
-    void
-    SetGroupID (uint32_t gid);
-    
-    SBFileSpec
-    GetExecutableFile ();
-
-    //----------------------------------------------------------------------
-    /// Set the executable file that will be used to launch the process and
-    /// optionally set it as the first argument in the argument vector.
-    ///
-    /// This only needs to be specified if clients wish to carefully control
-    /// the exact path will be used to launch a binary. If you create a
-    /// target with a symlink, that symlink will get resolved in the target
-    /// and the resolved path will get used to launch the process. Calling
-    /// this function can help you still launch your process using the
-    /// path of your choice.
-    ///
-    /// If this function is not called prior to launching with
-    /// SBTarget::Launch(...), the target will use the resolved executable
-    /// path that was used to create the target.
-    ///
-    /// @param[in] exe_file
-    ///     The override path to use when launching the executable.
-    ///
-    /// @param[in] add_as_first_arg
-    ///     If true, then the path will be inserted into the argument vector
-    ///     prior to launching. Otherwise the argument vector will be left
-    ///     alone.
-    //----------------------------------------------------------------------
-    void
-    SetExecutableFile (SBFileSpec exe_file, bool add_as_first_arg);
-
-
-    //----------------------------------------------------------------------
-    /// Get the listener that will be used to receive process events.
-    ///
-    /// If no listener has been set via a call to
-    /// SBLaunchInfo::SetListener(), then an invalid SBListener will be
-    /// returned (SBListener::IsValid() will return false). If a listener
-    /// has been set, then the valid listener object will be returned.
-    //----------------------------------------------------------------------
-    SBListener
-    GetListener ();
-
-    //----------------------------------------------------------------------
-    /// Set the listener that will be used to receive process events.
-    ///
-    /// By default the SBDebugger, which has a listener, that the SBTarget
-    /// belongs to will listen for the process events. Calling this function
-    /// allows a different listener to be used to listen for process events.
-    //----------------------------------------------------------------------
-    void
-    SetListener (SBListener &listener);
-
-    uint32_t
-    GetNumArguments ();
-    
-    const char *
-    GetArgumentAtIndex (uint32_t idx);
-    
-    void
-    SetArguments (const char **argv, bool append);
-    
-    uint32_t
-    GetNumEnvironmentEntries ();
-    
-    const char *
-    GetEnvironmentEntryAtIndex (uint32_t idx);
-    
-    void
-    SetEnvironmentEntries (const char **envp, bool append);
-    
-    void
-    Clear ();
-    
-    const char *
-    GetWorkingDirectory () const;
-    
-    void
-    SetWorkingDirectory (const char *working_dir);
-    
-    uint32_t
-    GetLaunchFlags ();
-    
-    void
-    SetLaunchFlags (uint32_t flags);
-    
-    const char *
-    GetProcessPluginName ();
-    
-    void
-    SetProcessPluginName (const char *plugin_name);
-    
-    const char *
-    GetShell ();
-    
-    void
-    SetShell (const char * path);
-    
-    uint32_t
-    GetResumeCount ();
-    
-    void
-    SetResumeCount (uint32_t c);
-    
-    bool
-    AddCloseFileAction (int fd);
-    
-    bool
-    AddDuplicateFileAction (int fd, int dup_fd);
-    
-    bool
-    AddOpenFileAction (int fd, const char *path, bool read, bool write);
-    
-    bool
-    AddSuppressFileAction (int fd, bool read, bool write);
-    
-    void
-    SetLaunchEventData (const char *data);
-    
-    const char *
-    GetLaunchEventData () const;
-    
-    bool
-    GetDetachOnError() const;
-    
-    void
-    SetDetachOnError(bool enable);
-    
-protected:
-    friend class SBTarget;
-    
-    lldb_private::ProcessLaunchInfo &
-    ref ();
-
-    ProcessLaunchInfoSP m_opaque_sp;
-};
-
 class SBAttachInfo
 {
 public:
     SBAttachInfo ();
     
     SBAttachInfo (lldb::pid_t pid);
     
     SBAttachInfo (const char *path, bool wait_for);

include/lldb/Target/Platform.h

//        FindPlugin (Process *process, const ConstString &plugin_name);
         //------------------------------------------------------------------
         /// Launch a new process on a platform, not necessarily for 
         /// debugging, it could be just for running the process.
         //------------------------------------------------------------------
         virtual Error
         LaunchProcess (ProcessLaunchInfo &launch_info);
 
         //------------------------------------------------------------------
+        /// Kill process on a platform.
+        //------------------------------------------------------------------
+        virtual Error
+        KillProcess (const lldb::pid_t pid);
+
+        //------------------------------------------------------------------
         /// Lets a platform answer if it is compatible with a given
         /// architecture and the target triple contained within.
         //------------------------------------------------------------------
         virtual bool
         IsCompatibleArchitecture (const ArchSpec &arch,
                                   bool exact_arch_match,
                                   ArchSpec *compatible_arch_ptr);
 

lldb.xcodeproj/project.pbxproj

/* Begin PBXBuildFile section */
     23CDD8FB19D47B3600461DDC /* ThreadStateCoordinator.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 23CDD8E819D3E13200461DDC /* ThreadStateCoordinator.cpp */; };
     23DDF226196C3EE600BB8417 /* CommandOptionValidators.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 23DDF224196C3EE600BB8417 /* CommandOptionValidators.cpp */; };
     23EDE33319269E7C00F6A132 /* NativeRegisterContext.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 23EDE3301926839700F6A132 /* NativeRegisterContext.cpp */; };
     23EFE389193D1ABC00E54E54 /* SBTypeEnumMember.h in Headers */ = {isa = PBXBuildFile; fileRef = 23EFE388193D1ABC00E54E54 /* SBTypeEnumMember.h */; settings = {ATTRIBUTES = (Public, ); }; };
     23EFE38B193D1AEC00E54E54 /* SBTypeEnumMember.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 23EFE38A193D1AEC00E54E54 /* SBTypeEnumMember.cpp */; };
     23F4034D1926E0F60046DC9B /* NativeRegisterContextRegisterInfo.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 23F403481926CC250046DC9B /* NativeRegisterContextRegisterInfo.cpp */; };
     25420ECD1A6490B8009ADBCB /* OptionValueChar.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 25420ECC1A6490B8009ADBCB /* OptionValueChar.cpp */; };
     25420ED21A649D88009ADBCB /* PipeBase.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 25420ED11A649D88009ADBCB /* PipeBase.cpp */; };
+    254FBB951A81AA7F00BD6378 /* SBLaunchInfo.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 254FBB941A81AA7F00BD6378 /* SBLaunchInfo.cpp */; };
+    254FBB971A81B03100BD6378 /* SBLaunchInfo.h in Headers */ = {isa = PBXBuildFile; fileRef = 254FBB961A81B03100BD6378 /* SBLaunchInfo.h */; settings = {ATTRIBUTES = (Public, ); }; };
     260157C61885F51C00F875CF /* libpanel.dylib in Frameworks */ = {isa = PBXBuildFile; fileRef = 260157C41885F4FF00F875CF /* libpanel.dylib */; };
     260157C71885F52500F875CF /* libpanel.dylib in Frameworks */ = {isa = PBXBuildFile; fileRef = 260157C41885F4FF00F875CF /* libpanel.dylib */; };
     260157C81885F53100F875CF /* libpanel.dylib in Frameworks */ = {isa = PBXBuildFile; fileRef = 260157C41885F4FF00F875CF /* libpanel.dylib */; };
     2606EDDE184E68940034641B /* Foundation.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 260C876910F538E700BB2B04 /* Foundation.framework */; };
     2606EDDF184E68A10034641B /* liblldb-core.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 2689FFCA13353D7A00698AC0 /* liblldb-core.a */; };
     260A248E15D06C50009981B0 /* OptionValues.h in Headers */ = {isa = PBXBuildFile; fileRef = 260A248D15D06C4F009981B0 /* OptionValues.h */; };
     260A39A619647A3A004B4130 /* Pipe.h in Headers */ = {isa = PBXBuildFile; fileRef = 260A39A519647A3A004B4130 /* Pipe.h */; };
     260A63171861008E00FECF8E /* IOHandler.h in Headers */ = {isa = PBXBuildFile; fileRef = 260A63161861008E00FECF8E /* IOHandler.h */; };
/* Begin PBXFileReference section */
     23EDE3371926AAD500F6A132 /* RegisterInfoInterface.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = RegisterInfoInterface.h; path = Utility/RegisterInfoInterface.h; sourceTree = "<group>"; };
     23EFE388193D1ABC00E54E54 /* SBTypeEnumMember.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = SBTypeEnumMember.h; path = include/lldb/API/SBTypeEnumMember.h; sourceTree = "<group>"; };
     23EFE38A193D1AEC00E54E54 /* SBTypeEnumMember.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; name = SBTypeEnumMember.cpp; path = source/API/SBTypeEnumMember.cpp; sourceTree = "<group>"; };
     23F403471926C8D50046DC9B /* NativeRegisterContextRegisterInfo.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = NativeRegisterContextRegisterInfo.h; path = include/lldb/Host/common/NativeRegisterContextRegisterInfo.h; sourceTree = "<group>"; };
     23F403481926CC250046DC9B /* NativeRegisterContextRegisterInfo.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = NativeRegisterContextRegisterInfo.cpp; path = source/Host/common/NativeRegisterContextRegisterInfo.cpp; sourceTree = "<group>"; };
     25420ECC1A6490B8009ADBCB /* OptionValueChar.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = OptionValueChar.cpp; path = source/Interpreter/OptionValueChar.cpp; sourceTree = "<group>"; };
     25420ECE1A64911B009ADBCB /* OptionValueChar.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = OptionValueChar.h; path = include/lldb/Interpreter/OptionValueChar.h; sourceTree = "<group>"; };
     25420ED11A649D88009ADBCB /* PipeBase.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = PipeBase.cpp; sourceTree = "<group>"; };
+    254FBB921A81AA5200BD6378 /* SBLaunchInfo.i */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c.preprocessed; path = SBLaunchInfo.i; sourceTree = "<group>"; };
+    254FBB941A81AA7F00BD6378 /* SBLaunchInfo.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SBLaunchInfo.cpp; path = source/API/SBLaunchInfo.cpp; sourceTree = "<group>"; };
+    254FBB961A81B03100BD6378 /* SBLaunchInfo.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SBLaunchInfo.h; path = include/lldb/API/SBLaunchInfo.h; sourceTree = "<group>"; };
     260157C41885F4FF00F875CF /* libpanel.dylib */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.dylib"; name = libpanel.dylib; path = /usr/lib/libpanel.dylib; sourceTree = "<absolute>"; };
     260223E7115F06D500A601A2 /* SBCommunication.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SBCommunication.h; path = include/lldb/API/SBCommunication.h; sourceTree = "<group>"; };
     260223E8115F06E500A601A2 /* SBCommunication.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SBCommunication.cpp; path = source/API/SBCommunication.cpp; sourceTree = "<group>"; };
     26022531115F27FA00A601A2 /* SBFileSpec.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SBFileSpec.h; path = include/lldb/API/SBFileSpec.h; sourceTree = "<group>"; };
     26022532115F281400A601A2 /* SBFileSpec.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SBFileSpec.cpp; path = source/API/SBFileSpec.cpp; sourceTree = "<group>"; };
     260A248D15D06C4F009981B0 /* OptionValues.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = OptionValues.h; path = include/lldb/Interpreter/OptionValues.h; sourceTree = "<group>"; };
     260A39A519647A3A004B4130 /* Pipe.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = Pipe.h; path = include/lldb/Host/Pipe.h; sourceTree = "<group>"; };
     260A63111860FDB600FECF8E /* Queue.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = Queue.h; path = include/lldb/Target/Queue.h; sourceTree = "<group>"; };
260C89E110F57C5600BB2B04 /* MacOSX */ = {
         260C89E310F57C5600BB2B04 /* SymbolVendorMacOSX.h */,
       );
       path = MacOSX;
       sourceTree = "<group>";
     };
     2611FEEE142D83060017FEA3 /* interface */ = {
       isa = PBXGroup;
       children = (
+        254FBB921A81AA5200BD6378 /* SBLaunchInfo.i */,
         2611FEEF142D83060017FEA3 /* SBAddress.i */,
         2611FEF0142D83060017FEA3 /* SBBlock.i */,
         2611FEF1142D83060017FEA3 /* SBBreakpoint.i */,
         2611FEF2142D83060017FEA3 /* SBBreakpointLocation.i */,
         2611FEF3142D83060017FEA3 /* SBBroadcaster.i */,
         2611FEF4142D83060017FEA3 /* SBCommandInterpreter.i */,
         2611FEF5142D83060017FEA3 /* SBCommandReturnObject.i */,
         2611FEF6142D83060017FEA3 /* SBCommunication.i */,
26274FA414030F79006BA130 /* Darwin-Kernel */ = {
         26274FA614030F79006BA130 /* DynamicLoaderDarwinKernel.h */,
       );
       path = "Darwin-Kernel";
       sourceTree = "<group>";
     };
     262D3190111B4341004E6F88 /* API */ = {
       isa = PBXGroup;
       children = (
+        254FBB961A81B03100BD6378 /* SBLaunchInfo.h */,
+        254FBB941A81AA7F00BD6378 /* SBLaunchInfo.cpp */,
         2611FEEE142D83060017FEA3 /* interface */,
         26BC7C2510F1B3BC00F91463 /* lldb-defines.h */,
         26BC7C2610F1B3BC00F91463 /* lldb-enumerations.h */,
         26DE1E6A11616C2E00A093E2 /* lldb-forward.h */,
         26651A14133BEC76005B64B7 /* lldb-public.h */,
         26BC7C2910F1B3BC00F91463 /* lldb-types.h */,
         94145430175D7FDE00284436 /* lldb-versioning.h */,
         26B42C4C1187ABA50079C8C8 /* LLDB.h */,
26680202115FD0ED008E1FE4 /* Headers */ = {
         26680224115FD13D008E1FE4 /* SBFileSpec.h in Headers */,
         4CF52AF51428291E0051E832 /* SBFileSpecList.h in Headers */,
         26680225115FD13D008E1FE4 /* SBFrame.h in Headers */,
         26DE205311618FAC00A093E2 /* SBFunction.h in Headers */,
         9A3576A8116E9AB700E8ED2F /* SBHostOS.h in Headers */,
         9AC7038E117674FB0086C050 /* SBInstruction.h in Headers */,
         9AC70390117675270086C050 /* SBInstructionList.h in Headers */,
         26DE205911618FE700A093E2 /* SBLineEntry.h in Headers */,
+        254FBB971A81B03100BD6378 /* SBLaunchInfo.h in Headers */,
         AF0EBBED185941360059E52F /* SBQueueItem.h in Headers */,
         26680227115FD13D008E1FE4 /* SBListener.h in Headers */,
         26DE204F11618E9800A093E2 /* SBModule.h in Headers */,
         2668022A115FD13D008E1FE4 /* SBProcess.h in Headers */,
         26B8283D142D01E9002DBC64 /* SBSection.h in Headers */,
         2668022B115FD13D008E1FE4 /* SBSourceManager.h in Headers */,
         26C72C94124322890068DC16 /* SBStream.h in Headers */,
         9A357671116E7B5200E8ED2F /* SBStringList.h in Headers */,
26680204115FD0ED008E1FE4 /* Sources */ = {
         B2A58724143119D50092BFBA /* SBWatchpoint.cpp in Sources */,
         263C4938178B50C40070F12D /* SBModuleSpec.cpp in Sources */,
         2660AAB914622483003A9694 /* LLDBWrapPython.cpp in Sources */,
         9475C18814E5E9FA001BFC6D /* SBTypeCategory.cpp in Sources */,
         9475C18E14E5F834001BFC6D /* SBTypeNameSpecifier.cpp in Sources */,
         9452573A16262D0200325455 /* SBDeclaration.cpp in Sources */,
         4CE4F675162C973F00F75CB3 /* SBExpressionOptions.cpp in Sources */,
         AF9107EE168570D200DBCD3C /* RegisterContextDarwin_arm64.cpp in Sources */,
+        254FBB951A81AA7F00BD6378 /* SBLaunchInfo.cpp in Sources */,
       );
       runOnlyForDeploymentPostprocessing = 0;
     };
     2689FFC613353D7A00698AC0 /* Sources */ = {
       isa = PBXSourcesBuildPhase;
       buildActionMask = 2147483647;
       files = (
         33E5E8471A674FB60024ED68 /* StringConvert.cpp in Sources */,

scripts/Python/build-swig-Python.sh

 " ${SRC_ROOT}/include/lldb/API/SBExecutionContext.h"\
 " ${SRC_ROOT}/include/lldb/API/SBExpressionOptions.h"\
 " ${SRC_ROOT}/include/lldb/API/SBFileSpec.h"\
 " ${SRC_ROOT}/include/lldb/API/SBFrame.h"\
 " ${SRC_ROOT}/include/lldb/API/SBFunction.h"\
 " ${SRC_ROOT}/include/lldb/API/SBHostOS.h"\
 " ${SRC_ROOT}/include/lldb/API/SBInstruction.h"\
 " ${SRC_ROOT}/include/lldb/API/SBInstructionList.h"\
+" ${SRC_ROOT}/include/lldb/API/SBLaunchInfo.h"\
 " ${SRC_ROOT}/include/lldb/API/SBLineEntry.h"\
 " ${SRC_ROOT}/include/lldb/API/SBListener.h"\
 " ${SRC_ROOT}/include/lldb/API/SBModule.h"\
 " ${SRC_ROOT}/include/lldb/API/SBModuleSpec.h"\
 " ${SRC_ROOT}/include/lldb/API/SBProcess.h"\
 " ${SRC_ROOT}/include/lldb/API/SBQueue.h"\
 " ${SRC_ROOT}/include/lldb/API/SBQueueItem.h"\
 " ${SRC_ROOT}/include/lldb/API/SBSourceManager.h"\

 " ${SRC_ROOT}/scripts/Python/interface/SBExecutionContext.i"\
 " ${SRC_ROOT}/scripts/Python/interface/SBExpressionOptions.i"\
 " ${SRC_ROOT}/scripts/Python/interface/SBFileSpec.i"\
 " ${SRC_ROOT}/scripts/Python/interface/SBFrame.i"\
 " ${SRC_ROOT}/scripts/Python/interface/SBFunction.i"\
 " ${SRC_ROOT}/scripts/Python/interface/SBHostOS.i"\
 " ${SRC_ROOT}/scripts/Python/interface/SBInstruction.i"\
 " ${SRC_ROOT}/scripts/Python/interface/SBInstructionList.i"\
+" ${SRC_ROOT}/scripts/Python/interface/SBLaunchInfo.i"\
 " ${SRC_ROOT}/scripts/Python/interface/SBLineEntry.i"\
 " ${SRC_ROOT}/scripts/Python/interface/SBListener.i"\
 " ${SRC_ROOT}/scripts/Python/interface/SBModule.i"\
 " ${SRC_ROOT}/scripts/Python/interface/SBModuleSpec.i"\
 " ${SRC_ROOT}/scripts/Python/interface/SBPlatform.i"\
 " ${SRC_ROOT}/scripts/Python/interface/SBProcess.i"\
 " ${SRC_ROOT}/scripts/Python/interface/SBQueue.i"\
 " ${SRC_ROOT}/scripts/Python/interface/SBQueueItem.i"\

scripts/Python/buildSwigPython.py

listHeaderFiles = [ "/include/lldb/API/lldb.h", # .sh has /include/lldb/lldb.h 21/11/2013
             "/include/lldb/API/SBExpressionOptions.h",
             "/include/lldb/API/SBFileSpec.h",
             "/include/lldb/API/SBFrame.h",
             "/include/lldb/API/SBFunction.h",
             "/include/lldb/API/SBHostOS.h",
             "/include/lldb/API/SBInputReader.h",
             "/include/lldb/API/SBInstruction.h",
             "/include/lldb/API/SBInstructionList.h",
+            "/include/lldb/API/SBLaunchInfo.h",
             "/include/lldb/API/SBLineEntry.h",
             "/include/lldb/API/SBListener.h",
             "/include/lldb/API/SBModule.h",
             "/include/lldb/API/SBModuleSpec.h",
             "/include/lldb/API/SBProcess.h",
             "/include/lldb/API/SBSourceManager.h",
             "/include/lldb/API/SBStream.h",
             "/include/lldb/API/SBStringList.h",
listIFaceFiles = [  "/scripts/Python/interface/SBAddress.i",
             "/scripts/Python/interface/SBExpressionOptions.i",
             "/scripts/Python/interface/SBFileSpec.i",
             "/scripts/Python/interface/SBFrame.i",
             "/scripts/Python/interface/SBFunction.i",
             "/scripts/Python/interface/SBHostOS.i",
             "/scripts/Python/interface/SBInputReader.i",
             "/scripts/Python/interface/SBInstruction.i",
             "/scripts/Python/interface/SBInstructionList.i",
+            "/scripts/Python/interface/SBLaunchInfo.i",
             "/scripts/Python/interface/SBLineEntry.i",
             "/scripts/Python/interface/SBListener.i",
             "/scripts/Python/interface/SBModule.i",
             "/scripts/Python/interface/SBModuleSpec.i",
             "/scripts/Python/interface/SBProcess.i",
             "/scripts/Python/interface/SBSourceManager.i",
             "/scripts/Python/interface/SBStream.i",
             "/scripts/Python/interface/SBStringList.i",

scripts/Python/interface/SBLaunchInfo.i

+//===-- SWIG Interface for SBLaunchInfo--------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+namespace lldb {
+
+class SBLaunchInfo
+{
+public:
+    SBLaunchInfo (const char **argv);
+
+    pid_t
+    GetProcessID();
+
+    uint32_t
+    GetUserID();
+
+    uint32_t
+    GetGroupID();
+
+    bool
+    UserIDIsValid ();
+
+    bool
+    GroupIDIsValid ();
+
+    void
+    SetUserID (uint32_t uid);
+
+    void
+    SetGroupID (uint32_t gid);
+
+    lldb::SBFileSpec
+    GetExecutableFile ();
+
+    void
+    SetExecutableFile (lldb::SBFileSpec exe_file, bool add_as_first_arg);
+
+    lldb::SBListener
+    GetListener ();
+
+    void
+    SetListener (lldb::SBListener &listener);
+
+    uint32_t
+    GetNumArguments ();
+
+    const char *
+    GetArgumentAtIndex (uint32_t idx);
+
+    void
+    SetArguments (const char **argv, bool append);
+
+    uint32_t
+    GetNumEnvironmentEntries ();
+
+    const char *
+    GetEnvironmentEntryAtIndex (uint32_t idx);
+
+    void
+    SetEnvironmentEntries (const char **envp, bool append);
+
+    void
+    Clear ();
+
+    const char *
+    GetWorkingDirectory () const;
+
+    void
+    SetWorkingDirectory (const char *working_dir);
+
+    uint32_t
+    GetLaunchFlags ();
+
+    void
+    SetLaunchFlags (uint32_t flags);
+
+    const char *
+    GetProcessPluginName ();
+
+    void
+    SetProcessPluginName (const char *plugin_name);
+
+    const char *
+    GetShell ();
+
+    void
+    SetShell (const char * path);
+
+    uint32_t
+    GetResumeCount ();
+
+    void
+    SetResumeCount (uint32_t c);
+
+    bool
+    AddCloseFileAction (int fd);
+
+    bool
+    AddDuplicateFileAction (int fd, int dup_fd);
+
+    bool
+    AddOpenFileAction (int fd, const char *path, bool read, bool write);
+
+    bool
+    AddSuppressFileAction (int fd, bool read, bool write);
+
+    void
+    SetLaunchEventData (const char *data);
+
+    const char *
+    GetLaunchEventData () const;
+
+    bool
+    GetDetachOnError() const;
+
+    void
+    SetDetachOnError(bool enable);
+};
+
+} // namespace lldb

scripts/Python/interface/SBPlatform.i

public:
     
     lldb::SBError
     Install (lldb::SBFileSpec &src, lldb::SBFileSpec &dst);
     
     lldb::SBError
     Run (lldb::SBPlatformShellCommand &shell_command);
 
     lldb::SBError
+    Launch (lldb::SBLaunchInfo &launch_info);
+
+    lldb::SBError
+    Kill (const lldb::pid_t pid);
+
+    lldb::SBError
     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);
 
 };
 
 } // namespace lldb

scripts/Python/interface/SBTarget.i

 //===-- SWIG Interface for SBTarget -----------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 namespace lldb {
 
-class SBLaunchInfo
-{
-public:
-    SBLaunchInfo (const char **argv);
-    
-    uint32_t
-    GetUserID();
-    
-    uint32_t
-    GetGroupID();
-    
-    bool
-    UserIDIsValid ();
-    
-    bool
-    GroupIDIsValid ();
-    
-    void
-    SetUserID (uint32_t uid);
-    
-    void
-    SetGroupID (uint32_t gid);
-    
-    lldb::SBFileSpec
-    GetExecutableFile ();
-    
-    void
-    SetExecutableFile (lldb::SBFileSpec exe_file, bool add_as_first_arg);
-
-    lldb::SBListener
-    GetListener ();
-
-    void
-    SetListener (lldb::SBListener &listener);
-
-    uint32_t
-    GetNumArguments ();
-    
-    const char *
-    GetArgumentAtIndex (uint32_t idx);
-    
-    void
-    SetArguments (const char **argv, bool append);
-    
-    uint32_t
-    GetNumEnvironmentEntries ();
-    
-    const char *
-    GetEnvironmentEntryAtIndex (uint32_t idx);
-    
-    void
-    SetEnvironmentEntries (const char **envp, bool append);
-    
-    void
-    Clear ();
-    
-    const char *
-    GetWorkingDirectory () const;
-    
-    void
-    SetWorkingDirectory (const char *working_dir);
-    
-    uint32_t
-    GetLaunchFlags ();
-    
-    void
-    SetLaunchFlags (uint32_t flags);
-    
-    const char *
-    GetProcessPluginName ();
-    
-    void
-    SetProcessPluginName (const char *plugin_name);
-    
-    const char *
-    GetShell ();
-    
-    void
-    SetShell (const char * path);
-    
-    uint32_t
-    GetResumeCount ();
-    
-    void
-    SetResumeCount (uint32_t c);
-    
-    bool
-    AddCloseFileAction (int fd);
-    
-    bool
-    AddDuplicateFileAction (int fd, int dup_fd);
-    
-    bool
-    AddOpenFileAction (int fd, const char *path, bool read, bool write);
-    
-    bool
-    AddSuppressFileAction (int fd, bool read, bool write);
-
-    void
-    SetLaunchEventData (const char *data);
-    
-    const char *
-    GetLaunchEventData () const;
-    
-    bool
-    GetDetachOnError() const;
-    
-    void
-    SetDetachOnError(bool enable);
-};
-
 class SBAttachInfo
 {
 public:
     SBAttachInfo ();
     
     SBAttachInfo (lldb::pid_t pid);
     
     SBAttachInfo (const char *path, bool wait_for);

scripts/lldb.swig

 #include "lldb/API/SBExpressionOptions.h"
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/API/SBFileSpecList.h"
 #include "lldb/API/SBFrame.h"
 #include "lldb/API/SBFunction.h"
 #include "lldb/API/SBHostOS.h"
 #include "lldb/API/SBInstruction.h"
 #include "lldb/API/SBInstructionList.h"
+#include "lldb/API/SBLaunchInfo.h"
 #include "lldb/API/SBLineEntry.h"
 #include "lldb/API/SBListener.h"
 #include "lldb/API/SBModule.h"
 #include "lldb/API/SBModuleSpec.h"
 #include "lldb/API/SBPlatform.h"
 #include "lldb/API/SBProcess.h"
 #include "lldb/API/SBQueue.h"
 #include "lldb/API/SBQueueItem.h"

 %include "./Python/interface/SBExpressionOptions.i"
 %include "./Python/interface/SBFileSpec.i"
 %include "./Python/interface/SBFileSpecList.i"
 %include "./Python/interface/SBFrame.i"
 %include "./Python/interface/SBFunction.i"
 %include "./Python/interface/SBHostOS.i"
 %include "./Python/interface/SBInstruction.i"
 %include "./Python/interface/SBInstructionList.i"
+%include "./Python/interface/SBLaunchInfo.i"
 %include "./Python/interface/SBLineEntry.i"
 %include "./Python/interface/SBListener.i"
 %include "./Python/interface/SBModule.i"
 %include "./Python/interface/SBModuleSpec.i"
 %include "./Python/interface/SBPlatform.i"
 %include "./Python/interface/SBProcess.i"
 %include "./Python/interface/SBQueue.i"
 %include "./Python/interface/SBQueueItem.i"

source/API/CMakeLists.txt

add_lldb_library(lldbAPI
   SBExpressionOptions.cpp
   SBFileSpec.cpp
   SBFileSpecList.cpp
   SBFrame.cpp
   SBFunction.cpp
   SBHostOS.cpp
   SBInstruction.cpp
   SBInstructionList.cpp
+  SBLaunchInfo.cpp
   SBLineEntry.cpp
   SBListener.cpp
   SBModule.cpp
   SBModuleSpec.cpp
   SBPlatform.cpp
   SBProcess.cpp
   SBQueue.cpp
   SBQueueItem.cpp

source/API/SBLaunchInfo.cpp

+//===-- SBLaunchInfo.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-python.h"
+
+#include "lldb/API/SBLaunchInfo.h"
+
+#include "lldb/API/SBFileSpec.h"
+#include "lldb/API/SBListener.h"
+#include "lldb/Target/ProcessLaunchInfo.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+SBLaunchInfo::SBLaunchInfo (const char **argv) :
+    m_opaque_sp(new ProcessLaunchInfo())
+{
+    m_opaque_sp->GetFlags().Reset (eLaunchFlagDebug | eLaunchFlagDisableASLR);
+    if (argv && argv[0])
+        m_opaque_sp->GetArguments().SetArguments(argv);
+}
+
+SBLaunchInfo::~SBLaunchInfo()
+{
+}
+
+lldb_private::ProcessLaunchInfo &
+SBLaunchInfo::ref ()
+{
+    return *m_opaque_sp;
+}
+
+lldb::pid_t
+SBLaunchInfo::GetProcessID()
+{
+    return m_opaque_sp->GetProcessID();
+}
+
+uint32_t
+SBLaunchInfo::GetUserID()
+{
+    return m_opaque_sp->GetUserID();
+}
+
+uint32_t
+SBLaunchInfo::GetGroupID()
+{
+    return m_opaque_sp->GetGroupID();
+}
+
+bool
+SBLaunchInfo::UserIDIsValid ()
+{
+    return m_opaque_sp->UserIDIsValid();
+}
+
+bool
+SBLaunchInfo::GroupIDIsValid ()
+{
+    return m_opaque_sp->GroupIDIsValid();
+}
+
+void
+SBLaunchInfo::SetUserID (uint32_t uid)
+{
+    m_opaque_sp->SetUserID (uid);
+}
+
+void
+SBLaunchInfo::SetGroupID (uint32_t gid)
+{
+    m_opaque_sp->SetGroupID (gid);
+}
+
+SBFileSpec
+SBLaunchInfo::GetExecutableFile ()
+{
+    return SBFileSpec (m_opaque_sp->GetExecutableFile());
+}
+
+void
+SBLaunchInfo::SetExecutableFile (SBFileSpec exe_file, bool add_as_first_arg)
+{
+    m_opaque_sp->SetExecutableFile(exe_file.ref(), add_as_first_arg);
+}
+
+SBListener
+SBLaunchInfo::GetListener ()
+{
+    return SBListener(m_opaque_sp->GetListener());
+}
+
+void
+SBLaunchInfo::SetListener (SBListener &listener)
+{
+    m_opaque_sp->SetListener(listener.GetSP());
+}
+
+uint32_t
+SBLaunchInfo::GetNumArguments ()
+{
+    return m_opaque_sp->GetArguments().GetArgumentCount();
+}
+
+const char *
+SBLaunchInfo::GetArgumentAtIndex (uint32_t idx)
+{
+    return m_opaque_sp->GetArguments().GetArgumentAtIndex(idx);
+}
+
+void
+SBLaunchInfo::SetArguments (const char **argv, bool append)
+{
+    if (append)
+    {
+        if (argv)
+            m_opaque_sp->GetArguments().AppendArguments(argv);
+    }
+    else
+    {
+        if (argv)
+            m_opaque_sp->GetArguments().SetArguments(argv);
+        else
+            m_opaque_sp->GetArguments().Clear();
+    }
+}
+
+uint32_t
+SBLaunchInfo::GetNumEnvironmentEntries ()
+{
+    return m_opaque_sp->GetEnvironmentEntries().GetArgumentCount();
+}
+
+const char *
+SBLaunchInfo::GetEnvironmentEntryAtIndex (uint32_t idx)
+{
+    return m_opaque_sp->GetEnvironmentEntries().GetArgumentAtIndex(idx);
+}
+
+void
+SBLaunchInfo::SetEnvironmentEntries (const char **envp, bool append)
+{
+    if (append)
+    {
+        if (envp)
+            m_opaque_sp->GetEnvironmentEntries().AppendArguments(envp);
+    }
+    else
+    {
+        if (envp)
+            m_opaque_sp->GetEnvironmentEntries().SetArguments(envp);
+        else
+            m_opaque_sp->GetEnvironmentEntries().Clear();
+    }
+}
+
+void
+SBLaunchInfo::Clear ()
+{
+    m_opaque_sp->Clear();
+}
+
+const char *
+SBLaunchInfo::GetWorkingDirectory () const
+{
+    return m_opaque_sp->GetWorkingDirectory();
+}
+
+void
+SBLaunchInfo::SetWorkingDirectory (const char *working_dir)
+{
+    m_opaque_sp->SetWorkingDirectory(working_dir);
+}
+
+uint32_t
+SBLaunchInfo::GetLaunchFlags ()
+{
+    return m_opaque_sp->GetFlags().Get();
+}
+
+void
+SBLaunchInfo::SetLaunchFlags (uint32_t flags)
+{
+    m_opaque_sp->GetFlags().Reset(flags);
+}
+
+const char *
+SBLaunchInfo::GetProcessPluginName ()
+{
+    return m_opaque_sp->GetProcessPluginName();
+}
+
+void
+SBLaunchInfo::SetProcessPluginName (const char *plugin_name)
+{
+    return m_opaque_sp->SetProcessPluginName (plugin_name);
+}
+
+const char *
+SBLaunchInfo::GetShell ()
+{
+    // Constify this string so that it is saved in the string pool.  Otherwise
+    // it would be freed when this function goes out of scope.
+    ConstString shell(m_opaque_sp->GetShell().GetPath().c_str());
+    return shell.AsCString();
+}
+
+void
+SBLaunchInfo::SetShell (const char * path)
+{
+    m_opaque_sp->SetShell (FileSpec(path, false));
+}
+
+uint32_t
+SBLaunchInfo::GetResumeCount ()
+{
+    return m_opaque_sp->GetResumeCount();
+}
+
+void
+SBLaunchInfo::SetResumeCount (uint32_t c)
+{
+    m_opaque_sp->SetResumeCount (c);
+}
+
+bool
+SBLaunchInfo::AddCloseFileAction (int fd)
+{
+    return m_opaque_sp->AppendCloseFileAction(fd);
+}
+
+bool
+SBLaunchInfo::AddDuplicateFileAction (int fd, int dup_fd)
+{
+    return m_opaque_sp->AppendDuplicateFileAction(fd, dup_fd);
+}
+
+bool
+SBLaunchInfo::AddOpenFileAction (int fd, const char *path, bool read, bool write)
+{
+    return m_opaque_sp->AppendOpenFileAction(fd, path, read, write);
+}
+
+bool
+SBLaunchInfo::AddSuppressFileAction (int fd, bool read, bool write)
+{
+    return m_opaque_sp->AppendSuppressFileAction(fd, read, write);
+}
+
+void
+SBLaunchInfo::SetLaunchEventData (const char *data)
+{
+    m_opaque_sp->SetLaunchEventData (data);
+}
+
+const char *
+SBLaunchInfo::GetLaunchEventData () const
+{
+    return m_opaque_sp->GetLaunchEventData ();
+}
+
+void
+SBLaunchInfo::SetDetachOnError (bool enable)
+{
+    m_opaque_sp->SetDetachOnError (enable);
+}
+
+bool
+SBLaunchInfo::GetDetachOnError () const
+{
+    return m_opaque_sp->GetDetachOnError ();
+}

source/API/SBPlatform.cpp

 const char *
 SBPlatformShellCommand::GetWorkingDirectory ()
 {
     if (m_opaque_ptr->m_working_dir.empty())
         return NULL;
     return m_opaque_ptr->m_working_dir.c_str();
 }
 
+
 void
 SBPlatformShellCommand::SetWorkingDirectory (const char *path)
 {
     if (path && path[0])
         m_opaque_ptr->m_working_dir = path;
     else
         m_opaque_ptr->m_working_dir.clear();
 }

 SBPlatformShellCommand::GetOutput ()
 {
     if (m_opaque_ptr->m_output.empty())
         return NULL;
     return m_opaque_ptr->m_output.c_str();
 }
 
 //----------------------------------------------------------------------
 // SBPlatform
 //----------------------------------------------------------------------
 SBPlatform::SBPlatform () :
     m_opaque_sp ()
 {
     
 }
 
 SBPlatform::SBPlatform (const char *platform_name) :
     m_opaque_sp ()
 {
     Error error;
     if (platform_name && platform_name[0])
         m_opaque_sp = Platform::Create (ConstString(platform_name), error);
 }
 
 SBPlatform::~SBPlatform()
 {
 }
 
 bool
 SBPlatform::IsValid () const
 {
     return m_opaque_sp.get() != NULL;
 }
 
 void
 SBPlatform::Clear ()
 {
     m_opaque_sp.reset();
 }
 
 const char *
 SBPlatform::GetName ()
 {
     PlatformSP platform_sp(GetSP());
     if (platform_sp)
         return platform_sp->GetName().GetCString();
     return NULL;
 }
 
 lldb::PlatformSP
 SBPlatform::GetSP () const
 {
     return m_opaque_sp;
 }
 
 void
 SBPlatform::SetSP (const lldb::PlatformSP& platform_sp)
 {
     m_opaque_sp = platform_sp;
SBPlatform::Get (SBFileSpec &src,
     }
     return sb_error;
 }
 
 SBError
 SBPlatform::Put (SBFileSpec &src,
                  SBFileSpec &dst)
 {
-    SBError sb_error;
-    
-    PlatformSP platform_sp(GetSP());
-    if (platform_sp)
+  return ExecuteConnected(
+      [&](const lldb::PlatformSP& platform_sp)
       {
           if (src.Exists())
           {
               uint32_t permissions = src.ref().GetPermissions();
               if (permissions == 0)
               {
                   if (src.ref().GetFileType() == FileSpec::eFileTypeDirectory)
                       permissions = eFilePermissionsDirectoryDefault;
                   else
                       permissions = eFilePermissionsFileDefault;
               }
 
-            sb_error.ref() = platform_sp->PutFile(src.ref(),
-                                                  dst.ref(),
-                                                  permissions);
-        }
-        else
-        {
-            sb_error.ref().SetErrorStringWithFormat("'src' argument doesn't exist: '%s'", src.ref().GetPath().c_str());
+              return platform_sp->PutFile(src.ref(), dst.ref(), permissions);
           }
-    }
-    else
-    {
-        sb_error.SetErrorString("invalid platform");
-    }
-    return sb_error;
+
+          Error error;
+          error.SetErrorStringWithFormat("'src' argument doesn't exist: '%s'", src.ref().GetPath().c_str());
+          return error;
+      });
 }
 
 SBError
 SBPlatform::Install (SBFileSpec &src,
                      SBFileSpec &dst)
 {
-    SBError sb_error;
-    PlatformSP platform_sp(GetSP());
-    if (platform_sp)
+  return ExecuteConnected(
+      [&](const lldb::PlatformSP& platform_sp)
       {
           if (src.Exists())
-        {
-            sb_error.ref() = platform_sp->Install(src.ref(), dst.ref());
-        }
-        else
-        {
-            sb_error.ref().SetErrorStringWithFormat("'src' argument doesn't exist: '%s'", src.ref().GetPath().c_str());
-        }
-    }
-    else
-    {
-        sb_error.SetErrorString("invalid platform");
-    }
-    return sb_error;
+              return platform_sp->Install(src.ref(), dst.ref());
+
+          Error error;
+          error.SetErrorStringWithFormat("'src' argument doesn't exist: '%s'", src.ref().GetPath().c_str());
+          return error;
+      });
 }
 
 
 SBError
 SBPlatform::Run (SBPlatformShellCommand &shell_command)
 {
-    SBError sb_error;
-    PlatformSP platform_sp(GetSP());
-    if (platform_sp)
-    {
-        if (platform_sp->IsConnected())
+    return ExecuteConnected(
+        [&](const lldb::PlatformSP& platform_sp)
         {
             const char *command = shell_command.GetCommand();
-            if (command)
-            {
-                const char *working_dir = shell_command.GetWorkingDirectory();
-                if (working_dir == NULL)
-                {
-                    working_dir = platform_sp->GetWorkingDirectory().GetCString();
-                    if (working_dir)
-                        shell_command.SetWorkingDirectory(working_dir);
-                }
-                sb_error.ref() = platform_sp->RunShellCommand(command,
-                                                              working_dir,
-                                                              &shell_command.m_opaque_ptr->m_status,
-                                                              &shell_command.m_opaque_ptr->m_signo,
-                                                              &shell_command.m_opaque_ptr->m_output,
-                                                              shell_command.m_opaque_ptr->m_timeout_sec);
-            }
-            else
-            {
-                sb_error.SetErrorString("invalid shell command (empty)");
-            }
-        }
-        else
-        {
+            if (!command)
+                return Error("invalid shell command (empty)");
+
+            return platform_sp->RunShellCommand(command,
+        });
+
+SBError
+SBPlatform::Launch (SBLaunchInfo &launch_info)
+    return ExecuteConnected(
+        [&](const lldb::PlatformSP& platform_sp)
+        {
+            return platform_sp->LaunchProcess(launch_info.ref());
+        });
+
+SBError
+SBPlatform::Kill (const lldb::pid_t pid)
+{
+    return ExecuteConnected(
+        [&](const lldb::PlatformSP& platform_sp)
+        {
+            return platform_sp->KillProcess(pid);
+        });
+
+SBError
+SBPlatform::ExecuteConnected (const std::function<Error(const lldb::PlatformSP&)>& func)
+{
+    SBError sb_error;
+    const auto platform_sp(GetSP());
+    if (platform_sp)
+        if (platform_sp->IsConnected())
+            sb_error.ref() = func(platform_sp);
+        else
             sb_error.SetErrorString("not connected");
-        }
-    }
     else
-    {
         sb_error.SetErrorString("invalid platform");
-    }
-    return sb_error;
+
 }
 
 SBError
 SBPlatform::MakeDirectory (const char *path, uint32_t file_permissions)
 {
     SBError sb_error;
     PlatformSP platform_sp(GetSP());
     if (platform_sp)

source/API/SBTarget.cpp

 #include "llvm/Support/Regex.h"
 
 
 using namespace lldb;
 using namespace lldb_private;
 
 #define DEFAULT_DISASM_BYTE_SIZE 32
 
-SBLaunchInfo::SBLaunchInfo (const char **argv) : 
-    m_opaque_sp(new ProcessLaunchInfo())
-{
-    m_opaque_sp->GetFlags().Reset (eLaunchFlagDebug | eLaunchFlagDisableASLR);
-    if (argv && argv[0])
-        m_opaque_sp->GetArguments().SetArguments(argv);
-}
-
-SBLaunchInfo::~SBLaunchInfo()
-{
-}
-
-lldb_private::ProcessLaunchInfo &
-SBLaunchInfo::ref ()
-{
-    return *m_opaque_sp;
-}
-
-
-uint32_t
-SBLaunchInfo::GetUserID()
-{
-    return m_opaque_sp->GetUserID();
-}
-
-uint32_t
-SBLaunchInfo::GetGroupID()
-{
-    return m_opaque_sp->GetGroupID();
-}
-
-bool
-SBLaunchInfo::UserIDIsValid ()
-{
-    return m_opaque_sp->UserIDIsValid();
-}
-
-bool
-SBLaunchInfo::GroupIDIsValid ()
-{
-    return m_opaque_sp->GroupIDIsValid();
-}
-
-void
-SBLaunchInfo::SetUserID (uint32_t uid)
-{
-    m_opaque_sp->SetUserID (uid);
-}
-
-void
-SBLaunchInfo::SetGroupID (uint32_t gid)
-{
-    m_opaque_sp->SetGroupID (gid);
-}
-
-SBFileSpec
-SBLaunchInfo::GetExecutableFile ()
-{
-    return SBFileSpec (m_opaque_sp->GetExecutableFile());
-}
-
-void
-SBLaunchInfo::SetExecutableFile (SBFileSpec exe_file, bool add_as_first_arg)
-{
-    m_opaque_sp->SetExecutableFile(exe_file.ref(), add_as_first_arg);
-}
-
-SBListener
-SBLaunchInfo::GetListener ()
-{
-    return SBListener(m_opaque_sp->GetListener());
-}
-
-void
-SBLaunchInfo::SetListener (SBListener &listener)
-{
-    m_opaque_sp->SetListener(listener.GetSP());
-}
-
-uint32_t
-SBLaunchInfo::GetNumArguments ()
-{
-    return m_opaque_sp->GetArguments().GetArgumentCount();
-}
-
-const char *
-SBLaunchInfo::GetArgumentAtIndex (uint32_t idx)
-{
-    return m_opaque_sp->GetArguments().GetArgumentAtIndex(idx);
-}
-
-void
-SBLaunchInfo::SetArguments (const char **argv, bool append)
-{
-    if (append)
-    {
-        if (argv)
-            m_opaque_sp->GetArguments().AppendArguments(argv);
-    }
-    else
-    {
-        if (argv)
-            m_opaque_sp->GetArguments().SetArguments(argv);
-        else
-            m_opaque_sp->GetArguments().Clear();
-    }
-}
-
-uint32_t
-SBLaunchInfo::GetNumEnvironmentEntries ()
-{
-    return m_opaque_sp->GetEnvironmentEntries().GetArgumentCount();
-}
-
-const char *
-SBLaunchInfo::GetEnvironmentEntryAtIndex (uint32_t idx)
-{
-    return m_opaque_sp->GetEnvironmentEntries().GetArgumentAtIndex(idx);
-}
-
-void
-SBLaunchInfo::SetEnvironmentEntries (const char **envp, bool append)
-{
-    if (append)
-    {
-        if (envp)
-            m_opaque_sp->GetEnvironmentEntries().AppendArguments(envp);
-    }
-    else
-    {
-        if (envp)
-            m_opaque_sp->GetEnvironmentEntries().SetArguments(envp);
-        else
-            m_opaque_sp->GetEnvironmentEntries().Clear();
-    }
-}
-
-void
-SBLaunchInfo::Clear ()
-{
-    m_opaque_sp->Clear();
-}
-
-const char *
-SBLaunchInfo::GetWorkingDirectory () const
-{
-    return m_opaque_sp->GetWorkingDirectory();
-}
-
-void
-SBLaunchInfo::SetWorkingDirectory (const char *working_dir)
-{
-    m_opaque_sp->SetWorkingDirectory(working_dir);
-}
-
-uint32_t
-SBLaunchInfo::GetLaunchFlags ()
-{
-    return m_opaque_sp->GetFlags().Get();
-}
-
-void
-SBLaunchInfo::SetLaunchFlags (uint32_t flags)
-{
-    m_opaque_sp->GetFlags().Reset(flags);
-}
-
-const char *
-SBLaunchInfo::GetProcessPluginName ()
-{
-    return m_opaque_sp->GetProcessPluginName();
-}
-
-void
-SBLaunchInfo::SetProcessPluginName (const char *plugin_name)
-{
-    return m_opaque_sp->SetProcessPluginName (plugin_name);
-}
-
-const char *
-SBLaunchInfo::GetShell ()
-{
-    // Constify this string so that it is saved in the string pool.  Otherwise
-    // it would be freed when this function goes out of scope.
-    ConstString shell(m_opaque_sp->GetShell().GetPath().c_str());
-    return shell.AsCString();
-}
-
-void
-SBLaunchInfo::SetShell (const char * path)
-{
-    m_opaque_sp->SetShell (FileSpec(path, false));
-}
-
-uint32_t
-SBLaunchInfo::GetResumeCount ()
-{
-    return m_opaque_sp->GetResumeCount();
-}
-
-void
-SBLaunchInfo::SetResumeCount (uint32_t c)
-{
-    m_opaque_sp->SetResumeCount (c);
-}
-
-bool
-SBLaunchInfo::AddCloseFileAction (int fd)
-{
-    return m_opaque_sp->AppendCloseFileAction(fd);
-}
-
-bool
-SBLaunchInfo::AddDuplicateFileAction (int fd, int dup_fd)
-{
-    return m_opaque_sp->AppendDuplicateFileAction(fd, dup_fd);
-}
-
-bool
-SBLaunchInfo::AddOpenFileAction (int fd, const char *path, bool read, bool write)
-{
-    return m_opaque_sp->AppendOpenFileAction(fd, path, read, write);
-}
-
-bool
-SBLaunchInfo::AddSuppressFileAction (int fd, bool read, bool write)
-{
-    return m_opaque_sp->AppendSuppressFileAction(fd, read, write);
-}
-
-void
-SBLaunchInfo::SetLaunchEventData (const char *data)
-{
-    m_opaque_sp->SetLaunchEventData (data);
-}
-
-const char *
-SBLaunchInfo::GetLaunchEventData () const
-{
-    return m_opaque_sp->GetLaunchEventData ();
-}
-
-void
-SBLaunchInfo::SetDetachOnError (bool enable)
-{
-    m_opaque_sp->SetDetachOnError (enable);
-}
-
-bool
-SBLaunchInfo::GetDetachOnError () const
-{
-    return m_opaque_sp->GetDetachOnError ();
-}
 
 SBAttachInfo::SBAttachInfo () :
     m_opaque_sp (new ProcessAttachInfo())
 {
 }
 
 SBAttachInfo::SBAttachInfo (lldb::pid_t pid) :
     m_opaque_sp (new ProcessAttachInfo())

source/CMakeLists.txt

add_lldb_library(liblldb SHARED
   API/SBExpressionOptions.cpp
   API/SBFileSpec.cpp
   API/SBFileSpecList.cpp
   API/SBFrame.cpp
   API/SBFunction.cpp
   API/SBHostOS.cpp
   API/SBInstruction.cpp
   API/SBInstructionList.cpp
+  API/SBLaunchInfo.cpp
   API/SBLineEntry.cpp
   API/SBListener.cpp
   API/SBModule.cpp
   API/SBModuleSpec.cpp
   API/SBPlatform.cpp
   API/SBProcess.cpp
   API/SBQueue.cpp
   API/SBQueueItem.cpp

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

GetProcessInfo (lldb::pid_t pid,
                     lldb_private::ProcessInstanceInfo &proc_info);
     
     virtual uint32_t
     FindProcesses (const lldb_private::ProcessInstanceInfoMatch &match_info,
                    lldb_private::ProcessInstanceInfoList &process_infos);
 
     virtual lldb_private::Error
     LaunchProcess (lldb_private::ProcessLaunchInfo &launch_info);
-    
+    virtual lldb_private::Error
+    KillProcess (const lldb::pid_t pid);
+
     virtual lldb::ProcessSP
     DebugProcess (lldb_private::ProcessLaunchInfo &launch_info,
                   lldb_private::Debugger &debugger,
                   lldb_private::Target *target,       // Can be NULL, if NULL create a new target, else use existing one
                   lldb_private::Error &error);
 
     virtual lldb::ProcessSP
     Attach (lldb_private::ProcessAttachInfo &attach_info,

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

 }
 
 
 Error
 PlatformRemoteGDBServer::LaunchProcess (ProcessLaunchInfo &launch_info)
 {
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PLATFORM));
     Error error;
-    lldb::pid_t pid = LLDB_INVALID_PROCESS_ID;
 
     if (log)
         log->Printf ("PlatformRemoteGDBServer::%s() called", __FUNCTION__);
 
-    m_gdb_client.SetSTDIN ("/dev/null");
-    m_gdb_client.SetSTDOUT ("/dev/null");
-    m_gdb_client.SetSTDERR ("/dev/null");
+    auto num_file_actions = launch_info.GetNumFileActions ();
+    for (decltype(num_file_actions) i = 0; i < num_file_actions; ++i)
+    {
+        const auto file_action = launch_info.GetFileActionAtIndex (i);
+        if (file_action->GetAction () != FileAction::eFileActionOpen)
+            continue;
+        switch(file_action->GetFD())
+        {
+        case STDIN_FILENO:
+            m_gdb_client.SetSTDIN (file_action->GetPath());
+            break;
+        case STDOUT_FILENO:
+            m_gdb_client.SetSTDOUT (file_action->GetPath());
+            break;
+        case STDERR_FILENO:
+            m_gdb_client.SetSTDERR (file_action->GetPath());
+            break;
+        }
+    }
+
     m_gdb_client.SetDisableASLR (launch_info.GetFlags().Test (eLaunchFlagDisableASLR));
     m_gdb_client.SetDetachOnError (launch_info.GetFlags().Test (eLaunchFlagDetachOnError));
     
     const char *working_dir = launch_info.GetWorkingDirectory();
     if (working_dir && working_dir[0])
     {
         m_gdb_client.SetWorkingDir (working_dir);
     }
PlatformRemoteGDBServer::LaunchProcess (ProcessLaunchInfo &launch_info)
     const uint32_t old_packet_timeout = m_gdb_client.SetPacketTimeout (5);
     int arg_packet_err = m_gdb_client.SendArgumentsPacket (launch_info);
     m_gdb_client.SetPacketTimeout (old_packet_timeout);
     if (arg_packet_err == 0)
     {
         std::string error_str;
         if (m_gdb_client.GetLaunchSuccess (error_str))
         {
-            pid = m_gdb_client.GetCurrentProcessID ();
+            const auto pid = m_gdb_client.GetCurrentProcessID (false);
             if (pid != LLDB_INVALID_PROCESS_ID)
             {
                 launch_info.SetProcessID (pid);
                 if (log)
                     log->Printf ("PlatformRemoteGDBServer::%s() pid %" PRIu64 " launched successfully", __FUNCTION__, pid);
             }
             else
             {
                 if (log)
                     log->Printf ("PlatformRemoteGDBServer::%s() launch succeeded but we didn't get a valid process id back!", __FUNCTION__);
-                // FIXME isn't this an error condition? Do we need to set an error here?  Check with Greg.
+                error.SetErrorString ("failed to get PID");
             }
         }
         else
         {
             error.SetErrorString (error_str.c_str());
             if (log)
                 log->Printf ("PlatformRemoteGDBServer::%s() launch failed: %s", __FUNCTION__, error.AsCString ());
         }
     }
     else
     {
         error.SetErrorStringWithFormat("'A' packet returned an error: %i", arg_packet_err);
     }
     return error;
 }
 
+Error
+PlatformRemoteGDBServer::KillProcess (const lldb::pid_t pid)
+{
+    if (!m_gdb_client.KillSpawnedProcess(pid))
+        return Error("failed to kill remote spawned process");
+    return Error();
+}
+
 lldb::ProcessSP
 PlatformRemoteGDBServer::DebugProcess (lldb_private::ProcessLaunchInfo &launch_info,
                                        lldb_private::Debugger &debugger,
                                        lldb_private::Target *target,       // Can be NULL, if NULL create a new target, else use existing one
                                        lldb_private::Error &error)
 {
     lldb::ProcessSP process_sp;
     if (IsRemote())

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

public:
     SendAsyncSignal (int signo);
 
     bool
     SendInterrupt (lldb_private::Mutex::Locker &locker, 
                    uint32_t seconds_to_wait_for_stop, 
                    bool &timed_out);
 
     lldb::pid_t
-    GetCurrentProcessID ();
+    GetCurrentProcessID (bool allow_lazy = true);
 
     bool
     GetLaunchSuccess (std::string &error_str);
 
     uint16_t
     LaunchGDBserverAndGetPort (lldb::pid_t &pid, const char *remote_accept_hostname);
     
     bool

 protected:
 
     PacketResult
     SendPacketAndWaitForResponseNoLock (const char *payload,
                                         size_t payload_length,
                                         StringExtractorGDBRemote &response);
 
     bool
-    GetCurrentProcessInfo ();
+    GetCurrentProcessInfo (bool allow_lazy_pid = true);
 
     bool
     GetGDBServerVersion();
 
     //------------------------------------------------------------------
     // Classes that inherit from GDBRemoteCommunicationClient can see and modify these
     //------------------------------------------------------------------
     lldb_private::LazyBool m_supports_not_sending_acks;

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

)
     {
         if (log)
             log->Printf ("SendInterrupt () - not running");
     }
     return true;
 }
 
 lldb::pid_t
-GDBRemoteCommunicationClient::GetCurrentProcessID ()
+GDBRemoteCommunicationClient::GetCurrentProcessID (bool allow_lazy)
 {
-    if (m_curr_pid_is_valid == eLazyBoolYes)
+    if (allow_lazy && m_curr_pid_is_valid == eLazyBoolYes)
         return m_curr_pid;
     
     // First try to retrieve the pid via the qProcessInfo request.
-    GetCurrentProcessInfo ();
+    GetCurrentProcessInfo (allow_lazy);
     if (m_curr_pid_is_valid == eLazyBoolYes)
     {
         // We really got it.
         return m_curr_pid;
     }
     else
     {
         // If we don't get a response for qProcessInfo, check if $qC gives us a result.
if (m_supports_qProcessInfoPID)
             m_supports_qProcessInfoPID = false;
             return false;
         }
     }
     return false;
 }
 
 bool
-GDBRemoteCommunicationClient::GetCurrentProcessInfo ()
+GDBRemoteCommunicationClient::GetCurrentProcessInfo (bool allow_lazy)
 {
     Log *log (ProcessGDBRemoteLog::GetLogIfAnyCategoryIsSet (GDBR_LOG_PROCESS | GDBR_LOG_PACKETS));
 
+    if (allow_lazy)
+    {
         if (m_qProcessInfo_is_valid == eLazyBoolYes)
             return true;
         if (m_qProcessInfo_is_valid == eLazyBoolNo)
             return false;
+    }
 
     GetHostInfo ();
 
     StringExtractorGDBRemote response;
     if (SendPacketAndWaitForResponse ("qProcessInfo", response, false) == PacketResult::Success)
     {
         if (response.IsNormalResponse())
         {

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

if (!error.Success ())
         fprintf (stderr, "%s: failed to launch executable %s", __FUNCTION__, m_process_launch_info.GetArguments ().GetArgumentAtIndex (0));
         return error;
     }
 
     printf ("Launched '%s' as process %" PRIu64 "...\n", m_process_launch_info.GetArguments ().GetArgumentAtIndex (0), m_process_launch_info.GetProcessID());
 
     // add to list of spawned processes.  On an lldb-gdbserver, we
     // would expect there to be only one.
-    lldb::pid_t pid;
-    if ( (pid = m_process_launch_info.GetProcessID()) != LLDB_INVALID_PROCESS_ID )
+    const auto pid = m_process_launch_info.GetProcessID();
+    if (pid != LLDB_INVALID_PROCESS_ID)
     {
         // add to spawned pids
-        {
-            Mutex::Locker locker (m_spawned_pids_mutex);
-            m_spawned_pids.insert(pid);
-        }
-    }
 
     return error;
 }
 
 lldb_private::Error
 GDBRemoteCommunicationServer::AttachToProcess (lldb::pid_t pid)
 {
     Error error;
#endif
     }
 
 }
 
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServer::Handle_qProcessInfo (StringExtractorGDBRemote &packet)
 {
-    // Only the gdb server handles this.
-    if (!IsGdbServer ())
-        return SendUnimplementedResponse (packet.GetStringRef ().c_str ());
-    
+    lldb::pid_t pid = LLDB_INVALID_PROCESS_ID;
+    if (IsGdbServer ())
+    {
         // Fail if we don't have a current process.
         if (!m_debugged_process_sp || (m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID))
             return SendErrorResponse (68);
-    
-    ProcessInstanceInfo proc_info;
-    if (Host::GetProcessInfo (m_debugged_process_sp->GetID (), proc_info))
+        pid = m_debugged_process_sp->GetID ();
+    }
+    else if (m_is_platform)
     {
-        StreamString response;
-        CreateProcessInfoResponse_DebugServerStyle(proc_info, response);
-        return SendPacketNoLock (response.GetData (), response.GetSize ());
+        pid = m_process_launch_info.GetProcessID ();
     }
-    
+    else
+        return SendUnimplementedResponse (packet.GetStringRef ().c_str ());
+    if (pid == LLDB_INVALID_PROCESS_ID)
         return SendErrorResponse (1);
+
+    ProcessInstanceInfo proc_info;
+    if (!Host::GetProcessInfo (pid, proc_info))
+        return SendErrorResponse (1);
+
+    StreamString response;
+    CreateProcessInfoResponse_DebugServerStyle(proc_info, response);
+    return SendPacketNoLock (response.GetData (), response.GetSize ());
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServer::Handle_qProcessInfoPID (StringExtractorGDBRemote &packet)
 {
     // Packet format: "qProcessInfoPID:%i" where %i is the pid
     packet.SetFilePos(::strlen ("qProcessInfoPID:"));
     lldb::pid_t pid = packet.GetU32 (LLDB_INVALID_PROCESS_ID);

source/Target/Platform.cpp

if (IsHost())
 
         error = Host::LaunchProcess (launch_info);
     }
     else
         error.SetErrorString ("base lldb_private::Platform class can't launch remote processes");
     return error;
 }
 
+Error
+Platform::KillProcess (const lldb::pid_t pid)
+{
+    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PLATFORM));
+    if (log)
+        log->Printf ("Platform::%s, pid %" PRIu64, __FUNCTION__, pid);
+
+    if (!IsHost ())
+        return Error ("base lldb_private::Platform class can't launch remote processes");
+
+    Host::Kill (pid, SIGTERM);
+    return Error();
+}
+
 lldb::ProcessSP
 Platform::DebugProcess (ProcessLaunchInfo &launch_info, 
                         Debugger &debugger,
                         Target *target,       // Can be NULL, if NULL create a new target, else use existing one
                         Error &error)
 {
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PLATFORM));
     if (log)

test/lldbtest.py

 ........................................................................
 ----------------------------------------------------------------------
 Ran 72 tests in 135.468s
 
 OK
 $ 
 """
 
+import abc
 import os, sys, traceback
 import os.path
 import re
 import signal
 from subprocess import *
 import StringIO
 import time
 import types
 import unittest2
 import lldb
+from _pyio import __metaclass__
 
 # See also dotest.parseOptionsAndInitTestdirs(), where the environment variables
 # LLDB_COMMAND_TRACE and LLDB_DO_CLEANUP are set from '-t' and '-r dir' options.
 
 # By default, traceAlways is False.
 if "LLDB_COMMAND_TRACE" in os.environ and os.environ["LLDB_COMMAND_TRACE"]=="YES":
     traceAlways = True
 else:
def __exit__(self, type, value, tb):
         recordings to our session object.  And close the StringIO object, too.
         """
         if self.trace:
             print >> sys.stderr, self.getvalue()
         if self.session:
             print >> self.session, self.getvalue()
         self.close()
 
+class _BaseProcess(object):
+    __metaclass__ = abc.ABCMeta
+
+    @abc.abstractproperty
+    def pid(self):
+        """Returns process PID if has been launched already."""
+
+    @abc.abstractmethod
+    def launch(self, executable, args):
+        """Launches new process with given executable and args."""
+
+    @abc.abstractmethod
+    def terminate(self):
+        """Terminates previously launched process.."""
+
+class _LocalProcess(_BaseProcess):
+
+    def __init__(self, trace_on):
+        self._proc = None
+        self._trace_on = trace_on
+
+    @property
+    def pid(self):
+        return self._proc.pid
+
+    def launch(self, executable, args):
+        self._proc = Popen([executable] + args,
+                           stdout = open(os.devnull) if not self._trace_on else None,
+                           stdin = PIPE)
+
+    def terminate(self):
+        if self._proc.poll() == None:
+            self._proc.terminate()
+
+class _RemoteProcess(_BaseProcess):
+
+    def __init__(self):
+        self._pid = None
+
+    @property
+    def pid(self):
+        return self._pid
+
+    def launch(self, executable, args):
+        remote_work_dir = lldb.remote_platform.GetWorkingDirectory()
+        src_path = executable
+        dst_path = os.path.join(remote_work_dir, os.path.basename(executable))
+
+        dst_file_spec = lldb.SBFileSpec(dst_path, False)
+        err = lldb.remote_platform.Install(lldb.SBFileSpec(src_path, True),
+                                           dst_file_spec)
+        if err.Fail():
+            raise Exception("remote_platform.Install('%s', '%s') failed: %s" % (src_path, dst_path, err))
+
+        launch_info = lldb.SBLaunchInfo(args)
+        launch_info.SetExecutableFile(dst_file_spec, True)
+        launch_info.SetWorkingDirectory(remote_work_dir)
+
+        # Redirect stdout and stderr to /dev/null
+        launch_info.AddSuppressFileAction(1, False, True)
+        launch_info.AddSuppressFileAction(2, False, True)
+
+        err = lldb.remote_platform.Launch(launch_info)
+        if err.Fail():
+            raise Exception("remote_platform.Launch('%s', '%s') failed: %s" % (dst_path, args, err))
+        self._pid = launch_info.GetProcessID()
+
+    def terminate(self):
+        err = lldb.remote_platform.Kill(self._pid)
+        if err.Fail():
+            raise Exception("remote_platform.Kill(%d) failed: %s" % (self._pid, err))
+
 # From 2.7's subprocess.check_output() convenience function.
 # Return a tuple (stdoutdata, stderrdata).
 def system(commands, **kwargs):
     r"""Run an os command with arguments and return its output as a byte string.
 
     If the exit code was non-zero it raises a CalledProcessError.  The
     CalledProcessError object will have the return code in the returncode
     attribute and output in the output attribute.
def setAsync(self, value):
         """ Sets async mode to True/False and ensures it is reset after the testcase completes."""
         old_async = self.dbg.GetAsync()
         self.dbg.SetAsync(value)
         self.addTearDownHook(lambda: self.dbg.SetAsync(old_async))
 
     def cleanupSubprocesses(self):
         # Ensure any subprocesses are cleaned up
         for p in self.subprocesses:
-            if p.poll() == None:
-                p.terminate()
             del p
         del self.subprocesses[:]
         # Ensure any forked processes are cleaned up
         for pid in self.forkedProcessPids:
             if os.path.exists("/proc/" + str(pid)):
                 os.kill(pid, signal.SIGTERM)
 
     def spawnSubprocess(self, executable, args=[]):
         """ Creates a subprocess.Popen object with the specified executable and arguments,
             saves it in self.subprocesses, and returns the object.
             NOTE: if using this function, ensure you also call:
 
               self.addTearDownHook(self.cleanupSubprocesses)
 
             otherwise the test suite will leak processes.
         """
-
-        # Don't display the stdout if not in TraceOn() mode.
-        proc = Popen([executable] + args,
-                     stdout = open(os.devnull) if not self.TraceOn() else None,
-                     stdin = PIPE)
+        proc = _RemoteProcess() if lldb.remote_platform else _LocalProcess(self.TraceOn())
+        proc.launch(executable, args)
         self.subprocesses.append(proc)
         return proc
 
     def forkSubprocess(self, executable, args=[]):
         """ Fork a subprocess with its own group ID.
             NOTE: if using this function, ensure you also call:
 
               self.addTearDownHook(self.cleanupSubprocesses)