Pass normalized target file paths via GDB-remote to a target and denormalize them on the target.

[ovyalov]

Summary

FileSpec.GetPath() by default applies de-normalization for a path using a native path syntax.
If host sends a path to a target we can always pass it from host in normalized form (calling FileSpec::GetPath(false)) and denormalize it on a target (FileSpec::GetPath(true)).
I appied such approach only for OpenFile and ModuleInfo requests - if it looks reasonable I will migrate other path-related protocol commands to follow the same style.

[tberghammer]

Please check what GDB does and try to do the same to keep the protocol compatible with that one (in both direction).

[ovyalov]

In D8980#156074, @tberghammer wrote:

Please check what GDB does and try to do the same to keep the protocol compatible with that one (in both direction).

I haven't found any path requirements for vFile I/O packets in GDB protocol.
My proposal with this CL is to add protection to implementation layer with normalizing path on host side. If target side uses FileSpec to handle received path it can accept both formats - normalized and denormalized.

[tberghammer]

If there is no requirement in the protocol then it looks good.

[ovyalov]

AFFECTED FILES

/lldb/trunk/source/Plugins/Platform/gdb-server/PlatformRemoteGDBServer.cpp
/lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp
/lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerCommon.cpp

USERS

ovyalov (Author)

http://reviews.llvm.org/rL235077

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

 
 bool
 PlatformRemoteGDBServer::GetModuleSpec (const FileSpec& module_file_spec,
                                         const ArchSpec& arch,
                                         ModuleSpec &module_spec)
 {
     Log *log = GetLogIfAnyCategoriesSet (LIBLLDB_LOG_PLATFORM);
 
-    const auto module_path = module_file_spec.GetPath ();
+    const auto module_path = module_file_spec.GetPath (false);
 
     if (!m_gdb_client.GetModuleInfo (module_file_spec, arch, module_spec))
     {
         if (log)
             log->Printf ("PlatformRemoteGDBServer::%s - failed to get module info for %s:%s",
                          __FUNCTION__, module_path.c_str (), arch.GetTriple ().getTriple ().c_str ());
         return false;
     }

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

 lldb::user_id_t
 GDBRemoteCommunicationClient::OpenFile (const lldb_private::FileSpec& file_spec,
                                         uint32_t flags,
                                         mode_t mode,
                                         Error &error)
 {
     lldb_private::StreamString stream;
     stream.PutCString("vFile:open:");
-    std::string path (file_spec.GetPath());
+    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::RestoreRegisterState (lldb::tid_t tid, uint32_t save_id)
     return false;
 }
 
 bool
 GDBRemoteCommunicationClient::GetModuleInfo (const FileSpec& module_file_spec,
                                              const lldb_private::ArchSpec& arch_spec,
                                              ModuleSpec &module_spec)
 {
-    std::string module_path = module_file_spec.GetPath ();
+    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();

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

if (!path.empty())
         if (packet.GetChar() == ',')
         {
             uint32_t flags = File::ConvertOpenOptionsForPOSIXOpen(
                 packet.GetHexMaxU32(false, 0));
             if (packet.GetChar() == ',')
             {
                 mode_t mode = packet.GetHexMaxU32(false, 0600);
                 Error error;
-                int fd = ::open (path.c_str(), flags, mode);
+                const FileSpec path_spec(path.c_str(), true);
+                int fd = ::open (path_spec.GetPath().c_str(), flags, mode);
                 const int save_errno = fd == -1 ? errno : 0;
                 StreamString response;
                 response.PutChar('F');
                 response.Printf("%i", fd);
                 if (save_errno)
                     response.Printf(",%i", save_errno);
                 return SendPacketNoLock(response.GetData(), response.GetSize());
             }
GDBRemoteCommunicationServerCommon::Handle_qModuleInfo (StringExtractorGDBRemote &packet)
 
     if (packet.GetChar() != ';')
         return SendErrorResponse (2);
 
     std::string triple;
     packet.GetHexByteString(triple);
     ArchSpec arch(triple.c_str());
 
-    const FileSpec module_path_spec = FindModuleFile(module_path, arch);
+    const FileSpec req_module_path_spec(module_path.c_str(), true);
+    const FileSpec module_path_spec = FindModuleFile(req_module_path_spec.GetPath(), arch);
     const ModuleSpec module_spec(module_path_spec, arch);
 
     ModuleSpecList module_specs;
     if (!ObjectFile::GetModuleSpecifications(module_path_spec, 0, 0, module_specs))
         return SendErrorResponse (3);
 
     ModuleSpec matched_module_spec;
     if (!module_specs.FindMatchingModuleSpec(module_spec, matched_module_spec))