Fix ModuleCache usage in Platform - ask remote platform for module's ModuleSpec beforehand so we can look for a module by UUID locally without need to download it.

http://reviews.llvm.org/D8557

llvm-svn: 233136

1 files changed, 69 insertions, 54 deletions

diff --git a/lldb/source/Target/Platform.cpp b/lldb/source/Target/Platform.cpp
index 671ebf071da..d5a61f0ecdb 100644
--- a/lldb/source/Target/Platform.cpp
+++ b/lldb/source/Target/Platform.cpp
@@ -253,23 +253,23 @@ Platform::GetSharedModule (const ModuleSpec &module_spec,
                            ModuleSP *old_module_sp_ptr,
                            bool *did_create_ptr)
 {
-    if (!IsHost () && GetGlobalPlatformProperties ()->GetUseModuleCache ())
-    {
-        // Use caching only when talking to a remote platform.
-        if (GetCachedSharedModule (module_spec, process, module_sp))
-        {
-            if (did_create_ptr)
-                *did_create_ptr = true;
-
-            return Error ();
-        }
-    }
-    return ModuleList::GetSharedModule (module_spec, 
-                                        module_sp,
-                                        module_search_paths_ptr,
-                                        old_module_sp_ptr,
-                                        did_create_ptr,
-                                        false);
+    if (IsHost ())
+        return ModuleList::GetSharedModule (module_spec,
+                                            module_sp,
+                                            module_search_paths_ptr,
+                                            old_module_sp_ptr,
+                                            did_create_ptr,
+                                            false);
+
+    return GetRemoteSharedModule (module_spec,
+                                  process,
+                                  module_sp,
+                                  [&](const ModuleSpec &spec)
+                                  {
+                                      return ModuleList::GetSharedModule (
+                                          spec, module_sp, module_search_paths_ptr, old_module_sp_ptr, did_create_ptr, false);
+                                  },
+                                  did_create_ptr);
 }
 
 bool
@@ -1779,66 +1779,80 @@ Platform::LoadCachedExecutable (const ModuleSpec &module_spec,
                                 const FileSpecList *module_search_paths_ptr,
                                 Platform &remote_platform)
 {
-    if (GetGlobalPlatformProperties ()->GetUseModuleCache ())
-    {
-        if (GetCachedSharedModule (module_spec, nullptr, module_sp))
-            return Error ();
-    }
-
-    return remote_platform.ResolveExecutable (module_spec,
-                                              module_sp,
-                                              module_search_paths_ptr);
+    return GetRemoteSharedModule (module_spec,
+                                  nullptr,
+                                  module_sp,
+                                  [&](const ModuleSpec &spec)
+                                  {
+                                      return remote_platform.ResolveExecutable (
+                                          spec, module_sp, module_search_paths_ptr);
+                                  },
+                                  nullptr);
 }
 
-bool
-Platform::GetCachedSharedModule (const ModuleSpec &module_spec,
+Error
+Platform::GetRemoteSharedModule (const ModuleSpec &module_spec,
                                  Process* process,
-                                 lldb::ModuleSP &module_sp)
-{
-    return (m_module_cache && GetModuleFromLocalCache (module_spec, process, module_sp));
-}
-
-bool
-Platform::GetModuleFromLocalCache (const ModuleSpec& module_spec,
-                                   Process* process,
-                                   lldb::ModuleSP &module_sp)
+                                 lldb::ModuleSP &module_sp,
+                                 const ModuleResolver &module_resolver,
+                                 bool *did_create_ptr)
 {
-    Log *log = GetLogIfAnyCategoriesSet (LIBLLDB_LOG_PLATFORM);
-
-    
+    // Get module information from a target.
     ModuleSpec resolved_module_spec;
     bool got_module_spec = false;
-
     if (process)
     {
         // Try to get module information from the process
         if (process->GetModuleSpec (module_spec.GetFileSpec (), module_spec.GetArchitecture (), resolved_module_spec))
-            got_module_spec = true;
+          got_module_spec = true;
     }
 
     if (!got_module_spec)
     {
         // Get module information from a target.
         if (!GetModuleSpec (module_spec.GetFileSpec (), module_spec.GetArchitecture (), resolved_module_spec))
-            return false;
+            return module_resolver (module_spec);
     }
 
+    // Trying to find a module by UUID on local file system.
+    const auto error = module_resolver (resolved_module_spec);
+    if (error.Fail ())
+     {
+          if (GetCachedSharedModule (resolved_module_spec, module_sp, did_create_ptr))
+              return Error ();
+     }
+
+    return error;
+}
+
+bool
+Platform::GetCachedSharedModule (const ModuleSpec &module_spec,
+                                 lldb::ModuleSP &module_sp,
+                                 bool *did_create_ptr)
+{
+    if (IsHost() ||
+        !GetGlobalPlatformProperties ()->GetUseModuleCache ())
+        return false;
+
+    Log *log = GetLogIfAnyCategoriesSet (LIBLLDB_LOG_PLATFORM);
+
     // Check local cache for a module.
     auto error = m_module_cache->Get (GetModuleCacheRoot (),
                                       GetHostname (),
-                                      resolved_module_spec,
-                                      module_sp);
+                                      module_spec,
+                                      module_sp,
+                                      did_create_ptr);
     if (error.Success ())
         return true;
 
     if (log)
         log->Printf("Platform::%s - module %s not found in local cache: %s",
-                    __FUNCTION__, resolved_module_spec.GetUUID ().GetAsString ().c_str (), error.AsCString ());
+                    __FUNCTION__, module_spec.GetUUID ().GetAsString ().c_str (), error.AsCString ());
 
     // Get temporary file name for a downloaded module.
     llvm::SmallString<PATH_MAX> tmp_download_file_path;
     const auto err_code = llvm::sys::fs::createTemporaryFile (
-        "lldb", resolved_module_spec.GetUUID ().GetAsString ().c_str (), tmp_download_file_path);
+        "lldb", module_spec.GetUUID ().GetAsString ().c_str (), tmp_download_file_path);
     if (err_code)
     {
         if (log)
@@ -1851,9 +1865,9 @@ Platform::GetModuleFromLocalCache (const ModuleSpec& module_spec,
 
     const FileSpec tmp_download_file_spec (tmp_download_file_path.c_str (), true);
     // Download a module file.
-    error = DownloadModuleSlice (resolved_module_spec.GetFileSpec (),
-                                 resolved_module_spec.GetObjectOffset (),
-                                 resolved_module_spec.GetObjectSize (),
+    error = DownloadModuleSlice (module_spec.GetFileSpec (),
+                                 module_spec.GetObjectOffset (),
+                                 module_spec.GetObjectSize (),
                                  tmp_download_file_spec);
     if (error.Fail ())
     {
@@ -1867,21 +1881,22 @@ Platform::GetModuleFromLocalCache (const ModuleSpec& module_spec,
     // Put downloaded file into local module cache.
     error = m_module_cache->Put (GetModuleCacheRoot (),
                                  GetHostname (),
-                                 resolved_module_spec,
+                                 module_spec,
                                  tmp_download_file_spec);
     if (error.Fail ())
     {
         if (log)
             log->Printf("Platform::%s - failed to put module %s into cache: %s",
-                        __FUNCTION__, resolved_module_spec.GetUUID ().GetAsString ().c_str (),
+                        __FUNCTION__, module_spec.GetUUID ().GetAsString ().c_str (),
                         error.AsCString ());
         return false;
     }
 
     error = m_module_cache->Get (GetModuleCacheRoot (),
                                  GetHostname (),
-                                 resolved_module_spec,
-                                 module_sp);
+                                 module_spec,
+                                 module_sp,
+                                 did_create_ptr);
     return error.Success ();
 }