Fix TestNamespace and TestThreadJump for remote Windows to Android.

[chaoren]

Summary

Update DYLDRendezvous and SOEntry to use FileSpecs instead of storing paths as
strings, which caused incorrect comparison results due to denormalization.

[emaste]

LGTM. It looks like this solves PR17880 too, at least for the basic case.

I want to confirm (by code inspection or testing) that the path resolution/normalization happens within DYLDRendezvous::DYLDRendezvous, if e.g. the process does chdir prior to the dyld rendezvous.

[ovyalov]

source/Plugins/DynamicLoader/POSIX-DYLD/DYLDRendezvous.cpp

410

Should resolve be false since this path might be SO path on remote machine?

[emaste]

source/Plugins/DynamicLoader/POSIX-DYLD/DYLDRendezvous.cpp

410

I think this is what's responsible for fixing PR 17880?

[emaste]

source/Plugins/DynamicLoader/POSIX-DYLD/DYLDRendezvous.cpp

410

Oh, scratch that. This is the entry returned by the dyld rendezvous, and I think should behave the same way wrt PR 17880 if it is true or false.

[chaoren]

• Address review comments.

[ovyalov]

LGTM

source/Plugins/DynamicLoader/POSIX-DYLD/DYLDRendezvous.h

 // C Includes
 // C++ Includes
 #include <list>
 #include <string>
 
 // Other libraries and framework includes
 #include "lldb/lldb-defines.h"
 #include "lldb/lldb-types.h"
+#include "lldb/Host/FileSpec.h"
 
 namespace lldb_private {
 class Process;
 }
 
 /// @class DYLDRendezvous
 /// @brief Interface to the runtime linker.
 ///
public:
     };
 
     /// @brief Structure representing the shared objects currently loaded into
     /// the inferior process.
     ///
     /// This object is a rough analogue to the struct link_map object which
     /// actually lives in the inferiors memory.
     struct SOEntry {
-        lldb::addr_t link_addr; ///< Address of this link_map.
-        lldb::addr_t base_addr; ///< Base address of the loaded object.
-        lldb::addr_t path_addr; ///< String naming the shared object.
-        lldb::addr_t dyn_addr;  ///< Dynamic section of shared object.
-        lldb::addr_t next;      ///< Address of next so_entry.
-        lldb::addr_t prev;      ///< Address of previous so_entry.
-        std::string  path;      ///< File name of shared object.
+        lldb::addr_t link_addr;           ///< Address of this link_map.
+        lldb::addr_t base_addr;           ///< Base address of the loaded object.
+        lldb::addr_t path_addr;           ///< String naming the shared object.
+        lldb::addr_t dyn_addr;            ///< Dynamic section of shared object.
+        lldb::addr_t next;                ///< Address of next so_entry.
+        lldb::addr_t prev;                ///< Address of previous so_entry.
+        lldb_private::FileSpec file_spec; ///< File spec of shared object.
 
         SOEntry() { clear(); }
 
         bool operator ==(const SOEntry &entry) {
-            return this->path == entry.path;
+            return file_spec == entry.file_spec;
         }
 
         void clear() {
             link_addr = 0;
             base_addr = 0;
             path_addr = 0;
             dyn_addr  = 0;
             next = 0;
             prev = 0;
-            path.clear();
+            file_spec.Clear();
         }
     };
 
 protected:
     typedef std::list<SOEntry> SOEntryList;
 
 public:
     typedef SOEntryList::const_iterator iterator;
public:
     /// Iterators over all modules unloaded from the inferior since the last
     /// call to Resolve().
     iterator unloaded_begin() const { return m_removed_soentries.begin(); }
     iterator unloaded_end() const { return m_removed_soentries.end(); }
     
 protected:
     lldb_private::Process *m_process;
 
-    // Cached copy of executable pathname
-    char m_exe_path[PATH_MAX];
+    // Cached copy of executable file spec
+    lldb_private::FileSpec m_exe_file_spec;
 
     /// Location of the r_debug structure in the inferiors address space.
     lldb::addr_t m_rendezvous_addr;
 
     /// Current and previous snapshots of the rendezvous structure.
     Rendezvous m_current;
     Rendezvous m_previous;
 

source/Plugins/DynamicLoader/POSIX-DYLD/DYLDRendezvous.cpp

DYLDRendezvous::DYLDRendezvous(Process *process)
     m_thread_info.valid = false;
 
     // Cache a copy of the executable path
     if (m_process)
     {
         Module *exe_mod = m_process->GetTarget().GetExecutableModulePointer();
         if (exe_mod)
         {
-            exe_mod->GetPlatformFileSpec().GetPath(m_exe_path, PATH_MAX);
+            m_exe_file_spec = exe_mod->GetPlatformFileSpec();
             if (log)
-                log->Printf ("DYLDRendezvous::%s exe module executable path set: '%s'", __FUNCTION__, m_exe_path);
+                log->Printf ("DYLDRendezvous::%s exe module executable path set: '%s'",
+                        __FUNCTION__, m_exe_file_spec.GetCString());
         }
         else
         {
             if (log)
                 log->Printf ("DYLDRendezvous::%s cannot cache exe module path: null executable module pointer", __FUNCTION__);
         }
     }
 }
DYLDRendezvous::SOEntryIsMainExecutable(const SOEntry &entry)
     // FreeBSD and on Android it is the full path to the executable.
 
     auto triple = m_process->GetTarget().GetArchitecture().GetTriple();
     auto os_type = triple.getOS();
     auto env_type = triple.getEnvironment();
 
     switch (os_type) {
         case llvm::Triple::FreeBSD:
-            return ::strcmp(entry.path.c_str(), m_exe_path) == 0;
+            return entry.file_spec == m_exe_file_spec;
         case llvm::Triple::Linux:
             switch (env_type) {
                 case llvm::Triple::Android:
-                    return ::strcmp(entry.path.c_str(), m_exe_path) == 0;
+                    return entry.file_spec == m_exe_file_spec;
                 default:
-                    return entry.path.empty();
+                    return !entry.file_spec;
             }
         default:
             return false;
     }
 }
 
 bool
 DYLDRendezvous::TakeSnapshot(SOEntryList &entry_list)
DYLDRendezvous::ReadSOEntryFromMemory(lldb::addr_t addr, SOEntry &entry)
     if (!(addr = ReadPointer(addr, &entry.dyn_addr)))
         return false;
     
     if (!(addr = ReadPointer(addr, &entry.next)))
         return false;
     
     if (!(addr = ReadPointer(addr, &entry.prev)))
         return false;
-    
-    entry.path = ReadStringFromMemory(entry.path_addr);
-    
+    entry.file_spec.SetFile(ReadStringFromMemory(entry.path_addr), false);
     return true;
 }
 
 
 bool
 DYLDRendezvous::FindMetadata(const char *name, PThreadField field, uint32_t& value)
 {
     Target& target = m_process->GetTarget();
DYLDRendezvous::DumpToLog(Log *log) const
     iterator I = begin();
     iterator E = end();
 
     if (I != E) 
         log->PutCString("DYLDRendezvous SOEntries:");
     
     for (int i = 1; I != E; ++I, ++i) 
     {
-        log->Printf("\n   SOEntry [%d] %s", i, I->path.c_str());
+        log->Printf("\n   SOEntry [%d] %s", i, I->file_spec.GetCString());
         log->Printf("      Base : %" PRIx64, I->base_addr);
         log->Printf("      Path : %" PRIx64, I->path_addr);
         log->Printf("      Dyn  : %" PRIx64, I->dyn_addr);
         log->Printf("      Next : %" PRIx64, I->next);
         log->Printf("      Prev : %" PRIx64, I->prev);
     }
 }

source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.cpp

DynamicLoaderPOSIXDYLD::RefreshModules()
 
     if (m_rendezvous.ModulesDidLoad()) 
     {
         ModuleList new_modules;
 
         E = m_rendezvous.loaded_end();
         for (I = m_rendezvous.loaded_begin(); I != E; ++I)
         {
-            FileSpec file(I->path.c_str(), true);
-            ModuleSP module_sp = LoadModuleAtAddress(file, I->link_addr, I->base_addr);
+            ModuleSP module_sp = LoadModuleAtAddress(I->file_spec, I->link_addr, I->base_addr);
             if (module_sp.get())
             {
                 loaded_modules.AppendIfNeeded(module_sp);
                 new_modules.Append(module_sp);
             }
         }
         m_process->GetTarget().ModulesDidLoad(new_modules);
     }
     
     if (m_rendezvous.ModulesDidUnload())
     {
         ModuleList old_modules;
 
         E = m_rendezvous.unloaded_end();
         for (I = m_rendezvous.unloaded_begin(); I != E; ++I)
         {
-            FileSpec file(I->path.c_str(), true);
-            ModuleSpec module_spec (file);
-            ModuleSP module_sp = 
+            ModuleSpec module_spec{I->file_spec};
+            ModuleSP module_sp =
                 loaded_modules.FindFirstModule (module_spec);
 
             if (module_sp.get())
             {
                 old_modules.Append(module_sp);
                 UnloadSections(module_sp);
             }
         }
DynamicLoaderPOSIXDYLD::LoadAllCurrentModules()
     // The rendezvous class doesn't enumerate the main module, so track
     // that ourselves here.
     ModuleSP executable = GetTargetExecutable();
     m_loaded_modules[executable] = m_rendezvous.GetLinkMapAddress();
 
 
     for (I = m_rendezvous.begin(), E = m_rendezvous.end(); I != E; ++I)
     {
-        const char *module_path = I->path.c_str();
-        FileSpec file(module_path, false);
-        ModuleSP module_sp = LoadModuleAtAddress(file, I->link_addr, I->base_addr);
+        ModuleSP module_sp = LoadModuleAtAddress(I->file_spec, I->link_addr, I->base_addr);
         if (module_sp.get())
         {
             module_list.Append(module_sp);
         }
         else
         {
             Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
             if (log)
                 log->Printf("DynamicLoaderPOSIXDYLD::%s failed loading module %s at 0x%" PRIx64,
-                            __FUNCTION__, module_path, I->base_addr);
+                            __FUNCTION__, I->file_spec.GetCString(), I->base_addr);
         }
     }
 
     m_process->GetTarget().ModulesDidLoad(module_list);
 }
 
 addr_t
 DynamicLoaderPOSIXDYLD::ComputeLoadOffset()