Refactor many file functions to use FileSpec over strings.

[chaoren]

Summary

This should solve the issue of sending denormalized paths over gdb-remote
if we stick to GetPath(false) in GDBRemoteCommunicationClient, and let the
server handle any denormalization.

[chaoren]

This change is not very complicated, but spans over many many files. This is sort of a rough draft before I spend more time testing/fixing it on all platforms.

[clayborg]

So I stopped looking, but the following fixes need to be made:

• don't remove spaces between function names and the first paren
• when using FileSpec::GetPath().c_str(), you must use that on a single line for a function call, or store the result in a local std::string. There are many places where you do:

const char *s = my_spec.GetPath().c_str(); // s contains a reference to freed memory

foo(s); // Can crash due to "s" containing questionable contents.

include/lldb/Target/Platform.h

254–264

Revert these space removals?

source/API/SBLaunchInfo.cpp

178–179

This is a crasher waiting to happen. You can't make a temp std::string and then call c_str() on it, the storage will go away. The only way to hand out "const char *" via the API is to make it a ConstString() so it gets uniqued and stored permanently in the string pool:

return ConstString(m_opaque_sp->GetWorkingDirectory().GetPath()).GetCString();

Once a string is in the constant string pool it never gets removed, so the above approach is the way to do it.

source/API/SBPlatform.cpp

321–324

This will crash. Fix it like in SBLaunchInfo::GetWorkingDirectory().

546–547

You need to store the path into a std::string so the storage doesn't go away otherwise the "GetPath()" temporary will clean itself up after this. You might have seen this pattern elsewhere as:

call_some_function(my_spec.GetPath().c_str(), ...);

This pattern is OK because the temporary will live until after the function call. But if you use two separate calls in separate expression statements, then you can't.

source/Host/common/Host.cpp

846–847

Can crash. Please store in local std::string:

std::string working_dir = launch_info.GetWorkingDirectory().GetPath();

Then use as "working_dir.c_str()".

source/Host/macosx/Host.mm

416

Note this is ok hello use working_dir.GetPath().c_str() as C++ will keep the temp around for the duration of the "Printf()" call.

[zturner]

In D9728#172126, @clayborg wrote:

So I stopped looking, but the following fixes need to be made:

• don't remove spaces between function names and the first paren

I thought we removed the part from the coding standard about putting a space between the function name and the first parenthesis. Unless you just mean "Don't introduce unnecessary churn to remove spaces unless you're already editing the signature of the function anyway"

[clayborg]

Zachary: yes that was my point. There were functions above and below that still had spaces and only a few were fixed. We should fix these kinds of things in separate patches and if we fix one, we should fix them all.

[zturner]

Ok, cool. Just making sure. Agree we shouldn't be changing things for
style issues alone.

[chaoren]

Address review comments.

[chaoren]

CreateProcessA should take NULL instead of empty string.

[clayborg]

Just one place to fix the need to not have to make a string into a ConstString when passing it to ProcessMonitor constructor. See inlined comment.

source/Plugins/Process/POSIX/ProcessPOSIX.cpp

203

You shouldn't need to constify this string. If ProcessMonitor takes "const char *" args, it should be making copies of the strings in std::string buffers if needed, and not assuming the storage for the strings will stay around.

[clayborg]

See previous comment for change request reasons.

[chaoren]

source/Plugins/Process/POSIX/ProcessPOSIX.cpp

203

Unfortunately, ProcessMonitor simply passes working_dir to LaunchArgs, which then just assigns it directly to m_working_dir to be used later. I'm going to convert ProcessMonitor/LaunchArgs to use FileSpecs too.

[chaoren]

• Convert ProcessMonitor, FileAction, etc to use FileSpecs as well.

[chaoren]

source/Host/common/Host.cpp

685–687

&((*command_output_ptr)[0])

I don't think this has a well defined behavior.

[chaoren]

• Remove undefined behavior of writing to std::string internals.

[chaoren]

• Convert NativeProcessLinux, SetSTD{IN, OUT, ERR}, etc to use FileSpecs.

[chaoren]

• Update ProcessLauncherAndroid to use FileSpecs.

[chaoren]

• Accidentally made LaunchArgs members references.

[ovyalov]

source/Host/common/Host.cpp

687

Could you check for error before assigning?

source/Plugins/Process/Linux/NativeProcessLinux.cpp

1466–1467

Is it guaranteed that path that launch_info.GetWorkingDirectory()} returns is resolved or we need to call working_dir.ResolvePath() ?

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

735

FileSpec{path, true} ?

774

FileSpecMissing repository, expected "{src repository:path ...}" or "{src path repository=...}" in: {src, true}, FileSpecMissing repository, expected "{src repository:path ...}" or "{src path repository=...}" in: {src, false}?

786

FileSpec{path, true}

source/Target/FileAction.cpp

45–51

m_file_spec.GetPath().c_str() returns pointer to a temp std::string object - could you modify method's signature to return std::string? Or remove this method at all since there is GetFileSpec method.

source/Target/Platform.cpp

698

Is it needed to return with error here if (!src_resolved.ResolvePath() || !src_resolved) ?

848

s/error.Success()/src_resolved.ResolvePath() && src_resolved

1513

s/NULL/empty FileSpec

[vharron]

Only got through ProcessPOSIX, will continue later

source/API/SBLaunchInfo.cpp

178–179

If ConstString gets destructed after GetWorkingDirectory () returns, will the memory pointed to by working_dir.GetCString() be freed?

source/API/SBPlatform.cpp

323

If ConstString gets destructed after GetWorkingDirectory () returns, will the memory pointed to by working_dir.GetCString() be freed?

If the memory does get freed, you could probably fix this by switching the GetWorkingDirectory() result to a FileSpec

source/Plugins/Process/Linux/NativeProcessLinux.cpp

1784

Maybe a slight difference in behavior? If working_dir != 0 but working_dir[0]==0, the chdir is skipped?

[chaoren]

source/API/SBLaunchInfo.cpp

178–179

Yes, IIUC from Greg, ConstString uses a global string pool.

source/Plugins/Process/Linux/NativeProcessLinux.cpp

1784

No it's good. FileSpec::operator bool() returns true only when m_filename or m_directory are valid and nonempty.

[chaoren]

• Address review comments. More FileSpecs.

Also added a bunch of FileSpec wrapper functions for convenience.

Note: This diff is only tested and expected to work for Linux. OS X & Windows
are probably broken by this. Will submit another diff tomorrow to address those.

source/Host/common/Host.cpp

687

Done. Also using vector instead because it looks nicer.

source/Plugins/Process/Linux/NativeProcessLinux.cpp

1466–1467

I think it's a good idea to resolve regardless. Done.

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

735

Done.

774

Done and done.

786

Done.

source/Target/FileAction.cpp

45–51

I added FileSpec::GetCString to prevent this kind mistakes once and for all.

source/Target/Platform.cpp

698

Apparently FileSpec::ResolvePath() doesn't actually resolve symlinks, just resolves to an absolute path. I updated FileSystem::Readlink to take FileSpecs.

848

See previous comment.

1513

Done.

[chaoren]

• Minor cleanup to use new FileSpec wrapper functions.
• Fix windows/FileSystem.
• Fix macosx/Host.

[chaoren]

Ping? I've tested this on Linux, FreeBSD, OS X, and Windows with no obvious regression.

[clayborg]

Looks good.

[chaoren]

• resolve_path should be false for mkdir.

[emaste]

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

1188–1191 ↗

(On Diff #26814)

For better or worse Linux/ProcessMonitor.cpp and FreeBSD/ProcessMonitor.cpp are largely identical code, and changes to one should have a corresponding change to the other. I'll commit the FreeBSD version of this change soon.

include/lldb/Host/Host.h

#endif // defined (__APPLE__) || defined (__linux__) || defined (__FreeBSD__) || defined (__GLIBC__) || defined(__NetBSD__)
     //  environment variable replacement, and whatever other
     //  argument magic the platform defines as part of its typical
     //  user experience
     //------------------------------------------------------------------
     static Error
     ShellExpandArguments (ProcessLaunchInfo &launch_info);
     
     static Error
-    RunShellCommand (const char *command,           // Shouldn't be NULL
-                     const char *working_dir,       // Pass NULL to use the current working directory
-                     int *status_ptr,               // Pass NULL if you don't want the process exit status
-                     int *signo_ptr,                // Pass NULL if you don't want the signal that caused the process to exit
-                     std::string *command_output,   // Pass NULL if you don't want the command output
-                     uint32_t timeout_sec,
-                     bool run_in_default_shell = true);
+    RunShellCommand(const char *command,           // Shouldn't be NULL
+                    const FileSpec &working_dir,   // Pass empty FileSpec to use the current working directory
 
     static Error
-    RunShellCommand (const Args& args,
-                     const char *working_dir,       // Pass NULL to use the current working directory
-                     int *status_ptr,               // Pass NULL if you don't want the process exit status
-                     int *signo_ptr,                // Pass NULL if you don't want the signal that caused the process to exit
-                     std::string *command_output,   // Pass NULL if you don't want the command output
-                     uint32_t timeout_sec,
-                     bool run_in_default_shell = true);
+    RunShellCommand(const Args& args,
+                    const FileSpec &working_dir,   // Pass empty FileSpec to use the current working directory
     
     static lldb::DataBufferSP
     GetAuxvData (lldb_private::Process *process);
 
     static lldb::DataBufferSP
     GetAuxvData (lldb::pid_t pid);
 
     static bool

include/lldb/Target/FileAction.h

 //===-- FileAction.h --------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_Target_FileAction_h
 #define liblldb_Target_FileAction_h
 
 #include <string>
+#include "lldb/Host/FileSpec.h"
 
 namespace lldb_private
 {
 
 class FileAction
 {
   public:
     enum Action
     {
         eFileActionNone,
         eFileActionClose,
         eFileActionDuplicate,
         eFileActionOpen
     };
 
     FileAction();
 
     void Clear();
 
     bool Close(int fd);
 
     bool Duplicate(int fd, int dup_fd);
 
-    bool Open(int fd, const char *path, bool read, bool write);
+    bool Open(int fd, const FileSpec &file_spec, bool read, bool write);
 
     int
     GetFD() const
     {
         return m_fd;
     }
 
     Action
     GetAction() const
     {
         return m_action;
     }
 
     int
     GetActionArgument() const
     {
         return m_arg;
     }
 
-    const char *GetPath() const;
+    const char *
+    GetPath() const;
+
+    const FileSpec &
+    GetFileSpec() const;
 
     void
     Dump (Stream &stream) const;
 
   protected:
-    Action m_action;    // The action for this file
-    int m_fd;           // An existing file descriptor
-    int m_arg;          // oflag for eFileActionOpen*, dup_fd for eFileActionDuplicate
-    std::string m_path; // A file path to use for opening after fork or posix_spawn
+    Action m_action;      // The action for this file
+    int m_fd;             // An existing file descriptor
+    int m_arg;            // oflag for eFileActionOpen*, dup_fd for eFileActionDuplicate
+    FileSpec m_file_spec; // A file spec to use for opening after fork or posix_spawn
 };
 
 } // namespace lldb_private
 
 #endif

include/lldb/Target/Platform.h

 // Project includes
 #include "lldb/lldb-private-forward.h"
 #include "lldb/lldb-public.h"
 #include "lldb/Core/ArchSpec.h"
 #include "lldb/Core/ConstString.h"
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Core/UserSettingsController.h"
 #include "lldb/Interpreter/Options.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Host/Mutex.h"
 
 // TODO pull NativeDelegate class out of NativeProcessProtocol so we
 // can just forward ref the NativeDelegate rather than include it here.
 #include "lldb/Host/common/NativeProcessProtocol.h"
 
 namespace lldb_private {
 
//        FindPlugin (Process *process, const ConstString &plugin_name);
         virtual bool
         ResolveRemotePath (const FileSpec &platform_path,
                            FileSpec &resolved_platform_path);
 
         bool
         GetOSVersion (uint32_t &major, 
                       uint32_t &minor, 
                       uint32_t &update);
            
         bool
         SetOSVersion (uint32_t major, 
                       uint32_t minor, 
                       uint32_t update);
 
         bool
         GetOSBuildString (std::string &s);
         
         bool
         GetOSKernelDescription (std::string &s);
 
         // Returns the name of the platform
         ConstString
         GetName ();
 
         virtual const char *
         GetHostname ();
 
//        FindPlugin (Process *process, const ConstString &plugin_name);
         }
 
         // Remote Platform subclasses need to override this function
         virtual ArchSpec
         GetRemoteSystemArchitecture ()
         {
             return ArchSpec(); // Return an invalid architecture
         }
-        
-        virtual ConstString
+        virtual FileSpec
         GetRemoteWorkingDirectory()
         {
             return m_working_dir;
         }
         
         virtual bool
-        SetRemoteWorkingDirectory(const ConstString &path);
+        SetRemoteWorkingDirectory(const FileSpec &working_dir);
 
         virtual const char *
         GetUserName (uint32_t uid);
 
         virtual const char *
         GetGroupName (uint32_t gid);
 
         //------------------------------------------------------------------
//                Error &error) = 0;
         // You may also need to override AddClangModuleCompilationOptions to pass the right Clang flags for your platform.
         virtual bool
         SupportsModules () { return false; }
         
         // Appends the platform-specific options required to find the modules for the current platform.
         virtual void
         AddClangModuleCompilationOptions (Target *target, std::vector<std::string> &options);
 
-        ConstString
-        GetWorkingDirectory ();
-        
+        FileSpec
+        GetWorkingDirectory();
         bool
-        SetWorkingDirectory (const ConstString &path);
-        
+        SetWorkingDirectory(const FileSpec &working_dir);
         // There may be modules that we don't want to find by default for operations like "setting breakpoint by name".
         // The platform will return "true" from this call if the passed in module happens to be one of these.
         
         virtual bool
         ModuleIsExcludedForUnconstrainedSearches (Target &target, const lldb::ModuleSP &module_sp)
         {
             return false;
         }
         
         virtual Error
-        MakeDirectory (const char *path, uint32_t permissions);
-        
+        MakeDirectory(const FileSpec &file_spec, uint32_t permissions);
         virtual Error
-        GetFilePermissions (const char *path, uint32_t &file_permissions);
+        GetFilePermissions(const FileSpec &file_spec, uint32_t &file_permissions);
 
         virtual Error
-        SetFilePermissions (const char *path, uint32_t file_permissions);
+        SetFilePermissions(const FileSpec &file_spec, uint32_t file_permissions);
 
         virtual lldb::user_id_t
         OpenFile (const FileSpec& file_spec,
                   uint32_t flags,
                   uint32_t mode,
                   Error &error)
         {
             return UINT64_MAX;
//                Error &error) = 0;
         
         virtual Error
         PutFile (const FileSpec& source,
                  const FileSpec& destination,
                  uint32_t uid = UINT32_MAX,
                  uint32_t gid = UINT32_MAX);
 
         virtual Error
-        CreateSymlink (const char *src, // The name of the link is in src
-                       const char *dst);// The symlink points to dst
+        CreateSymlink(const FileSpec &src,  // The name of the link is in src
+                      const FileSpec &dst); // The symlink points to dst
 
         //----------------------------------------------------------------------
         /// Install a file or directory to the remote system.
         ///
         /// Install is similar to Platform::PutFile(), but it differs in that if
         /// an application/framework/shared library is installed on a remote
         /// platform and the remote platform requires something to be done to
         /// register the application/framework/shared library, then this extra
//                Error &error) = 0;
 
         virtual size_t
         GetEnvironment (StringList &environment);
         
         virtual bool
         GetFileExists (const lldb_private::FileSpec& file_spec);
         
         virtual Error
-        Unlink (const char *path);
+        Unlink(const FileSpec &file_spec);
 
         virtual uint64_t
         ConvertMmapFlagsToPlatform(unsigned flags);
 
         virtual bool
         GetSupportsRSync ()
         {
             return m_supports_rsync;
//                Error &error) = 0;
         
         virtual lldb_private::OptionGroupOptions *
         GetConnectionOptions (CommandInterpreter& interpreter)
         {
             return NULL;
         }
         
         virtual lldb_private::Error
-        RunShellCommand (const char *command,           // Shouldn't be NULL
-                         const char *working_dir,       // Pass NULL to use the current working directory
-                         int *status_ptr,               // Pass NULL if you don't want the process exit status
-                         int *signo_ptr,                // Pass NULL if you don't want the signal that caused the process to exit
-                         std::string *command_output,   // Pass NULL if you don't want the command output
-                         uint32_t timeout_sec);         // Timeout in seconds to wait for shell program to finish
-        
+        RunShellCommand(const char *command,           // Shouldn't be NULL
+                        const FileSpec &working_dir,   // Pass empty FileSpec to use the current working directory
         virtual void
         SetLocalCacheDirectory (const char* local);
         
         virtual const char*
         GetLocalCacheDirectory ();
         
         virtual std::string
         GetPlatformSpecificConnectionInformation()
protected:
         // being connected. For remote platforms, we might set the version ahead
         // of time before we actually connect and this version might change when
         // we actually connect to a remote platform. For the host platform this
         // will be set to the once we call HostInfo::GetOSVersion().
         bool m_os_version_set_while_connected;
         bool m_system_arch_set_while_connected;
         ConstString m_sdk_sysroot; // the root location of where the SDK files are all located
         ConstString m_sdk_build;
-        ConstString m_working_dir; // The working directory which is used when installing modules that have no install path set
+        FileSpec m_working_dir; // The working directory which is used when installing modules that have no install path set
         std::string m_remote_url;
         std::string m_name;
         uint32_t m_major_os_version;
         uint32_t m_minor_os_version;
         uint32_t m_update_os_version;
         ArchSpec m_system_arch; // The architecture of the kernel or the remote platform
         typedef std::map<uint32_t, ConstString> IDToNameMap;
         Mutex m_mutex; // Mutex for modifying Platform data structures that should only be used for non-reentrant code

include/lldb/Target/ProcessLaunchInfo.h

namespace lldb_private
     //----------------------------------------------------------------------
 
     class ProcessLaunchInfo : public ProcessInfo
     {
     public:
 
         ProcessLaunchInfo ();
 
-        ProcessLaunchInfo (const char *stdin_path,
-                           const char *stdout_path,
-                           const char *stderr_path,
-                           const char *working_directory,
-                           uint32_t launch_flags);
+        ProcessLaunchInfo(const FileSpec &stdin_file_spec,
+                          const FileSpec &stdout_file_spec,
+                          const FileSpec &stderr_file_spec,
+                          const FileSpec &working_dir,
 
         void
         AppendFileAction (const FileAction &info)
         {
             m_file_actions.push_back(info);
         }
 
         bool
         AppendCloseFileAction (int fd);
 
         bool
         AppendDuplicateFileAction (int fd, int dup_fd);
 
         bool
-        AppendOpenFileAction (int fd, const char *path, bool read, bool write);
+        AppendOpenFileAction(int fd, const FileSpec &file_spec,
+                             bool read, bool write);
 
         bool
         AppendSuppressFileAction (int fd, bool read, bool write);
 
         void
         FinalizeFileActions (Target *target,
                              bool default_to_use_pty);
 
public:
         }
 
         const Flags &
         GetFlags () const
         {
             return m_flags;
         }
 
-        const char *
-        GetWorkingDirectory () const;
+        const FileSpec &
+        GetWorkingDirectory() const;
 
         void
-        SetWorkingDirectory (const char *working_dir);
-
-        void
-        SwapWorkingDirectory (std::string &working_dir)
-        {
-            m_working_dir.swap (working_dir);
-        }
+        SetWorkingDirectory(const FileSpec &working_dir);
 
         const char *
         GetProcessPluginName () const;
 
         void
         SetProcessPluginName (const char *plugin);
 
         const FileSpec &
public:
 
         bool
         GetDetachOnError () const
         {
             return m_flags.Test(lldb::eLaunchFlagDetachOnError);
         }
 
     protected:
-        std::string m_working_dir;
+        FileSpec m_working_dir;
         std::string m_plugin_name;
         FileSpec m_shell;
         Flags m_flags;       // Bitwise OR of bits from lldb::LaunchFlags
         std::vector<FileAction> m_file_actions; // File actions for any other files
         std::shared_ptr<lldb_utility::PseudoTerminal> m_pty;
         uint32_t m_resume_count; // How many times do we resume after launching
         Host::MonitorChildProcessCallback m_monitor_callback;
         void *m_monitor_callback_baton;
         bool m_monitor_signals;
         std::string m_event_data; // A string passed to the plugin launch, having no meaning to the upper levels of lldb.
         lldb::ListenerSP m_listener_sp;
         lldb::ListenerSP m_hijack_listener_sp;
     };
 }
 
 #endif // liblldb_ProcessLaunch_Info_h

source/API/SBLaunchInfo.cpp

 SBLaunchInfo::Clear ()
 {
     m_opaque_sp->Clear();
 }
 
 const char *
 SBLaunchInfo::GetWorkingDirectory () const
 {
-    return m_opaque_sp->GetWorkingDirectory();
+    ConstString working_dir{m_opaque_sp->GetWorkingDirectory().GetPath()};
+    return working_dir.GetCString();
 }
 
 void
 SBLaunchInfo::SetWorkingDirectory (const char *working_dir)
 {
-    m_opaque_sp->SetWorkingDirectory(working_dir);
+    m_opaque_sp->SetWorkingDirectory(FileSpec{working_dir, false});
 }
 
 uint32_t
 SBLaunchInfo::GetLaunchFlags ()
 {
     return m_opaque_sp->GetFlags().Get();
 }
 

 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);
+    return m_opaque_sp->AppendOpenFileAction(fd, FileSpec{path, false}, read, write);
 }
 
 bool
 SBLaunchInfo::AddSuppressFileAction (int fd, bool read, bool write)
 {
     return m_opaque_sp->AppendSuppressFileAction(fd, read, write);
 }
 

source/API/SBPlatform.cpp

SBPlatform::SetSP (const lldb::PlatformSP& platform_sp)
     m_opaque_sp = platform_sp;
 }
 
 const char *
 SBPlatform::GetWorkingDirectory()
 {
     PlatformSP platform_sp(GetSP());
     if (platform_sp)
-        return platform_sp->GetWorkingDirectory().GetCString();
+    {
+        ConstString working_dir{platform_sp->GetWorkingDirectory().GetPath()};
+        return working_dir.GetCString();
+    }
     return NULL;
 }
 
 bool
 SBPlatform::SetWorkingDirectory(const char *path)
 {
     PlatformSP platform_sp(GetSP());
     if (platform_sp)
     {
         if (path)
-            platform_sp->SetWorkingDirectory(ConstString(path));
+            platform_sp->SetWorkingDirectory(FileSpec{path, false});
         else
-            platform_sp->SetWorkingDirectory(ConstString());
+            platform_sp->SetWorkingDirectory(FileSpec{});
         return true;
     }
     return false;
 }
 
 SBError
 SBPlatform::ConnectRemote (SBPlatformConnectOptions &connect_options)
 {

 {
     return ExecuteConnected(
         [&](const lldb::PlatformSP& platform_sp)
         {
             const char *command = shell_command.GetCommand();
             if (!command)
                 return Error("invalid shell command (empty)");
 
-            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);
+            const char *wd{shell_command.GetWorkingDirectory()};
+            std::string working_dir{wd ? wd : ""};
+            if (working_dir.empty())
+            {
+                working_dir = platform_sp->GetWorkingDirectory().GetPath();
+                if (!working_dir.empty())
+                    shell_command.SetWorkingDirectory(working_dir.c_str());
             }
             return platform_sp->RunShellCommand(command,
-                                                working_dir,
+                                                FileSpec{working_dir.c_str(), false},
                                                 &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);
         });
 }
 
 SBError

 
 SBError
 SBPlatform::MakeDirectory (const char *path, uint32_t file_permissions)
 {
     SBError sb_error;
     PlatformSP platform_sp(GetSP());
     if (platform_sp)
     {
-        sb_error.ref() = platform_sp->MakeDirectory(path, file_permissions);
+        sb_error.ref() = platform_sp->MakeDirectory(FileSpec{path, false}, file_permissions);
     }
     else
     {
         sb_error.SetErrorString("invalid platform");
     }
     return sb_error;
 }
 
 uint32_t
 SBPlatform::GetFilePermissions (const char *path)
 {
     PlatformSP platform_sp(GetSP());
     if (platform_sp)
     {
         uint32_t file_permissions = 0;
-        platform_sp->GetFilePermissions(path, file_permissions);
+        platform_sp->GetFilePermissions(FileSpec{path, false}, file_permissions);
         return file_permissions;
     }
     return 0;
     
 }
 
 SBError
 SBPlatform::SetFilePermissions (const char *path, uint32_t file_permissions)
 {
     SBError sb_error;
     PlatformSP platform_sp(GetSP());
     if (platform_sp)
     {
-        sb_error.ref() = platform_sp->SetFilePermissions(path, file_permissions);
+        sb_error.ref() = platform_sp->SetFilePermissions(FileSpec{path, false}, file_permissions);
     }
     else
     {
         sb_error.SetErrorString("invalid platform");
     }
     return sb_error;
     
 }
 

source/API/SBProcess.cpp

SBProcess::RemoteLaunch (char const **argv,
     ProcessSP process_sp(GetSP());
     if (process_sp)
     {
         Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
         if (process_sp->GetState() == eStateConnected)
         {
             if (stop_at_entry)
                 launch_flags |= eLaunchFlagStopAtEntry;
-            ProcessLaunchInfo launch_info (stdin_path,
-                                           stdout_path,
-                                           stderr_path,
-                                           working_directory,
-                                           launch_flags);
+            ProcessLaunchInfo launch_info(FileSpec{stdin_path, false},
+                                          FileSpec{stdout_path, false},
+                                          FileSpec{stderr_path, false},
+                                          FileSpec{working_directory, false},
             Module *exe_module = process_sp->GetTarget().GetExecutableModulePointer();
             if (exe_module)
                 launch_info.SetExecutableFile(exe_module->GetPlatformFileSpec(), true);
             if (argv)
                 launch_info.GetArguments().AppendArguments (argv);
             if (envp)
                 launch_info.GetEnvironmentEntries ().SetArguments (envp);
             error.SetError (process_sp->Launch (launch_info));

source/API/SBTarget.cpp

if (target_sp)
                 error.SetErrorString ("process is connected and already has a listener, pass empty listener");
                 return sb_process;
             }
         }
 
         if (getenv("LLDB_LAUNCH_FLAG_DISABLE_STDIO"))
             launch_flags |= eLaunchFlagDisableSTDIO;
 
-        ProcessLaunchInfo launch_info (stdin_path, stdout_path, stderr_path, working_directory, launch_flags);
+        ProcessLaunchInfo launch_info(FileSpec{stdin_path, false},
+                                      FileSpec{stdout_path, false},
+                                      FileSpec{stderr_path, false},
+                                      FileSpec{working_directory, false},
+                                      launch_flags);
 
         Module *exe_module = target_sp->GetExecutableModulePointer();
         if (exe_module)
             launch_info.SetExecutableFile(exe_module->GetPlatformFileSpec(), true);
         if (argv)
             launch_info.GetArguments().AppendArguments (argv);
         if (envp)
             launch_info.GetEnvironmentEntries ().SetArguments (envp);

source/Commands/CommandObjectPlatform.cpp

 protected:
     virtual bool
     DoExecute (Args& args, CommandReturnObject &result)
     {
         PlatformSP platform_sp (m_interpreter.GetDebugger().GetPlatformList().GetSelectedPlatform());
         if (platform_sp)
         {
             if (m_option_working_dir.GetOptionValue().OptionWasSet())
-                platform_sp->SetWorkingDirectory (ConstString(m_option_working_dir.GetOptionValue().GetCurrentValue().GetPath().c_str()));
+                platform_sp->SetWorkingDirectory(m_option_working_dir.GetOptionValue().GetCurrentValue());
         }
         else
         {
             result.AppendError ("no platform is currently selected");
             result.SetStatus (eReturnStatusFailed);
         }
         return result.Succeeded();
     }
DoExecute (Args& args, CommandReturnObject &result)
             std::string cmd_line;
             args.GetCommandString(cmd_line);
             uint32_t mode;
             const OptionPermissions* options_permissions = (const OptionPermissions*)m_options.GetGroupWithOption('r');
             if (options_permissions)
                 mode = options_permissions->m_permissions;
             else
                 mode = lldb::eFilePermissionsUserRWX | lldb::eFilePermissionsGroupRWX | lldb::eFilePermissionsWorldRX;
-            Error error = platform_sp->MakeDirectory(cmd_line.c_str(), mode);
+            Error error = platform_sp->MakeDirectory(FileSpec{cmd_line.c_str(), false}, mode);
             if (error.Success())
             {
                 result.SetStatus (eReturnStatusSuccessFinishResult);
             }
             else
             {
                 result.AppendError(error.AsCString());
                 result.SetStatus (eReturnStatusFailed);
DoExecute (const char *raw_command_line, CommandReturnObject &result)
         
         if (expr == NULL)
             expr = raw_command_line;
         
         PlatformSP platform_sp (m_interpreter.GetDebugger().GetPlatformList().GetSelectedPlatform());
         Error error;
         if (platform_sp)
         {
-            const char *working_dir = NULL;
+            FileSpec working_dir{};
             std::string output;
             int status = -1;
             int signo = -1;
             error = (platform_sp->RunShellCommand (expr, working_dir, &status, &signo, &output, m_options.timeout));
             if (!output.empty())
                 result.GetOutputStream().PutCString(output.c_str());
             if (status > 0)
             {

source/Host/android/ProcessLauncherAndroid.cpp

 //===-- ProcessLauncherAndroid.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/Host/FileSpec.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostProcess.h"
 #include "lldb/Host/android/ProcessLauncherAndroid.h"
 
 #include "lldb/Target/ProcessLaunchInfo.h"
 
 #include <limits.h>
 
 using namespace lldb;
 using namespace lldb_private;
 
 static bool
-DupDescriptor(const char *path, int fd, int flags)
+DupDescriptor(const FileSpec &file_spec, int fd, int flags)
 {
-    int target_fd = ::open(path, flags, 0666);
+    int target_fd = ::open(file_spec.GetPath().c_str(), flags, 0666);
 
     if (target_fd == -1)
         return false;
 
     if (::dup2(target_fd, fd) == -1)
         return false;
 
     return (::close(target_fd) == -1) ? false : true;
ProcessLauncherAndroid::LaunchProcess(const ProcessLaunchInfo &launch_info, Error &error)
     {
         // Fork failed
         error.SetErrorStringWithFormat("Fork failed with error message: %s", strerror(errno));
         return HostProcess(LLDB_INVALID_PROCESS_ID);
     }
     else if (pid == 0)
     {
         if (const lldb_private::FileAction *file_action = launch_info.GetFileActionForFD(STDIN_FILENO)) {
-            const char* path = file_action->GetPath();
-            if (path && ::strlen(path))
-                if (!DupDescriptor(path, STDIN_FILENO, O_RDONLY))
+            FileSpec file_spec = file_action->GetFileSpec();
+            if (file_spec)
+                if (!DupDescriptor(file_spec, STDIN_FILENO, O_RDONLY))
                     exit(-1);
         }
 
         if (const lldb_private::FileAction *file_action = launch_info.GetFileActionForFD(STDOUT_FILENO)) {
-            const char* path = file_action->GetPath();
-            if (path && ::strlen(path))
-                if (!DupDescriptor(path, STDOUT_FILENO, O_WRONLY | O_CREAT | O_TRUNC))
+            FileSpec file_spec = file_action->GetFileSpec();
+            if (file_spec)
+                if (!DupDescriptor(file_spec, STDOUT_FILENO, O_WRONLY | O_CREAT | O_TRUNC))
                     exit(-1);
         }
 
         if (const lldb_private::FileAction *file_action = launch_info.GetFileActionForFD(STDERR_FILENO)) {
-            const char* path = file_action->GetPath();
-            if (path && ::strlen(path))
-                if (!DupDescriptor(path, STDERR_FILENO, O_WRONLY | O_CREAT | O_TRUNC))
+            FileSpec file_spec = file_action->GetFileSpec();
+            if (file_spec)
+                if (!DupDescriptor(file_spec, STDERR_FILENO, O_WRONLY | O_CREAT | O_TRUNC))
                     exit(-1);
         }
 
         // Child process
         const char **argv = launch_info.GetArguments().GetConstArgumentVector();
 
         Args env = launch_info.GetEnvironmentEntries();
         FixupEnvironment(env);
         const char **envp = env.GetConstArgumentVector();
 
-        const char *working_dir = launch_info.GetWorkingDirectory();
-        if (working_dir != nullptr && working_dir[0])
+        FileSpec working_dir = launch_info.GetWorkingDirectory();
+        if (working_dir)
         {
-            if (::chdir(working_dir) != 0)
+            if (::chdir(working_dir.GetPath().c_str()) != 0)
                 exit(-1);
         }
 
         execve(argv[0],
                const_cast<char *const *>(argv),
                const_cast<char *const *>(envp));
         exit(-1);
     }
    
     return HostProcess(pid);
 }

source/Host/common/Host.cpp

MonitorShellCommand (void *callback_baton,
     // Sleep a bit to allow the shell_info->can_delete.SetValue() to complete...
     usleep(1000);
     // Now delete the shell info that was passed into this function
     delete shell_info;
     return true;
 }
 
 Error
-Host::RunShellCommand (const char *command,
-                       const char *working_dir,
-                       int *status_ptr,
-                       int *signo_ptr,
-                       std::string *command_output_ptr,
-                       uint32_t timeout_sec,
-                       bool run_in_default_shell)
+Host::RunShellCommand(const char *command,
+                      const FileSpec &working_dir,
 {
     return RunShellCommand(Args(command), working_dir, status_ptr, signo_ptr, command_output_ptr, timeout_sec, run_in_default_shell);
 }
 
 Error
-Host::RunShellCommand (const Args &args,
-                       const char *working_dir,
-                       int *status_ptr,
-                       int *signo_ptr,
-                       std::string *command_output_ptr,
-                       uint32_t timeout_sec,
-                       bool run_in_default_shell)
+Host::RunShellCommand(const Args &args,
+                      const FileSpec &working_dir,
 {
     Error error;
     ProcessLaunchInfo launch_info;
     launch_info.SetArchitecture(HostInfo::GetArchitecture());
     if (run_in_default_shell)
     {
         // Run the command in a shell
         launch_info.SetShell(HostInfo::GetDefaultShell());
if (command_output_ptr)
             tmpdir_file_spec.AppendPathComponent("lldb-shell-output.%%%%%%");
             llvm::sys::fs::createUniqueFile(tmpdir_file_spec.GetPath().c_str(), output_file_path);
         }
         else
         {
             llvm::sys::fs::createTemporaryFile("lldb-shell-output.%%%%%%", "", output_file_path);
         }
     }
-    
+    FileSpec output_file_spec{output_file_path.c_str(), false};
+
     launch_info.AppendSuppressFileAction (STDIN_FILENO, true, false);
-    if (!output_file_path.empty())
+    if (output_file_spec)
     {
-        launch_info.AppendOpenFileAction(STDOUT_FILENO, output_file_path.c_str(), false, true);
+        launch_info.AppendOpenFileAction(STDOUT_FILENO, output_file_spec, false, true);
         launch_info.AppendDuplicateFileAction(STDOUT_FILENO, STDERR_FILENO);
     }
     else
     {
         launch_info.AppendSuppressFileAction (STDOUT_FILENO, false, true);
         launch_info.AppendSuppressFileAction (STDERR_FILENO, false, true);
     }
     
if (error.Success())
                 *status_ptr = shell_info->status;
             
             if (signo_ptr)
                 *signo_ptr = shell_info->signo;
             
             if (command_output_ptr)
             {
                 command_output_ptr->clear();
-                FileSpec file_spec(output_file_path.c_str(), File::eOpenOptionRead);
-                uint64_t file_size = file_spec.GetByteSize();
+                uint64_t file_size = output_file_spec.GetByteSize();
                 if (file_size > 0)
                 {
                     if (file_size > command_output_ptr->max_size())
                     {
                         error.SetErrorStringWithFormat("shell command output is too large to fit into a std::string");
                     }
                     else
                     {
-                        command_output_ptr->resize(file_size);
-                        file_spec.ReadFileContents(0, &((*command_output_ptr)[0]), command_output_ptr->size(), &error);
+                        std::unique_ptr<char[]> command_output_data{new char[file_size]};
+                        output_file_spec.ReadFileContents(0, command_output_data.get(), file_size, &error);
+                        command_output_ptr->assign(command_output_data.get(), file_size);
                     }
                 }
             }
         }
         shell_info->can_delete.SetValue(true, eBroadcastAlways);
     }
-    
-    FileSpec output_file_spec(output_file_path.c_str(), false);
     if (FileSystem::GetFileExists(output_file_spec))
         FileSystem::Unlink(output_file_path.c_str());
     // Handshake with the monitor thread, or just let it know in advance that
     // it can delete "shell_info" in case we timed out and were not able to kill
     // the process...
     return error;
 }
 
if (argv == NULL)
         argv = (char * const*)tmp_argv;
     }
 
 #if !defined (__APPLE__)
     // manage the working directory
     char current_dir[PATH_MAX];
     current_dir[0] = '\0';
 #endif
 
-    const char *working_dir = launch_info.GetWorkingDirectory();
-    if (working_dir)
+    std::string working_dir{launch_info.GetWorkingDirectory().GetPath()};
+    if (!working_dir.empty())
     {
 #if defined (__APPLE__)
         // Set the working directory on this thread only
-        if (__pthread_chdir (working_dir) < 0) {
+        if (__pthread_chdir(working_dir.c_str()) < 0) {
             if (errno == ENOENT) {
-                error.SetErrorStringWithFormat("No such file or directory: %s", working_dir);
+                error.SetErrorStringWithFormat("No such file or directory: %s", working_dir.c_str());
             } else if (errno == ENOTDIR) {
-                error.SetErrorStringWithFormat("Path doesn't name a directory: %s", working_dir);
+                error.SetErrorStringWithFormat("Path doesn't name a directory: %s", working_dir.c_str());
             } else {
                 error.SetErrorStringWithFormat("An unknown error occurred when changing directory for process execution.");
             }
             return error;
         }
 #else
         if (::getcwd(current_dir, sizeof(current_dir)) == NULL)
         {
             error.SetError(errno, eErrorTypePOSIX);
             error.LogIfError(log, "unable to save the current directory");
             return error;
         }
 
-        if (::chdir(working_dir) == -1)
+        if (::chdir(working_dir.c_str()) == -1)
         {
             error.SetError(errno, eErrorTypePOSIX);
-            error.LogIfError(log, "unable to change working directory to %s", working_dir);
+            error.LogIfError(log, "unable to change working directory to %s", working_dir.c_str());
             return error;
         }
 #endif
     }
 
     ::pid_t result_pid = LLDB_INVALID_PROCESS_ID;
     const size_t num_file_actions = launch_info.GetNumFileActions ();
     if (num_file_actions > 0)
else
             {
                 for (int ii=0; argv[ii]; ++ii)
                     log->Printf("argv[%i] = '%s'", ii, argv[ii]);
             }
         }
     }
     pid = result_pid;
 
-    if (working_dir)
+    if (!working_dir.empty())
     {
 #if defined (__APPLE__)
         // No more thread specific current working directory
         __pthread_fchdir (-1);
 #else
         if (::chdir(current_dir) == -1 && error.Success())
         {
             error.SetError(errno, eErrorTypePOSIX);

source/Host/macosx/Host.mm

LaunchInNewTerminalWithAppleScript (const char *exe_path, ProcessLaunchInfo &launch_info)
     if (arch_spec.IsValid() && arch_spec.GetCore() != ArchSpec::eCore_x86_64_x86_64h)
         command.Printf("arch -arch %s ", arch_spec.GetArchitectureName());
 
     command.Printf("'%s' --unix-socket=%s", launcher_path, unix_socket_name);
 
     if (arch_spec.IsValid())
         command.Printf(" --arch=%s", arch_spec.GetArchitectureName());
 
-    const char *working_dir = launch_info.GetWorkingDirectory();
+    FileSpec working_dir{launch_info.GetWorkingDirectory()};
     if (working_dir)
-        command.Printf(" --working-dir '%s'", working_dir);
+        command.Printf(" --working-dir '%s'", working_dir.GetPath().c_str());
     else
     {
         char cwd[PATH_MAX];
         if (getcwd(cwd, PATH_MAX))
             command.Printf(" --working-dir '%s'", cwd);
     }
     
     if (launch_info.GetFlags().Test (eLaunchFlagDisableASLR))

source/Host/windows/ProcessLauncherWindows.cpp

 
 HostProcess
 ProcessLauncherWindows::LaunchProcess(const ProcessLaunchInfo &launch_info, Error &error)
 {
     error.Clear();
 
     std::string executable;
     std::string commandLine;
+    std::string working_dir;
     std::vector<char> environment;
     STARTUPINFO startupinfo = {0};
     PROCESS_INFORMATION pi = {0};
 
     HANDLE stdin_handle = GetStdioHandle(launch_info, STDIN_FILENO);
     HANDLE stdout_handle = GetStdioHandle(launch_info, STDOUT_FILENO);
     HANDLE stderr_handle = GetStdioHandle(launch_info, STDERR_FILENO);
 
ProcessLauncherWindows::LaunchProcess(const ProcessLaunchInfo &launch_info, Error &error)
     }
 
     DWORD flags = CREATE_NEW_CONSOLE;
     if (launch_info.GetFlags().Test(eLaunchFlagDebug))
         flags |= DEBUG_ONLY_THIS_PROCESS;
 
     executable = launch_info.GetExecutableFile().GetPath();
     launch_info.GetArguments().GetQuotedCommandString(commandLine);
+    working_dir = launch_info.GetWorkingDirectory().GetPath();
     BOOL result = ::CreateProcessA(executable.c_str(), const_cast<char *>(commandLine.c_str()), NULL, NULL, TRUE, flags, NULL,
-                                   launch_info.GetWorkingDirectory(), &startupinfo, &pi);
+                                   working_dir.empty() ? NULL : working_dir.c_str(), &startupinfo, &pi);
     if (result)
     {
         // Do not call CloseHandle on pi.hProcess, since we want to pass that back through the HostProcess.
         ::CloseHandle(pi.hThread);
     }
 
     if (stdin_handle)
         ::CloseHandle(stdin_handle);

source/Plugins/Platform/FreeBSD/PlatformFreeBSD.h

public:
     // lldb_private::Platform functions
     //------------------------------------------------------------
     bool
     GetModuleSpec (const lldb_private::FileSpec& module_file_spec,
                    const lldb_private::ArchSpec& arch,
                    lldb_private::ModuleSpec &module_spec) override;
 
     lldb_private::Error
-    RunShellCommand (const char *command,
-                     const char *working_dir,
-                     int *status_ptr,
-                     int *signo_ptr,
-                     std::string *command_output,
-                     uint32_t timeout_sec) override;
+    RunShellCommand(const char *command,
+                    const lldb_private::FileSpec &working_dir,
 
     lldb_private::Error
     ResolveExecutable (const lldb_private::ModuleSpec &module_spec,
                        lldb::ModuleSP &module_sp,
                        const lldb_private::FileSpecList *module_search_paths_ptr) override;
 
     size_t
     GetSoftwareBreakpointTrapOpcode (lldb_private::Target &target,

source/Plugins/Platform/FreeBSD/PlatformFreeBSD.cpp

 {
     if (m_remote_platform_sp)
         return m_remote_platform_sp->GetModuleSpec (module_file_spec, arch, module_spec);
 
     return Platform::GetModuleSpec (module_file_spec, arch, module_spec);
 }
 
 lldb_private::Error
-PlatformFreeBSD::RunShellCommand (const char *command,
-                                  const char *working_dir,
-                                  int *status_ptr,
-                                  int *signo_ptr,
-                                  std::string *command_output,
-                                  uint32_t timeout_sec)
+PlatformFreeBSD::RunShellCommand(const char *command,
+                                 const FileSpec &working_dir,
 {
     if (IsHost())
         return Host::RunShellCommand(command, working_dir, status_ptr, signo_ptr, command_output, timeout_sec);
     else
     {
         if (m_remote_platform_sp)
             return m_remote_platform_sp->RunShellCommand(command, working_dir, status_ptr, signo_ptr, command_output, timeout_sec);
         else

source/Plugins/Platform/POSIX/PlatformPOSIX.h

WriteFile (lldb::user_id_t fd,
                const void* src,
                uint64_t src_len,
                lldb_private::Error &error) override;
     
     lldb::user_id_t
     GetFileSize (const lldb_private::FileSpec& file_spec) override;
 
     lldb_private::Error
-    CreateSymlink(const char *src, const char *dst) override;
+    CreateSymlink(const lldb_private::FileSpec &src,
+                  const lldb_private::FileSpec &dst) override;
 
     lldb_private::Error
-    GetFile (const lldb_private::FileSpec& source,
-             const lldb_private::FileSpec& destination) override;
-    
-    lldb_private::ConstString
+    GetFile(const lldb_private::FileSpec &source,
+            const lldb_private::FileSpec &destination) override;
+    lldb_private::FileSpec
     GetRemoteWorkingDirectory() override;
     
     bool
-    SetRemoteWorkingDirectory(const lldb_private::ConstString &path) override;
+    SetRemoteWorkingDirectory(const lldb_private::FileSpec &working_dir) override;
 
     bool
     GetRemoteOSVersion () override;
 
     bool
     GetRemoteOSBuildString (std::string &s) override;
 
     bool
     GetRemoteOSKernelDescription (std::string &s) override;
 
     lldb_private::ArchSpec
     GetRemoteSystemArchitecture () override;
 
     size_t
     GetEnvironment (lldb_private::StringList &environment) override;
 
     bool
     IsConnected () const override;
 
     lldb_private::Error
-    RunShellCommand (const char *command,           // Shouldn't be NULL
-                     const char *working_dir,       // Pass NULL to use the current working directory
-                     int *status_ptr,               // Pass NULL if you don't want the process exit status
-                     int *signo_ptr,                // Pass NULL if you don't want the signal that caused the process to exit
-                     std::string *command_output,   // Pass NULL if you don't want the command output
-                     uint32_t timeout_sec) override;// Timeout in seconds to wait for shell program to finish
+    RunShellCommand(const char *command,                       // Shouldn't be NULL
+                    const lldb_private::FileSpec &working_dir, // Pass empty FileSpec to use the current working directory
+                    int *status_ptr,                           // Pass NULL if you don't want the process exit status
+                    int *signo_ptr,                            // Pass NULL if you don't want the signal that caused the process to exit
+                    std::string *command_output,               // Pass NULL if you don't want the command output
+                    uint32_t timeout_sec) override;            // Timeout in seconds to wait for shell program to finish
 
     lldb_private::Error
-    MakeDirectory (const char *path, uint32_t mode) override;
-    
+    MakeDirectory(const lldb_private::FileSpec &file_spec, uint32_t mode) override;
     lldb_private::Error
-    GetFilePermissions (const char *path, uint32_t &file_permissions) override;
+    GetFilePermissions(const lldb_private::FileSpec &file_spec, uint32_t &file_permissions) override;
 
     lldb_private::Error
-    SetFilePermissions (const char *path, uint32_t file_permissions) override;
+    SetFilePermissions(const lldb_private::FileSpec &file_spec, uint32_t file_permissions) override;
 
     bool
     GetFileExists (const lldb_private::FileSpec& file_spec) override;
     
     lldb_private::Error
-    Unlink (const char *path) override;
+    Unlink(const lldb_private::FileSpec &file_spec) override;
 
     lldb_private::Error
     LaunchProcess (lldb_private::ProcessLaunchInfo &launch_info) override;
 
     lldb_private::Error
     KillProcess (const lldb::pid_t pid) override;
 
     lldb::ProcessSP

source/Plugins/Platform/POSIX/PlatformPOSIX.cpp

PlatformPOSIX::IsConnected () const
     if (IsHost())
         return true;
     else if (m_remote_platform_sp)
         return m_remote_platform_sp->IsConnected();
     return false;
 }
 
 lldb_private::Error
-PlatformPOSIX::RunShellCommand (const char *command,           // Shouldn't be NULL
-                                const char *working_dir,       // Pass NULL to use the current working directory
-                                int *status_ptr,               // Pass NULL if you don't want the process exit status
-                                int *signo_ptr,                // Pass NULL if you don't want the signal that caused the process to exit
-                                std::string *command_output,   // Pass NULL if you don't want the command output
-                                uint32_t timeout_sec)         // Timeout in seconds to wait for shell program to finish
+PlatformPOSIX::RunShellCommand(const char *command,           // Shouldn't be NULL
+                               const FileSpec &working_dir,   // Pass empty FileSpec to use the current working directory
+                               uint32_t timeout_sec)          // Timeout in seconds to wait for shell program to finish
 {
     if (IsHost())
         return Host::RunShellCommand(command, working_dir, status_ptr, signo_ptr, command_output, timeout_sec);
     else
     {
         if (m_remote_platform_sp)
             return m_remote_platform_sp->RunShellCommand(command, working_dir, status_ptr, signo_ptr, command_output, timeout_sec);
         else
             return Error("unable to run a remote command without a platform");
     }
 }
 
 Error
-PlatformPOSIX::MakeDirectory (const char *path, uint32_t file_permissions)
+PlatformPOSIX::MakeDirectory(const FileSpec &file_spec, uint32_t file_permissions)
 {
     if (m_remote_platform_sp)
-        return m_remote_platform_sp->MakeDirectory(path, file_permissions);
+        return m_remote_platform_sp->MakeDirectory(file_spec, file_permissions);
     else
-        return Platform::MakeDirectory(path ,file_permissions);
+        return Platform::MakeDirectory(file_spec ,file_permissions);
 }
 
 Error
-PlatformPOSIX::GetFilePermissions (const char *path, uint32_t &file_permissions)
+PlatformPOSIX::GetFilePermissions(const FileSpec &file_spec, uint32_t &file_permissions)
 {
     if (m_remote_platform_sp)
-        return m_remote_platform_sp->GetFilePermissions(path, file_permissions);
+        return m_remote_platform_sp->GetFilePermissions(file_spec, file_permissions);
     else
-        return Platform::GetFilePermissions(path ,file_permissions);
+        return Platform::GetFilePermissions(file_spec ,file_permissions);
 }
 
 Error
-PlatformPOSIX::SetFilePermissions (const char *path, uint32_t file_permissions)
+PlatformPOSIX::SetFilePermissions(const FileSpec &file_spec, uint32_t file_permissions)
 {
     if (m_remote_platform_sp)
-        return m_remote_platform_sp->SetFilePermissions(path, file_permissions);
+        return m_remote_platform_sp->SetFilePermissions(file_spec, file_permissions);
     else
-        return Platform::SetFilePermissions(path ,file_permissions);
+        return Platform::SetFilePermissions(file_spec, file_permissions);
 }
 
 lldb::user_id_t
 PlatformPOSIX::OpenFile (const FileSpec& file_spec,
                          uint32_t flags,
                          uint32_t mode,
                          Error &error)
 {
if (IsHost())
         return FileSystem::GetFileSize(file_spec);
     else if (m_remote_platform_sp)
         return m_remote_platform_sp->GetFileSize(file_spec);
     else
         return Platform::GetFileSize(file_spec);
 }
 
 Error
-PlatformPOSIX::CreateSymlink(const char *src, const char *dst)
+PlatformPOSIX::CreateSymlink(const FileSpec &src, const FileSpec &dst)
 {
     if (IsHost())
-        return FileSystem::Symlink(src, dst);
+        return FileSystem::Symlink(src.GetPath().c_str(), dst.GetPath().c_str());
     else if (m_remote_platform_sp)
         return m_remote_platform_sp->CreateSymlink(src, dst);
     else
         return Platform::CreateSymlink(src, dst);
 }
 
 bool
 PlatformPOSIX::GetFileExists (const FileSpec& file_spec)
 {
     if (IsHost())
         return file_spec.Exists();
     else if (m_remote_platform_sp)
         return m_remote_platform_sp->GetFileExists(file_spec);
     else
         return Platform::GetFileExists(file_spec);
 }
 
 Error
-PlatformPOSIX::Unlink (const char *path)
+PlatformPOSIX::Unlink(const FileSpec &file_spec)
 {
     if (IsHost())
-        return FileSystem::Unlink(path);
+        return FileSystem::Unlink(file_spec.GetPath().c_str());
     else if (m_remote_platform_sp)
-        return m_remote_platform_sp->Unlink(path);
+        return m_remote_platform_sp->Unlink(file_spec);
     else
-        return Platform::Unlink(path);
+        return Platform::Unlink(file_spec);
 }
 
 lldb_private::Error
-PlatformPOSIX::GetFile (const lldb_private::FileSpec& source /* remote file path */,
-                        const lldb_private::FileSpec& destination /* local file path */)
+PlatformPOSIX::GetFile(const lldb_private::FileSpec &source,      // remote file path
+                       const lldb_private::FileSpec &destination) // local file path
 {
     Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM));
 
     // Check the args, first.
     std::string src_path (source.GetPath());
     if (src_path.empty())
         return Error("unable to get file path for source");
     std::string dst_path (destination.GetPath());
else if (m_remote_platform_sp)
                                      File::eOpenOptionRead,
                                      lldb::eFilePermissionsFileDefault,
                                      error);
 
         if (fd_src == UINT64_MAX)
             return Error("unable to open source file");
 
         uint32_t permissions = 0;
-        error = GetFilePermissions(source.GetPath().c_str(), permissions);
-        
+        error = GetFilePermissions(source, permissions);
         if (permissions == 0)
             permissions = lldb::eFilePermissionsFileDefault;
 
         user_id_t fd_dst = FileCache::GetInstance().OpenFile(
             destination, File::eOpenOptionCanCreate | File::eOpenOptionWrite | File::eOpenOptionTruncate, permissions,
             error);
 
         if (fd_dst == UINT64_MAX)

 {
     if (IsHost())
         return Platform::CalculateMD5 (file_spec, low, high);
     if (m_remote_platform_sp)
         return m_remote_platform_sp->CalculateMD5(file_spec, low, high);
     return false;
 }
 
-lldb_private::ConstString
+FileSpec
 PlatformPOSIX::GetRemoteWorkingDirectory()
 {
     if (IsRemote() && m_remote_platform_sp)
         return m_remote_platform_sp->GetRemoteWorkingDirectory();
     else
         return Platform::GetRemoteWorkingDirectory();
 }
 
 bool
-PlatformPOSIX::SetRemoteWorkingDirectory(const lldb_private::ConstString &path)
+PlatformPOSIX::SetRemoteWorkingDirectory(const FileSpec &working_dir)
 {
     if (IsRemote() && m_remote_platform_sp)
-        return m_remote_platform_sp->SetRemoteWorkingDirectory(path);
+        return m_remote_platform_sp->SetRemoteWorkingDirectory(working_dir);
     else
-        return Platform::SetRemoteWorkingDirectory(path);
+        return Platform::SetRemoteWorkingDirectory(working_dir);
 }
 
 bool
 PlatformPOSIX::GetRemoteOSVersion ()
 {
     if (m_remote_platform_sp)
         return m_remote_platform_sp->GetOSVersion (m_major_os_version,
                                                    m_minor_os_version,

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

public:
     
     bool
     GetRemoteOSKernelDescription (std::string &s) override;
 
     // Remote Platform subclasses need to override this function
     ArchSpec
     GetRemoteSystemArchitecture () override;
 
-    ConstString
+    FileSpec
     GetRemoteWorkingDirectory() override;
     
     bool
-    SetRemoteWorkingDirectory(const ConstString &path) override;
+    SetRemoteWorkingDirectory(const FileSpec &working_dir) override;
 
     // Remote subclasses should override this and return a valid instance
     // name if connected.
     const char *
     GetHostname () override;
 
     const char *
     GetUserName (uint32_t uid) override;
     
     const char *
     GetGroupName (uint32_t gid) override;
 
     bool
     IsConnected () const override;
 
     Error
     ConnectRemote (Args& args) override;
 
     Error
     DisconnectRemote () override;
     
     Error
-    MakeDirectory (const char *path, uint32_t file_permissions) override;
-    
+    MakeDirectory(const FileSpec &file_spec, uint32_t file_permissions) override;
     Error
-    GetFilePermissions (const char *path, uint32_t &file_permissions) override;
-    
+    GetFilePermissions(const FileSpec &file_spec, uint32_t &file_permissions) override;
     Error
-    SetFilePermissions (const char *path, uint32_t file_permissions) override;
-    
+    SetFilePermissions(const FileSpec &file_spec, uint32_t file_permissions) override;
 
     lldb::user_id_t
     OpenFile (const FileSpec& file_spec, uint32_t flags, uint32_t mode, Error &error) override;
     
     bool
     CloseFile (lldb::user_id_t fd, Error &error) override;
     
     uint64_t
public:
 
     Error
     PutFile (const FileSpec& source,
              const FileSpec& destination,
              uint32_t uid = UINT32_MAX,
              uint32_t gid = UINT32_MAX) override;
     
     Error
-    CreateSymlink (const char *src, const char *dst) override;
+    CreateSymlink(const FileSpec &src, const FileSpec &dst) override;
 
     bool
     GetFileExists (const FileSpec& file_spec) override;
 
     Error
-    Unlink (const char *path) override;
+    Unlink(const FileSpec &path) override;
 
     Error
-    RunShellCommand (const char *command,            // Shouldn't be NULL
-                     const char *working_dir,        // Pass NULL to use the current working directory
-                     int *status_ptr,                // Pass NULL if you don't want the process exit status
-                     int *signo_ptr,                 // Pass NULL if you don't want the signal that caused the process to exit
-                     std::string *command_output,    // Pass NULL if you don't want the command output
-                     uint32_t timeout_sec) override; // Timeout in seconds to wait for shell program to finish
+    RunShellCommand(const char *command,            // Shouldn't be NULL
+                    const FileSpec &working_dir,    // Pass empty FileSpec to use the current working directory
 
     void
     CalculateTrapHandlerSymbolNames () override;
 
 protected:
     process_gdb_remote::GDBRemoteCommunicationClient m_gdb_client;
     std::string m_platform_description; // After we connect we can get a more complete description of what we are connected to
     std::string m_platform_scheme;

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

 
 // Remote Platform subclasses need to override this function
 ArchSpec
 PlatformRemoteGDBServer::GetRemoteSystemArchitecture ()
 {
     return m_gdb_client.GetSystemArchitecture();
 }
 
-ConstString
+FileSpec
 PlatformRemoteGDBServer::GetRemoteWorkingDirectory()
 {
     if (IsConnected())
     {
         Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM);
-        std::string cwd;
-        if (m_gdb_client.GetWorkingDir(cwd))
-        {
-            ConstString working_dir(cwd.c_str());
-            if (log)
-                log->Printf("PlatformRemoteGDBServer::GetRemoteWorkingDirectory() -> '%s'", working_dir.GetCString());
-            return working_dir;
-        }
-        else
-        {
-            return ConstString();
-        }
-    }
-    else
-    {
+        FileSpec working_dir;
+        if (m_gdb_client.GetWorkingDir(working_dir) && log)
+            log->Printf("PlatformRemoteGDBServer::GetRemoteWorkingDirectory() -> '%s'",
+                    working_dir.GetPath().c_str());
         return Platform::GetRemoteWorkingDirectory();
     }
 }
 
 bool
-PlatformRemoteGDBServer::SetRemoteWorkingDirectory(const ConstString &path)
+PlatformRemoteGDBServer::SetRemoteWorkingDirectory(const FileSpec &working_dir)
 {
     if (IsConnected())
     {
         // Clear the working directory it case it doesn't get set correctly. This will
         // for use to re-read it
         Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM);
         if (log)
-            log->Printf("PlatformRemoteGDBServer::SetRemoteWorkingDirectory('%s')", path.GetCString());
-        return m_gdb_client.SetWorkingDir(path.GetCString()) == 0;
+            log->Printf("PlatformRemoteGDBServer::SetRemoteWorkingDirectory('%s')",
+                    working_dir.GetPath().c_str());
+        return m_gdb_client.SetWorkingDir(working_dir) == 0;
     }
     else
-        return Platform::SetRemoteWorkingDirectory(path);
+        return Platform::SetRemoteWorkingDirectory(working_dir);
 }
 
 bool
 PlatformRemoteGDBServer::IsConnected () const
 {
     return m_gdb_client.IsConnected();
 }        
 
else
             const ConnectionStatus status = m_gdb_client.Connect(url, &error);
             if (status == eConnectionStatusSuccess)
             {
                 if (m_gdb_client.HandshakeWithServer(&error))
                 {
                     m_gdb_client.GetHostInfo();
                     // If a working directory was set prior to connecting, send it down now
                     if (m_working_dir)
-                        m_gdb_client.SetWorkingDir(m_working_dir.GetCString());
+                        m_gdb_client.SetWorkingDir(m_working_dir);
                 }
                 else
                 {
                     m_gdb_client.Disconnect();
                     if (error.Success())
                         error.SetErrorString("handshake failed");
                 }
             }
PlatformRemoteGDBServer::LaunchProcess (ProcessLaunchInfo &launch_info)
     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());
+            m_gdb_client.SetSTDIN(file_action->GetFileSpec());
             break;
         case STDOUT_FILENO:
-            m_gdb_client.SetSTDOUT (file_action->GetPath());
+            m_gdb_client.SetSTDOUT(file_action->GetFileSpec());
             break;
         case STDERR_FILENO:
-            m_gdb_client.SetSTDERR (file_action->GetPath());
+            m_gdb_client.SetSTDERR(file_action->GetFileSpec());
             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])
+    FileSpec working_dir = launch_info.GetWorkingDirectory();
+    if (working_dir)
     {
-        m_gdb_client.SetWorkingDir (working_dir);
+        m_gdb_client.SetWorkingDir(working_dir);
     }
     
     // Send the environment and the program + arguments after we connect
     const char **envp = launch_info.GetEnvironmentEntries().GetConstArgumentVector();
 
     if (envp)
     {
         const char *env_entry;
if (IsRemote())
         {
             error.SetErrorString("not connected to remote gdb server");
         }
     }
     return process_sp;
 }
 
 Error
-PlatformRemoteGDBServer::MakeDirectory (const char *path, uint32_t mode)
+PlatformRemoteGDBServer::MakeDirectory(const FileSpec &file_spec, uint32_t mode)
 {
-    Error error = m_gdb_client.MakeDirectory(path,mode);
+    Error error = m_gdb_client.MakeDirectory(file_spec, mode);
     Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM);
     if (log)
-        log->Printf ("PlatformRemoteGDBServer::MakeDirectory(path='%s', mode=%o) error = %u (%s)", path, mode, error.GetError(), error.AsCString());
+        log->Printf ("PlatformRemoteGDBServer::MakeDirectory(path='%s', mode=%o) error = %u (%s)",
+                file_spec.GetPath().c_str(), mode, error.GetError(), error.AsCString());
     return error;
 }
 
 
 Error
-PlatformRemoteGDBServer::GetFilePermissions (const char *path, uint32_t &file_permissions)
+PlatformRemoteGDBServer::GetFilePermissions(const FileSpec &file_spec,
+                                            uint32_t &file_permissions)
 {
-    Error error = m_gdb_client.GetFilePermissions(path, file_permissions);
+    Error error = m_gdb_client.GetFilePermissions(file_spec, file_permissions);
     Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM);
     if (log)
-        log->Printf ("PlatformRemoteGDBServer::GetFilePermissions(path='%s', file_permissions=%o) error = %u (%s)", path, file_permissions, error.GetError(), error.AsCString());
+        log->Printf ("PlatformRemoteGDBServer::GetFilePermissions(path='%s', file_permissions=%o) error = %u (%s)",
+                file_spec.GetPath().c_str(), file_permissions, error.GetError(), error.AsCString());
     return error;
 }
 
 Error
-PlatformRemoteGDBServer::SetFilePermissions (const char *path, uint32_t file_permissions)
+PlatformRemoteGDBServer::SetFilePermissions(const FileSpec &file_spec,
+                                            uint32_t file_permissions)
 {
-    Error error = m_gdb_client.SetFilePermissions(path, file_permissions);
+    Error error = m_gdb_client.SetFilePermissions(file_spec, file_permissions);
     Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM);
     if (log)
-        log->Printf ("PlatformRemoteGDBServer::SetFilePermissions(path='%s', file_permissions=%o) error = %u (%s)", path, file_permissions, error.GetError(), error.AsCString());
+        log->Printf ("PlatformRemoteGDBServer::SetFilePermissions(path='%s', file_permissions=%o) error = %u (%s)",
+                file_spec.GetPath().c_str(), file_permissions, error.GetError(), error.AsCString());
     return error;
 }
 
 
 lldb::user_id_t
 PlatformRemoteGDBServer::OpenFile (const FileSpec& file_spec,
                                    uint32_t flags,
                                    uint32_t mode,
PlatformRemoteGDBServer::PutFile (const FileSpec& source,
          const FileSpec& destination,
          uint32_t uid,
          uint32_t gid)
 {
     return Platform::PutFile(source,destination,uid,gid);
 }
 
 Error
-PlatformRemoteGDBServer::CreateSymlink (const char *src,    // The name of the link is in src
-                                        const char *dst)    // The symlink points to dst
+PlatformRemoteGDBServer::CreateSymlink(const FileSpec &src,    // The name of the link is in src
+                                       const FileSpec &dst)    // The symlink points to dst
 {
-    Error error = m_gdb_client.CreateSymlink (src, dst);
+    Error error = m_gdb_client.CreateSymlink(src, dst);
     Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM);
     if (log)
-        log->Printf ("PlatformRemoteGDBServer::CreateSymlink(src='%s', dst='%s') error = %u (%s)", src, dst, error.GetError(), error.AsCString());
+        log->Printf ("PlatformRemoteGDBServer::CreateSymlink(src='%s', dst='%s') error = %u (%s)",
+                src.GetPath().c_str(), dst.GetPath().c_str(), error.GetError(), error.AsCString());
     return error;
 }
 
 Error
-PlatformRemoteGDBServer::Unlink (const char *path)
+PlatformRemoteGDBServer::Unlink(const FileSpec &file_spec)
 {
-    Error error = m_gdb_client.Unlink (path);
+    Error error = m_gdb_client.Unlink(file_spec);
     Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM);
     if (log)
-        log->Printf ("PlatformRemoteGDBServer::Unlink(path='%s') error = %u (%s)", path, error.GetError(), error.AsCString());
+        log->Printf ("PlatformRemoteGDBServer::Unlink(path='%s') error = %u (%s)",
+                file_spec.GetPath().c_str(), error.GetError(), error.AsCString());
     return error;
 }
 
 bool
 PlatformRemoteGDBServer::GetFileExists (const FileSpec& file_spec)
 {
     return m_gdb_client.GetFileExists (file_spec);
 }
 
 Error
-PlatformRemoteGDBServer::RunShellCommand (const char *command,           // Shouldn't be NULL
-                                          const char *working_dir,       // Pass NULL to use the current working directory
-                                          int *status_ptr,               // Pass NULL if you don't want the process exit status
-                                          int *signo_ptr,                // Pass NULL if you don't want the signal that caused the process to exit
-                                          std::string *command_output,   // Pass NULL if you don't want the command output
-                                          uint32_t timeout_sec)          // Timeout in seconds to wait for shell program to finish
+PlatformRemoteGDBServer::RunShellCommand(const char *command,           // Shouldn't be NULL
+                                         const FileSpec &working_dir,   // Pass empty FileSpec to use the current working directory
 {
-    return m_gdb_client.RunShellCommand (command, working_dir, status_ptr, signo_ptr, command_output, timeout_sec);
+    return m_gdb_client.RunShellCommand(command, working_dir, status_ptr, signo_ptr, command_output, timeout_sec);
 }
 
 void
 PlatformRemoteGDBServer::CalculateTrapHandlerSymbolNames ()
 {   
     m_trap_handlers.push_back (ConstString ("_sigtramp"));
 }

source/Plugins/Process/Linux/NativeProcessLinux.h

private:
         ///
         /// @brief Simple structure to pass data to the thread responsible for
         /// launching a child process.
         struct LaunchArgs
         {
             LaunchArgs(Module *module,
                     char const **argv,
                     char const **envp,
-                    const std::string &stdin_path,
-                    const std::string &stdout_path,
-                    const std::string &stderr_path,
-                    const char *working_dir,
+                    const FileSpec &stdin_file_spec,
+                    const FileSpec &stdout_file_spec,
+                    const FileSpec &stderr_file_spec,
+                    const FileSpec &working_dir,
                     const ProcessLaunchInfo &launch_info);
 
             ~LaunchArgs();
 
-            Module *m_module;                 // The executable image to launch.
-            char const **m_argv;              // Process arguments.
-            char const **m_envp;              // Process environment.
-            const std::string &m_stdin_path;  // Redirect stdin if not empty.
-            const std::string &m_stdout_path; // Redirect stdout if not empty.
-            const std::string &m_stderr_path; // Redirect stderr if not empty.
-            const char *m_working_dir;        // Working directory or NULL.
+            Module *m_module;                   // The executable image to launch.
+            char const **m_argv;                // Process arguments.
+            char const **m_envp;                // Process environment.
+            const FileSpec &m_stdin_file_spec;  // Redirect stdin if not empty.
+            const FileSpec &m_stdout_file_spec; // Redirect stdout if not empty.
+            const FileSpec &m_stderr_file_spec; // Redirect stderr if not empty.
+            const FileSpec &m_working_dir;      // Working directory or empty.
             const ProcessLaunchInfo &m_launch_info;
         };
 
         typedef std::function<::pid_t(Error &)> InitialOperation;
 
         // ---------------------------------------------------------------------
         // Private Instance Methods
         // ---------------------------------------------------------------------
         NativeProcessLinux ();
 
         /// Launches an inferior process ready for debugging.  Forms the
         /// implementation of Process::DoLaunch.
         void
         LaunchInferior (
             Module *module,
             char const *argv[],
             char const *envp[],
-            const std::string &stdin_path,
-            const std::string &stdout_path,
-            const std::string &stderr_path,
-            const char *working_dir,
+            const FileSpec &stdin_file_spec,
+            const FileSpec &stdout_file_spec,
+            const FileSpec &stderr_file_spec,
+            const FileSpec &working_dir,
             const ProcessLaunchInfo &launch_info,
             Error &error);
 
         /// Attaches to an existing process.  Forms the
         /// implementation of Process::DoAttach
         void
         AttachToInferior (lldb::pid_t pid, Error &error);
 
         void
         StartMonitorThread(const InitialOperation &operation, Error &error);
 
         ::pid_t
         Launch(LaunchArgs *args, Error &error);
 
         ::pid_t
         Attach(lldb::pid_t pid, Error &error);
 
         static Error
         SetDefaultPtraceOpts(const lldb::pid_t);
 
         static bool
-        DupDescriptor(const char *path, int fd, int flags);
+        DupDescriptor(const FileSpec &file_spec, int fd, int flags);
 
         static void *
         MonitorThread(void *baton);
 
         void
         MonitorCallback(lldb::pid_t pid, bool exited, int signal, int status);
 
         void

source/Plugins/Process/Linux/NativeProcessLinux.cpp

NativeProcessLinux::Monitor::RunMonitor(void *arg)
     static_cast<Monitor *>(arg)->MainLoop();
     return nullptr;
 }
 
 
 NativeProcessLinux::LaunchArgs::LaunchArgs(Module *module,
                                        char const **argv,
                                        char const **envp,
-                                       const std::string &stdin_path,
-                                       const std::string &stdout_path,
-                                       const std::string &stderr_path,
-                                       const char *working_dir,
+                                       const FileSpec &stdin_file_spec,
+                                       const FileSpec &stdout_file_spec,
+                                       const FileSpec &stderr_file_spec,
+                                       const FileSpec &working_dir,
                                        const ProcessLaunchInfo &launch_info)
     : m_module(module),
       m_argv(argv),
       m_envp(envp),
-      m_stdin_path(stdin_path),
-      m_stdout_path(stdout_path),
-      m_stderr_path(stderr_path),
+      m_stdin_file_spec(stdin_file_spec),
+      m_stdout_file_spec(stdout_file_spec),
+      m_stderr_file_spec(stderr_file_spec),
       m_working_dir(working_dir),
       m_launch_info(launch_info)
 {
 }
 
 NativeProcessLinux::LaunchArgs::~LaunchArgs()
 { }
 
 // -----------------------------------------------------------------------------
 // Public Static Methods
 // -----------------------------------------------------------------------------
 
 Error
 NativeProcessLinux::LaunchProcess (
     Module *exe_module,
     ProcessLaunchInfo &launch_info,
     NativeProcessProtocol::NativeDelegate &native_delegate,
     NativeProcessProtocolSP &native_process_sp)
 {
     Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
 
     Error error;
 
     // Verify the working directory is valid if one was specified.
-    const char* working_dir = launch_info.GetWorkingDirectory ();
-    if (working_dir)
+    FileSpec working_dir{launch_info.GetWorkingDirectory()};
+    if (working_dir && working_dir.GetFileType () != FileSpec::eFileTypeDirectory)
     {
-      FileSpec working_dir_fs (working_dir, true);
-      if (!working_dir_fs || working_dir_fs.GetFileType () != FileSpec::eFileTypeDirectory)
-      {
-          error.SetErrorStringWithFormat ("No such file or directory: %s", working_dir);
-          return error;
-      }
-    }
+        error.SetErrorStringWithFormat ("No such file or directory: %s",
+                working_dir.GetPath().c_str());
 
     const FileAction *file_action;
 
-    // Default of NULL will mean to use existing open file descriptors.
-    std::string stdin_path;
-    std::string stdout_path;
-    std::string stderr_path;
+    // Default of empty will mean to use existing open file descriptors.
+    FileSpec stdin_file_spec{};
+    FileSpec stdout_file_spec{};
+    FileSpec stderr_file_spec{};
 
     file_action = launch_info.GetFileActionForFD (STDIN_FILENO);
     if (file_action)
-        stdin_path = file_action->GetPath ();
+        stdin_file_spec = file_action->GetFileSpec();
 
     file_action = launch_info.GetFileActionForFD (STDOUT_FILENO);
     if (file_action)
-        stdout_path = file_action->GetPath ();
+        stdout_file_spec = file_action->GetFileSpec();
 
     file_action = launch_info.GetFileActionForFD (STDERR_FILENO);
     if (file_action)
-        stderr_path = file_action->GetPath ();
+        stderr_file_spec = file_action->GetFileSpec();
 
     if (log)
     {
-        if (!stdin_path.empty ())
-            log->Printf ("NativeProcessLinux::%s setting STDIN to '%s'", __FUNCTION__, stdin_path.c_str ());
+        if (stdin_file_spec)
+            log->Printf ("NativeProcessLinux::%s setting STDIN to '%s'",
+                    __FUNCTION__, stdin_file_spec.GetPath().c_str());
         else
             log->Printf ("NativeProcessLinux::%s leaving STDIN as is", __FUNCTION__);
 
-        if (!stdout_path.empty ())
-            log->Printf ("NativeProcessLinux::%s setting STDOUT to '%s'", __FUNCTION__, stdout_path.c_str ());
+        if (stdout_file_spec)
+            log->Printf ("NativeProcessLinux::%s setting STDOUT to '%s'",
+                    __FUNCTION__, stdout_file_spec.GetPath().c_str());
         else
             log->Printf ("NativeProcessLinux::%s leaving STDOUT as is", __FUNCTION__);
 
-        if (!stderr_path.empty ())
-            log->Printf ("NativeProcessLinux::%s setting STDERR to '%s'", __FUNCTION__, stderr_path.c_str ());
+        if (stderr_file_spec)
+            log->Printf ("NativeProcessLinux::%s setting STDERR to '%s'",
+                    __FUNCTION__, stderr_file_spec.GetPath().c_str());
         else
             log->Printf ("NativeProcessLinux::%s leaving STDERR as is", __FUNCTION__);
     }
 
     // Create the NativeProcessLinux in launch mode.
     native_process_sp.reset (new NativeProcessLinux ());
 
     if (log)
if (!native_process_sp->RegisterNativeDelegate (native_delegate))
         error.SetErrorStringWithFormat ("failed to register the native delegate");
         return error;
     }
 
     std::static_pointer_cast<NativeProcessLinux> (native_process_sp)->LaunchInferior (
             exe_module,
             launch_info.GetArguments ().GetConstArgumentVector (),
             launch_info.GetEnvironmentEntries ().GetConstArgumentVector (),
-            stdin_path,
-            stdout_path,
-            stderr_path,
+            stdin_file_spec,
+            stdout_file_spec,
+            stderr_file_spec,
             working_dir,
             launch_info,
             error);
 
     if (error.Fail ())
     {
         native_process_sp.reset ();
         if (log)

 // NativeProcessLinux spawns a new thread which performs all operations on the inferior process.
 // Refer to Monitor and Operation classes to see why this is necessary.
 //------------------------------------------------------------------------------
 void
 NativeProcessLinux::LaunchInferior (
     Module *module,
     const char *argv[],
     const char *envp[],
-    const std::string &stdin_path,
-    const std::string &stdout_path,
-    const std::string &stderr_path,
-    const char *working_dir,
+    const FileSpec &stdin_file_spec,
+    const FileSpec &stdout_file_spec,
+    const FileSpec &stderr_file_spec,
+    const FileSpec &working_dir,
     const ProcessLaunchInfo &launch_info,
     Error &error)
 {
     if (module)
         m_arch = module->GetArchitecture ();
 
     SetState (eStateLaunching);
 
     std::unique_ptr<LaunchArgs> args(
-        new LaunchArgs(
-            module, argv, envp,
-            stdin_path, stdout_path, stderr_path,
-            working_dir, launch_info));
+        new LaunchArgs(module, argv, envp,
+                       stdin_file_spec,
+                       stdout_file_spec,
+                       stderr_file_spec,
+                       working_dir,
+                       launch_info));
 
     StartMonitorThread ([&] (Error &e) { return Launch(args.get(), e); }, error);
     if (!error.Success ())
         return;
 }
 
 void
 NativeProcessLinux::AttachToInferior (lldb::pid_t pid, Error &error)

 
 ::pid_t
 NativeProcessLinux::Launch(LaunchArgs *args, Error &error)
 {
     assert (args && "null args");
 
     const char **argv = args->m_argv;
     const char **envp = args->m_envp;
-    const char *working_dir = args->m_working_dir;
+    const FileSpec working_dir = args->m_working_dir;
 
     lldb_utility::PseudoTerminal terminal;
     const size_t err_len = 1024;
     char err_str[err_len];
     lldb::pid_t pid;
     NativeThreadProtocolSP thread_sp;
 
     lldb::ThreadSP inferior;
if (pid == 0)
         // Attempt to have our own process group.
         if (setpgid(0, 0) != 0)
         {
             // FIXME log that this failed. This is common.
             // Don't allow this to prevent an inferior exec.
         }
 
         // Dup file descriptors if needed.
-        if (!args->m_stdin_path.empty ())
-            if (!DupDescriptor(args->m_stdin_path.c_str (), STDIN_FILENO, O_RDONLY))
+        if (args->m_stdin_file_spec)
+            if (!DupDescriptor(args->m_stdin_file_spec, STDIN_FILENO, O_RDONLY))
                 exit(eDupStdinFailed);
 
-        if (!args->m_stdout_path.empty ())
-            if (!DupDescriptor(args->m_stdout_path.c_str (), STDOUT_FILENO, O_WRONLY | O_CREAT | O_TRUNC))
+        if (args->m_stdout_file_spec)
+            if (!DupDescriptor(args->m_stdout_file_spec, STDOUT_FILENO, O_WRONLY | O_CREAT | O_TRUNC))
                 exit(eDupStdoutFailed);
 
-        if (!args->m_stderr_path.empty ())
-            if (!DupDescriptor(args->m_stderr_path.c_str (), STDERR_FILENO, O_WRONLY | O_CREAT | O_TRUNC))
+        if (args->m_stderr_file_spec)
+            if (!DupDescriptor(args->m_stderr_file_spec, STDERR_FILENO, O_WRONLY | O_CREAT | O_TRUNC))
                 exit(eDupStderrFailed);
 
         // Close everything besides stdin, stdout, and stderr that has no file
         // action to avoid leaking
         for (int fd = 3; fd < sysconf(_SC_OPEN_MAX); ++fd)
             if (!args->m_launch_info.GetFileActionForFD(fd))
                 close(fd);
 
         // Change working directory
-        if (working_dir != NULL && working_dir[0])
-          if (0 != ::chdir(working_dir))
+        if (working_dir && 0 != ::chdir(working_dir.GetPath().c_str()))
               exit(eChdirFailed);
 
         // Disable ASLR if requested.
         if (args->m_launch_info.GetFlags ().Test (lldb::eLaunchFlagDisableASLR))
         {
             const int old_personality = personality (LLDB_PERSONALITY_GET_CURRENT_SETTINGS);
             if (old_personality == -1)
             {
if (tid == LLDB_INVALID_THREAD_ID)
         return Error();
 
     DetachOperation op(tid);
     m_monitor_up->DoOperation(&op);
     return op.GetError();
 }
 
 bool
-NativeProcessLinux::DupDescriptor(const char *path, int fd, int flags)
+NativeProcessLinux::DupDescriptor(const FileSpec &file_spec, int fd, int flags)
 {
-    int target_fd = open(path, flags, 0666);
+    int target_fd = open(file_spec.GetPath().c_str(), flags, 0666);
 
     if (target_fd == -1)
         return false;
 
     if (dup2(target_fd, fd) == -1)
         return false;
 
     return (close(target_fd) == -1) ? false : true;

source/Plugins/Process/Linux/ProcessMonitor.h

 
 // C Includes
 #include <semaphore.h>
 #include <signal.h>
 
 // C++ Includes
 // Other libraries and framework includes
 #include "lldb/lldb-types.h"
+#include "lldb/Host/FileSpec.h"
 #include "lldb/Host/HostThread.h"
 #include "lldb/Host/Mutex.h"
 
 namespace lldb_private {
 
 class Error;
 class Module;
 class Scalar;

 public:
 
     /// Launches an inferior process ready for debugging.  Forms the
     /// implementation of Process::DoLaunch.
     ProcessMonitor(ProcessPOSIX *process,
                    lldb_private::Module *module,
                    char const *argv[],
                    char const *envp[],
-                   const char *stdin_path,
-                   const char *stdout_path,
-                   const char *stderr_path,
-                   const char *working_dir,
+                   const lldb_private::FileSpec &stdin_file_spec,
+                   const lldb_private::FileSpec &stdout_file_spec,
+                   const lldb_private::FileSpec &stderr_file_spec,
+                   const lldb_private::FileSpec &working_dir,
                    const lldb_private::ProcessLaunchInfo &launch_info,
                    lldb_private::Error &error);
 
     ProcessMonitor(ProcessPOSIX *process,
                    lldb::pid_t pid,
                    lldb_private::Error &error);
 
     ~ProcessMonitor();
private:
     /// @brief Simple structure to pass data to the thread responsible for
     /// launching a child process.
     struct LaunchArgs : OperationArgs
     {
         LaunchArgs(ProcessMonitor *monitor,
                    lldb_private::Module *module,
                    char const **argv,
                    char const **envp,
-                   const char *stdin_path,
-                   const char *stdout_path,
-                   const char *stderr_path,
-                   const char *working_dir,
+                   const lldb_private::FileSpec &stdin_file_spec,
+                   const lldb_private::FileSpec &stdout_file_spec,
+                   const lldb_private::FileSpec &stderr_file_spec,
+                   const lldb_private::FileSpec &working_dir,
                    const lldb_private::ProcessLaunchInfo &launch_info);
 
         ~LaunchArgs();
 
-        lldb_private::Module *m_module; // The executable image to launch.
-        char const **m_argv;            // Process arguments.
-        char const **m_envp;            // Process environment.
-        const char *m_stdin_path;       // Redirect stdin or NULL.
-        const char *m_stdout_path;      // Redirect stdout or NULL.
-        const char *m_stderr_path;      // Redirect stderr or NULL.
-        const char *m_working_dir;      // Working directory or NULL.
+        lldb_private::Module *m_module;                   // The executable image to launch.
+        char const **m_argv;                              // Process arguments.
+        char const **m_envp;                              // Process environment.
+        const lldb_private::FileSpec &m_stdin_file_spec;  // Redirect stdin or empty.
+        const lldb_private::FileSpec &m_stdout_file_spec; // Redirect stdout or empty.
+        const lldb_private::FileSpec &m_stderr_file_spec; // Redirect stderr or empty.
+        const lldb_private::FileSpec &m_working_dir;      // Working directory or empty.
         const lldb_private::ProcessLaunchInfo &m_launch_info;
     };
 
     void
     StartLaunchOpThread(LaunchArgs *args, lldb_private::Error &error);
 
     static void *
     LaunchOpThread(void *arg);
private:
 
     static bool
     SetDefaultPtraceOpts(const lldb::pid_t);
 
     static void
     ServeOperation(OperationArgs *args);
 
     static bool
-    DupDescriptor(const char *path, int fd, int flags);
+    DupDescriptor(const lldb_private::FileSpec &file_spec, int fd, int flags);
 
     static bool
     MonitorCallback(void *callback_baton,
                     lldb::pid_t pid, bool exited, int signal, int status);
 
     static ProcessMessage
     MonitorSIGTRAP(ProcessMonitor *monitor,
                    const siginfo_t *info, lldb::pid_t pid);

source/Plugins/Process/Linux/ProcessMonitor.cpp

 {
     sem_destroy(&m_semaphore);
 }
 
 ProcessMonitor::LaunchArgs::LaunchArgs(ProcessMonitor *monitor,
                                        lldb_private::Module *module,
                                        char const **argv,
                                        char const **envp,
-                                       const char *stdin_path,
-                                       const char *stdout_path,
-                                       const char *stderr_path,
-                                       const char *working_dir,
+                                       const FileSpec &stdin_file_spec,
+                                       const FileSpec &stdout_file_spec,
+                                       const FileSpec &stderr_file_spec,
+                                       const FileSpec &working_dir,
                                        const lldb_private::ProcessLaunchInfo &launch_info)
     : OperationArgs(monitor),
       m_module(module),
       m_argv(argv),
       m_envp(envp),
-      m_stdin_path(stdin_path),
-      m_stdout_path(stdout_path),
-      m_stderr_path(stderr_path),
+      m_stdin_file_spec(stdin_file_spec),
+      m_stdout_file_spec(stdout_file_spec),
+      m_stderr_file_spec(stderr_file_spec),
       m_working_dir(working_dir),
       m_launch_info(launch_info)
 {
 }
 
 ProcessMonitor::LaunchArgs::~LaunchArgs()
 { }
 

 /// The second thread (@see OperationThread) is responsible for two things 1)
 /// launching or attaching to the inferior process, and then 2) servicing
 /// operations such as register reads/writes, stepping, etc.  See the comments
 /// on the Operation class for more info as to why this is needed.
 ProcessMonitor::ProcessMonitor(ProcessPOSIX *process,
                                Module *module,
                                const char *argv[],
                                const char *envp[],
-                               const char *stdin_path,
-                               const char *stdout_path,
-                               const char *stderr_path,
-                               const char *working_dir,
+                               const FileSpec &stdin_file_spec,
+                               const FileSpec &stdout_file_spec,
+                               const FileSpec &stderr_file_spec,
+                               const FileSpec &working_dir,
                                const lldb_private::ProcessLaunchInfo &launch_info,
                                lldb_private::Error &error)
     : m_process(static_cast<ProcessLinux *>(process)),
       m_operation_thread(LLDB_INVALID_HOST_THREAD),
       m_monitor_thread(LLDB_INVALID_HOST_THREAD),
       m_pid(LLDB_INVALID_PROCESS_ID),
       m_terminal_fd(-1),
       m_operation(0)
 {
     std::unique_ptr<LaunchArgs> args(new LaunchArgs(this, module, argv, envp,
-                                     stdin_path, stdout_path, stderr_path,
-                                     working_dir, launch_info));
+                                                    stdin_file_spec,
+                                                    stdout_file_spec,
+                                                    stderr_file_spec,
+                                                    working_dir,
+                                                    launch_info));
 
     sem_init(&m_operation_pending, 0, 0);
     sem_init(&m_operation_done, 0, 0);
 
     StartLaunchOpThread(args.get(), error);
     if (!error.Success())
         return;
 
ProcessMonitor::Launch(LaunchArgs *args)
     assert (args && "null args");
     if (!args)
         return false;
 
     ProcessMonitor *monitor = args->m_monitor;
     ProcessLinux &process = monitor->GetProcess();
     const char **argv = args->m_argv;
     const char **envp = args->m_envp;
-    const char *stdin_path = args->m_stdin_path;
-    const char *stdout_path = args->m_stdout_path;
-    const char *stderr_path = args->m_stderr_path;
-    const char *working_dir = args->m_working_dir;
+    const FileSpec &stdin_file_spec = args->m_stdin_file_spec;
+    const FileSpec &stdout_file_spec = args->m_stdout_file_spec;
+    const FileSpec &stderr_file_spec = args->m_stderr_file_spec;
+    const FileSpec &working_dir = args->m_working_dir;
 
     lldb_utility::PseudoTerminal terminal;
     const size_t err_len = 1024;
     char err_str[err_len];
     lldb::pid_t pid;
 
     lldb::ThreadSP inferior;
     Log *log (ProcessPOSIXLog::GetLogIfAllCategoriesSet (POSIX_LOG_PROCESS));
if (pid == 0)
 
         // Let us have our own process group.
         setpgid(0, 0);
 
         // Dup file descriptors if needed.
         //
         // FIXME: If two or more of the paths are the same we needlessly open
         // the same file multiple times.
-        if (stdin_path != NULL && stdin_path[0])
-            if (!DupDescriptor(stdin_path, STDIN_FILENO, O_RDONLY))
+        if (stdin_file_spec)
+            if (!DupDescriptor(stdin_file_spec, STDIN_FILENO, O_RDONLY))
                 exit(eDupStdinFailed);
 
-        if (stdout_path != NULL && stdout_path[0])
-            if (!DupDescriptor(stdout_path, STDOUT_FILENO, O_WRONLY | O_CREAT))
+        if (stdout_file_spec)
+            if (!DupDescriptor(stdout_file_spec, STDOUT_FILENO, O_WRONLY | O_CREAT))
                 exit(eDupStdoutFailed);
 
-        if (stderr_path != NULL && stderr_path[0])
-            if (!DupDescriptor(stderr_path, STDERR_FILENO, O_WRONLY | O_CREAT))
+        if (stderr_file_spec)
+            if (!DupDescriptor(stderr_file_spec, STDERR_FILENO, O_WRONLY | O_CREAT))
                 exit(eDupStderrFailed);
 
         // Change working directory
-        if (working_dir != NULL && working_dir[0])
-          if (0 != ::chdir(working_dir))
+        if (working_dir)
+            if (0 != ::chdir(working_dir.GetPath().c_str()))
                 exit(eChdirFailed);
 
         // Disable ASLR if requested.
         if (args->m_launch_info.GetFlags ().Test (lldb::eLaunchFlagDisableASLR))
         {
             const int old_personality = personality (LLDB_PERSONALITY_GET_CURRENT_SETTINGS);
             if (old_personality == -1)
             {
                 if (log)
ProcessMonitor::Detach(lldb::tid_t tid)
     {
         DetachOperation op(tid, error);
         DoOperation(&op);
     }
     return error;
 }
 
 bool
-ProcessMonitor::DupDescriptor(const char *path, int fd, int flags)
+ProcessMonitor::DupDescriptor(const FileSpec &file_spec, int fd, int flags)
 {
-    int target_fd = open(path, flags, 0666);
+    int target_fd = open(file_spec.GetPath().c_str(), flags, 0666);
 
     if (target_fd == -1)
         return false;
 
     if (dup2(target_fd, fd) == -1)
         return false;
 
     return (close(target_fd) == -1) ? false : true;

source/Plugins/Process/POSIX/ProcessPOSIX.h

public:
 
     /// Registers the given message with this process.
     virtual void
     SendMessage(const ProcessMessage &message);
 
     ProcessMonitor &
     GetMonitor() { assert(m_monitor); return *m_monitor; }
 
-    const char *GetFilePath(const lldb_private::FileAction *file_action, const char *default_path,
-                            const char *dbg_pts_path);
+    lldb_private::FileSpec
+    GetFileSpec(const lldb_private::FileAction *file_action,
+                const lldb_private::FileSpec &default_file_spec,
+                const lldb_private::FileSpec &dbg_pts_file_spec);
 
     /// Stops all threads in the process.
     /// The \p stop_tid parameter indicates the thread which initiated the stop.
     virtual void
     StopAllThreads(lldb::tid_t stop_tid);
 
     /// Adds the thread to the list of threads for which we have received the initial stopping signal.
     /// The \p stop_tid parameter indicates the thread which the stop happened for.

source/Plugins/Process/POSIX/ProcessPOSIX.cpp

: Process(target, listener, unix_signals_sp),
       m_monitor(NULL),
       m_module(NULL),
       m_message_mutex (Mutex::eMutexTypeRecursive),
       m_exit_now(false),
       m_seen_initial_stop()
 {
     // FIXME: Putting this code in the ctor and saving the byte order in a
     // member variable is a hack to avoid const qual issues in GetByteOrder.
-  lldb::ModuleSP module = GetTarget().GetExecutableModule();
-  if (module && module->GetObjectFile())
-    m_byte_order = module->GetObjectFile()->GetByteOrder();
+    lldb::ModuleSP module = GetTarget().GetExecutableModule();
+    if (module && module->GetObjectFile())
+        m_byte_order = module->GetObjectFile()->GetByteOrder();
 }
 
 ProcessPOSIX::~ProcessPOSIX()
 {
     delete m_monitor;
 }
 
 //------------------------------------------------------------------------------

 
 Error
 ProcessPOSIX::WillLaunch(Module* module)
 {
     Error error;
     return error;
 }
 
-const char *
-ProcessPOSIX::GetFilePath(const lldb_private::FileAction *file_action, const char *default_path,
-                          const char *dbg_pts_path)
+FileSpec
+ProcessPOSIX::GetFileSpec(const lldb_private::FileAction *file_action,
+                          const FileSpec &default_file_spec,
+                          const FileSpec &dbg_pts_file_spec)
 {
-    const char *path = NULL;
+    FileSpec file_spec{};
 
-    if (file_action)
+    if (file_action && file_action->GetAction() == FileAction::eFileActionOpen)
     {
-        if (file_action->GetAction() == FileAction::eFileActionOpen)
-        {
-            path = file_action->GetPath();
-            // By default the stdio paths passed in will be pseudo-terminal
-            // (/dev/pts). If so, convert to using a different default path
-            // instead to redirect I/O to the debugger console. This should
-            //  also handle user overrides to /dev/null or a different file.
-            if (!path || (dbg_pts_path &&
-                          ::strncmp(path, dbg_pts_path, ::strlen(dbg_pts_path)) == 0))
-                path = default_path;
-        }
+        file_spec = file_action->GetFileSpec();
+        // also handle user overrides to /dev/null or a different file.
+        if (!file_spec || file_spec == dbg_pts_file_spec)
+            file_spec = default_file_spec;
     }
-    return path;
+    return file_spec;
 }
 
 Error
 ProcessPOSIX::DoLaunch (Module *module,
                         ProcessLaunchInfo &launch_info)
 {
     Error error;
     assert(m_monitor == NULL);
 
-    const char* working_dir = launch_info.GetWorkingDirectory();
-    if (working_dir) {
-      FileSpec WorkingDir(working_dir, true);
-      if (!WorkingDir || WorkingDir.GetFileType() != FileSpec::eFileTypeDirectory)
-      {
-          error.SetErrorStringWithFormat("No such file or directory: %s", working_dir);
-          return error;
-      }
-    }
+    FileSpec working_dir = launch_info.GetWorkingDirectory();
+    if (working_dir && working_dir.GetFileType() != FileSpec::eFileTypeDirectory)
+        error.SetErrorStringWithFormat("No such file or directory: %s",
+                working_dir.GetPath().c_str());
 
     SetPrivateState(eStateLaunching);
 
     const lldb_private::FileAction *file_action;
 
-    // Default of NULL will mean to use existing open file descriptors
-    const char *stdin_path = NULL;
-    const char *stdout_path = NULL;
-    const char *stderr_path = NULL;
+    // Default of empty will mean to use existing open file descriptors
+    FileSpec stdin_file_spec{};
+    FileSpec stdout_file_spec{};
+    FileSpec stderr_file_spec{};
 
-    const char * dbg_pts_path = launch_info.GetPTY().GetSlaveName(NULL,0);
+    const FileSpec dbg_pts_file_spec{launch_info.GetPTY().GetSlaveName(NULL,0), false};
 
     file_action = launch_info.GetFileActionForFD (STDIN_FILENO);
-    stdin_path = GetFilePath(file_action, stdin_path, dbg_pts_path);
+    stdin_file_spec = GetFileSpec(file_action, stdin_file_spec, dbg_pts_file_spec);
 
     file_action = launch_info.GetFileActionForFD (STDOUT_FILENO);
-    stdout_path = GetFilePath(file_action, stdout_path, dbg_pts_path);
+    stdout_file_spec = GetFileSpec(file_action, stdout_file_spec, dbg_pts_file_spec);
 
     file_action = launch_info.GetFileActionForFD (STDERR_FILENO);
-    stderr_path = GetFilePath(file_action, stderr_path, dbg_pts_path);
+    stderr_file_spec = GetFileSpec(file_action, stderr_file_spec, dbg_pts_file_spec);
 
-    m_monitor = new ProcessMonitor (this, 
-                                    module,
-                                    launch_info.GetArguments().GetConstArgumentVector(), 
-                                    launch_info.GetEnvironmentEntries().GetConstArgumentVector(),
-                                    stdin_path, 
-                                    stdout_path, 
-                                    stderr_path,
-                                    working_dir,
-                                    launch_info,
-                                    error);
+    m_monitor = new ProcessMonitor(this,
+                                   launch_info.GetArguments().GetConstArgumentVector(),
+                                   stdin_file_spec,
+                                   stdout_file_spec,
+                                   stderr_file_spec,
 
     m_module = module;
 
     if (!error.Success())
         return error;
 
     int terminal = m_monitor->GetTerminalFD();
     if (terminal >= 0) {

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

public:
     ///
     /// @param[in] path
     ///     The path to use for stdin/out/err
     ///
     /// @return
     ///     Zero if the for success, or an error code for failure.
     //------------------------------------------------------------------
     int
-    SetSTDIN (char const *path);
+    SetSTDIN(const FileSpec &file_spec);
     int
-    SetSTDOUT (char const *path);
+    SetSTDOUT(const FileSpec &file_spec);
     int
-    SetSTDERR (char const *path);
+    SetSTDERR(const FileSpec &file_spec);
 
     //------------------------------------------------------------------
     /// Sets the disable ASLR flag to \a enable for a process that will 
     /// be launched with the 'A' packet.
     ///
     /// @param[in] enable
     ///     A boolean value indicating whether to disable ASLR or not.
     ///
public:
 
     //------------------------------------------------------------------
     /// Sets the working directory to \a path for a process that will 
     /// be launched with the 'A' packet for non platform based
     /// connections. If this packet is sent to a GDB server that
     /// implements the platform, it will change the current working
     /// directory for the platform process.
     ///
-    /// @param[in] path
+    /// @param[in] working_dir
     ///     The path to a directory to use when launching our process
     ///
     /// @return
     ///     Zero if the for success, or an error code for failure.
     //------------------------------------------------------------------
     int
-    SetWorkingDir (char const *path);
+    SetWorkingDir(const FileSpec &working_dir);
 
     //------------------------------------------------------------------
     /// Gets the current working directory of a remote platform GDB
     /// server.
     ///
-    /// @param[out] cwd
+    /// @param[out] working_dir
     ///     The current working directory on the remote platform.
     ///
     /// @return
     ///     Boolean for success
     //------------------------------------------------------------------
     bool
-    GetWorkingDir (std::string &cwd);
+    GetWorkingDir(FileSpec &working_dir);
 
     lldb::addr_t
     AllocateMemory (size_t size, uint32_t permissions);
 
     bool
     DeallocateMemory (lldb::addr_t addr);
 
     Error
public:
     
     bool
     CloseFile (lldb::user_id_t fd, Error &error);
     
     lldb::user_id_t
     GetFileSize (const FileSpec& file_spec);
     
     Error
-    GetFilePermissions(const char *path, uint32_t &file_permissions);
+    GetFilePermissions(const FileSpec &file_spec, uint32_t &file_permissions);
 
     Error
-    SetFilePermissions(const char *path, uint32_t file_permissions);
+    SetFilePermissions(const FileSpec &file_spec, uint32_t file_permissions);
 
     uint64_t
     ReadFile (lldb::user_id_t fd,
               uint64_t offset,
               void *dst,
               uint64_t dst_len,
               Error &error);
     
     uint64_t
     WriteFile (lldb::user_id_t fd,
                uint64_t offset,
                const void* src,
                uint64_t src_len,
                Error &error);
     
     Error
-    CreateSymlink (const char *src,
-                   const char *dst);
+    CreateSymlink(const FileSpec &src,
+                  const FileSpec &dst);
     
     Error
-    Unlink (const char *path);
+    Unlink(const FileSpec &file_spec);
 
     Error
-    MakeDirectory (const char *path, uint32_t mode);
-    
+    MakeDirectory(const FileSpec &file_spec, uint32_t mode);
     bool
     GetFileExists (const FileSpec& file_spec);
     
     Error
-    RunShellCommand (const char *command,           // Shouldn't be NULL
-                     const char *working_dir,       // Pass NULL to use the current working directory
-                     int *status_ptr,               // Pass NULL if you don't want the process exit status
-                     int *signo_ptr,                // Pass NULL if you don't want the signal that caused the process to exit
-                     std::string *command_output,   // Pass NULL if you don't want the command output
-                     uint32_t timeout_sec);         // Timeout in seconds to wait for shell program to finish
-    
+    RunShellCommand(const char *command,           // Shouldn't be NULL
+                    const FileSpec &working_dir,   // Pass empty FileSpec to use the current working directory
     bool
     CalculateMD5 (const FileSpec& file_spec, uint64_t &high, uint64_t &low);
     
     std::string
     HarmonizeThreadIdsForProfileData (ProcessGDBRemote *process,
                                       StringExtractorGDBRemote &inputStringExtractor);
 
     bool

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

GDBRemoteCommunicationClient::SendArgumentsPacket (const ProcessLaunchInfo &launch_info)
     // Since we don't get the send argv0 separate from the executable path, we need to
     // make sure to use the actual executable path found in the launch_info...
     std::vector<const char *> argv;
     FileSpec exe_file = launch_info.GetExecutableFile();
     std::string exe_path;
     const char *arg = NULL;
     const Args &launch_args = launch_info.GetArguments();
     if (exe_file)
-        exe_path = exe_file.GetPath();
+        exe_path = exe_file.GetPath(false);
     else
     {
         arg = launch_args.GetArgumentAtIndex(0);
         if (arg)
             exe_path = arg;
     }
     if (!exe_path.empty())
     {
GDBRemoteCommunicationClient::GetWatchpointsTriggerAfterInstruction (bool &after)
     if (m_qHostInfo_is_valid != eLazyBoolYes)
         after = true;
     else
         after = (m_watchpoints_trigger_after_instruction != eLazyBoolNo);
     return error;
 }
 
 int
-GDBRemoteCommunicationClient::SetSTDIN (char const *path)
+GDBRemoteCommunicationClient::SetSTDIN(const FileSpec &file_spec)
 {
-    if (path && path[0])
+    if (file_spec)
     {
+        std::string path{file_spec.GetPath(false)};
         StreamString packet;
         packet.PutCString("QSetSTDIN:");
-        packet.PutBytesAsRawHex8(path, strlen(path));
+        packet.PutCStringAsRawHex8(path.c_str());
 
         StringExtractorGDBRemote response;
         if (SendPacketAndWaitForResponse (packet.GetData(), packet.GetSize(), response, false) == PacketResult::Success)
         {
             if (response.IsOKResponse())
                 return 0;
             uint8_t error = response.GetError();
             if (error)
                 return error;
         }
     }
     return -1;
 }
 
 int
-GDBRemoteCommunicationClient::SetSTDOUT (char const *path)
+GDBRemoteCommunicationClient::SetSTDOUT(const FileSpec &file_spec)
 {
-    if (path && path[0])
+    if (file_spec)
     {
+        std::string path{file_spec.GetPath(false)};
         StreamString packet;
         packet.PutCString("QSetSTDOUT:");
-        packet.PutBytesAsRawHex8(path, strlen(path));
-        
+        packet.PutCStringAsRawHex8(path.c_str());
         StringExtractorGDBRemote response;
         if (SendPacketAndWaitForResponse (packet.GetData(), packet.GetSize(), response, false) == PacketResult::Success)
         {
             if (response.IsOKResponse())
                 return 0;
             uint8_t error = response.GetError();
             if (error)
                 return error;
         }
     }
     return -1;
 }
 
 int
-GDBRemoteCommunicationClient::SetSTDERR (char const *path)
+GDBRemoteCommunicationClient::SetSTDERR(const FileSpec &file_spec)
 {
-    if (path && path[0])
+    if (file_spec)
     {
+        std::string path{file_spec.GetPath(false)};
         StreamString packet;
         packet.PutCString("QSetSTDERR:");
-        packet.PutBytesAsRawHex8(path, strlen(path));
-        
+        packet.PutCStringAsRawHex8(path.c_str());
         StringExtractorGDBRemote response;
         if (SendPacketAndWaitForResponse (packet.GetData(), packet.GetSize(), response, false) == PacketResult::Success)
         {
             if (response.IsOKResponse())
                 return 0;
             uint8_t error = response.GetError();
             if (error)
                 return error;
         }
     }
     return -1;
 }
 
 bool
-GDBRemoteCommunicationClient::GetWorkingDir (std::string &cwd)
+GDBRemoteCommunicationClient::GetWorkingDir(FileSpec &working_dir)
 {
     StringExtractorGDBRemote response;
     if (SendPacketAndWaitForResponse ("qGetWorkingDir", response, false) == PacketResult::Success)
     {
         if (response.IsUnsupportedResponse())
             return false;
         if (response.IsErrorResponse())
             return false;
-        response.GetHexByteString (cwd);
+        std::string cwd;
+        response.GetHexByteString(cwd);
+        working_dir = FileSpec{cwd.c_str(), false};
         return !cwd.empty();
     }
     return false;
 }
 
 int
-GDBRemoteCommunicationClient::SetWorkingDir (char const *path)
+GDBRemoteCommunicationClient::SetWorkingDir(const FileSpec &working_dir)
 {
-    if (path && path[0])
+    if (working_dir)
     {
+        std::string path{working_dir.GetPath(false)};
         StreamString packet;
         packet.PutCString("QSetWorkingDir:");
-        packet.PutBytesAsRawHex8(path, strlen(path));
-        
+        packet.PutCStringAsRawHex8(path.c_str());
         StringExtractorGDBRemote response;
         if (SendPacketAndWaitForResponse (packet.GetData(), packet.GetSize(), response, false) == PacketResult::Success)
         {
             if (response.IsOKResponse())
                 return 0;
             uint8_t error = response.GetError();
             if (error)
                 return error;
if (!IsRunning())
             if (response.IsNormalResponse())
                 return response.GetHexMaxU64(false, LLDB_INVALID_ADDRESS);
         }
     }
     return LLDB_INVALID_ADDRESS;
 }
 
 lldb_private::Error
-GDBRemoteCommunicationClient::RunShellCommand (const char *command,           // Shouldn't be NULL
-                                               const char *working_dir,       // Pass NULL to use the current working directory
-                                               int *status_ptr,               // Pass NULL if you don't want the process exit status
-                                               int *signo_ptr,                // Pass NULL if you don't want the signal that caused the process to exit
-                                               std::string *command_output,   // Pass NULL if you don't want the command output
-                                               uint32_t timeout_sec)          // Timeout in seconds to wait for shell program to finish
+GDBRemoteCommunicationClient::RunShellCommand(const char *command,           // Shouldn't be NULL
+                                              const FileSpec &working_dir,   // Pass empty FileSpec to use the current working directory
 {
     lldb_private::StreamString stream;
     stream.PutCString("qPlatform_shell:");
     stream.PutBytesAsRawHex8(command, strlen(command));
     stream.PutChar(',');
     stream.PutHex32(timeout_sec);
-    if (working_dir && *working_dir)
+    if (working_dir)
     {
+        std::string path{working_dir.GetPath(false)};
         stream.PutChar(',');
-        stream.PutBytesAsRawHex8(working_dir, strlen(working_dir));
+        stream.PutCStringAsRawHex8(path.c_str());
     }
     const char *packet = stream.GetData();
     int packet_len = stream.GetSize();
     StringExtractorGDBRemote response;
     if (SendPacketAndWaitForResponse(packet, packet_len, response, false) == PacketResult::Success)
     {
         if (response.GetChar() != 'F')
             return Error("malformed reply");
if (SendPacketAndWaitForResponse(packet, packet_len, response, false) == PacketResult::Success)
         if (command_output)
             command_output->assign(output);
         return Error();
     }
     return Error("unable to send packet");
 }
 
 Error
-GDBRemoteCommunicationClient::MakeDirectory (const char *path,
-                                             uint32_t file_permissions)
+GDBRemoteCommunicationClient::MakeDirectory(const FileSpec &file_spec,
 {
+    std::string path{file_spec.GetPath(false)};
     lldb_private::StreamString stream;
     stream.PutCString("qPlatform_mkdir:");
     stream.PutHex32(file_permissions);
     stream.PutChar(',');
-    stream.PutBytesAsRawHex8(path, strlen(path));
+    stream.PutCStringAsRawHex8(path.c_str());
     const char *packet = stream.GetData();
     int packet_len = stream.GetSize();
     StringExtractorGDBRemote response;
 
     if (SendPacketAndWaitForResponse(packet, packet_len, response, false) != PacketResult::Success)
         return Error("failed to send '%s' packet", packet);
 
     if (response.GetChar() != 'F')
         return Error("invalid response to '%s' packet", packet);
 
     return Error(response.GetU32(UINT32_MAX), eErrorTypePOSIX);
 }
 
 Error
-GDBRemoteCommunicationClient::SetFilePermissions (const char *path,
-                                                  uint32_t file_permissions)
+GDBRemoteCommunicationClient::SetFilePermissions(const FileSpec &file_spec,
 {
+    std::string path{file_spec.GetPath(false)};
     lldb_private::StreamString stream;
     stream.PutCString("qPlatform_chmod:");
     stream.PutHex32(file_permissions);
     stream.PutChar(',');
-    stream.PutBytesAsRawHex8(path, strlen(path));
+    stream.PutCStringAsRawHex8(path.c_str());
     const char *packet = stream.GetData();
     int packet_len = stream.GetSize();
     StringExtractorGDBRemote response;
 
     if (SendPacketAndWaitForResponse(packet, packet_len, response, false) != PacketResult::Success)
         return Error("failed to send '%s' packet", packet);
 
     if (response.GetChar() != 'F')
ParseHostIOPacketResponse (StringExtractorGDBRemote &response,
     return  result;
 }
 lldb::user_id_t
 GDBRemoteCommunicationClient::OpenFile (const lldb_private::FileSpec& file_spec,
                                         uint32_t flags,
                                         mode_t mode,
                                         Error &error)
 {
+    std::string path(file_spec.GetPath(false));
     lldb_private::StreamString stream;
     stream.PutCString("vFile:open:");
-    std::string path (file_spec.GetPath(false));
     if (path.empty())
         return UINT64_MAX;
     stream.PutCStringAsRawHex8(path.c_str());
     stream.PutChar(',');
     stream.PutHex32(flags);
     stream.PutChar(',');
     stream.PutHex32(mode);
     const char* packet = stream.GetData();
GDBRemoteCommunicationClient::CloseFile (lldb::user_id_t fd,
     }
     return false;
 }
 
 // Extension of host I/O packets to get the file size.
 lldb::user_id_t
 GDBRemoteCommunicationClient::GetFileSize (const lldb_private::FileSpec& file_spec)
 {
+    std::string path(file_spec.GetPath(false));
     lldb_private::StreamString stream;
     stream.PutCString("vFile:size:");
-    std::string path (file_spec.GetPath());
     stream.PutCStringAsRawHex8(path.c_str());
     const char* packet = stream.GetData();
     int packet_len = stream.GetSize();
     StringExtractorGDBRemote response;
     if (SendPacketAndWaitForResponse(packet, packet_len, response, false) == PacketResult::Success)
     {
         if (response.GetChar() != 'F')
             return UINT64_MAX;
         uint32_t retcode = response.GetHexMaxU64(false, UINT64_MAX);
         return retcode;
     }
     return UINT64_MAX;
 }
 
 Error
-GDBRemoteCommunicationClient::GetFilePermissions(const char *path, uint32_t &file_permissions)
+GDBRemoteCommunicationClient::GetFilePermissions(const FileSpec &file_spec,
+                                                 uint32_t &file_permissions)
 {
+    std::string path{file_spec.GetPath(false)};
     Error error;
     lldb_private::StreamString stream;
     stream.PutCString("vFile:mode:");
-    stream.PutCStringAsRawHex8(path);
+    stream.PutCStringAsRawHex8(path.c_str());
     const char* packet = stream.GetData();
     int packet_len = stream.GetSize();
     StringExtractorGDBRemote response;
     if (SendPacketAndWaitForResponse(packet, packet_len, response, false) == PacketResult::Success)
     {
         if (response.GetChar() != 'F')
         {
             error.SetErrorStringWithFormat ("invalid response to '%s' packet", packet);
GDBRemoteCommunicationClient::WriteFile (lldb::user_id_t fd,
     else
     {
         error.SetErrorString ("failed to send vFile:pwrite packet");
     }
     return 0;
 }
 
 Error
-GDBRemoteCommunicationClient::CreateSymlink (const char *src, const char *dst)
+GDBRemoteCommunicationClient::CreateSymlink(const FileSpec &src, const FileSpec &dst)
 {
+    std::string src_path{src.GetPath(false)},
+                dst_path{dst.GetPath(false)};
     Error error;
     lldb_private::StreamGDBRemote stream;
     stream.PutCString("vFile:symlink:");
     // the unix symlink() command reverses its parameters where the dst if first,
     // so we follow suit here
-    stream.PutCStringAsRawHex8(dst);
+    stream.PutCStringAsRawHex8(dst_path.c_str());
     stream.PutChar(',');
-    stream.PutCStringAsRawHex8(src);
+    stream.PutCStringAsRawHex8(src_path.c_str());
     const char* packet = stream.GetData();
     int packet_len = stream.GetSize();
     StringExtractorGDBRemote response;
     if (SendPacketAndWaitForResponse(packet, packet_len, response, false) == PacketResult::Success)
     {
         if (response.GetChar() == 'F')
         {
             uint32_t result = response.GetU32(UINT32_MAX);
GDBRemoteCommunicationClient::CreateSymlink(const FileSpec &src, const FileSpec &dst)
     else
     {
         error.SetErrorString ("failed to send vFile:symlink packet");
     }
     return error;
 }
 
 Error
-GDBRemoteCommunicationClient::Unlink (const char *path)
+GDBRemoteCommunicationClient::Unlink(const FileSpec &file_spec)
 {
+    std::string path{file_spec.GetPath(false)};
     Error error;
     lldb_private::StreamGDBRemote stream;
     stream.PutCString("vFile:unlink:");
     // the unix symlink() command reverses its parameters where the dst if first,
     // so we follow suit here
-    stream.PutCStringAsRawHex8(path);
+    stream.PutCStringAsRawHex8(path.c_str());
     const char* packet = stream.GetData();
     int packet_len = stream.GetSize();
     StringExtractorGDBRemote response;
     if (SendPacketAndWaitForResponse(packet, packet_len, response, false) == PacketResult::Success)
     {
         if (response.GetChar() == 'F')
         {
             uint32_t result = response.GetU32(UINT32_MAX);
GDBRemoteCommunicationClient::Unlink(const FileSpec &file_spec)
     }
     return error;
 }
 
 // Extension of host I/O packets to get whether a file exists.
 bool
 GDBRemoteCommunicationClient::GetFileExists (const lldb_private::FileSpec& file_spec)
 {
+    std::string path(file_spec.GetPath(false));
     lldb_private::StreamString stream;
     stream.PutCString("vFile:exists:");
-    std::string path (file_spec.GetPath());
     stream.PutCStringAsRawHex8(path.c_str());
     const char* packet = stream.GetData();
     int packet_len = stream.GetSize();
     StringExtractorGDBRemote response;
     if (SendPacketAndWaitForResponse(packet, packet_len, response, false) == PacketResult::Success)
     {
         if (response.GetChar() != 'F')
             return false;
         if (response.GetChar() != ',')
             return false;
         bool retcode = (response.GetChar() != '0');
         return retcode;
     }
     return false;
 }
 
 bool
 GDBRemoteCommunicationClient::CalculateMD5 (const lldb_private::FileSpec& file_spec,
                                             uint64_t &high,
                                             uint64_t &low)
 {
+    std::string path(file_spec.GetPath(false));
     lldb_private::StreamString stream;
     stream.PutCString("vFile:MD5:");
-    std::string path (file_spec.GetPath());
     stream.PutCStringAsRawHex8(path.c_str());
     const char* packet = stream.GetData();
     int packet_len = stream.GetSize();
     StringExtractorGDBRemote response;
     if (SendPacketAndWaitForResponse(packet, packet_len, response, false) == PacketResult::Success)
     {
         if (response.GetChar() != 'F')
             return false;
GDBRemoteCommunicationClient::GetModuleInfo (const FileSpec& module_file_spec,
     if (module_path.empty ())
         return false;
 
     StreamString packet;
     packet.PutCString("qModuleInfo:");
     packet.PutCStringAsRawHex8(module_path.c_str());
     packet.PutCString(";");
     const auto& triple = arch_spec.GetTriple().getTriple();
-    packet.PutBytesAsRawHex8(triple.c_str(), triple.size());
+    packet.PutCStringAsRawHex8(triple.c_str());
 
     StringExtractorGDBRemote response;
     if (SendPacketAndWaitForResponse (packet.GetData(), packet.GetSize(), response, false) != PacketResult::Success)
         return false;
 
     if (response.IsErrorResponse () || response.IsUnsupportedResponse ())
         return false;
 

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

 GDBRemoteCommunicationServerCommon::Handle_vFile_Mode (StringExtractorGDBRemote &packet)
 {
     packet.SetFilePos(::strlen("vFile:mode:"));
     std::string path;
     packet.GetHexByteString(path);
     if (!path.empty())
     {
         Error error;
         const uint32_t mode = File::GetPermissions(path.c_str(), error);
         StreamString response;
         response.Printf("F%u", mode);
         if (mode == 0 || error.Fail())
             response.Printf(",%i", (int)error.GetError());
         return SendPacketNoLock(response.GetData(), response.GetSize());
     }
     return SendErrorResponse(23);
 }

 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerCommon::Handle_vFile_symlink (StringExtractorGDBRemote &packet)
 {
     packet.SetFilePos(::strlen("vFile:symlink:"));
     std::string dst, src;
     packet.GetHexByteStringTerminatedBy(dst, ',');
     packet.GetChar(); // Skip ',' char
     packet.GetHexByteString(src);
     Error error = FileSystem::Symlink(src.c_str(), dst.c_str());
     StreamString response;
     response.Printf("F%u,%u", error.GetError(), error.GetError());
     return SendPacketNoLock(response.GetData(), response.GetSize());
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerCommon::Handle_vFile_unlink (StringExtractorGDBRemote &packet)
 {
     packet.SetFilePos(::strlen("vFile:unlink:"));
     std::string path;
     packet.GetHexByteString(path);
     Error error = FileSystem::Unlink(path.c_str());
     StreamString response;
     response.Printf("F%u,%u", error.GetError(), error.GetError());
     return SendPacketNoLock(response.GetData(), response.GetSize());
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerCommon::Handle_qPlatform_shell (StringExtractorGDBRemote &packet)
 {
     packet.SetFilePos(::strlen("qPlatform_shell:"));
     std::string path;
     std::string working_dir;
     packet.GetHexByteStringTerminatedBy(path,',');
     if (!path.empty())
     {
         if (packet.GetChar() == ',')
         {
             // FIXME: add timeout to qPlatform_shell packet
             // uint32_t timeout = packet.GetHexMaxU32(false, 32);
             uint32_t timeout = 10;
             if (packet.GetChar() == ',')
                 packet.GetHexByteString(working_dir);
             int status, signo;
             std::string output;
             Error err = Host::RunShellCommand(path.c_str(),
-                                              working_dir.empty() ? NULL : working_dir.c_str(),
+                                              FileSpec{working_dir.c_str(), true},
                                               &status, &signo, &output, timeout);
             StreamGDBRemote response;
             if (err.Fail())
             {
                 response.PutCString("F,");
                 response.PutHex32(UINT32_MAX);
             }
             else

 GDBRemoteCommunicationServerCommon::Handle_QSetSTDIN (StringExtractorGDBRemote &packet)
 {
     packet.SetFilePos(::strlen ("QSetSTDIN:"));
     FileAction file_action;
     std::string path;
     packet.GetHexByteString(path);
     const bool read = false;
     const bool write = true;
-    if (file_action.Open(STDIN_FILENO, path.c_str(), read, write))
+    if (file_action.Open(STDIN_FILENO, FileSpec{path.c_str(), false}, read, write))
     {
         m_process_launch_info.AppendFileAction(file_action);
         return SendOKResponse ();
     }
     return SendErrorResponse (15);
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerCommon::Handle_QSetSTDOUT (StringExtractorGDBRemote &packet)
 {
     packet.SetFilePos(::strlen ("QSetSTDOUT:"));
     FileAction file_action;
     std::string path;
     packet.GetHexByteString(path);
     const bool read = true;
     const bool write = false;
-    if (file_action.Open(STDOUT_FILENO, path.c_str(), read, write))
+    if (file_action.Open(STDOUT_FILENO, FileSpec{path.c_str(), false}, read, write))
     {
         m_process_launch_info.AppendFileAction(file_action);
         return SendOKResponse ();
     }
     return SendErrorResponse (16);
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerCommon::Handle_QSetSTDERR (StringExtractorGDBRemote &packet)
 {
     packet.SetFilePos(::strlen ("QSetSTDERR:"));
     FileAction file_action;
     std::string path;
     packet.GetHexByteString(path);
     const bool read = true;
     const bool write = false;
-    if (file_action.Open(STDERR_FILENO, path.c_str(), read, write))
+    if (file_action.Open(STDERR_FILENO, FileSpec{path.c_str(), false}, read, write))
     {
         m_process_launch_info.AppendFileAction(file_action);
         return SendOKResponse ();
     }
     return SendErrorResponse (17);
 }
 
 GDBRemoteCommunication::PacketResult

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

 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_QSetWorkingDir (StringExtractorGDBRemote &packet)
 {
     packet.SetFilePos (::strlen ("QSetWorkingDir:"));
     std::string path;
     packet.GetHexByteString (path);
-    m_process_launch_info.SwapWorkingDirectory (path);
+    m_process_launch_info.SetWorkingDirectory(FileSpec{path.c_str(), true});
     return SendOKResponse ();
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_qGetWorkingDir (StringExtractorGDBRemote &packet)
 {
-    const char *working_dir = m_process_launch_info.GetWorkingDirectory();
-    if (working_dir && working_dir[0])
+    FileSpec working_dir{m_process_launch_info.GetWorkingDirectory()};
+    if (working_dir)
     {
         StreamString response;
-        response.PutBytesAsRawHex8(working_dir, strlen(working_dir));
+        response.PutCStringAsRawHex8(working_dir.GetPath().c_str());
         return SendPacketNoLock(response.GetData(), response.GetSize());
     }
 
     return SendErrorResponse(14);
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_C (StringExtractorGDBRemote &packet)

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

 {
     Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PROCESS));
     Error error;
 
     if (log)
         log->Printf ("ProcessGDBRemote::%s() entered", __FUNCTION__);
 
     uint32_t launch_flags = launch_info.GetFlags().Get();
-    const char *stdin_path = NULL;
-    const char *stdout_path = NULL;
-    const char *stderr_path = NULL;
-    const char *working_dir = launch_info.GetWorkingDirectory();
+    FileSpec stdin_file_spec{};
+    FileSpec stdout_file_spec{};
+    FileSpec stderr_file_spec{};
+    FileSpec working_dir = launch_info.GetWorkingDirectory();
 
     const FileAction *file_action;
     file_action = launch_info.GetFileActionForFD (STDIN_FILENO);
     if (file_action)
     {
         if (file_action->GetAction() == FileAction::eFileActionOpen)
-            stdin_path = file_action->GetPath();
+            stdin_file_spec = file_action->GetFileSpec();
     }
     file_action = launch_info.GetFileActionForFD (STDOUT_FILENO);
     if (file_action)
     {
         if (file_action->GetAction() == FileAction::eFileActionOpen)
-            stdout_path = file_action->GetPath();
+            stdout_file_spec = file_action->GetFileSpec();
     }
     file_action = launch_info.GetFileActionForFD (STDERR_FILENO);
     if (file_action)
     {
         if (file_action->GetAction() == FileAction::eFileActionOpen)
-            stderr_path = file_action->GetPath();
+            stderr_file_spec = file_action->GetFileSpec();
     }
 
     if (log)
     {
-        if (stdin_path || stdout_path || stderr_path)
+        if (stdin_file_spec || stdout_file_spec || stderr_file_spec)
             log->Printf ("ProcessGDBRemote::%s provided with STDIO paths via launch_info: stdin=%s, stdout=%s, stderr=%s",
                          __FUNCTION__,
-                         stdin_path ? stdin_path : "<null>",
-                         stdout_path ? stdout_path : "<null>",
-                         stderr_path ? stderr_path : "<null>");
+                          stdin_file_spec ?  stdin_file_spec.GetPath().c_str() : "<null>",
+                         stdout_file_spec ? stdout_file_spec.GetPath().c_str() : "<null>",
+                         stderr_file_spec ? stderr_file_spec.GetPath().c_str() : "<null>");
         else
             log->Printf ("ProcessGDBRemote::%s no STDIO paths given via launch_info", __FUNCTION__);
     }
 
     const bool disable_stdio = (launch_flags & eLaunchFlagDisableSTDIO) != 0;
-    if (stdin_path || disable_stdio)
+    if (stdin_file_spec || disable_stdio)
     {
         // the inferior will be reading stdin from the specified file
         // or stdio is completely disabled
         m_stdin_forward = false;
     }
     else
     {
         m_stdin_forward = true;
if (object_file)
         {
             lldb_utility::PseudoTerminal pty;
             const bool disable_stdio = (launch_flags & eLaunchFlagDisableSTDIO) != 0;
 
             PlatformSP platform_sp (m_target.GetPlatform());
             if (disable_stdio)
             {
                 // set to /dev/null unless redirected to a file above
-                if (!stdin_path)
-                    stdin_path = "/dev/null";
-                if (!stdout_path)
-                    stdout_path = "/dev/null";
-                if (!stderr_path)
-                    stderr_path = "/dev/null";
+                if (!stdin_file_spec)
+                    stdin_file_spec = FileSpec{"/dev/null", false};
+                if (!stdout_file_spec)
+                    stdout_file_spec = FileSpec{"/dev/null", false};
+                if (!stderr_file_spec)
+                    stderr_file_spec = FileSpec{"/dev/null", false};
             }
             else if (platform_sp && platform_sp->IsHost())
             {
                 // If the debugserver is local and we aren't disabling STDIO, lets use
                 // a pseudo terminal to instead of relying on the 'O' packets for stdio
                 // since 'O' packets can really slow down debugging if the inferior
                 // does a lot of output.
-                const char *slave_name = NULL;
-                if (stdin_path == NULL || stdout_path == NULL || stderr_path == NULL)
+                if ((!stdin_file_spec || !stdout_file_spec || !stderr_file_spec) &&
+                        pty.OpenFirstAvailableMaster(O_RDWR|O_NOCTTY, NULL, 0))
                 {
-                    if (pty.OpenFirstAvailableMaster(O_RDWR|O_NOCTTY, NULL, 0))
-                        slave_name = pty.GetSlaveName (NULL, 0);
-                }
-                if (stdin_path == NULL) 
-                    stdin_path = slave_name;
+                    FileSpec slave_name = FileSpec{pty.GetSlaveName(NULL, 0), false};
 
-                if (stdout_path == NULL)
-                    stdout_path = slave_name;
+                    if (!stdin_file_spec)
+                        stdin_file_spec = slave_name;
 
-                if (stderr_path == NULL)
-                    stderr_path = slave_name;
+                    if (!stdout_file_spec)
+                        stdout_file_spec = slave_name;
 
+                    if (!stderr_file_spec)
+                        stderr_file_spec = slave_name;
+                }
                 if (log)
                     log->Printf ("ProcessGDBRemote::%s adjusted STDIO paths for local platform (IsHost() is true) using slave: stdin=%s, stdout=%s, stderr=%s",
                                  __FUNCTION__,
-                                 stdin_path ? stdin_path : "<null>",
-                                 stdout_path ? stdout_path : "<null>",
-                                 stderr_path ? stderr_path : "<null>");
+                                  stdin_file_spec ?  stdin_file_spec.GetPath().c_str() : "<null>",
+                                 stdout_file_spec ? stdout_file_spec.GetPath().c_str() : "<null>",
+                                 stderr_file_spec ? stderr_file_spec.GetPath().c_str() : "<null>");
             }
 
             if (log)
                 log->Printf ("ProcessGDBRemote::%s final STDIO paths after all adjustments: stdin=%s, stdout=%s, stderr=%s",
                              __FUNCTION__,
-                             stdin_path ? stdin_path : "<null>",
-                             stdout_path ? stdout_path : "<null>",
-                             stderr_path ? stderr_path : "<null>");
-
-            if (stdin_path)
-                m_gdb_comm.SetSTDIN (stdin_path);
-            if (stdout_path)
-                m_gdb_comm.SetSTDOUT (stdout_path);
-            if (stderr_path)
-                m_gdb_comm.SetSTDERR (stderr_path);
+                              stdin_file_spec ?  stdin_file_spec.GetPath().c_str() : "<null>",
+                             stdout_file_spec ? stdout_file_spec.GetPath().c_str() : "<null>",
+                             stderr_file_spec ? stderr_file_spec.GetPath().c_str() : "<null>");
+
+            if (stdin_file_spec)
+                m_gdb_comm.SetSTDIN(stdin_file_spec);
+            if (stdout_file_spec)
+                m_gdb_comm.SetSTDOUT(stdout_file_spec);
+            if (stderr_file_spec)
+                m_gdb_comm.SetSTDERR(stderr_file_spec);
 
             m_gdb_comm.SetDisableASLR (launch_flags & eLaunchFlagDisableASLR);
             m_gdb_comm.SetDetachOnError (launch_flags & eLaunchFlagDetachOnError);
 
             m_gdb_comm.SendLaunchArchPacket (m_target.GetArchitecture().GetArchitectureName());
             
             const char * launch_event_data = launch_info.GetLaunchEventData();
             if (launch_event_data != NULL && *launch_event_data != '\0')
                 m_gdb_comm.SendLaunchEventDataPacket (launch_event_data);
             
-            if (working_dir && working_dir[0])
+            if (working_dir)
             {
                 m_gdb_comm.SetWorkingDir (working_dir);
             }
 
             // Send the environment and the program + arguments after we connect
             const Args &environment = launch_info.GetEnvironmentEntries();
             if (environment.GetArgumentCount())
             {

source/Target/FileAction.cpp

 //----------------------------------------------------------------------------
 // FileAction member functions
 //----------------------------------------------------------------------------
 
 FileAction::FileAction() : 
     m_action(eFileActionNone),
     m_fd(-1),
     m_arg(-1),
-    m_path()
+    m_file_spec()
 {
 }
 
 void
 FileAction::Clear()
 {
     m_action = eFileActionNone;
     m_fd = -1;
     m_arg = -1;
-    m_path.clear();
+    m_file_spec.Clear();
 }
 
 const char *
 FileAction::GetPath() const
 {
-    if (m_path.empty())
-        return NULL;
-    return m_path.c_str();
+    return m_file_spec ? m_file_spec.GetPath().c_str() : NULL;
+}
+
+const FileSpec &
+FileAction::GetFileSpec() const
+{
+    return m_file_spec;
 }
 
 bool
-FileAction::Open(int fd, const char *path, bool read, bool write)
+FileAction::Open(int fd, const FileSpec &file_spec, bool read, bool write)
 {
-    if ((read || write) && fd >= 0 && path && path[0])
+    if ((read || write) && fd >= 0 && file_spec)
     {
         m_action = eFileActionOpen;
         m_fd = fd;
         if (read && write)
             m_arg = O_NOCTTY | O_CREAT | O_RDWR;
         else if (read)
             m_arg = O_NOCTTY | O_RDONLY;
         else
             m_arg = O_NOCTTY | O_CREAT | O_WRONLY;
-        m_path.assign(path);
+        m_file_spec = file_spec;
         return true;
     }
     else
     {
         Clear();
     }
     return false;
 }
switch (m_action)
             break;
         case eFileActionDuplicate:
             stream.Printf("duplicate fd %d to %d", m_fd, m_arg);
             break;
         case eFileActionNone:
             stream.PutCString("no action");
             break;
         case eFileActionOpen:
-            stream.Printf("open fd %d with '%s', OFLAGS = 0x%x", m_fd, m_path.c_str(), m_arg);
+            stream.Printf("open fd %d with '%s', OFLAGS = 0x%x",
+                    m_fd, m_file_spec.GetPath().c_str(), m_arg);
             break;
     }
 }

source/Target/Platform.cpp

else
         const bool is_connected = IsConnected();
         if (is_connected)
             strm.Printf("  Hostname: %s\n", GetHostname());
         strm.Printf(" Connected: %s\n", is_connected ? "yes" : "no");
     }
 
     if (GetWorkingDirectory())
     {
-        strm.Printf("WorkingDir: %s\n", GetWorkingDirectory().GetCString());
+        strm.Printf("WorkingDir: %s\n", GetWorkingDirectory().GetPath().c_str());
     }
     if (!IsConnected())
         return;
 
     std::string specific_info(GetPlatformSpecificConnectionInformation());
     
     if (specific_info.empty() == false)
         strm.Printf("Platform-specific connection: %s\n", specific_info.c_str());
Platform::AddClangModuleCompilationOptions (Target *target, std::vector<std::string> &options)
     };
     
     options.insert(options.end(),
                    default_compilation_options.begin(),
                    default_compilation_options.end());
 }
 
 
-ConstString
+FileSpec
 Platform::GetWorkingDirectory ()
 {
     if (IsHost())
     {
         char cwd[PATH_MAX];
         if (getcwd(cwd, sizeof(cwd)))
-            return ConstString(cwd);
+            return FileSpec{cwd, true};
         else
-            return ConstString();
+            return FileSpec{};
     }
     else
     {
         if (!m_working_dir)
             m_working_dir = GetRemoteWorkingDirectory();
         return m_working_dir;
     }
 }
switch (file_type)
             break;
             
         case FileSpec::eFileTypeDirectory:
             {
                 // make the new directory and get in there
                 FileSpec dst_dir = rc_baton->dst;
                 if (!dst_dir.GetFilename())
                     dst_dir.GetFilename() = src.GetLastPathComponent();
-                std::string dst_dir_path (dst_dir.GetPath());
-                Error error = rc_baton->platform_ptr->MakeDirectory(dst_dir_path.c_str(), lldb::eFilePermissionsDirectoryDefault);
+                Error error = rc_baton->platform_ptr->MakeDirectory(dst_dir, lldb::eFilePermissionsDirectoryDefault);
                 if (error.Fail())
                 {
-                    rc_baton->error.SetErrorStringWithFormat("unable to setup directory %s on remote end", dst_dir_path.c_str());
+                    rc_baton->error.SetErrorStringWithFormat("unable to setup directory %s on remote end",
+                            dst_dir.GetPath().c_str());
                     return FileSpec::eEnumerateDirectoryResultQuit; // got an error, bail out
                 }
                 
                 // now recurse
                 std::string src_dir_path (src.GetPath());
                 
                 // Make a filespec that only fills in the directory of a FileSpec so
                 // when we enumerate we can quickly fill in the filename for dst copies
switch (file_type)
             break;
             
         case FileSpec::eFileTypeSymbolicLink:
             {
                 // copy the file and keep going
                 FileSpec dst_file = rc_baton->dst;
                 if (!dst_file.GetFilename())
                     dst_file.GetFilename() = src.GetFilename();
-                
-                char buf[PATH_MAX];
-
-                rc_baton->error = FileSystem::Readlink(src.GetPath().c_str(), buf, sizeof(buf));
-
                 if (rc_baton->error.Fail())
                     return FileSpec::eEnumerateDirectoryResultQuit; // got an error, bail out
-                
-                rc_baton->error = rc_baton->platform_ptr->CreateSymlink(dst_file.GetPath().c_str(), buf);
+                FileSpec src_resolved = src;
+                src_resolved.ResolvePath();
+                rc_baton->error = rc_baton->platform_ptr->CreateSymlink(dst_file, src_resolved);
 
                 if (rc_baton->error.Fail())
                     return FileSpec::eEnumerateDirectoryResultQuit; // got an error, bail out
 
                 return FileSpec::eEnumerateDirectoryResultNext;
             }
             break;
         case FileSpec::eFileTypeRegular:
Platform::Install (const FileSpec& src, const FileSpec& dst)
     Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM);
     if (log)
         log->Printf ("Platform::Install (src='%s', dst='%s')", src.GetPath().c_str(), dst.GetPath().c_str());
     FileSpec fixed_dst(dst);
     
     if (!fixed_dst.GetFilename())
         fixed_dst.GetFilename() = src.GetFilename();
 
-    ConstString working_dir = GetWorkingDirectory();
+    FileSpec working_dir = GetWorkingDirectory();
 
     if (dst)
     {
         if (dst.GetDirectory())
         {
             const char first_dst_dir_char = dst.GetDirectory().GetCString()[0];
             if (first_dst_dir_char == '/' || first_dst_dir_char  == '\\')
             {
                 fixed_dst.GetDirectory() = dst.GetDirectory();
             }
             // If the fixed destination file doesn't have a directory yet,
             // then we must have a relative path. We will resolve this relative
             // path against the platform's working directory
             if (!fixed_dst.GetDirectory())
             {
                 FileSpec relative_spec;
                 std::string path;
                 if (working_dir)
                 {
-                    relative_spec.SetFile(working_dir.GetCString(), false);
+                    relative_spec = working_dir;
                     relative_spec.AppendPathComponent(dst.GetPath().c_str());
                     fixed_dst.GetDirectory() = relative_spec.GetDirectory();
                 }
                 else
                 {
                     error.SetErrorStringWithFormat("platform working directory must be valid for relative path '%s'", dst.GetPath().c_str());
                     return error;
                 }
             }
         }
         else
         {
             if (working_dir)
             {
-                fixed_dst.GetDirectory() = working_dir;
+                fixed_dst.GetDirectory() = ConstString{working_dir.GetPath()};
             }
             else
             {
                 error.SetErrorStringWithFormat("platform working directory must be valid for relative path '%s'", dst.GetPath().c_str());
                 return error;
             }
         }
     }
     else
     {
         if (working_dir)
         {
-            fixed_dst.GetDirectory() = working_dir;
+            fixed_dst.GetDirectory() = ConstString{working_dir.GetPath()};
         }
         else
         {
             error.SetErrorStringWithFormat("platform working directory must be valid when destination directory is empty");
             return error;
         }
     }
     
     if (log)
         log->Printf ("Platform::Install (src='%s', dst='%s') fixed_dst='%s'", src.GetPath().c_str(), dst.GetPath().c_str(), fixed_dst.GetPath().c_str());
 
     if (GetSupportsRSync())
     {
         error = PutFile(src, dst);
     }
     else
     {
         switch (src.GetFileType())
         {
             case FileSpec::eFileTypeDirectory:
                 {
                     if (GetFileExists (fixed_dst))
-                        Unlink (fixed_dst.GetPath().c_str());
+                        Unlink(fixed_dst);
                     uint32_t permissions = src.GetPermissions();
                     if (permissions == 0)
                         permissions = eFilePermissionsDirectoryDefault;
-                    std::string dst_dir_path(fixed_dst.GetPath());
-                    error = MakeDirectory(dst_dir_path.c_str(), permissions);
+                    error = MakeDirectory(fixed_dst, permissions);
                     if (error.Success())
                     {
                         // Make a filespec that only fills in the directory of a FileSpec so
                         // when we enumerate we can quickly fill in the filename for dst copies
                         FileSpec recurse_dst;
-                        recurse_dst.GetDirectory().SetCString(dst_dir_path.c_str());
+                        recurse_dst.GetDirectory().SetCString(fixed_dst.GetPath().c_str());
                         std::string src_dir_path (src.GetPath());
                         RecurseCopyBaton baton = { recurse_dst, this, Error() };
                         FileSpec::EnumerateDirectory(src_dir_path.c_str(), true, true, true, RecurseCopy_Callback, &baton);
                         return baton.error;
                     }
                 }
                 break;
 
             case FileSpec::eFileTypeRegular:
                 if (GetFileExists (fixed_dst))
-                    Unlink (fixed_dst.GetPath().c_str());
+                    Unlink(fixed_dst);
                 error = PutFile(src, fixed_dst);
                 break;
 
             case FileSpec::eFileTypeSymbolicLink:
                 {
                     if (GetFileExists (fixed_dst))
-                        Unlink (fixed_dst.GetPath().c_str());
-                    char buf[PATH_MAX];
-                    error = FileSystem::Readlink(src.GetPath().c_str(), buf, sizeof(buf));
+                        Unlink(fixed_dst);
+                    FileSpec src_resolved = src;
+                    src_resolved.ResolvePath();
                     if (error.Success())
-                        error = CreateSymlink(dst.GetPath().c_str(), buf);
+                        error = CreateSymlink(dst, src_resolved);
                 }
                 break;
             case FileSpec::eFileTypePipe:
                 error.SetErrorString("platform install doesn't handle pipes");
                 break;
             case FileSpec::eFileTypeSocket:
                 error.SetErrorString("platform install doesn't handle sockets");
                 break;
             case FileSpec::eFileTypeInvalid:
             case FileSpec::eFileTypeUnknown:
             case FileSpec::eFileTypeOther:
                 error.SetErrorString("platform install doesn't handle non file or directory items");
                 break;
         }
     }
     return error;
 }
 
 bool
-Platform::SetWorkingDirectory (const ConstString &path)
+Platform::SetWorkingDirectory(const FileSpec &file_spec)
 {
     if (IsHost())
     {
         Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM);
         if (log)
-            log->Printf("Platform::SetWorkingDirectory('%s')", path.GetCString());
-        if (path)
+            log->Printf("Platform::SetWorkingDirectory('%s')",
+                    file_spec.GetPath().c_str());
+        if (file_spec)
         {
-            if (chdir(path.GetCString()) == 0)
+            if (chdir(file_spec.GetPath().c_str()) == 0)
                 return true;
         }
         return false;
     }
     else
     {
         m_working_dir.Clear();
-        return SetRemoteWorkingDirectory(path);
+        return SetRemoteWorkingDirectory(file_spec);
     }
 }
 
 Error
-Platform::MakeDirectory (const char *path, uint32_t permissions)
+Platform::MakeDirectory(const FileSpec &file_spec, uint32_t permissions)
 {
     if (IsHost())
-        return FileSystem::MakeDirectory(path, permissions);
+        return FileSystem::MakeDirectory(file_spec.GetPath().c_str(), permissions);
     else
     {
         Error error;
         error.SetErrorStringWithFormat("remote platform %s doesn't support %s", GetPluginName().GetCString(), __PRETTY_FUNCTION__);
         return error;
     }
 }
 
 Error
-Platform::GetFilePermissions (const char *path, uint32_t &file_permissions)
+Platform::GetFilePermissions(const FileSpec &file_spec, uint32_t &file_permissions)
 {
     if (IsHost())
-        return FileSystem::GetFilePermissions(path, file_permissions);
+        return FileSystem::GetFilePermissions(file_spec.GetPath().c_str(), file_permissions);
     else
     {
         Error error;
         error.SetErrorStringWithFormat("remote platform %s doesn't support %s", GetPluginName().GetCString(), __PRETTY_FUNCTION__);
         return error;
     }
 }
 
 Error
-Platform::SetFilePermissions (const char *path, uint32_t file_permissions)
+Platform::SetFilePermissions(const FileSpec &file_spec, uint32_t file_permissions)
 {
     if (IsHost())
-        return FileSystem::SetFilePermissions(path, file_permissions);
+        return FileSystem::SetFilePermissions(file_spec.GetPath().c_str(), file_permissions);
     else
     {
         Error error;
         error.SetErrorStringWithFormat("remote platform %s doesn't support %s", GetPluginName().GetCString(), __PRETTY_FUNCTION__);
         return error;
     }
 }
 
if (IsHost())
         return "127.0.0.1";
 
     if (m_name.empty())        
         return NULL;
     return m_name.c_str();
 }
 
 bool
-Platform::SetRemoteWorkingDirectory(const ConstString &path)
+Platform::SetRemoteWorkingDirectory(const FileSpec &working_dir)
 {
     Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM);
     if (log)
-        log->Printf("Platform::SetRemoteWorkingDirectory('%s')", path.GetCString());
-    m_working_dir = path;
+        log->Printf("Platform::SetRemoteWorkingDirectory('%s')",
+                working_dir.GetPath().c_str());
+    m_working_dir = working_dir;
     return true;
 }
 
 const char *
 Platform::GetUserName (uint32_t uid)
 {
 #if !defined(LLDB_DISABLE_POSIX)
     const char *user_name = GetCachedUserName(uid);
if (uid == UINT32_MAX && gid == UINT32_MAX)
         return error;
 
     // TODO: ChownFile?
 
     return error;
 }
 
 Error
-Platform::GetFile (const FileSpec& source,
-                   const FileSpec& destination)
+Platform::GetFile(const FileSpec &source,
+                  const FileSpec &destination)
 {
     Error error("unimplemented");
     return error;
 }
 
 Error
-Platform::CreateSymlink (const char *src, // The name of the link is in src
-                         const char *dst)// The symlink points to dst
+Platform::CreateSymlink(const FileSpec &src, // The name of the link is in src
+                        const FileSpec &dst) // The symlink points to dst
 {
     Error error("unimplemented");
     return error;
 }
 
 bool
-Platform::GetFileExists (const lldb_private::FileSpec& file_spec)
+Platform::GetFileExists(const lldb_private::FileSpec &file_spec)
 {
     return false;
 }
 
 Error
-Platform::Unlink (const char *path)
+Platform::Unlink(const FileSpec &path)
 {
     Error error("unimplemented");
     return error;
 }
 
 uint64_t
 Platform::ConvertMmapFlagsToPlatform(unsigned flags)
 {
     uint64_t flags_platform = 0;
     if (flags & eMmapFlagsPrivate)
         flags_platform |= MAP_PRIVATE;
     if (flags & eMmapFlagsAnon)
         flags_platform |= MAP_ANON;
     return flags_platform;
 }
 
 lldb_private::Error
-Platform::RunShellCommand (const char *command,           // Shouldn't be NULL
-                           const char *working_dir,       // Pass NULL to use the current working directory
-                           int *status_ptr,               // Pass NULL if you don't want the process exit status
-                           int *signo_ptr,                // Pass NULL if you don't want the signal that caused the process to exit
-                           std::string *command_output,   // Pass NULL if you don't want the command output
-                           uint32_t timeout_sec)          // Timeout in seconds to wait for shell program to finish
+Platform::RunShellCommand(const char *command,           // Shouldn't be NULL
+                          const FileSpec &working_dir,   // Pass NULL to use the current working directory
 {
     if (IsHost())
         return Host::RunShellCommand (command, working_dir, status_ptr, signo_ptr, command_output, timeout_sec);
     else
         return Error("unimplemented");
 }
 
 

source/Target/Process.cpp

ProcessLaunchCommandOptions::SetOptionValue (uint32_t option_idx, const char *option_arg)
     {
         case 's':   // Stop at program entry point
             launch_info.GetFlags().Set (eLaunchFlagStopAtEntry); 
             break;
             
         case 'i':   // STDIN for read only
         {
             FileAction action;
-            if (action.Open (STDIN_FILENO, option_arg, true, false))
+            if (action.Open(STDIN_FILENO, FileSpec{option_arg, false}, true, false))
                 launch_info.AppendFileAction (action);
             break;
         }
             
         case 'o':   // Open STDOUT for write only
         {
             FileAction action;
-            if (action.Open (STDOUT_FILENO, option_arg, false, true))
+            if (action.Open(STDOUT_FILENO, FileSpec{option_arg, false}, false, true))
                 launch_info.AppendFileAction (action);
             break;
         }
 
         case 'e':   // STDERR for write only
         {
             FileAction action;
-            if (action.Open (STDERR_FILENO, option_arg, false, true))
+            if (action.Open(STDERR_FILENO, FileSpec{option_arg, false}, false, true))
                 launch_info.AppendFileAction (action);
             break;
         }
 
         case 'p':   // Process plug-in name
             launch_info.SetProcessPluginName (option_arg);    
             break;
             
         case 'n':   // Disable STDIO
         {
             FileAction action;
-            if (action.Open (STDIN_FILENO, "/dev/null", true, false))
+            const FileSpec dev_null{"/dev/null", false};
+            if (action.Open(STDIN_FILENO, dev_null, true, false))
                 launch_info.AppendFileAction (action);
-            if (action.Open (STDOUT_FILENO, "/dev/null", false, true))
+            if (action.Open(STDOUT_FILENO, dev_null, false, true))
                 launch_info.AppendFileAction (action);
-            if (action.Open (STDERR_FILENO, "/dev/null", false, true))
+            if (action.Open(STDERR_FILENO, dev_null, false, true))
                 launch_info.AppendFileAction (action);
             break;
         }
             
         case 'w': 
-            launch_info.SetWorkingDirectory (option_arg);    
+            launch_info.SetWorkingDirectory(FileSpec{option_arg, false});
             break;
             
         case 't':   // Open process in new terminal window
             launch_info.GetFlags().Set (eLaunchFlagLaunchInTTY); 
             break;
             
         case 'a':
             if (!launch_info.GetArchitecture().SetTriple (option_arg, m_interpreter.GetPlatform(true).get()))

source/Target/ProcessLaunchInfo.cpp

ProcessLaunchInfo::ProcessLaunchInfo () :
     m_monitor_callback (NULL),
     m_monitor_callback_baton (NULL),
     m_monitor_signals (false),
     m_listener_sp (),
     m_hijack_listener_sp ()
 {
 }
 
-ProcessLaunchInfo::ProcessLaunchInfo(const char *stdin_path, const char *stdout_path, const char *stderr_path,
-                                     const char *working_directory, uint32_t launch_flags) :
+ProcessLaunchInfo::ProcessLaunchInfo(const FileSpec &stdin_file_spec,
+                                     const FileSpec &stdout_file_spec,
+                                     const FileSpec &stderr_file_spec,
+                                     const FileSpec &working_directory,
+                                     uint32_t launch_flags) :
     ProcessInfo(),
     m_working_dir(),
     m_plugin_name(),
     m_flags(launch_flags),
     m_file_actions(),
     m_pty(new lldb_utility::PseudoTerminal),
     m_resume_count(0),
     m_monitor_callback(NULL),
     m_monitor_callback_baton(NULL),
     m_monitor_signals(false),
     m_listener_sp (),
     m_hijack_listener_sp()
 {
-    if (stdin_path)
+    if (stdin_file_spec)
     {
         FileAction file_action;
         const bool read = true;
         const bool write = false;
-        if (file_action.Open(STDIN_FILENO, stdin_path, read, write))
+        if (file_action.Open(STDIN_FILENO, stdin_file_spec, read, write))
             AppendFileAction (file_action);
     }
-    if (stdout_path)
+    if (stdout_file_spec)
     {
         FileAction file_action;
         const bool read = false;
         const bool write = true;
-        if (file_action.Open(STDOUT_FILENO, stdout_path, read, write))
+        if (file_action.Open(STDOUT_FILENO, stdout_file_spec, read, write))
             AppendFileAction (file_action);
     }
-    if (stderr_path)
+    if (stderr_file_spec)
     {
         FileAction file_action;
         const bool read = false;
         const bool write = true;
-        if (file_action.Open(STDERR_FILENO, stderr_path, read, write))
+        if (file_action.Open(STDERR_FILENO, stderr_file_spec, read, write))
             AppendFileAction (file_action);
     }
     if (working_directory)
         SetWorkingDirectory(working_directory);
 }
 
 bool
 ProcessLaunchInfo::AppendCloseFileAction (int fd)
ProcessLaunchInfo::AppendDuplicateFileAction (int fd, int dup_fd)
     {
         AppendFileAction (file_action);
         return true;
     }
     return false;
 }
 
 bool
-ProcessLaunchInfo::AppendOpenFileAction (int fd, const char *path, bool read, bool write)
+ProcessLaunchInfo::AppendOpenFileAction(int fd, const FileSpec &file_spec,
+                                        bool read, bool write)
 {
     FileAction file_action;
-    if (file_action.Open (fd, path, read, write))
+    if (file_action.Open(fd, file_spec, read, write))
     {
         AppendFileAction (file_action);
         return true;
     }
     return false;
 }
 
 bool
 ProcessLaunchInfo::AppendSuppressFileAction (int fd, bool read, bool write)
 {
     FileAction file_action;
-    if (file_action.Open (fd, "/dev/null", read, write))
+    if (file_action.Open(fd, FileSpec{"/dev/null", false}, read, write))
     {
         AppendFileAction (file_action);
         return true;
     }
     return false;
 }
 
 const FileAction *
ProcessLaunchInfo::GetFileActionForFD(int fd) const
     for (size_t idx=0, count=m_file_actions.size(); idx < count; ++idx)
     {
         if (m_file_actions[idx].GetFD () == fd)
             return &m_file_actions[idx];
     }
     return NULL;
 }
 
-const char *
-ProcessLaunchInfo::GetWorkingDirectory () const
+const FileSpec &
+ProcessLaunchInfo::GetWorkingDirectory() const
 {
-    if (m_working_dir.empty())
-        return NULL;
-    return m_working_dir.c_str();
+    return m_working_dir;
 }
 
 void
-ProcessLaunchInfo::SetWorkingDirectory (const char *working_dir)
+ProcessLaunchInfo::SetWorkingDirectory(const FileSpec &working_dir)
 {
-    if (working_dir && working_dir[0])
-        m_working_dir.assign (working_dir);
-    else
-        m_working_dir.clear();
+    m_working_dir = working_dir;
 }
 
 const char *
 ProcessLaunchInfo::GetProcessPluginName () const
 {
     if (m_plugin_name.empty())
         return NULL;
     return m_plugin_name.c_str();
ProcessLaunchInfo::SetShellExpandArguments (bool expand)
     else
         m_flags.Clear(lldb::eLaunchFlagShellExpandArguments);
 }
 
 void
 ProcessLaunchInfo::Clear ()
 {
     ProcessInfo::Clear();
-    m_working_dir.clear();
+    m_working_dir.Clear();
     m_plugin_name.clear();
     m_shell.Clear();
     m_flags.Clear();
     m_file_actions.clear();
     m_resume_count = 0;
     m_listener_sp.reset();
     m_hijack_listener_sp.reset();
 }
if (GetFileActionForFD(STDIN_FILENO) == NULL ||
             AppendSuppressFileAction (STDERR_FILENO, false, true);
         }
         else
         {
             // Check for any values that might have gotten set with any of:
             // (lldb) settings set target.input-path
             // (lldb) settings set target.output-path
             // (lldb) settings set target.error-path
-            FileSpec in_path;
-            FileSpec out_path;
-            FileSpec err_path;
+            FileSpec in_file_spec;
+            FileSpec out_file_spec;
+            FileSpec err_file_spec;
             if (target)
             {
                 // Only override with the target settings if we don't already have
                 // an action for in, out or error
                 if (GetFileActionForFD(STDIN_FILENO) == NULL)
-                    in_path = target->GetStandardInputPath();
+                    in_file_spec = target->GetStandardInputPath();
                 if (GetFileActionForFD(STDOUT_FILENO) == NULL)
-                    out_path = target->GetStandardOutputPath();
+                    out_file_spec = target->GetStandardOutputPath();
                 if (GetFileActionForFD(STDERR_FILENO) == NULL)
-                    err_path = target->GetStandardErrorPath();
+                    err_file_spec = target->GetStandardErrorPath();
             }
 
             if (log)
                 log->Printf ("ProcessLaunchInfo::%s target stdin='%s', target stdout='%s', stderr='%s'",
                              __FUNCTION__,
-                              in_path ?  in_path.GetPath().c_str () : "<null>",
-                             out_path ? out_path.GetPath().c_str () : "<null>",
-                             err_path ? err_path.GetPath().c_str () : "<null>");
+                              in_file_spec ?  in_file_spec.GetPath().c_str () : "<null>",
+                             out_file_spec ? out_file_spec.GetPath().c_str () : "<null>",
+                             err_file_spec ? err_file_spec.GetPath().c_str () : "<null>");
 
-            char path[PATH_MAX];
-            if (in_path && in_path.GetPath(path, sizeof(path)))
+            if (in_file_spec)
             {
-                AppendOpenFileAction(STDIN_FILENO, path, true, false);
+                AppendOpenFileAction(STDIN_FILENO, in_file_spec, true, false);
                 if (log)
                     log->Printf ("ProcessLaunchInfo::%s appended stdin open file action for %s",
-                                 __FUNCTION__,
-                                 in_path.GetPath().c_str ());
+                                 __FUNCTION__, in_file_spec.GetPath().c_str ());
             }
 
-            if (out_path && out_path.GetPath(path, sizeof(path)))
+            if (out_file_spec)
             {
-                AppendOpenFileAction(STDOUT_FILENO, path, false, true);
+                AppendOpenFileAction(STDOUT_FILENO, out_file_spec, false, true);
                 if (log)
                     log->Printf ("ProcessLaunchInfo::%s appended stdout open file action for %s",
-                                 __FUNCTION__,
-                                 out_path.GetPath().c_str ());
+                                 __FUNCTION__, out_file_spec.GetPath().c_str ());
             }
 
-            if (err_path && err_path.GetPath(path, sizeof(path)))
+            if (err_file_spec)
             {
+                AppendOpenFileAction(STDERR_FILENO, err_file_spec, false, true);
                 if (log)
                     log->Printf ("ProcessLaunchInfo::%s appended stderr open file action for %s",
-                                 __FUNCTION__,
-                                 err_path.GetPath().c_str ());
-                AppendOpenFileAction(STDERR_FILENO, path, false, true);
+                                 __FUNCTION__, err_file_spec.GetPath().c_str ());
             }
 
-            if (default_to_use_pty && (!in_path || !out_path || !err_path))
+            if (default_to_use_pty && (!in_file_spec || !out_file_spec || !err_file_spec))
             {
                 if (log)
                     log->Printf ("ProcessLaunchInfo::%s default_to_use_pty is set, and at least one stdin/stderr/stdout is unset, so generating a pty to use for it",
                                  __FUNCTION__);
 
                 int open_flags = O_RDWR | O_NOCTTY;
 #if !defined(_MSC_VER)
                 // We really shouldn't be specifying platform specific flags
                 // that are intended for a system call in generic code.  But
                 // this will have to do for now.
                 open_flags |= O_CLOEXEC;
 #endif
                 if (m_pty->OpenFirstAvailableMaster(open_flags, NULL, 0))
                 {
-                    const char *slave_path = m_pty->GetSlaveName(NULL, 0);
+                    const FileSpec slave_file_spec{m_pty->GetSlaveName(NULL, 0), false};
 
                     // Only use the slave tty if we don't have anything specified for
                     // input and don't have an action for stdin
-                    if (!in_path && GetFileActionForFD(STDIN_FILENO) == NULL)
+                    if (!in_file_spec && GetFileActionForFD(STDIN_FILENO) == NULL)
                     {
-                        AppendOpenFileAction(STDIN_FILENO, slave_path, true, false);
+                        AppendOpenFileAction(STDIN_FILENO, slave_file_spec, true, false);
                     }
 
                     // Only use the slave tty if we don't have anything specified for
                     // output and don't have an action for stdout
-                    if (!out_path && GetFileActionForFD(STDOUT_FILENO) == NULL)
+                    if (!out_file_spec && GetFileActionForFD(STDOUT_FILENO) == NULL)
                     {
-                        AppendOpenFileAction(STDOUT_FILENO, slave_path, false, true);
+                        AppendOpenFileAction(STDOUT_FILENO, slave_file_spec, false, true);
                     }
 
                     // Only use the slave tty if we don't have anything specified for
                     // error and don't have an action for stderr
-                    if (!err_path && GetFileActionForFD(STDERR_FILENO) == NULL)
+                    if (!err_file_spec && GetFileActionForFD(STDERR_FILENO) == NULL)
                     {
-                        AppendOpenFileAction(STDERR_FILENO, slave_path, false, true);
+                        AppendOpenFileAction(STDERR_FILENO, slave_file_spec, false, true);
                     }
                 }
             }
         }
     }
 }
 
 
if (GetFlags().Test (eLaunchFlagLaunchInShell))
                 // Add a modified PATH environment variable in case argv[0]
                 // is a relative path.
                 const char *argv0 = argv[0];
                 FileSpec arg_spec(argv0, false);
                 if (arg_spec.IsRelativeToCurrentWorkingDirectory())
                 {
                     // We have a relative path to our executable which may not work if
                     // we just try to run "a.out" (without it being converted to "./a.out")
-                    const char *working_dir = GetWorkingDirectory();
+                    FileSpec working_dir = GetWorkingDirectory();
                     // Be sure to put quotes around PATH's value in case any paths have spaces...
                     std::string new_path("PATH=\"");
                     const size_t empty_path_len = new_path.size();
 
-                    if (working_dir && working_dir[0])
+                    if (working_dir)
                     {
-                        new_path += working_dir;
+                        new_path += working_dir.GetPath();
                     }
                     else
                     {
                         char current_working_dir[PATH_MAX];
                         const char *cwd = getcwd(current_working_dir, sizeof(current_working_dir));
                         if (cwd && cwd[0])
                             new_path += cwd;
                     }

source/Target/Target.cpp

if (platform_sp)
                         if (local_file)
                         {
                             FileSpec remote_file (module_sp->GetRemoteInstallFileSpec());
                             if (!remote_file)
                             {
                                 if (is_main_executable) // TODO: add setting for always installing main executable???
                                 {
                                     // Always install the main executable
-                                    remote_file = FileSpec(module_sp->GetFileSpec().GetFilename().AsCString(),
-                                                           false, module_sp->GetArchitecture());
-                                    remote_file.GetDirectory() = platform_sp->GetWorkingDirectory();
+                                    remote_file = platform_sp->GetRemoteWorkingDirectory();
+                                    remote_file.AppendPathComponent(module_sp->GetFileSpec().GetFilename().GetCString());
                                 }
                             }
                             if (remote_file)
                             {
                                 error = platform_sp->Install(local_file, remote_file);
                                 if (error.Success())
                                 {
                                     module_sp->SetPlatformFileSpec(remote_file);
                                     if (is_main_executable)
                                     {
-                                        platform_sp->SetFilePermissions(remote_file.GetPath(false).c_str(), 0700);
+                                        platform_sp->SetFilePermissions(remote_file, 0700);
                                         if (launch_info)
                                             launch_info->SetExecutableFile(remote_file, false);
                                     }
                                 }
                                 else
                                     break;
                             }
                         }
TargetProperties::EnvVarsValueChangedCallback(void *target_property_ptr, OptionValue *)
     if (this_->GetEnvironmentAsArgs(args))
         this_->m_launch_info.GetEnvironmentEntries() = args;
 }
 
 void
 TargetProperties::InputPathValueChangedCallback(void *target_property_ptr, OptionValue *)
 {
     TargetProperties *this_ = reinterpret_cast<TargetProperties *>(target_property_ptr);
-    this_->m_launch_info.AppendOpenFileAction(STDIN_FILENO, this_->GetStandardInputPath().GetPath().c_str(), true, false);
+    this_->m_launch_info.AppendOpenFileAction(STDIN_FILENO, this_->GetStandardInputPath(), true, false);
 }
 
 void
 TargetProperties::OutputPathValueChangedCallback(void *target_property_ptr, OptionValue *)
 {
     TargetProperties *this_ = reinterpret_cast<TargetProperties *>(target_property_ptr);
-    this_->m_launch_info.AppendOpenFileAction(STDOUT_FILENO, this_->GetStandardOutputPath().GetPath().c_str(), false, true);
+    this_->m_launch_info.AppendOpenFileAction(STDOUT_FILENO, this_->GetStandardOutputPath(), false, true);
 }
 
 void
 TargetProperties::ErrorPathValueChangedCallback(void *target_property_ptr, OptionValue *)
 {
     TargetProperties *this_ = reinterpret_cast<TargetProperties *>(target_property_ptr);
-    this_->m_launch_info.AppendOpenFileAction(STDERR_FILENO, this_->GetStandardErrorPath().GetPath().c_str(), false, true);
+    this_->m_launch_info.AppendOpenFileAction(STDERR_FILENO, this_->GetStandardErrorPath(), false, true);
 }
 
 void
 TargetProperties::DetachOnErrorValueChangedCallback(void *target_property_ptr, OptionValue *)
 {
     TargetProperties *this_ = reinterpret_cast<TargetProperties *>(target_property_ptr);
     if (this_->GetDetachOnError())
         this_->m_launch_info.GetFlags().Set(lldb::eLaunchFlagDetachOnError);