Extend Platform(s) in order to cache remote executables using ModuleCache and make POSIX dynamic loader to use this flow when attaching to a remote target.

[ovyalov]

Summary

Extended Platform(s) in order to cache remote executables using ModuleCache and make POSIX dynamic loader to use this flow when attaching to a remote target.
Added executable cache support to Linux, FreeBSD, Windows and Darwin platforms.

[clayborg]

Looks good.

[tberghammer]

lgtm

[ovyalov]

AFFECTED FILES

/lldb/trunk/include/lldb/Target/Platform.h
/lldb/trunk/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.cpp
/lldb/trunk/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.h
/lldb/trunk/source/Plugins/Platform/FreeBSD/PlatformFreeBSD.cpp
/lldb/trunk/source/Plugins/Platform/Linux/PlatformLinux.cpp
/lldb/trunk/source/Plugins/Platform/MacOSX/PlatformDarwin.cpp
/lldb/trunk/source/Plugins/Platform/Windows/PlatformWindows.cpp
/lldb/trunk/source/Target/Platform.cpp

USERS

ovyalov (Author)

http://reviews.llvm.org/rL232194

include/lldb/Target/Platform.h

protected:
 
         void
         ClearCachedGroupNames ()
         {
             Mutex::Locker locker (m_mutex);
             m_gid_map.clear();
         }
 
+        Error
+        GetCachedExecutable (ModuleSpec &module_spec,
+                             lldb::ModuleSP &module_sp,
+                             const FileSpecList *module_search_paths_ptr,
+                             Platform &remote_platform);
+
         bool
         GetCachedSharedModule (const ModuleSpec &module_spec,
                                lldb::ModuleSP &module_sp);
 
         Error
         DownloadModuleSlice (const FileSpec& src_file_spec,
                              const uint64_t src_offset,
                              const uint64_t src_size,
                              const FileSpec& dst_file_spec);
 
         bool
         GetFileFromLocalCache (const ModuleSpec& module_spec,
                                FileSpec &cached_file_spec);
 
         FileSpec GetModuleCacheRoot ();
 
     private:
+        Error
+        LoadCachedExecutable (const ModuleSpec &module_spec,
+                              lldb::ModuleSP &module_sp,
+                              const FileSpecList *module_search_paths_ptr,
+                              Platform &remote_platform);
+
         DISALLOW_COPY_AND_ASSIGN (Platform);
     };
 
     
     class PlatformList
     {
     public:
         PlatformList() :

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

protected:
     lldb::addr_t
     ComputeLoadOffset();
 
     /// Computes a value for m_entry_point returning the computed address on
     /// success and LLDB_INVALID_ADDRESS on failure.
     lldb::addr_t
     GetEntryPoint();
 
-    /// Loads ModuleSpec data from inferior process.
-    bool
-    GetProcessModuleSpec(lldb_private::ModuleSpec& module_spec);
+    /// Loads Module from inferior process.
+    void
+    ResolveExecutableModule(lldb::ModuleSP &module_sp);
 
 private:
     DISALLOW_COPY_AND_ASSIGN(DynamicLoaderPOSIXDYLD);
 };
 
 #endif  // liblldb_DynamicLoaderPOSIXDYLD_H_

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

DynamicLoaderPOSIXDYLD::DidAttach()
     if (log)
         log->Printf ("DynamicLoaderPOSIXDYLD::%s() pid %" PRIu64, __FUNCTION__, m_process ? m_process->GetID () : LLDB_INVALID_PROCESS_ID);
 
     m_auxv.reset(new AuxVector(m_process));
     if (log)
         log->Printf ("DynamicLoaderPOSIXDYLD::%s pid %" PRIu64 " reloaded auxv data", __FUNCTION__, m_process ? m_process->GetID () : LLDB_INVALID_PROCESS_ID);
 
     ModuleSP executable_sp = GetTargetExecutable();
-    ModuleSpec process_module_spec;
-    if (GetProcessModuleSpec(process_module_spec))
-    {
-        if (executable_sp == nullptr || !executable_sp->MatchesModuleSpec(process_module_spec))
-        {
-            executable_sp.reset(new Module(process_module_spec));
-            assert(m_process != nullptr);
-            m_process->GetTarget().SetExecutableModule(executable_sp, false);
-        }
-    }
+    ResolveExecutableModule(executable_sp);
 
     addr_t load_offset = ComputeLoadOffset();
     if (log)
         log->Printf ("DynamicLoaderPOSIXDYLD::%s pid %" PRIu64 " executable '%s', load_offset 0x%" PRIx64, __FUNCTION__, m_process ? m_process->GetID () : LLDB_INVALID_PROCESS_ID, executable_sp ? executable_sp->GetFileSpec().GetPath().c_str () : "<null executable>", load_offset);
 
 
     if (executable_sp && load_offset != LLDB_INVALID_ADDRESS)
     {
DynamicLoaderPOSIXDYLD::GetThreadLocalData (const lldb::ModuleSP module, const lldb::ThreadSP thread)
     if (log)
         log->Printf("DynamicLoaderPOSIXDYLD::Performed TLS lookup: "
                     "module=%s, link_map=0x%" PRIx64 ", tp=0x%" PRIx64 ", modid=%" PRId64 ", tls_block=0x%" PRIx64 "\n",
                     mod->GetObjectName().AsCString(""), link_map, tp, (int64_t)modid, tls_block);
 
     return tls_block;
 }
 
-bool
-DynamicLoaderPOSIXDYLD::GetProcessModuleSpec (ModuleSpec& module_spec)
+void
+DynamicLoaderPOSIXDYLD::ResolveExecutableModule (lldb::ModuleSP &module_sp)
 {
+    Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
+
     if (m_process == nullptr)
-        return false;
+        return;
 
-    auto& target = m_process->GetTarget ();
+    auto &target = m_process->GetTarget ();
+    const auto platform_sp = target.GetPlatform ();
+
     ProcessInstanceInfo process_info;
-    if (!target.GetPlatform ()->GetProcessInfo (m_process->GetID (), process_info))
-        return false;
+    if (!platform_sp->GetProcessInfo (m_process->GetID (), process_info))
+    {
+        if (log)
+            log->Printf ("DynamicLoaderPOSIXDYLD::%s - failed to get process info for pid %" PRIu64,
+                         __FUNCTION__, m_process->GetID ());
+        return;
+    }
+
+    if (log)
+        log->Printf ("DynamicLoaderPOSIXDYLD::%s - got executable by pid %" PRIu64 ": %s",
+                     __FUNCTION__, m_process->GetID (), process_info.GetExecutableFile ().GetPath ().c_str ());
+
+    ModuleSpec module_spec (process_info.GetExecutableFile (), process_info.GetArchitecture ());
+    if (module_sp && module_sp->MatchesModuleSpec (module_spec))
+        return;
+
+    auto error = platform_sp->ResolveExecutable (module_spec, module_sp, nullptr);
+    if (error.Fail ())
+    {
+        StreamString stream;
+        module_spec.Dump (stream);
+
+        if (log)
+            log->Printf ("DynamicLoaderPOSIXDYLD::%s - failed to resolve executable with module spec \"%s\": %s",
+                         __FUNCTION__, stream.GetString ().c_str (), error.AsCString ());
+        return;
+    }
 
-    module_spec = ModuleSpec (process_info.GetExecutableFile (), process_info.GetArchitecture ());
-    return true;
+    target.SetExecutableModule (module_sp, false);
 }

source/Plugins/Platform/FreeBSD/PlatformFreeBSD.cpp

if (IsHost())
         {
             error.SetErrorStringWithFormat("unable to find executable for '%s'", resolved_module_spec.GetFileSpec().GetPath().c_str());
         }
     }
     else
     {
         if (m_remote_platform_sp)
         {
-            error = m_remote_platform_sp->ResolveExecutable (module_spec,
-                                                             exe_module_sp,
-                                                             module_search_paths_ptr);
+            error = GetCachedExecutable (resolved_module_spec, exe_module_sp, module_search_paths_ptr, *m_remote_platform_sp);
         }
         else
         {
             // We may connect to a process and use the provided executable (Don't use local $PATH).
 
             // Resolve any executable within a bundle on MacOSX
             Host::ResolveExecutableInBundle (resolved_module_spec.GetFileSpec());
 

source/Plugins/Platform/Linux/PlatformLinux.cpp

if (IsHost())
         {
             error.SetErrorStringWithFormat("unable to find executable for '%s'", resolved_module_spec.GetFileSpec().GetPath().c_str());
         }
     }
     else
     {
         if (m_remote_platform_sp)
         {
-            error = m_remote_platform_sp->ResolveExecutable (ms,
-                                                             exe_module_sp,
-                                                             NULL);
+            error = GetCachedExecutable (resolved_module_spec, exe_module_sp, nullptr, *m_remote_platform_sp);
         }
         else
         {
             // We may connect to a process and use the provided executable (Don't use local $PATH).
 
             if (resolved_module_spec.GetFileSpec().Exists())
                 error.Clear();
             else

source/Plugins/Platform/MacOSX/PlatformDarwin.cpp

if (IsHost())
             else
                 error.SetErrorStringWithFormat ("unable to find executable for '%s'", resolved_module_spec.GetFileSpec().GetPath().c_str());
         }
     }
     else
     {
         if (m_remote_platform_sp)
         {
-            error = m_remote_platform_sp->ResolveExecutable (module_spec,
-                                                             exe_module_sp,
-                                                             module_search_paths_ptr);
+            error = GetCachedExecutable (resolved_module_spec, exe_module_sp, module_search_paths_ptr, *m_remote_platform_sp);
         }
         else
         {
             // We may connect to a process and use the provided executable (Don't use local $PATH).
 
             // Resolve any executable within a bundle on MacOSX
             Host::ResolveExecutableInBundle (resolved_module_spec.GetFileSpec());
 

source/Plugins/Platform/Windows/PlatformWindows.cpp

if (IsHost())
             ms.GetFileSpec().GetPath(exe_path, sizeof(exe_path));
             error.SetErrorStringWithFormat("unable to find executable for '%s'", exe_path);
         }
     }
     else
     {
         if (m_remote_platform_sp)
         {
-            error = m_remote_platform_sp->ResolveExecutable (ms,
-                                                             exe_module_sp,
-                                                             NULL);
+            error = GetCachedExecutable (resolved_module_spec, exe_module_sp, nullptr, *m_remote_platform_sp);
         }
         else
         {
             // We may connect to a process and use the provided executable (Don't use local $PATH).
             if (resolved_module_spec.GetFileSpec().Exists())
                 error.Clear();
             else
                 error.SetErrorStringWithFormat("the platform is not currently connected, and '%s' doesn't exist in the system root.", exe_path);

source/Target/Platform.cpp

if (!m_calculated_trap_handlers)
         {
             CalculateTrapHandlerSymbolNames();
             m_calculated_trap_handlers = true;
         }
     }
     return m_trap_handlers;
 }
 
+Error
+Platform::GetCachedExecutable (ModuleSpec &module_spec,
+                               lldb::ModuleSP &module_sp,
+                               const FileSpecList *module_search_paths_ptr,
+                               Platform &remote_platform)
+{
+    const auto platform_spec = module_spec.GetFileSpec ();
+    const auto error = LoadCachedExecutable (module_spec,
+                                             module_sp,
+                                             module_search_paths_ptr,
+                                             remote_platform);
+    if (error.Success ())
+    {
+        module_spec.GetFileSpec () = module_sp->GetFileSpec ();
+        module_spec.GetPlatformFileSpec () = platform_spec;
+    }
+
+    return error;
+}
+
+Error
+Platform::LoadCachedExecutable (const ModuleSpec &module_spec,
+                                lldb::ModuleSP &module_sp,
+                                const FileSpecList *module_search_paths_ptr,
+                                Platform &remote_platform)
+{
+    if (GetGlobalPlatformProperties ()->GetUseModuleCache ())
+    {
+        if (GetCachedSharedModule (module_spec, module_sp))
+            return Error ();
+    }
+
+    return remote_platform.ResolveExecutable (module_spec,
+                                              module_sp,
+                                              module_search_paths_ptr);
+}
+
 bool
 Platform::GetCachedSharedModule (const ModuleSpec &module_spec,
                                  lldb::ModuleSP &module_sp)
 {
     FileSpec cached_file_spec;
     if (m_module_cache && GetFileFromLocalCache (module_spec, cached_file_spec))
     {
         auto cached_module_spec (module_spec);