Add Utility/ModuleCache class and integrate it with PlatformGDBRemoteServer - in order to allow modules caching from remote targets.

[ovyalov]

Summary

It's initial version of ModuleCache which I integrated with existing caching plumbing - using "platform connect -c ..." or SBPlatform::ConnectRemote that takes local cache directory path.
Each module is cached using the following path - ${local_cache_directory}/${UUID}/${platform_module_path}.
ModuleCache::Options has m_max_size field which is no-op now - I'm planning to put LRU logic in with a subsequent CL.

Please let me know whether such approach looks reasonable to you.

[clayborg]

See my inline comments and let me know what you think. I think it would be nice if we had a global directory that we used for all locally cached files. The module cache would be writeable, and if someone specifies a system root with "platform select --sysroot=/path/to/read/only/root" the system root would be read only. We then cache files locally into /tmp/<platform-name>/<hostname>. We would store a global repository in /tmp/<platform-name> where we store the value using the UUID:

/tmp/<platform-name>/.cache/<uuid>/<cached-file>

Then in the host specific directory we could symlink to this:

/tmp/<platform-name>/<hostname1>/usr/lib/<symlink-to-cached-file>
/tmp/<platform-name>/<hostname2>/usr/lib/<symlink-to-cached-file>

The above two files could be symlinks to the same file. This way if you are connecting to a bunch of somewhat related linux distros, you might be able to share many files between then in your local cache.

So the main ideas here are:
1 - allow a read only sysroot to be specified with --sysroot when selecting the platform, or specify it after the fact
2 - allow a writeable cache that is auto generated for all platforms, but only if they opt into calling Platform::GetCachedSharedModule()
3 - implement a global file cache per platform that each hostname can then symlink to

Let me know what you think.

include/lldb/Core/ModuleSpec.h

17

Remove this?

source/Plugins/Platform/POSIX/PlatformPOSIX.h

35–40

Move this to Platform.h and rename the function to be GetCachedSharedModule? Then all platforms can take advantage of the local cache. It would be nice if we can create a global platform cache that just works for all platforms. The Platform::GetCachedSharedModule() would check the local cache directory for the module first and use it from there and if it isn't there download it via the Platform::GetFile() and update the cache?

127–128

Maybe we should just auto compute this path using the current platform name by picking a cache directory from the platform name, hostname, etc. Lets say we have a new setting:

(lldb) settings set platform.file-cache-directory /tmp

This setting would default to the current temporary directory, but it could be changed if desired so that it never goes away (some path into your home directory).

Then we can encode the cache as:

/tmp/<platform-name>/<hostname>/usr/lib/libc.so

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

234–246

Use lldb_private::ModuleSpec instead of a new class?

262–276

Can we move this into Platform.h and just use virtual API calls to implement this for all platforms?

[ovyalov]

Thank you for comments and suggestions - please see my comments inline:

In D8037#133641, @clayborg wrote:

See my inline comments and let me know what you think. I think it would be nice if we had a global directory that we used for all locally cached files. The module cache would be writeable, and if someone specifies a system root with "platform select --sysroot=/path/to/read/only/root" the system root would be read only. We then cache files locally into /tmp/<platform-name>/<hostname>. We would store a global repository in /tmp/<platform-name> where we store the value using the UUID:

/tmp/<platform-name>/.cache/<uuid>/<cached-file>

Then in the host specific directory we could symlink to this:

/tmp/<platform-name>/<hostname1>/usr/lib/<symlink-to-cached-file>
/tmp/<platform-name>/<hostname2>/usr/lib/<symlink-to-cached-file>

The above two files could be symlinks to the same file. This way if you are connecting to a bunch of somewhat related linux distros, you might be able to share many files between then in your local cache.

So the main ideas here are:
1 - allow a read only sysroot to be specified with --sysroot when selecting the platform, or specify it after the fact

Do you mean if --sysroot is specified we should use modules from /tmp/<platform-name>/<hostname> instead of local libraries and without matching UUIDs for modules in cache and on a remote target?

2 - allow a writeable cache that is auto generated for all platforms, but only if they opt into calling Platform::GetCachedSharedModule()

Is it okay to introduce a new property like platform.use-file-cache with default true value to control whether we're allowed to use local caching?

3 - implement a global file cache per platform that each hostname can then symlink to

Let me know what you think.

include/lldb/Core/ModuleSpec.h

17

I added this include since the class has "mutable Mutex m_mutex;" - otherwise got compilation errors.

source/Plugins/Platform/POSIX/PlatformPOSIX.h

35–40

I like the idea of having Platform::GetCachedSharedModule. But let me ask you next question - how we can get UUID by path, triple (i.e. call qModuleInfo request) from within Platform? Is it okay to lay out it in following way:

• Add ModuleSpec Platform::GetModuleSpec(const FileSpec&, const Arch&) method which in default implementation just returns ModuleSpec for local module.
• Make PlatformGDBRemoteServer::GetModuleSpec to call qModuleInfo request and return info for remote module.
• PlatformPOSIX and other platforms that have m_remote_platform field will override GetModuleSpec and delegate it to m_remote_platform if not a host.

Does it sound okay to you?

127–128

Yes, it might be easier then passing local path through SB API calls.

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

234–246

I thought about this but I see two main problems here:

• Is it safe to put md5 hash (if module doesn't have UUID) into ModuleSpec::m_uuid? I'm concerned about https://github.com/llvm-mirror/lldb/blob/master/source/Core/Module.cpp#L188 which tries to match UUIDs and if ModuleSpec::m_uuid contains MD5 hash then FindMatchingModuleSpec fails because module's UUID is empty. I can always clear ModuleSpec::m_uuid every time I create new Module instance to avoid this check. As an alternative we may have new ModuleSpec::m_hash field but I don't like this idea.

• New ModuleSpec::m_object_size field will be needed. Is it okay to bring File API into ModuleSpec in order to initialize m_object_size with size of ModuleSpec::m_file?

[clayborg]

Like your plan as detailed in your inlined comments and what you agree with from my initial comments. I look forward to seeing this next patch!

source/Plugins/Platform/POSIX/PlatformPOSIX.h

35–40

Yes that would be ok.

[ovyalov]

Redesigned CL accordingly to the plan discussed with Greg.
The change has become pretty big - please let me know if you want me to split it down to a few change lists.

Please take another look.
Thank you.

[ovyalov]

Friendly ping.

[ovyalov]

Please let me know if you have any suggestions on this CL - otherwise I'm going to submit it soon.

[clayborg]

There were inlined comments that weren't addressed. Please check the comments and let me know.

[ovyalov]

In D8037#136965, @clayborg wrote:

There were inlined comments that weren't addressed. Please check the comments and let me know.

I didn't implement --sysroot option for "platform select" command because I was thinking about doing this in a separate CL - sorry that didn't mention this before.

[clayborg]

Inlined comments that didn't get submitted...

include/lldb/Core/ModuleSpec.h

17

Does this need to be in the header file?

source/Core/Debugger.cpp

700–703 ↗

(On Diff #21243)

Does this play well with the other "platform" settings that are already there?

platform.plugin.linux.use-llgs-for-local (boolean) = false
platform.plugin.darwin-kernel.search-locally-for-kexts (boolean) = true
platform.plugin.darwin-kernel.kext-directories (file-list) =

[clayborg]

Sorry, looks like my inlined comments were never submitted. Check the bug again, I think I got them to appear in the public version of the bug...

[ovyalov]

Please see my comments.

include/lldb/Core/ModuleSpec.h

17

ModuleSpec::m_mutex needs it - https://github.com/llvm-mirror/lldb/blob/master/include/lldb/Core/ModuleSpec.h#L589, otherwise compilation is failing for me.

It seems to me that ModuleSpec has grown pretty big as for inlined class - we may add ModuleSpec.cpp and move methods' implementation over there. In this case we can use std::unique<Mutex> instead of Mutex, so it will be enough to have Mutex forward declaration inside of the header file.

source/Core/Debugger.cpp

700–703 ↗

(On Diff #21243)

I didn't notice any runtime issues with existing properties - here is the partial output of "settings show" from my Ubuntu:

...
target.process.thread.trace-thread (boolean) = false
platform.use-module-cache (boolean) = true
platform.module-cache-directory (file) = "/usr/local/google/home/ovyalov/lldb/module_cache/lldb"
platform.plugin.linux.use-llgs-for-local (boolean) = true
interpreter.expand-regex-aliases (boolean) = false

....

on OSX:

...
target.process.thread.trace-thread (boolean) = false

platform.use-module-cache (boolean) = true

platform.module-cache-directory (file) = "/Users/ovyalov/lldb/module_cache/lldb"

platform.plugin.linux.use-llgs-for-local (boolean) = true

platform.plugin.darwin-kernel.search-locally-for-kexts (boolean) = true

platform.plugin.darwin-kernel.kext-directories (file-list) =

interpreter.expand-regex-aliases (boolean) = false

interpreter.prompt-on-quit (boolean) = true

Since Platform a base class we're not allowed to use DebuggerInitialize method to initialize settings as PlatformLinux, for instance, does.

Will upload fixed version of the CL shortly to use user's home directory as a root folder for module cache instead of LLDB temp directory (which is cleaned when a process exits).

[ovyalov]

Use "~/lldb/module_cache" as module cache root instead of LLDB temporary directory which is cleaned after a process exits.

[vharron]

.lldb?

[clayborg]

We should make a new temp directory that doesn't get cleaned up after LLDB exits. We could add a new ePathTypeGlobalLLDBTempSystemDir path type and just have it return a path that isn't process specific...

[ovyalov]

Added ePathTypeGlobalLLDBTempSystemDir and made Platform to use it as a root cache directory.

Please take another look.

[clayborg]

Looks good.

[ovyalov]

AFFECTED FILES

/lldb/trunk/include/lldb/Core/ModuleSpec.h
/lldb/trunk/include/lldb/Host/HostInfoBase.h
/lldb/trunk/include/lldb/Target/Platform.h
/lldb/trunk/include/lldb/lldb-enumerations.h
/lldb/trunk/lldb.xcodeproj/project.pbxproj
/lldb/trunk/source/Core/Debugger.cpp
/lldb/trunk/source/Core/UUID.cpp
/lldb/trunk/source/Host/common/HostInfoBase.cpp
/lldb/trunk/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.cpp
/lldb/trunk/source/Plugins/ObjectContainer/BSD-Archive/ObjectContainerBSDArchive.cpp
/lldb/trunk/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp
/lldb/trunk/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp
/lldb/trunk/source/Plugins/Platform/FreeBSD/PlatformFreeBSD.cpp
/lldb/trunk/source/Plugins/Platform/FreeBSD/PlatformFreeBSD.h
/lldb/trunk/source/Plugins/Platform/POSIX/PlatformPOSIX.cpp
/lldb/trunk/source/Plugins/Platform/POSIX/PlatformPOSIX.h
/lldb/trunk/source/Plugins/Platform/Windows/PlatformWindows.cpp
/lldb/trunk/source/Plugins/Platform/Windows/PlatformWindows.h
/lldb/trunk/source/Plugins/Platform/gdb-server/PlatformRemoteGDBServer.cpp
/lldb/trunk/source/Plugins/Platform/gdb-server/PlatformRemoteGDBServer.h
/lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp
/lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerCommon.cpp
/lldb/trunk/source/Target/Platform.cpp
/lldb/trunk/source/Utility/CMakeLists.txt
/lldb/trunk/source/Utility/ModuleCache.cpp
/lldb/trunk/source/Utility/ModuleCache.h
/lldb/trunk/test/python_api/hello_world/TestHelloWorld.py

USERS

ovyalov (Author)

http://reviews.llvm.org/rL231734

include/lldb/Core/ModuleSpec.h

 //===-- ModuleSpec.h --------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_ModuleSpec_h_
 #define liblldb_ModuleSpec_h_
 
 #include "lldb/Core/ArchSpec.h"
 #include "lldb/Core/Stream.h"
 #include "lldb/Core/UUID.h"
 #include "lldb/Host/FileSpec.h"
+#include "lldb/Host/Mutex.h"
 #include "lldb/Target/PathMappingList.h"
 
 namespace lldb_private {
 
 class ModuleSpec
 {
 public:
     ModuleSpec () :

lldb.xcodeproj/project.pbxproj

/* Begin PBXBuildFile section */
     23F4034D1926E0F60046DC9B /* NativeRegisterContextRegisterInfo.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 23F403481926CC250046DC9B /* NativeRegisterContextRegisterInfo.cpp */; };
     250D6AE31A9679440049CC70 /* FileSystem.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 250D6AE11A9679270049CC70 /* FileSystem.cpp */; };
     25420ECD1A6490B8009ADBCB /* OptionValueChar.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 25420ECC1A6490B8009ADBCB /* OptionValueChar.cpp */; };
     25420ED21A649D88009ADBCB /* PipeBase.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 25420ED11A649D88009ADBCB /* PipeBase.cpp */; };
     254FBB951A81AA7F00BD6378 /* SBLaunchInfo.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 254FBB941A81AA7F00BD6378 /* SBLaunchInfo.cpp */; };
     254FBB971A81B03100BD6378 /* SBLaunchInfo.h in Headers */ = {isa = PBXBuildFile; fileRef = 254FBB961A81B03100BD6378 /* SBLaunchInfo.h */; settings = {ATTRIBUTES = (Public, ); }; };
     254FBBA31A9166F100BD6378 /* SBAttachInfo.h in Headers */ = {isa = PBXBuildFile; fileRef = 254FBBA21A9166F100BD6378 /* SBAttachInfo.h */; settings = {ATTRIBUTES = (Public, ); }; };
     254FBBA51A91670E00BD6378 /* SBAttachInfo.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 254FBBA41A91670E00BD6378 /* SBAttachInfo.cpp */; };
+    257E47171AA56C2000A62F81 /* ModuleCache.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 257E47151AA56C2000A62F81 /* ModuleCache.cpp */; };
+    257E47181AA56C2000A62F81 /* ModuleCache.h in Headers */ = {isa = PBXBuildFile; fileRef = 257E47161AA56C2000A62F81 /* ModuleCache.h */; };
     260157C61885F51C00F875CF /* libpanel.dylib in Frameworks */ = {isa = PBXBuildFile; fileRef = 260157C41885F4FF00F875CF /* libpanel.dylib */; };
     260157C81885F53100F875CF /* libpanel.dylib in Frameworks */ = {isa = PBXBuildFile; fileRef = 260157C41885F4FF00F875CF /* libpanel.dylib */; };
     2606EDDF184E68A10034641B /* liblldb-core.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 2689FFCA13353D7A00698AC0 /* liblldb-core.a */; };
     260A248E15D06C50009981B0 /* OptionValues.h in Headers */ = {isa = PBXBuildFile; fileRef = 260A248D15D06C4F009981B0 /* OptionValues.h */; };
     260A39A619647A3A004B4130 /* Pipe.h in Headers */ = {isa = PBXBuildFile; fileRef = 260A39A519647A3A004B4130 /* Pipe.h */; };
     260A63171861008E00FECF8E /* IOHandler.h in Headers */ = {isa = PBXBuildFile; fileRef = 260A63161861008E00FECF8E /* IOHandler.h */; };
     260A63191861009E00FECF8E /* IOHandler.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 260A63181861009E00FECF8E /* IOHandler.cpp */; };
     260CC62E15D04377002BF2E0 /* OptionValueArgs.h in Headers */ = {isa = PBXBuildFile; fileRef = 260CC62115D04377002BF2E0 /* OptionValueArgs.h */; };
/* Begin PBXFileReference section */
     25420ECE1A64911B009ADBCB /* OptionValueChar.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = OptionValueChar.h; path = include/lldb/Interpreter/OptionValueChar.h; sourceTree = "<group>"; };
     25420ED11A649D88009ADBCB /* PipeBase.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = PipeBase.cpp; sourceTree = "<group>"; };
     254FBB921A81AA5200BD6378 /* SBLaunchInfo.i */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c.preprocessed; path = SBLaunchInfo.i; sourceTree = "<group>"; };
     254FBB941A81AA7F00BD6378 /* SBLaunchInfo.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SBLaunchInfo.cpp; path = source/API/SBLaunchInfo.cpp; sourceTree = "<group>"; };
     254FBB961A81B03100BD6378 /* SBLaunchInfo.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SBLaunchInfo.h; path = include/lldb/API/SBLaunchInfo.h; sourceTree = "<group>"; };
     254FBBA21A9166F100BD6378 /* SBAttachInfo.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SBAttachInfo.h; path = include/lldb/API/SBAttachInfo.h; sourceTree = "<group>"; };
     254FBBA41A91670E00BD6378 /* SBAttachInfo.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SBAttachInfo.cpp; path = source/API/SBAttachInfo.cpp; sourceTree = "<group>"; };
     254FBBA61A91672800BD6378 /* SBAttachInfo.i */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c.preprocessed; path = SBAttachInfo.i; sourceTree = "<group>"; };
+    257E47151AA56C2000A62F81 /* ModuleCache.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = ModuleCache.cpp; path = source/Utility/ModuleCache.cpp; sourceTree = "<group>"; };
+    257E47161AA56C2000A62F81 /* ModuleCache.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = ModuleCache.h; path = source/Utility/ModuleCache.h; sourceTree = "<group>"; };
     260157C41885F4FF00F875CF /* libpanel.dylib */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.dylib"; name = libpanel.dylib; path = /usr/lib/libpanel.dylib; sourceTree = "<absolute>"; };
     260223E7115F06D500A601A2 /* SBCommunication.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SBCommunication.h; path = include/lldb/API/SBCommunication.h; sourceTree = "<group>"; };
     260223E8115F06E500A601A2 /* SBCommunication.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SBCommunication.cpp; path = source/API/SBCommunication.cpp; sourceTree = "<group>"; };
     26022531115F27FA00A601A2 /* SBFileSpec.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SBFileSpec.h; path = include/lldb/API/SBFileSpec.h; sourceTree = "<group>"; };
     26022532115F281400A601A2 /* SBFileSpec.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SBFileSpec.cpp; path = source/API/SBFileSpec.cpp; sourceTree = "<group>"; };
     260A248D15D06C4F009981B0 /* OptionValues.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = OptionValues.h; path = include/lldb/Interpreter/OptionValues.h; sourceTree = "<group>"; };
     260A39A519647A3A004B4130 /* Pipe.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = Pipe.h; path = include/lldb/Host/Pipe.h; sourceTree = "<group>"; };
     260A63111860FDB600FECF8E /* Queue.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = Queue.h; path = include/lldb/Target/Queue.h; sourceTree = "<group>"; };
266DFE9013FD64D200D0C574 /* OperatingSystem */ = {
         2698699715E6CBD0002415FF /* Python */,
       );
       path = OperatingSystem;
       sourceTree = "<group>";
     };
     2682F168115ED9C800CCFF99 /* Utility */ = {
       isa = PBXGroup;
       children = (
+        257E47151AA56C2000A62F81 /* ModuleCache.cpp */,
+        257E47161AA56C2000A62F81 /* ModuleCache.h */,
         33064C9B1A5C7A490033D415 /* UriParser.h */,
         33064C991A5C7A330033D415 /* UriParser.cpp */,
         AF9107E91685709A00DBCD3C /* ARM64_GCC_Registers.h */,
         26CF992414428766001E4138 /* AnsiTerminal.h */,
         26F996A7119B79C300412154 /* ARM_DWARF_Registers.h */,
         26ECA04213665FED008D1F18 /* ARM_DWARF_Registers.cpp */,
         264A12FF137252C700875C42 /* ARM64_DWARF_Registers.h */,
         264A12FE137252C700875C42 /* ARM64_DWARF_Registers.cpp */,
26680202115FD0ED008E1FE4 /* Headers */ = {
       );
       runOnlyForDeploymentPostprocessing = 0;
     };
     2689FFC813353D7A00698AC0 /* Headers */ = {
       isa = PBXHeadersBuildPhase;
       buildActionMask = 2147483647;
       files = (
         26A527C214E24F5F00F3A14A /* ProcessMachCore.h in Headers */,
+        257E47181AA56C2000A62F81 /* ModuleCache.h in Headers */,
         26BC17AC18C7F4CB00D2196D /* ProcessElfCore.h in Headers */,
         26A527C414E24F5F00F3A14A /* ThreadMachCore.h in Headers */,
         26474CD318D0CB710073DEBA /* RegisterInfos_i386.h in Headers */,
         4C6649A014EEE7F100B0316F /* StreamCallback.h in Headers */,
         26B7564F14F89356008D9CB3 /* PlatformiOSSimulator.h in Headers */,
         26474CCA18D0CB5B0073DEBA /* RegisterContextMemory.h in Headers */,
         26474CA018D0CAEC0073DEBA /* RegisterContext_mips64.h in Headers */,
         26BC17AE18C7F4CB00D2196D /* RegisterContextPOSIXCore_mips64.h in Headers */,
2689FFC613353D7A00698AC0 /* Sources */ = {
         2689006F13353E1A00698AC0 /* FileSpec.cpp in Sources */,
         2689007013353E1A00698AC0 /* Condition.cpp in Sources */,
         2689007113353E1A00698AC0 /* Host.cpp in Sources */,
         2635879417822FC2004C30BA /* SymbolVendorELF.cpp in Sources */,
         2689007213353E1A00698AC0 /* Mutex.cpp in Sources */,
         25420ED21A649D88009ADBCB /* PipeBase.cpp in Sources */,
         2689007313353E1A00698AC0 /* Symbols.cpp in Sources */,
         26474CBC18D0CB2D0073DEBA /* RegisterContextMach_arm.cpp in Sources */,
+        257E47171AA56C2000A62F81 /* ModuleCache.cpp in Sources */,
         2689007413353E1A00698AC0 /* Terminal.cpp in Sources */,
         2689007513353E1A00698AC0 /* TimeValue.cpp in Sources */,
         2689007613353E1A00698AC0 /* CFCBundle.cpp in Sources */,
         94BA8B70176F97CE005A91B5 /* CommandHistory.cpp in Sources */,
         2689007713353E1A00698AC0 /* CFCData.cpp in Sources */,
         2689007813353E1A00698AC0 /* CFCMutableArray.cpp in Sources */,
         2689007913353E1A00698AC0 /* CFCMutableDictionary.cpp in Sources */,
         2689007A13353E1A00698AC0 /* CFCMutableSet.cpp in Sources */,

source/API/SBPlatform.cpp

 {
     SBError sb_error;
     PlatformSP platform_sp(GetSP());
     if (platform_sp && connect_options.GetURL())
     {
         Args args;
         args.AppendArgument(connect_options.GetURL());
         sb_error.ref() = platform_sp->ConnectRemote(args);
+
+        if (sb_error.Success())
+        {
+            if (connect_options.GetLocalCacheDirectory())
+                platform_sp->SetLocalCacheDirectory (connect_options.GetLocalCacheDirectory());
+        }
     }
     else
     {
         sb_error.SetErrorString("invalid platform");
     }
     return sb_error;
 }
 

source/Core/UUID.cpp

UUID::SetFromCString (const char *cstr, uint32_t num_uuid_bytes)
     while (isspace(*p))
         ++p;
     
     const size_t uuid_byte_idx = UUID::DecodeUUIDBytesFromCString (p, m_uuid, &p, num_uuid_bytes);
 
     // If we successfully decoded a UUID, return the amount of characters that
     // were consumed
     if (uuid_byte_idx == num_uuid_bytes)
+    {
+        m_num_uuid_bytes = num_uuid_bytes;
         return p - cstr;
+    }
 
     // Else return zero to indicate we were not able to parse a UUID value
     return 0;
 }
 
 }
 
 bool

source/Plugins/Platform/POSIX/PlatformPOSIX.h

public:
     PlatformPOSIX (bool is_host);
     
     virtual
     ~PlatformPOSIX();
     
     //------------------------------------------------------------
     // lldb_private::Platform functions
     //------------------------------------------------------------
+
+    lldb_private::Error
+    GetSharedModule (const lldb_private::ModuleSpec &module_spec,
+                     lldb::ModuleSP &module_sp,
+                     const lldb_private::FileSpecList *module_search_paths_ptr,
+                     lldb::ModuleSP *old_module_sp_ptr,
+                     bool *did_create_ptr) override;
+
     virtual lldb_private::OptionGroupOptions
     *GetConnectionOptions(
         lldb_private::CommandInterpreter &interpreter) override;
 
     const char *
     GetHostname () override;
 
     const char *
public:
 
     virtual lldb_private::Error
     RunShellCommand (const char *command,           // Shouldn't be NULL
                      const char *working_dir,       // Pass NULL to use the current working directory
                      int *status_ptr,               // Pass NULL if you don't want the process exit status
                      int *signo_ptr,                // Pass NULL if you don't want the signal that caused the process to exit
                      std::string *command_output,   // Pass NULL if you don't want the command output
                      uint32_t timeout_sec) override;// Timeout in seconds to wait for shell program to finish
-    
+    virtual void
+    SetLocalCacheDirectory (const char* local) override;
+
     virtual lldb_private::Error
     MakeDirectory (const char *path, uint32_t mode) override;
     
     virtual lldb_private::Error
     GetFilePermissions (const char *path, uint32_t &file_permissions) override;
 
     virtual lldb_private::Error
     SetFilePermissions (const char *path, uint32_t file_permissions) override;

source/Plugins/Platform/POSIX/PlatformPOSIX.cpp

 ///
 /// The destructor is virtual since this class is designed to be
 /// inherited from by the plug-in instance.
 //------------------------------------------------------------------
 PlatformPOSIX::~PlatformPOSIX()
 {
 }
 
+Error
+PlatformPOSIX::GetSharedModule (const ModuleSpec &module_spec,
+                                ModuleSP &module_sp,
+                                const FileSpecList *module_search_paths_ptr,
+                                ModuleSP *old_module_sp_ptr,
+                                bool *did_create_ptr)
+{
+    if (m_remote_platform_sp)
+        return m_remote_platform_sp->GetSharedModule (module_spec,
+                                                      module_sp,
+                                                      module_search_paths_ptr,
+                                                      old_module_sp_ptr,
+                                                      did_create_ptr);
+
+    return Platform::GetSharedModule (module_spec,
+                                      module_sp,
+                                      module_search_paths_ptr,
+                                      old_module_sp_ptr,
+                                      did_create_ptr);
+}
+
 lldb_private::OptionGroupOptions*
 PlatformPOSIX::GetConnectionOptions (lldb_private::CommandInterpreter& interpreter)
 {
     if (m_options.get() == NULL)
     {
         m_options.reset(new OptionGroupOptions(interpreter));
         m_options->Append(new OptionGroupPlatformRSync());
         m_options->Append(new OptionGroupPlatformSSH());
PlatformPOSIX::RunShellCommand (const char *command,           // Shouldn't be NULL
     {
         if (m_remote_platform_sp)
             return m_remote_platform_sp->RunShellCommand(command, working_dir, status_ptr, signo_ptr, command_output, timeout_sec);
         else
             return Error("unable to run a remote command without a platform");
     }
 }
 
+void
+PlatformPOSIX::SetLocalCacheDirectory (const char* local)
+{
+    if (m_remote_platform_sp)
+        m_remote_platform_sp->SetLocalCacheDirectory (local);
+    else
+        Platform::SetLocalCacheDirectory (local);
+}
+
 Error
 PlatformPOSIX::MakeDirectory (const char *path, uint32_t file_permissions)
 {
     if (m_remote_platform_sp)
         return m_remote_platform_sp->MakeDirectory(path, file_permissions);
     else
         return Platform::MakeDirectory(path ,file_permissions);
 }

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

 //===-- PlatformRemoteGDBServer.h ----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_PlatformRemoteGDBServer_h_
 #define liblldb_PlatformRemoteGDBServer_h_
 
 // C Includes
 // C++ Includes
+#include <memory>
 #include <string>
 
 // Other libraries and framework includes
 // Project includes
+#include "lldb/Core/UUID.h"
 #include "lldb/Target/Platform.h"
 #include "../../Process/gdb-remote/GDBRemoteCommunicationClient.h"
 
+namespace lldb_private
+{
+
+class ModuleCache;
+
+}
+
 class PlatformRemoteGDBServer : public lldb_private::Platform
 {
 public:
 
     static void
     Initialize ();
 
     static void
public:
     //------------------------------------------------------------
     // lldb_private::Platform functions
     //------------------------------------------------------------
     virtual lldb_private::Error
     ResolveExecutable (const lldb_private::ModuleSpec &module_spec,
                        lldb::ModuleSP &module_sp,
                        const lldb_private::FileSpecList *module_search_paths_ptr);
 
+    virtual lldb_private::Error
+    GetSharedModule (const lldb_private::ModuleSpec &module_spec,
+                     lldb::ModuleSP &module_sp,
+                     const lldb_private::FileSpecList *module_search_paths_ptr,
+                     lldb::ModuleSP *old_module_sp_ptr,
+                     bool *did_create_ptr);
+
     virtual const char *
     GetDescription ();
 
     virtual lldb_private::Error
     GetFileWithUUID (const lldb_private::FileSpec &platform_file, 
                      const lldb_private::UUID *uuid_ptr,
                      lldb_private::FileSpec &local_file);
 
public:
     virtual lldb_private::ArchSpec
     GetRemoteSystemArchitecture ();
 
     virtual lldb_private::ConstString
     GetRemoteWorkingDirectory();
     
     virtual bool
     SetRemoteWorkingDirectory(const lldb_private::ConstString &path);
-    
-
     // Remote subclasses should override this and return a valid instance
     // name if connected.
     virtual const char *
     GetHostname ();
 
     virtual const char *
     GetUserName (uint32_t uid);
     
public:
     RunShellCommand (const char *command,           // Shouldn't be NULL
                      const char *working_dir,       // Pass NULL to use the current working directory
                      int *status_ptr,               // Pass NULL if you don't want the process exit status
                      int *signo_ptr,                // Pass NULL if you don't want the signal that caused the process to exit
                      std::string *command_output,   // Pass NULL if you don't want the command output
                      uint32_t timeout_sec);         // Timeout in seconds to wait for shell program to finish
 
     virtual void
+    SetLocalCacheDirectory (const char* local);
+
+    virtual void
     CalculateTrapHandlerSymbolNames ();
 
 protected:
+    struct ModuleInfo
+    {
+        lldb_private::UUID m_uuid;
+        lldb_private::ArchSpec m_arch;
+        uint64_t file_offset;
+        uint64_t file_size;
+
+        ModuleInfo ()
+            : file_offset (0),
+              file_size (0)
+        {
+        }
+    };
+
     GDBRemoteCommunicationClient m_gdb_client;
     std::string m_platform_description; // After we connect we can get a more complete description of what we are connected to
     std::string m_platform_hostname;
+    std::unique_ptr<lldb_private::ModuleCache> m_module_cache;
 
     // Launch the lldb-gdbserver on the remote host and return the port it is listening on or 0 on
     // failure. Subclasses should override this method if they want to do extra actions before or
     // after launching the lldb-gdbserver.
     virtual uint16_t
     LaunchGDBserverAndGetPort (lldb::pid_t &pid);
 
     virtual bool
     KillSpawnedProcess (lldb::pid_t pid);
 
+    void InitModuleCache (const char* local_cache_dir);
+
+    bool
+    GetModuleInfo (const lldb_private::ModuleSpec& module_spec, ModuleInfo& module_info);
+
+    lldb_private::Error
+    DownloadModuleSlice (const lldb_private::FileSpec& src_file_spec,
+                         const uint64_t src_offset,
+                         const uint64_t src_size,
+                         const lldb_private::FileSpec& dst_file_spec);
+
+    bool
+    GetFileFromLocalCache (const lldb_private::ModuleSpec& module_spec,
+                           lldb_private::FileSpec &cached_file_spec);
+
 private:
     DISALLOW_COPY_AND_ASSIGN (PlatformRemoteGDBServer);
 
 };
 
 #endif  // liblldb_PlatformRemoteGDBServer_h_

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

 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/StreamString.h"
 #include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/Host/FileSpec.h"
 #include "lldb/Host/Host.h"
+#include "lldb/Host/HostInfo.h"
+#include "lldb/Host/StringConvert.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
+#include "llvm/Support/FileSystem.h"
+#include "llvm/Support/FileUtilities.h"
 
+#include "Utility/ModuleCache.h"
 #include "Utility/UriParser.h"
 
+#include <algorithm>
+#include <fstream>
+#include <vector>
+
 using namespace lldb;
 using namespace lldb_private;
 
 static bool g_initialized = false;
 
 static std::string MakeGdbServerUrl (const std::string &platform_hostname, uint16_t port)
 {
     const char *override_hostname = getenv("LLDB_PLATFORM_REMOTE_GDB_SERVER_HOSTNAME");
PlatformRemoteGDBServer::ResolveExecutable (const ModuleSpec &module_spec,
     {
         error.SetErrorStringWithFormat ("'%s' does not exist",
                                         resolved_module_spec.GetFileSpec().GetPath().c_str());
     }
 
     return error;
 }
 
+lldb_private::Error
+PlatformRemoteGDBServer::GetSharedModule (const lldb_private::ModuleSpec &module_spec,
+                                          lldb::ModuleSP &module_sp,
+                                          const lldb_private::FileSpecList *module_search_paths_ptr,
+                                          lldb::ModuleSP *old_module_sp_ptr,
+                                          bool *did_create_ptr)
+{
+    FileSpec cached_file_spec;
+    if (m_module_cache && GetFileFromLocalCache (module_spec, cached_file_spec))
+    {
+        auto cached_module_spec (module_spec);
+        cached_module_spec.GetFileSpec () = cached_file_spec;
+        cached_module_spec.GetPlatformFileSpec () = module_spec.GetFileSpec ();
+        module_sp.reset (new Module (cached_module_spec));
+
+        if (did_create_ptr)
+            *did_create_ptr = true;
+
+        return Error ();
+    }
+
+    return Platform::GetSharedModule (module_spec,
+                                      module_sp,
+                                      module_search_paths_ptr,
+                                      old_module_sp_ptr,
+                                      did_create_ptr);
+}
+
+bool
+PlatformRemoteGDBServer::GetFileFromLocalCache (const ModuleSpec& module_spec,
+                                                FileSpec &cached_file_spec)
+{
+    Log *log = GetLogIfAnyCategoriesSet (LIBLLDB_LOG_PLATFORM);
+
+    // Get module information from a target.
+    ModuleInfo module_info;
+    if (!GetModuleInfo (module_spec, module_info))
+        return false;
+
+    auto resolved_module_spec (module_spec);
+    resolved_module_spec.GetUUID () = module_info.m_uuid;
+    resolved_module_spec.GetArchitecture () = module_info.m_arch;
+
+    // Check local cache for a module.
+    auto error = m_module_cache->Get (module_info.m_uuid, module_spec.GetFileSpec (), cached_file_spec);
+    if (error.Success ())
+        return true;
+
+    if (log)
+        log->Printf("PlatformRemoteGDBServer::%s - module %s not found in local cache: %s",
+                    __FUNCTION__, module_info.m_uuid.GetAsString ().c_str (), error.AsCString ());
+
+    // Get temporary file name for a downloaded module.
+    FileSpec tmp_dir_spec;
+    if (!HostInfo::GetLLDBPath (ePathTypeLLDBTempSystemDir, tmp_dir_spec))
+    {
+        if (log)
+            log->Printf ("PlatformRemoteGDBServer::%s - failed to get temp directory", __FUNCTION__);
+        return false;
+    }
+
+    const std::string tmp_path_pattern (module_info.m_uuid.GetAsString () + ".%%%%%%");
+    tmp_dir_spec.AppendPathComponent (tmp_path_pattern.c_str ());
+    llvm::SmallString<PATH_MAX> tmp_download_file_path;
+    const auto err_code = llvm::sys::fs::createUniqueFile (tmp_dir_spec.GetPath ().c_str (), tmp_download_file_path);
+    if (err_code)
+    {
+        if (log)
+            log->Printf ("PlatformRemoteGDBServer::%s - failed to create unique file in %s: %s",
+                         __FUNCTION__, tmp_dir_spec.GetPath ().c_str (), err_code.message ().c_str ());
+        return false;
+    }
+
+    llvm::FileRemover tmp_file_remover (tmp_download_file_path.c_str ());
+
+    const FileSpec tmp_download_file_spec (tmp_download_file_path.c_str (), true);
+    // Download a module file.
+    error = DownloadModuleSlice (module_spec.GetFileSpec (),
+                                 module_info.file_offset,
+                                 module_info.file_size,
+                                 tmp_download_file_spec);
+    if (error.Fail ())
+    {
+        if (log)
+            log->Printf("PlatformRemoteGDBServer::%s - failed to download %s to %s: %s",
+                        __FUNCTION__, module_spec.GetFileSpec ().GetPath ().c_str (),
+                        tmp_download_file_path.c_str (), error.AsCString ());
+        return false;
+    }
+
+    // Put downloaded file into local module cache.
+    error = m_module_cache->Put (module_info.m_uuid, module_spec.GetFileSpec (), tmp_download_file_spec);
+    if (error.Fail ())
+    {
+        if (log)
+            log->Printf("PlatformRemoteGDBServer::%s - failed to put module %s into cache: %s",
+                        __FUNCTION__, resolved_module_spec.GetUUID ().GetAsString ().c_str (),
+                        error.AsCString ());
+        return false;
+    }
+
+    error = m_module_cache->Get (module_info.m_uuid, module_spec.GetFileSpec (), cached_file_spec);
+    return error.Success ();
+}
+
+Error
+PlatformRemoteGDBServer::DownloadModuleSlice (const lldb_private::FileSpec& src_file_spec,
+                                              const uint64_t src_offset,
+                                              const uint64_t src_size,
+                                              const lldb_private::FileSpec& dst_file_spec)
+{
+    Error error;
+
+    std::ofstream dst (dst_file_spec.GetPath(), std::ios::out | std::ios::binary);
+    if (!dst.is_open())
+    {
+        error.SetErrorStringWithFormat ("unable to open destination file: %s", dst_file_spec.GetPath ().c_str ());
+        return error;
+    }
+
+    auto src_fd = OpenFile (src_file_spec,
+                            File::eOpenOptionRead,
+                            lldb::eFilePermissionsFileDefault,
+                            error);
+
+   if (error.Fail ())
+   {
+       error.SetErrorStringWithFormat ("unable to open source file: %s", error.AsCString ());
+       return error;
+   }
+
+    std::vector<char> buffer (1024);
+    auto offset = src_offset;
+    uint64_t total_bytes_read = 0;
+    while (total_bytes_read < src_size)
+    {
+        const auto to_read = std::min (static_cast<uint64_t>(buffer.size ()), src_size - total_bytes_read);
+        const uint64_t n_read = ReadFile (src_fd, offset, &buffer[0], to_read, error);
+        if (error.Fail ())
+            break;
+        if (n_read == 0)
+        {
+            error.SetErrorString ("read 0 bytes");
+            break;
+        }
+        offset += n_read;
+        total_bytes_read += n_read;
+        dst.write (&buffer[0], n_read);
+    }
+
+    Error close_error;
+    CloseFile (src_fd, close_error);  // Ignoring close error.
+
+    return error;
+}
+
+bool
+PlatformRemoteGDBServer::GetModuleInfo (const ModuleSpec& module_spec, ModuleInfo& module_info)
+{
+    Log *log = GetLogIfAnyCategoriesSet (LIBLLDB_LOG_PLATFORM);
+
+    const auto module_path = module_spec.GetFileSpec ().GetPath ();
+
+    StringExtractorGDBRemote response;
+    if (!m_gdb_client.GetModuleInfo (module_path.c_str (), module_spec.GetArchitecture (), response))
+    {
+        if (log)
+            log->Printf ("PlatformRemoteGDBServer::%s - failed to get module info for %s:%s",
+                         __FUNCTION__, module_path.c_str (), module_spec.GetArchitecture ().GetTriple ().getTriple ().c_str ());
+        return false;
+    }
+
+    std::string name;
+    std::string value;
+    bool success;
+    StringExtractor extractor;
+
+    while (response.GetNameColonValue (name, value))
+    {
+        if (name == "uuid" || name == "md5")
+        {
+            extractor.GetStringRef ().swap (value);
+            extractor.SetFilePos (0);
+            extractor.GetHexByteString (value);
+            module_info.m_uuid.SetFromCString (value.c_str(), value.size() / 2);
+        }
+        else if (name == "triple")
+        {
+            extractor.GetStringRef ().swap (value);
+            extractor.SetFilePos (0);
+            extractor.GetHexByteString (value);
+            module_info.m_arch.SetTriple (value.c_str ());
+        }
+        else if (name == "file_offset")
+        {
+            const auto ival = StringConvert::ToUInt64 (value.c_str (), 0, 16, &success);
+            if (success)
+                module_info.file_offset = ival;
+        }
+        else if (name == "file_size")
+        {
+            const auto ival = StringConvert::ToUInt64 (value.c_str (), 0, 16, &success);
+            if (success)
+                module_info.file_size = ival;
+        }
+    }
+
+    if (log)
+        log->Printf ("PlatformRemoteGDBServer::%s - got module info for %s:%s, uuid=%s, triple=%s, file_offset=%llu, file_size=%llu",
+                     __FUNCTION__, module_path.c_str (), module_spec.GetArchitecture ().GetTriple ().getTriple ().c_str (),
+                     module_info.m_uuid.GetAsString ().c_str (), module_info.m_arch.GetTriple ().getTriple ().c_str (),
+                     module_info.file_offset, module_info.file_size);
+
+    return true;
+}
+
 Error
 PlatformRemoteGDBServer::GetFileWithUUID (const FileSpec &platform_file, 
                                           const UUID *uuid_ptr,
                                           FileSpec &local_file)
 {
     // Default to the local case
     local_file = platform_file;
     return Error();
if (IsConnected())
                                         GetHostname());
     }
     else
     {
         if (args.GetArgumentCount() == 1)
         {
             const char *url = args.GetArgumentAtIndex(0);
             m_gdb_client.SetConnection (new ConnectionFileDescriptor());
-
             // we're going to reuse the hostname when we connect to the debugserver
             std::string scheme;
             int port;
             std::string path;
             if ( !UriParser::Parse(url, scheme, m_platform_hostname, port, path) )
             {
                 error.SetErrorString("invalid uri");
                 return error;
else
                 }
             }
         }
         else
         {
             error.SetErrorString ("\"platform connect\" takes a single argument: <connect-url>");
         }
     }
-
     return error;
 }
 
 Error
 PlatformRemoteGDBServer::DisconnectRemote ()
 {
     Error error;
     m_gdb_client.Disconnect(&error);
PlatformRemoteGDBServer::RunShellCommand (const char *command,           // Shouldn't be NULL
                                           int *signo_ptr,                // Pass NULL if you don't want the signal that caused the process to exit
                                           std::string *command_output,   // Pass NULL if you don't want the command output
                                           uint32_t timeout_sec)          // Timeout in seconds to wait for shell program to finish
 {
     return m_gdb_client.RunShellCommand (command, working_dir, status_ptr, signo_ptr, command_output, timeout_sec);
 }
 
 void
+PlatformRemoteGDBServer::SetLocalCacheDirectory (const char* local)
+{
+    Platform::SetLocalCacheDirectory (local);
+
+    if (!m_local_cache_directory.empty ())
+        InitModuleCache (m_local_cache_directory.c_str ());
+}
+
+void
 PlatformRemoteGDBServer::CalculateTrapHandlerSymbolNames ()
 {   
     m_trap_handlers.push_back (ConstString ("_sigtramp"));
-}   
+}
+
+void
+PlatformRemoteGDBServer::InitModuleCache (const char* local_cache_dir)
+{
+    Log *log = GetLogIfAnyCategoriesSet (LIBLLDB_LOG_PLATFORM);
+
+    if (log)
+        log->Printf ("PlatformRemoteGDBServer::%s - %s", __FUNCTION__, local_cache_dir);
+
+    ModuleCache::Options options;
+    options.m_root_dir = FileSpec (local_cache_dir, true);
+    auto module_cache = llvm::make_unique<ModuleCache> (options);
+    const auto error = module_cache->Init ();
+    if (error.Fail ())
+    {
+        if (log)
+        {
+            log->Printf ("PlatformRemoteGDBServer::%s - failed to init ModuleCache(%s): %s",
+                         __FUNCTION__,
+                         local_cache_dir,
+                         error.AsCString ());
+        }
+        return;
+    }
+
+    m_module_cache = std::move (module_cache);
+}

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

GDBRemoteCommunicationClient::GetModuleInfo (const char* module_path,
 
     StreamString packet;
     packet.PutCString("qModuleInfo:");
     packet.PutBytesAsRawHex8(module_path, strlen(module_path));
     packet.PutCString(";");
     const auto& tripple = arch_spec.GetTriple().getTriple();
     packet.PutBytesAsRawHex8(tripple.c_str(), tripple.size());
 
-    return SendPacketAndWaitForResponse (packet.GetData(), packet.GetSize(), response, false) == PacketResult::Success;
+    return SendPacketAndWaitForResponse (packet.GetData(), packet.GetSize(), response, false) == PacketResult::Success &&
+        !response.IsErrorResponse ();
 }

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

GDBRemoteCommunicationServerCommon::Handle_qModuleInfo (StringExtractorGDBRemote &packet)
     const ModuleSP module(new Module(matched_module_spec));
 
     const auto obj_file(module->GetObjectFile());
     const auto file_offset = obj_file->GetFileOffset();
     const auto file_size = obj_file->GetByteSize();
 
     StreamGDBRemote response;
 
-    const auto uuid_str = module->GetUUID().GetAsString();
+    const auto uuid_str = module->GetUUID().GetAsString("");
     if (uuid_str.empty())
     {
         std::string md5_hash;
         if (!FileSystem::CalculateMD5AsString(module_path_spec, file_offset, file_size, md5_hash))
             return SendErrorResponse (5);
         response.PutCString ("md5:");
         response.PutCStringAsRawHex8(md5_hash.c_str());
     }

source/Utility/CMakeLists.txt

 set(LLVM_NO_RTTI 1)
 
 add_lldb_library(lldbUtility
   ARM_DWARF_Registers.cpp
   ARM64_DWARF_Registers.cpp
   JSON.cpp
   KQueue.cpp
+  ModuleCache.cpp
   PseudoTerminal.cpp
   Range.cpp
   RegisterNumber.cpp
   SharingPtr.cpp
   StringExtractor.cpp
   StringExtractorGDBRemote.cpp
   StringLexer.cpp
   TimeSpecTimeout.cpp
   UriParser.cpp
   )

source/Utility/ModuleCache.h

+//===-- ModuleCache.h -------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef utility_ModuleCache_h_
+#define utility_ModuleCache_h_
+
+#include "lldb/lldb-types.h"
+#include "lldb/lldb-forward.h"
+
+#include "lldb/Core/Error.h"
+#include "lldb/Host/FileSpec.h"
+
+#include <string>
+
+namespace lldb_private {
+
+class UUID;
+
+class ModuleCache
+{
+public:
+    struct Options
+    {
+        FileSpec m_root_dir;
+        uint64_t m_max_size;
+    };
+
+    explicit ModuleCache (const Options &options);
+
+    Error
+    Init ();
+
+    Error
+    Put (const UUID &uuid, const FileSpec &platform_module_spec, const FileSpec &tmp_file);
+
+    Error
+    Get (const UUID &uuid, const FileSpec &platform_module_spec, FileSpec &cached_module_spec);
+
+private:
+    const Options m_options;
+    FileSpec m_modules_root;
+    bool m_initialized;
+
+    FileSpec
+    GetModuleDirectory (const UUID &uuid) const;
+};
+
+} // namespace lldb_private
+
+#endif  // utility_ModuleCache_h_

source/Utility/ModuleCache.cpp

+//===--------------------- ModuleCache.cpp ----------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "ModuleCache.h"
+
+#include "lldb/Core/Module.h"
+#include "lldb/Host/FileSystem.h"
+#include "llvm/Support/FileSystem.h"
+
+#include <assert.h>
+
+#include <cstdio>
+#include <sstream>
+
+using namespace lldb;
+using namespace lldb_private;
+
+namespace {
+
+const char* kModulesSubdir = "modules";
+
+FileSpec
+JoinPath (const FileSpec &path1, const FileSpec &path2)
+{
+    std::ostringstream path_stream;
+    path_stream << path1.GetPath () << "/" << path2.GetPath ();
+    return FileSpec (path_stream.str ().c_str (), true);
+}
+
+Error
+MakeDirectory (const FileSpec &dir_path)
+{
+    if (dir_path.Exists ())
+    {
+        if (!dir_path.IsDirectory ())
+            return Error ("Invalid existing path");
+
+        return Error ();
+    }
+
+    return FileSystem::MakeDirectory (dir_path.GetPath ().c_str (),
+                                      eFilePermissionsDirectoryDefault);
+}
+
+}  // namespace
+
+ModuleCache::ModuleCache (const Options &options)
+    : m_options (options),
+      m_initialized (false)
+{
+}
+
+Error
+ModuleCache::Init ()
+{
+    assert (!m_initialized);
+
+    auto error = MakeDirectory (m_options.m_root_dir);
+    if (error.Success ())
+    {
+        m_modules_root = JoinPath (m_options.m_root_dir, FileSpec (kModulesSubdir, false));
+        error = MakeDirectory (m_modules_root);
+    }
+
+    m_initialized = error.Success ();
+    return error;
+}
+
+Error
+ModuleCache::Put (const UUID &uuid, const FileSpec &platform_module_spec, const FileSpec &tmp_file)
+{
+    assert (m_initialized);
+
+    const auto module_dir = GetModuleDirectory (uuid);
+    auto error = MakeDirectory (module_dir);
+    if (error.Fail ())
+        return error;
+
+    const auto module_file_path = JoinPath (module_dir,platform_module_spec);
+
+    const FileSpec module_file_dir (module_file_path.GetDirectory ().AsCString (), true);
+    error = MakeDirectory (module_file_dir);
+    if (error.Fail ())
+        return error;
+
+    const auto tmp_file_path = tmp_file.GetPath ();
+    const auto err_code = llvm::sys::fs::copy_file (tmp_file_path.c_str (), module_file_path.GetPath ().c_str ());
+    if (err_code)
+    {
+        error.SetErrorStringWithFormat ("failed to rename file %s to %s: %s",
+                                        tmp_file_path.c_str (),
+                                        module_file_path.GetPath ().c_str (),
+                                        err_code.message ().c_str ());
+    }
+
+    return error;
+}
+
+Error
+ModuleCache::Get (const UUID &uuid, const FileSpec &platform_module_spec, FileSpec &cached_module_spec)
+{
+    assert (m_initialized);
+
+    cached_module_spec.Clear ();
+
+    Error error;
+    const auto module_file_path = JoinPath (GetModuleDirectory (uuid),
+                                            platform_module_spec);
+    if (module_file_path.Exists ())
+    {
+        cached_module_spec = module_file_path;
+    }
+    else
+        error.SetErrorStringWithFormat ("module %s not found", module_file_path.GetPath ().c_str ());
+
+    return error;
+}
+
+FileSpec
+ModuleCache::GetModuleDirectory (const UUID &uuid) const
+{
+    return JoinPath (m_modules_root, FileSpec (uuid.GetAsString ().c_str (), false));
+}

test/dotest.py

 import commands
 import os
 import errno
 import platform
 import progress
 import signal
 import subprocess
 import sys
+import tempfile
 import textwrap
 import time
 import inspect
 import unittest2
 
 if sys.version_info >= (2, 7):
     argparse = __import__('argparse')
 else:
if lldb_platform_name:
     print "Setting up remote platform '%s'" % (lldb_platform_name)
     lldb.remote_platform = lldb.SBPlatform(lldb_platform_name)
     if not lldb.remote_platform.IsValid():
         print "error: unable to create the LLDB platform named '%s'." % (lldb_platform_name)
         exitTestSuite(1)
     if lldb_platform_url:
         # We must connect to a remote platform if a LLDB platform URL was specified
         print "Connecting to remote platform '%s' at '%s'..." % (lldb_platform_name, lldb_platform_url)
-        platform_connect_options = lldb.SBPlatformConnectOptions(lldb_platform_url); 
+        platform_connect_options = lldb.SBPlatformConnectOptions(lldb_platform_url)
+        local_cache_dir = os.path.join(tempfile.gettempdir(), "lldb/cache")
+        print "Setting local cache directory '%s'" % (local_cache_dir)
+        platform_connect_options.SetLocalCacheDirectory(local_cache_dir)
         err = lldb.remote_platform.ConnectRemote(platform_connect_options)
         if err.Success():
             print "Connected."
         else:
             print "error: failed to connect to remote platform using URL '%s': %s" % (lldb_platform_url, err)
             exitTestSuite(1)
     
     if lldb_platform_working_dir:

test/python_api/hello_world/TestHelloWorld.py

def test_with_dsym_and_attach_to_process_with_id_api(self):
         """Create target, spawn a process, and attach to it with process id.
 
         Use dsym info and attach to process with id API.
         """
         self.buildDsym(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
         self.hello_world_attach_with_id_api()
 
-    @not_remote_testsuite_ready
     @python_api_test
     @dwarf_test
     @expectedFailurei386 # llvm.org/pr17384: lldb needs to be aware of linux-vdso.so to unwind stacks properly
     def test_with_dwarf_and_attach_to_process_with_id_api(self):
         """Create target, spawn a process, and attach to it with process id.
 
         Use dwarf map (no dsym) and attach to process with id API.
         """
def test_with_dsym_and_attach_to_process_with_name_api(self):
         """Create target, spawn a process, and attach to it with process name.
 
         Use dsym info and attach to process with name API.
         """
         self.buildDsym(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
         self.hello_world_attach_with_name_api()
 
-    @not_remote_testsuite_ready
     @python_api_test
     @dwarf_test
     @expectedFailurei386 # llvm.org/pr17384: lldb needs to be aware of linux-vdso.so to unwind stacks properly
     def test_with_dwarf_and_attach_to_process_with_name_api(self):
         """Create target, spawn a process, and attach to it with process name.
 
         Use dwarf map (no dsym) and attach to process with name API.
         """