Set path syntax for remote executable FileSpec.

[chaoren]

Using denormalize = false while getting the executable path was a hacky workaround. This feels more correct (and is probably why m_syntax was added in the first place).

source/Host/common/FileSpec.cpp

818

I tried putting this (and the one at line 614) in an unnamed namespace, but the resulting executable couldn't even run. Bug in MSVC?

[zturner]

source/Host/common/FileSpec.cpp

819–820

Is it possible for the directory to end with a slash even when it has more than one character? For example, on Windows I can imagine the directory might be D:\.

So I think we should check m_directory.ends_with or some simialr mechanism of looking at the last character, and not doing a full comparison. Regardless of platform, you don't want to have a double slash, so I think the check is valid regardless.

[chaoren]

source/Host/common/FileSpec.cpp

819–820

FileSpec::SetFile actually strips D:\ into D:, but I think it's a good idea to do that regardless.

[chaoren]

Address review comment. Remove duplicate code.

[chaoren]

Ping?

[zturner]

Lgtm

include/lldb/Host/FileSpec.h

public:
     /// @param[in] resolve_path
     ///     If \b true, then we resolve the path with realpath,
     ///     if \b false we trust the path is in canonical form already.
     ///
     /// @see FileSpec::SetFile (const char *path, bool resolve)
     //------------------------------------------------------------------
     explicit FileSpec (const char *path, bool resolve_path, PathSyntax syntax = ePathSyntaxHostNative);
 
+    explicit FileSpec (const char *path, bool resolve_path, ArchSpec arch);
+
     //------------------------------------------------------------------
     /// Copy constructor
     ///
     /// Makes a copy of the uniqued directory and filename strings from
     /// \a rhs.
     ///
     /// @param[in] rhs
     ///     A const FileSpec object reference to copy.

source/Host/common/FileSpec.cpp

 #include <string.h>
 #include <fstream>
 
 #include "lldb/Host/Config.h" // Have to include this before we test the define...
 #ifdef LLDB_CONFIG_TILDE_RESOLVES_TO_USER
 #include <pwd.h>
 #endif
 
+#include "lldb/Core/ArchSpec.h"
 #include "lldb/Core/DataBufferHeap.h"
 #include "lldb/Core/DataBufferMemoryMap.h"
 #include "lldb/Core/RegularExpression.h"
 #include "lldb/Core/StreamString.h"
 #include "lldb/Core/Stream.h"
 #include "lldb/Host/File.h"
 #include "lldb/Host/FileSpec.h"
 #include "lldb/Host/FileSystem.h"
FileSpec::FileSpec(const char *pathname, bool resolve_path, PathSyntax syntax) :
     m_filename(),
     m_is_resolved(false),
     m_syntax(syntax)
 {
     if (pathname && pathname[0])
         SetFile(pathname, resolve_path, syntax);
 }
 
+FileSpec::FileSpec(const char *pathname, bool resolve_path, ArchSpec arch) :
+    FileSpec(pathname, resolve_path, arch.GetTriple().isOSWindows() ? ePathSyntaxWindows : ePathSyntaxPosix)
+{
+}
+
 //------------------------------------------------------------------
 // Copy constructor
 //------------------------------------------------------------------
 FileSpec::FileSpec(const FileSpec& rhs) :
     m_directory (rhs.m_directory),
     m_filename (rhs.m_filename),
     m_is_resolved (rhs.m_is_resolved),
     m_syntax (rhs.m_syntax)

 //------------------------------------------------------------------
 // Dump the object to the supplied stream. If the object contains
 // a valid directory name, it will be displayed followed by a
 // directory delimiter, and the filename.
 //------------------------------------------------------------------
 void
 FileSpec::Dump(Stream *s) const
 {
-    static ConstString g_slash_only ("/");
     if (s)
     {
         m_directory.Dump(s);
-        if (m_directory && m_directory != g_slash_only)
+        if (m_directory && m_directory.GetStringRef().back() != '/')
             s->PutChar('/');
         m_filename.Dump(s);
     }
 }
 
 //------------------------------------------------------------------
 // Returns true if the file exists.
 //------------------------------------------------------------------
FileSpec::GetPath(bool denormalize) const
     llvm::SmallString<64> result;
     GetPath(result, denormalize);
     return std::string(result.begin(), result.end());
 }
 
 void
 FileSpec::GetPath(llvm::SmallVectorImpl<char> &path, bool denormalize) const
 {
-    if (m_directory)
-        path.append(m_directory.GetCString(), m_directory.GetCString() + m_directory.GetLength());
-    if (m_filename)
-        llvm::sys::path::append(path, m_filename.GetCString());
+    StreamString stream;
+    Dump(&stream);
+    path.append(stream.GetString().begin(), stream.GetString().end());
     Normalize(path, m_syntax);
     if (denormalize && !path.empty())
         DeNormalize(path, m_syntax);
 }
 
 ConstString
 FileSpec::GetFileNameExtension () const
 {

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(false);
+        exe_path = exe_file.GetPath();
     else
     {
         arg = launch_args.GetArgumentAtIndex(0);
         if (arg)
             exe_path = arg;
     }
     if (!exe_path.empty())
     {
GDBRemoteCommunicationClient::GetModuleInfo (const FileSpec& module_file_spec,
     std::string module_path = module_file_spec.GetPath (false);
     if (module_path.empty ())
         return false;
 
     StreamString packet;
     packet.PutCString("qModuleInfo:");
     packet.PutCStringAsRawHex8(module_path.c_str());
     packet.PutCString(";");
-    const auto& tripple = arch_spec.GetTriple().getTriple();
-    packet.PutBytesAsRawHex8(tripple.c_str(), tripple.size());
+    const auto& triple = arch_spec.GetTriple().getTriple();
+    packet.PutBytesAsRawHex8(triple.c_str(), triple.size());
 
     StringExtractorGDBRemote response;
     if (SendPacketAndWaitForResponse (packet.GetData(), packet.GetSize(), response, false) != PacketResult::Success)
         return false;
 
     if (response.IsErrorResponse () || response.IsUnsupportedResponse ())
         return false;
 
while (response.GetNameColonValue (name, value))
             if (success)
                 module_spec.SetObjectSize (ival);
         }
         else if (name == "file_path")
         {
             extractor.GetStringRef ().swap (value);
             extractor.SetFilePos (0);
             extractor.GetHexByteString (value);
-            module_spec.GetFileSpec () = FileSpec (value.c_str(), false);
+            module_spec.GetFileSpec() = FileSpec(value.c_str(), false, arch_spec);
         }
     }
 
     return true;
 }
 
 // query the target remote for extended information using the qXfer packet
 //

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.GetFilename() = module_sp->GetFileSpec().GetFilename();
                                 }
                             }
                             if (remote_file)
                             {
                                 error = platform_sp->Install(local_file, remote_file);
                                 if (error.Success())
                                 {
                                     module_sp->SetPlatformFileSpec(remote_file);