Add the ability to cache information for a module between debugger instances.

[clayborg]

Summary

Added the ability to cache the finalized symbol tables as a proof of concept and as a way to discuss caching items for a given module to allow subsequent debug sessions to start faster.

Module caching must be enabled by the user before this can be used:

(lldb) settings set symbols.enable-lldb-modules-cache true

There is also a setting that allows the user to specify a module cache directory that defaults to a directory that defaults to being next to the symbols.clang-modules-cache-path directory in a temp directory:

(lldb) settings show symbols.lldb-modules-cache-path

If this setting is enabled, the finalized symbol tables will be serialized and saved to disc so they can be quickly loaded next time you debug.

Each module gets a cache directory in the "symbols.lldb-modules-cache-path" directory. A directory is created in the cache directory that uses the module's basename as a directory and then a hash is created for the module which incorporates the full path to the executable, the architecture, the object name offset and modification time (if any). This allows universal mach-o files to support caching multuple architectures in the same module cache directory. Making the directory based on the this info allows this directory's contents to be deleted and replaced when the file gets updated on disk. This keeps the cache from growing over time during the compile/edit/debug cycle and prevents out of space issues.

If the cache is enabled, the symbol table will be loaded from the cache the next time you debug if the module has not changed.

[bulbazord]

This patch effectively introduces a file format to cache lldb internal state. While the tests and the code do give some information for what it looks like, some documentation about this format would be nice.

I like this idea a lot! My comments were kind of surface level but should help fix some of the rough edges of the patch.

lldb/include/lldb/Core/Module.h

879

nit: unnecessary whitespace change

951

typo: indentify -> identify

959

have a object name -> have an object name

lldb/include/lldb/Symbol/ObjectFile.h

710–713

Curious to know, why lldb::addr_t instead of something like lldb::offset_t?

lldb/include/lldb/Symbol/Symbol.h

21–22

nit: you have a namespace comment when you do this in an earlier file but not here. what does clang-format do?

lldb/source/Core/Mangled.cpp

431–432

What does "two different names that are not related" mean here?

lldb/source/Core/Module.cpp

65

nit: unrelated whitespace change

1706

typo: valie -> valid

lldb/source/Host/common/FileSystem.cpp

134

Could you break this line into multiple lines?

[clayborg]

Added more comments to the encoding functions to detail how things are encoded.
Fixed error typos.
Added version to symbol table cache file so we can improve the format as time goes on and avoid loading out of data caches.

[clayborg]

lldb/include/lldb/Symbol/ObjectFile.h

713

Because it can be an address in memory as well for object file that are read from memory only with no backing object file on disk

lldb/include/lldb/Symbol/Symbol.h

22

clang format didn't catch this, as I have it enabled.

lldb/source/Core/Mangled.cpp

432

I will improve the comment on this to explain!

[wallace]

There are two things that could be added. One is already mentioned in the comments, which is logging error messages in a way that we can track bugs in an automated fashion, as right now the errors are being thrown away or transformed into simple true/false values that lose the information of the actual issue. Now that we have a rich telemetry in place, we should use llvm::Error/Expected as much as possible and log the errors in both a log channel and the target stats. The second item to discuss is that there should be a configurable maximum size of the entire cache folder (e.g. 70GB), so that, for example, when lldb initializes it cleans up the oldest items that make the cache blow up. I can also add telemetry from the IDE side to track the size of the total cache folder, but I imagine that if we don't put a limiter, we might cause some issues.

lldb/include/lldb/Core/Mangled.h

24–28

being a little bit strict, you should move the FileWriter class out of gsym. That will also make it more generic and compelling to use for other stuff

lldb/include/lldb/Host/FileSystem.h

93

this should return an llvm::Error and the caller should decide whether to consume the error or not.

167–168

Rename this to RemoveFile to avoid any ambiguities

lldb/source/Core/CoreProperties.td

23

mention here what the default directory ends up being used if this setting is left unchanged

lldb/source/Core/Module.cpp

1669–1676

i'd prefer if there's a separator character like ; between each element just to avoid any future possible bugs

1680

this function is doing many things and reading is harder. Besides splitting it, we should log in the target stats if the cache was enabled or not, if the cache was used or not in a per module basis and any errors associated. This will help us fix issues without having to wait for users' reports.
you should also print the error in a log channel

lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

2723

log here in the target stats if the cache was effectively used or not

lldb/source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp

602

same here about telemetry

[labath]

Maybe it's good for starting a discussion, but I am surprised that we would need to cache symtab information. This is a fairly simple format that needs to be read at application runtime as well, so I am surprised that reading it from the cache is substantially faster than doing it from the object file. What is the slow part there? Is it demangling by any chance?

Now to the discussion. Overall, I think this is an interesting feature, but I do have some remarks/questions:

• I don't think that "lldb module cache" is very good name for this feature as we already have the "platform module cache" feature (see Target/ModuleCache.h and its callers), which deals with downloading (and caching) modules (object files) from remote systems. And then there's the clang module cache, of course.. (and the llvm modules, but we fortunately don't cache those). It would be better if we chose a slightly less overloaded name. Maybe "index cache" ? (I assume you will also want to store dwarf indexes there)
• I don't see anything which would ensure cache consistency for the case where multiple debugger instances try to cache the same module simultaneously. What's the plan for that?
• Have you considered the building upon the caching infrastructure in llvm (llvm/Caching.h, llvm/CachePruning.h)? I believe it already has some size limiting features and multiprocess synchronization built-in, so using it would take care of the previous item, and of @wallace's size limit request.
• it's moderately strange to be using the gsym file writer for this purpose

I haven't looked at the code in detail, but I noted that the filesystem changes, and some of the unrelated formatting cleanups could be put into separate patches.

lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

2722

Can we make it so that we don't need to add these bits to every object file implementation? Maybe create a protected CreateSymtab function, which would get only called if the Symtab really needs to be created?

lldb/source/Symbol/Symbol.cpp

645

It would be (much) better to put the bitfields in an (anonymous) union that can be accessed both as a uint16_t and as individual bitfields.

[clayborg]

In D113789#3130741, @labath wrote:

Maybe it's good for starting a discussion, but I am surprised that we would need to cache symtab information. This is a fairly simple format that needs to be read at application runtime as well, so I am surprised that reading it from the cache is substantially faster than doing it from the object file. What is the slow part there? Is it demangling by any chance?

Symbol tables for LLDB are made up by scouring every bit of data we can out of one or more symbol tables (ELF has normal symbol table and the dynamic symbol table, and optionally the symbol table in the zipped debug info). There are also many runtime sections like .eh_frame and others that can give us the start address of functions. If a binary is stripped, then we might not have a symbol for local functions, but many runtime sections have information on where functions start.

So while the symbol table seems simple, there is a ton of work that goes into creating these. Some things that are expensive:

• parse all symbol tables and unique the results
• reduce duplicate symbols as we parse one or more symbol tables (this happens a lot in mach-o files)
• keep a map of symbols that have been emitted so we can skip creating symbols from runtime information
• mach-o files have many symbols that describe the same thing: normal symbols and debug map symbols, so these symbols need to be coalesced into one symbol so we don't end up with multiple symbols with the same name and different info

I will post some performance results on loading a large Mac debug session as soon as my release build finishes. I was getting some really good performance improvements when I first started this patch as I tried this out before taking the time to try and finalize this patch.

Now to the discussion. Overall, I think this is an interesting feature, but I do have some remarks/questions:

• I don't think that "lldb module cache" is very good name for this feature as we already have the "platform module cache" feature (see Target/ModuleCache.h and its callers), which deals with downloading (and caching) modules (object files) from remote systems. And then there's the clang module cache, of course.. (and the llvm modules, but we fortunately don't cache those). It would be better if we chose a slightly less overloaded name. Maybe "index cache" ? (I assume you will also want to store dwarf indexes there)

yes debug info is the next item I want to put into this cache. "index cache" sounds fine. I will rename once I get a few NFC patches submitted and rebase.

• I don't see anything which would ensure cache consistency for the case where multiple debugger instances try to cache the same module simultaneously. What's the plan for that?

I was hoping to learn LLVM already had this kind of thing and using that! I see below there are some things already in LLVM I should be able to use.

• Have you considered the building upon the caching infrastructure in llvm (llvm/Caching.h, llvm/CachePruning.h)? I believe it already has some size limiting features and multiprocess synchronization built-in, so using it would take care of the previous item, and of @wallace's size limit request.

I will check into that and see if I can use that! I figured it would have been done already, glad to see it has!

• it's moderately strange to be using the gsym file writer for this purpose

When I made gsym I create the FileWriter as something that can easily create binary content without having to go with the ASM print/writer stuff in LLVM as that requires tons of stuff including LLVM targets and object file support.

What suggestions do people have on this front? Should I make a patch to move FileWriter out of GSYM? I don't know how if llvm::gym::FileWriter is useful enough for other folks in LLVM. Any thoughts? Should we just make our own FileWriter class that only does what we need for the caching? Is there any other tech in LLVM that does this kind of thing without having to use the full ARM printer/writer stuff?

I haven't looked at the code in detail, but I noted that the filesystem changes, and some of the unrelated formatting cleanups could be put into separate patches.

I can break those out into separate patches.

So my plan is to:

• make a separate patch for the symbol table parsing code in Module/ObjectFile
• make a separate patch for FileSystem stuff
• figure out what to do with llvm::gsym::FileWriter (input would be appreciated here!)
• rebase this patch on all above patches and try using the llvm caching libraries

lldb/include/lldb/Host/FileSystem.h

93

I can return a Status as like many other calls to be more consistent with the functions in this directory.

lldb/source/Core/Module.cpp

1676

Sounds good.

1680

Yes, stats should log if the cache was enabled, but each module should also emit stats for anything that was loaded from the cache. If the cache is enabled and nothing is in the cache yet, then we should emit stats for anything that was loaded from the cache.

lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

2722

Yeah, I was thinking about this as well as I was doing it. I will make a patch that does this as a NFC patch first and then rebase this patch on that.

2723

Yeah, each object file should remember what/if it loads anything from a cache and emit stats. This patch was already getting too big, and I was planning on doing a quick follow up patch.

lldb/source/Symbol/Symbol.cpp

645

Agreed.

[clayborg]

Thinking about this a bit more after Pavel's comment on if performance was improved due to mangling: we don't currently get any perf improvement from mangling/demangling. We might be able to get better performance out of this as well if we _do_ cache the "mangled/demangled" counterparts (save both strings when they are related instead of just saving the mangled string like I do in this patch) when we serialize the Mangled objects. When the objects are deserialized, they could read both strings and then no demangling would need to happen for that mangled name since it could be registers as the counterpart strings during deserialization...

[clayborg]

Some perf numbers that involve loading a large iOS Application and all of its shared libraries without caching first and then with caching are found below. The "lldb-perf.py" command will start a timer, run any LLDB commands and then stop the timer and print out. Before the first run, I run "sudo purge" to purge the kernel file cache, and then I run one "cold" run with the file caches being empty. Then I run the same thing again with hot file caches. So the first run is always slower.

First run with no cache enabled:

$ lldb-perf.py --lldb /Users/gclayton/Documents/src/llvm/main-clean/Release/bin/lldb --command 'file Facebook.app'
------------------------------------------------------------------------
Cold file cache run:
------------------------------------------------------------------------
(lldb) script import time; start_time = time.perf_counter()
(lldb) file Facebook.app
Current executable set to 'Facebook.app' (x86_64).
(lldb) script print(time.perf_counter() - start_time)
10.961282056
(lldb) quit
------------------------------------------------------------------------
Warm file cache run:
------------------------------------------------------------------------
(lldb) script import time; start_time = time.perf_counter()
(lldb) file Facebook.app
Current executable set to 'Facebook.app' (x86_64).
(lldb) script print(time.perf_counter() - start_time)
6.4026089829999995
(lldb) quit
------------------------------------------------------------------------
Warm file cache run:
------------------------------------------------------------------------
(lldb) script import time; start_time = time.perf_counter()
(lldb) file Facebook.app
Current executable set to 'Facebook.app' (x86_64).
(lldb) script print(time.perf_counter() - start_time)
6.43446597
(lldb) quit

Second run with caching enabled:

$ lldb-perf.py --lldb /Users/gclayton/Documents/src/llvm/main-clean/Release/bin/lldb --command 'settings set symbols.enable-lldb-modules-cache true' --command 'file Facebook.app'
------------------------------------------------------------------------
Cold file cache run:
------------------------------------------------------------------------
(lldb) script import time; start_time = time.perf_counter()
(lldb) settings set symbols.enable-lldb-modules-cache true
(lldb) file Facebook.app
Current executable set to 'Facebook.app' (x86_64).
(lldb) script print(time.perf_counter() - start_time)
9.102131989
(lldb) quit
------------------------------------------------------------------------
Warm file cache run:
------------------------------------------------------------------------
(lldb) script import time; start_time = time.perf_counter()
(lldb) settings set symbols.enable-lldb-modules-cache true
(lldb) file Facebook.app
Current executable set to 'Facebook.app' (x86_64).
(lldb) script print(time.perf_counter() - start_time)
4.374525497
(lldb) quit
------------------------------------------------------------------------
Warm file cache run:
------------------------------------------------------------------------
(lldb) script import time; start_time = time.perf_counter()
(lldb) settings set symbols.enable-lldb-modules-cache true
(lldb) file Facebook.app
Current executable set to 'Facebook.app' (x86_64).
(lldb) script print(time.perf_counter() - start_time)
4.353001629
(lldb) quit

Results from one large project:
20% faster for cold file caches
47% faster for warm file caches

[labath]

In D113789#3133205, @clayborg wrote:

In D113789#3130741, @labath wrote:

Maybe it's good for starting a discussion, but I am surprised that we would need to cache symtab information. This is a fairly simple format that needs to be read at application runtime as well, so I am surprised that reading it from the cache is substantially faster than doing it from the object file. What is the slow part there? Is it demangling by any chance?

Symbol tables for LLDB are made up by scouring every bit of data we can out of one or more symbol tables (ELF has normal symbol table and the dynamic symbol table, and optionally the symbol table in the zipped debug info). There are also many runtime sections like .eh_frame and [...]

Ok, you've convinced me. :) I completely forgot about all the things that go into these.

Now to the discussion. Overall, I think this is an interesting feature, but I do have some remarks/questions:

• I don't think that "lldb module cache" is very good name for this feature as we already have the "platform module cache" feature (see Target/ModuleCache.h and its callers), which deals with downloading (and caching) modules (object files) from remote systems. And then there's the clang module cache, of course.. (and the llvm modules, but we fortunately don't cache those). It would be better if we chose a slightly less overloaded name. Maybe "index cache" ? (I assume you will also want to store dwarf indexes there)

yes debug info is the next item I want to put into this cache. "index cache" sounds fine. I will rename once I get a few NFC patches submitted and rebase.

• I don't see anything which would ensure cache consistency for the case where multiple debugger instances try to cache the same module simultaneously. What's the plan for that?

I was hoping to learn LLVM already had this kind of thing and using that! I see below there are some things already in LLVM I should be able to use.

• Have you considered the building upon the caching infrastructure in llvm (llvm/Caching.h, llvm/CachePruning.h)? I believe it already has some size limiting features and multiprocess synchronization built-in, so using it would take care of the previous item, and of @wallace's size limit request.

I will check into that and see if I can use that! I figured it would have been done already, glad to see it has!

Cool. Thanks.

• it's moderately strange to be using the gsym file writer for this purpose

When I made gsym I create the FileWriter as something that can easily create binary content without having to go with the ASM print/writer stuff in LLVM as that requires tons of stuff including LLVM targets and object file support.

What suggestions do people have on this front? Should I make a patch to move FileWriter out of GSYM? I don't know how if llvm::gym::FileWriter is useful enough for other folks in LLVM. Any thoughts? Should we just make our own FileWriter class that only does what we need for the caching? Is there any other tech in LLVM that does this kind of thing without having to use the full ARM printer/writer stuff?

The binary writing capabilities in llvm mostly take form of various free functions instead of a single rule-them-all class. This makes it hard to discover, which is probably the reason for the existence of gsym::FileWriter-type classes (the ObjectYAML library also has things like that.) For binary endian-specific writing, there's llvm::endian::Writer in llvm/Support/EndianStream.h. It doesn't have anything fancy, but I don't think we need anything fancy here. The biggest thing it lacks is the ability to write a null-terminated string. We could make another free function for that, or maybe even add it to the raw_ostream interface (next to write_zeroes). I don't think you need them here, but there are [US]LEB128 writing functions in llvm/Support/LEB128.h.

We also have a DataEncoder class on the lldb side. It has (or could be made to have) all the writing capabilities you need, but it's not an exact fit because it's currently writing to a memory buffer. However, it only has a handful of uses, so I could imagine rafactoring it to work with raw_ostreams instead.

lldb/include/lldb/Core/Mangled.h

 //===-- Mangled.h -----------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_CORE_MANGLED_H
 #define LLDB_CORE_MANGLED_H
 #if defined(__cplusplus)
 
 #include "lldb/lldb-enumerations.h"
 #include "lldb/lldb-forward.h"
+#include "lldb/lldb-types.h"
 
 #include "lldb/Utility/ConstString.h"
 
 #include "llvm/ADT/StringRef.h"
 
 #include <cstddef>
 #include <memory>
 
+namespace llvm {
+namespace gsym {
+class FileWriter;
+} // namespace gsym
+} // namespace llvm
+
 namespace lldb_private {
 
 /// \class Mangled Mangled.h "lldb/Core/Mangled.h"
 /// A class that handles mangled names.
 ///
 /// Designed to handle mangled names. The demangled version of any names will
 /// be computed when the demangled name is accessed through the Demangled()
 /// acccessor. This class can also tokenize the demangled version of the name
public:
   /// mangled or not.
   ///
   /// \param[in] name
   ///     The already const name to copy into this object.
   explicit Mangled(ConstString name);
 
   explicit Mangled(llvm::StringRef name);
 
+  bool operator==(const Mangled &rhs) const {
+    return m_mangled == rhs.m_mangled &&
+           GetDemangledName() == rhs.GetDemangledName();
+  }
+
+  bool operator!=(const Mangled &rhs) const {
+    return m_mangled != rhs.m_mangled ||
+           GetDemangledName() != rhs.GetDemangledName();
+  }
+
   /// Convert to pointer operator.
   ///
   /// This allows code to check a Mangled object to see if it contains a valid
   /// mangled name using code such as:
   ///
   /// \code
   /// Mangled mangled(...);
   /// if (mangled)
public:
   /// \param[in] name
   ///     The name we are attempting to identify the mangling scheme for.
   ///
   /// \return
   ///     eManglingSchemeNone if no known mangling scheme could be identified
   ///     for s, otherwise the enumerator for the mangling scheme detected.
   static Mangled::ManglingScheme GetManglingScheme(llvm::StringRef const name);
 
+  bool Decode(const DataExtractor &data, lldb::offset_t *offset_ptr);
+  void Encode(llvm::gsym::FileWriter &file) const;
+
 private:
   /// Mangled member variables.
   ConstString m_mangled;           ///< The mangled version of the name
   mutable ConstString m_demangled; ///< Mutable so we can get it on demand with
                                    ///a const version of this object
 };
 
 Stream &operator<<(Stream &s, const Mangled &obj);
 
 } // namespace lldb_private
 
 #endif // #if defined(__cplusplus)
 #endif // LLDB_CORE_MANGLED_H

lldb/include/lldb/Core/MappedHash.h

bool Find(llvm::StringRef name, Pair &pair) const {
         }
       }
       return false;
     }
 
     // This method must be implemented in any subclasses. The KeyType is user
     // specified and must somehow result in a string value. For example, the
     // KeyType might be a string offset in a string table and subclasses can
-    // store their string table as a member of the subclass and return a valie
+    // store their string table as a member of the subclass and return a valid
     // "const char *" given a "key". The value could also be a C string
     // pointer, in which case just returning "key" will suffice.
     virtual const char *GetStringForKeyType(KeyType key) const = 0;
 
     virtual bool ReadHashData(uint32_t hash_data_offset,
                               HashData &hash_data) const = 0;
 
     // This method must be implemented in any subclasses and it must try to

lldb/include/lldb/Core/Module.h

public:
   /// Update the ArchSpec to a more specific variant.
   bool MergeArchitecture(const ArchSpec &arch_spec);
 
   /// Accessor for the symbol table parse time metric.
   ///
   /// The value is returned as a reference to allow it to be updated by the
   /// ElapsedTime RAII object.
   StatsDuration &GetSymtabParseTime() { return m_symtab_parse_time; }
-  
   /// Accessor for the symbol table index time metric.
   ///
   /// The value is returned as a reference to allow it to be updated by the
   /// ElapsedTime RAII object.
   StatsDuration &GetSymtabIndexTime() { return m_symtab_index_time; }
 
   /// \class LookupInfo Module.h "lldb/Core/Module.h"
   /// A class that encapsulates name lookup information.
protected:
     /// names we are looking for
     lldb::FunctionNameType m_name_type_mask = lldb::eFunctionNameTypeNone;
 
     ///< If \b true, then demangled names that match will need to contain
     ///< "m_name" in order to be considered a match
     bool m_match_name_after_lookup = false;
   };
 
+  /// Get a unique hash for this module.
+  ///
+  /// The hash should be enough to identify the file on disk and the
+  /// architecture of the file. If the module represents an object inside of a
+  /// file, then the hash should include the object name and object offset to
+  /// ensure a unique hash. Some examples:
+  /// - just a regular object file (mach-o, elf, coff, etc) should create a hash
+  /// - a universal mach-o file that contains to multiple architectures,
+  ///   each architecture slice should have a unique hash even though they come
+  ///   from the same file
+  /// - a .o file inside of a BSD archive. Each .o file will have an object name
+  ///   and object offset that should produce a unique hash. The object offset
+  ///   is needed as BSD archive files can contain multiple .o files that have
+  ///   the same name.
+  uint32_t Hash();
+
+  /// Get the cache directory for caching data for this module.
+  ///
+  /// LLDB can cache data for a module between runs. This cache directory can be
+  /// used to stored data that must be manually created each time you debug.
+  /// Examples include debug information indexes, symbol table indexes, symbol
+  /// tables, and more.
+  ///
+  /// The cache directory should be unique to a module's path on disk,
+  /// architecture and optional object name so the module cache can easily be
+  /// cleared and updated if the file gets updated. This keeps the module cache
+  /// from growing too large over time by only allowing one entry in the cache
+  /// for the same file/arch/object.
+  ///
+  /// \returns
+  ///   A valid FileSpec if caching is enabled and the cache directory was
+  ///   able to be created. llvm::None if caching is disabled or there was a
+  ///   failure to create the cache directory.
+  llvm::Optional<FileSpec> GetCacheDirectory();
+
 protected:
   // Member Variables
   mutable std::recursive_mutex m_mutex; ///< A mutex to keep this object happy
                                         ///in multi-threaded environments.
 
   /// The modification time for this module when it was created.
   llvm::sys::TimePoint<> m_mod_time;
 
FileSpec m_symfile_spec;   ///< If this path is valid, then this is the file
                              ///that _will_ be used as the symbol file for this
                              ///module
   ConstString m_object_name; ///< The name an object within this module that is
                              ///selected, or empty of the module is represented
                              ///by \a m_file.
   uint64_t m_object_offset = 0;
   llvm::sys::TimePoint<> m_object_mod_time;
 
+  /// The cache directory for caching data between LLDB processes.
+  llvm::Optional<FileSpec> m_cache_directory;
+
   /// DataBuffer containing the module image, if it was provided at
   /// construction time. Otherwise the data will be retrieved by mapping
   /// one of the FileSpec members above.
   lldb::DataBufferSP m_data_sp;
 
   lldb::ObjectFileSP m_objfile_sp; ///< A shared pointer to the object file
                                    ///parser for this module as it may or may
                                    ///not be shared with the SymbolFile

lldb/include/lldb/Core/ModuleList.h

 
 public:
   ModuleListProperties();
 
   FileSpec GetClangModulesCachePath() const;
   bool SetClangModulesCachePath(const FileSpec &path);
   bool GetEnableExternalLookup() const;
   bool SetEnableExternalLookup(bool new_value);
+  bool GetEnableLLDBModulesCache() const;
+  bool SetEnableLLDBModulesCache(bool new_value);
+
+  FileSpec GetLLDBModulesCachePath() const;
+  bool SetLLDBModulesCachePath(const FileSpec &path);
 
   PathMappingList GetSymlinkMappings() const;
 };
 
 /// \class ModuleList ModuleList.h "lldb/Core/ModuleList.h"
 /// A collection class for Module objects.
 ///
 /// Modules in the module collection class are stored as reference counted

lldb/include/lldb/Host/FileSystem.h

public:
   /// \}
 
   /// Returns the modification time of the given file.
   /// \{
   llvm::sys::TimePoint<> GetModificationTime(const FileSpec &file_spec) const;
   llvm::sys::TimePoint<> GetModificationTime(const llvm::Twine &path) const;
   /// \}
 
+  /// Set the access and modification time of the given file.
+  bool SetAccessAndModificationTime(const FileSpec &file_spec,
+                                    llvm::sys::TimePoint<> time);
+
   /// Returns the on-disk size of the given file in bytes.
   /// \{
   uint64_t GetByteSize(const FileSpec &file_spec) const;
   uint64_t GetByteSize(const llvm::Twine &path) const;
   /// \}
 
   /// Return the current permissions of the given file.
   ///
public:
   /// \}
 
   /// Resolve path to make it canonical.
   /// \{
   void Resolve(llvm::SmallVectorImpl<char> &path);
   void Resolve(FileSpec &file_spec);
   /// \}
 
+  /// Create a directory.
+  ///
+  /// Create as many directories as needed in the path.
+  /// \{
+  Status CreateDirectory(const FileSpec &file_spec);
+  Status CreateDirectory(const llvm::Twine &path);
+  /// \}
+
+  /// Remove a single directory that must be empty.
+  /// \{
+  Status RemoveDirectory(const FileSpec &file_spec);
+  Status RemoveDirectory(const llvm::Twine &path);
+  /// \}
+
+  /// Remove a single file.
+  ///
+  /// The path must specify a file an not a directory.
+  /// \{
+  Status Remove(const FileSpec &file_spec);
+  Status Remove(const llvm::Twine &path);
+  /// \}
+
   //// Create memory buffer from path.
   /// \{
   std::shared_ptr<DataBufferLLVM> CreateDataBuffer(const llvm::Twine &path,
                                                    uint64_t size = 0,
                                                    uint64_t offset = 0);
   std::shared_ptr<DataBufferLLVM> CreateDataBuffer(const FileSpec &file_spec,
                                                    uint64_t size = 0,
                                                    uint64_t offset = 0);

lldb/include/lldb/Symbol/ObjectFile.h

 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Symbol/Symtab.h"
 #include "lldb/Symbol/UnwindTable.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/UUID.h"
 #include "lldb/lldb-private.h"
+#include "llvm/ADT/Optional.h"
 #include "llvm/Support/VersionTuple.h"
 
 namespace lldb_private {
 
 class ObjectFileJITDelegate {
 public:
   ObjectFileJITDelegate() = default;
 
public:
   ///
   /// \return
   ///     Returns true if any binaries were loaded.
 
   virtual bool LoadCoreFileImages(lldb_private::Process &process) {
     return false;
   }
 
+  /// Get a hash that can be used for caching object file releated information.
+  ///
+  /// Data for object files can be cached between runs of debug sessions and
+  /// a module can end up using a main file and a symbol file, both of which
+  /// can be object files. So we need a unique hash that identifies an object
+  /// file when storing cached data.
+  uint32_t GetCacheHash();
+
 protected:
   // Member variables.
   FileSpec m_file;
   Type m_type;
   Strata m_strata;
-  lldb::addr_t m_file_offset; ///< The offset in bytes into the file, or the
-                              ///address in memory
-  lldb::addr_t m_length; ///< The length of this object file if it is known (can
-                         ///be zero if length is unknown or can't be
-                         ///determined).
-  DataExtractor
-      m_data; ///< The data for this object file so things can be parsed lazily.
+  /// The offset in bytes into the file, or the address in memory.
+  lldb::addr_t m_file_offset;
+  /// The length of this object file if it is known. This can be zero if length
+  /// is unknown or can't be determined.
+  lldb::addr_t m_length;
+  /// The data for this object file so things can be parsed lazily.
+  DataExtractor m_data;
   lldb::ProcessWP m_process_wp;
   const lldb::addr_t m_memory_addr;
   std::unique_ptr<lldb_private::SectionList> m_sections_up;
   std::unique_ptr<lldb_private::Symtab> m_symtab_up;
   uint32_t m_synthetic_symbol_idx;
+  llvm::Optional<uint32_t> m_cache_hash;
 
   /// Sets the architecture for a module.  At present the architecture can
   /// only be set if it is invalid.  It is not allowed to switch from one
   /// concrete architecture to another.
   ///
   /// \param[in] new_arch
   ///     The architecture this module will be set to.
   ///

lldb/include/lldb/Symbol/Symbol.h

 #define LLDB_SYMBOL_SYMBOL_H
 
 #include "lldb/Core/AddressRange.h"
 #include "lldb/Core/Mangled.h"
 #include "lldb/Symbol/SymbolContextScope.h"
 #include "lldb/Utility/UserID.h"
 #include "lldb/lldb-private.h"
 
+namespace llvm {
+namespace gsym {
+  class FileWriter;
+} // namespace gsym
+} // namespace llvm
+
 namespace lldb_private {
 
 class Symbol : public SymbolContextScope {
 public:
   // ObjectFile readers can classify their symbol table entries and searches
   // can be made on specific types where the symbol values will have
   // drastically different meanings and sorting requirements.
   Symbol();
bool GetDisassembly(const ExecutionContext &exe_ctx, const char *flavor,
                       bool prefer_file_cache, Stream &strm);
 
   bool ContainsFileAddress(lldb::addr_t file_addr) const;
 
   static llvm::StringRef GetSyntheticSymbolPrefix() {
     return "___lldb_unnamed_symbol";
   }
 
+  bool Decode(const DataExtractor &data, lldb::offset_t *offset_ptr,
+              const SectionList *section_list);
+  void Encode(llvm::gsym::FileWriter &file) const;
+
+  bool operator==(const Symbol &rhs) const;
+
 protected:
   // This is the internal guts of ResolveReExportedSymbol, it assumes
   // reexport_name is not null, and that module_spec is valid.  We track the
   // modules we've already seen to make sure we don't get caught in a cycle.
 
   Symbol *ResolveReExportedSymbolInModuleSpec(
       Target &target, ConstString &reexport_name,
       lldb_private::ModuleSpec &module_spec,

lldb/include/lldb/Symbol/Symtab.h

enum Debug {
     eDebugAny
   };
 
   enum Visibility { eVisibilityAny, eVisibilityExtern, eVisibilityPrivate };
 
   Symtab(ObjectFile *objfile);
   ~Symtab();
 
+  llvm::Optional<FileSpec> GetSymtabCacheFile();
+  void SaveToCache();
+  /// Encode the symbol table into a binary format for caching.
+  ///
+  /// The format is described in the implementation file.
+  ///
+  /// \param file
+  ///   A file writer object that the data is to be encoded into.
+  void Encode(llvm::gsym::FileWriter &file) const;
+  bool Decode(const DataExtractor &data, lldb::offset_t *offset_ptr);
+  bool LoadFromCache();
   void PreloadSymbols();
   void Reserve(size_t count);
   Symbol *Resize(size_t count);
   uint32_t AddSymbol(const Symbol &symbol);
   size_t GetNumSymbols() const;
   void SectionFileAddressesChanged();
   void
   Dump(Stream *s, Target *target, SortOrder sort_type,

lldb/packages/Python/lldbsuite/test/lldbtest.py

""".format(cmd_status, filecheck_cmd, output, cmd_stdout, cmd_stderr)
 
     """Assert that an lldb.SBError is in the "success" state."""
     def assertSuccess(self, obj, msg=None):
         if not obj.Success():
             error = obj.GetCString()
             self.fail(self._formatMessage(msg,
                 "'{}' is not success".format(error)))
 
-    def createTestTarget(self, file_path=None, msg=None):
+    def createTestTarget(self, file_path=None, msg=None,
+                         load_dependent_modules=True):
         """
         Creates a target from the file found at the given file path.
         Asserts that the resulting target is valid.
         :param file_path: The file path that should be used to create the target.
                           The default argument opens the current default test
                           executable in the current test directory.
         :param msg: A custom error message.
         """
         if file_path is None:
             file_path = self.getBuildArtifact("a.out")
         error = lldb.SBError()
         triple = ""
         platform = ""
-        load_dependent_modules = True
         target = self.dbg.CreateTarget(file_path, triple, platform,
                                        load_dependent_modules, error)
         if error.Fail():
             err = "Couldn't create target for path '{}': {}".format(file_path,
                                                                     str(error))
             self.fail(self._formatMessage(msg, err))
 
         self.assertTrue(target.IsValid(), "Got invalid target without error")

lldb/source/API/SBDebugger.cpp

SBTarget SBDebugger::CreateTargetWithFileAndArch(const char *filename,
   SBTarget sb_target;
   TargetSP target_sp;
   if (m_opaque_sp) {
     Status error;
     if (arch_cstr == nullptr) {
       // The version of CreateTarget that takes an ArchSpec won't accept an
       // empty ArchSpec, so when the arch hasn't been specified, we need to
       // call the target triple version.
-      error = m_opaque_sp->GetTargetList().CreateTarget(*m_opaque_sp, filename, 
+      error = m_opaque_sp->GetTargetList().CreateTarget(*m_opaque_sp, filename,
           arch_cstr, eLoadDependentsYes, nullptr, target_sp);
     } else {
       PlatformSP platform_sp = m_opaque_sp->GetPlatformList()
           .GetSelectedPlatform();
-      ArchSpec arch = Platform::GetAugmentedArchSpec(platform_sp.get(), 
+      ArchSpec arch = Platform::GetAugmentedArchSpec(platform_sp.get(),
           arch_cstr);
       if (arch.IsValid())
-        error = m_opaque_sp->GetTargetList().CreateTarget(*m_opaque_sp, filename, 
+        error = m_opaque_sp->GetTargetList().CreateTarget(*m_opaque_sp, filename,
             arch, eLoadDependentsYes, platform_sp, target_sp);
       else
         error.SetErrorStringWithFormat("invalid arch_cstr: %s", arch_cstr);
     }
     if (error.Success())
       sb_target.SetSP(target_sp);
   }
 

lldb/source/Core/CoreProperties.td

 include "../../include/lldb/Core/PropertiesBase.td"
 
 let Definition = "modulelist" in {
   def EnableExternalLookup: Property<"enable-external-lookup", "Boolean">,
     Global,
     DefaultTrue,
     Desc<"Control the use of external tools and repositories to locate symbol files. Directories listed in target.debug-file-search-paths and directory of the executable are always checked first for separate debug info files. Then depending on this setting: On macOS, Spotlight would be also used to locate a matching .dSYM bundle based on the UUID of the executable. On NetBSD, directory /usr/libdata/debug would be also searched. On platforms other than NetBSD directory /usr/lib/debug would be also searched.">;
   def ClangModulesCachePath: Property<"clang-modules-cache-path", "FileSpec">,
     Global,
     DefaultStringValue<"">,
     Desc<"The path to the clang modules cache directory (-fmodules-cache-path).">;
   def SymLinkPaths: Property<"debug-info-symlink-paths", "FileSpecList">,
     Global,
     DefaultStringValue<"">,
     Desc<"Debug info path which should be resolved while parsing, relative to the host filesystem.">;
+  def EnableLLDBModulesCache: Property<"enable-lldb-modules-cache", "Boolean">,
+    Global,
+    DefaultFalse,
+    Desc<"Enable module caching for debug sessions in LLDB. LLDB can cache data for each module for improved performance in subsequent debug sessions.">;
+  def LLDBModulesCachePath: Property<"lldb-modules-cache-path", "FileSpec">,
+    Global,
+    DefaultStringValue<"">,
+    Desc<"The path to the LLDB module cache directory.">;
 }
 
 let Definition = "debugger" in {
   def AutoConfirm: Property<"auto-confirm", "Boolean">,
     Global,
     DefaultFalse,
     Desc<"If true all confirmation prompts will receive their default reply.">;
   def DisassemblyFormat: Property<"disassembly-format", "FormatEntity">,

lldb/source/Core/Mangled.cpp

 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Logging.h"
 #include "lldb/Utility/RegularExpression.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/lldb-enumerations.h"
 
 #include "llvm/ADT/StringRef.h"
+#include "llvm/DebugInfo/GSYM/FileWriter.h"
 #include "llvm/Demangle/Demangle.h"
 #include "llvm/Support/Compiler.h"
 
 #include <mutex>
 #include <string>
 #include <utility>
 
 #include <cstdlib>
Stream &operator<<(Stream &s, const Mangled &obj) {
 
   ConstString demangled = obj.GetDemangledName();
   if (demangled)
     s << ", demangled = '" << demangled << '\'';
   else
     s << ", demangled = <error>";
   return s;
 }
+
+
+// When encoding Mangled objects we can get away with encoding as little
+// information as is required. The enumeration below helps us to efficiently
+// encode Mangled objects.
+enum MangledEncoding {
+  /// If the Mangled object has neither a mangled name or demangled name we can
+  /// encode the object with one zero byte using the Empty enumeration.
+  Empty = 0u,
+  /// If the Mangled object has only a demangled name and no mangled named, we
+  /// can encode only the demangled name.
+  DemangledOnly = 1u,
+  /// If the mangle name can calculate the demangled name (it is the
+  /// mangled/demangled counterpart), then we only need to encode the mangled
+  /// name as the demangled name can be recomputed.
+  MangledOnly = 2u,
+  /// If we have a Mangled object with two different names that are not related
+  /// then we need to save both strings. This can happen if we have a name that
+  /// isn't a true mangled name, but we want to be able to lookup a symbol by
+  /// name and type in the symbol table. We do this for Objective C symbols like
+  /// "OBJC_CLASS_$_NSValue" where the mangled named will be set to
+  /// "OBJC_CLASS_$_NSValue" and the demangled name will be manually set to
+  /// "NSValue". If we tried to demangled the name "OBJC_CLASS_$_NSValue" it
+  /// would fail, but in these cases we want these unrelated names to be
+  /// preserved.
+  MangledAndDemangled = 3u
+};
+
+bool Mangled::Decode(const DataExtractor &data,
+                     lldb::offset_t *offset_ptr) {
+  m_mangled.Clear();
+  m_demangled.Clear();
+  MangledEncoding encoding = (MangledEncoding)data.GetU8(offset_ptr);
+  switch (encoding) {
+    case Empty:
+      return true;
+
+    case DemangledOnly:
+      m_demangled.SetCString(data.GetCStr(offset_ptr));
+      return true;
+
+    case MangledOnly:
+      m_mangled.SetCString(data.GetCStr(offset_ptr));
+      return true;
+
+    case MangledAndDemangled:
+      m_mangled.SetCString(data.GetCStr(offset_ptr));
+      m_demangled.SetCString(data.GetCStr(offset_ptr));
+      return true;
+  }
+  return false;
+}
+/// The encoding format for the Mangled object is as follows:
+///
+/// uint8_t encoding;
+/// char str1[]; (only if DemangledOnly, MangledOnly)
+/// char str2[]; (only if MangledAndDemangled)
+///
+/// The strings are stored as NULL terminated UTF8 strings and str1 and str2
+/// are only saved if we need them based on the encoding.
+///
+/// Some mangled names have a mangled name that can be demangled by the built
+/// in demanglers. These kinds of mangled objects know when the mangled and
+/// demangled names are the counterparts for each other. This is done because
+/// demangling is very expensive and avoiding demangling the same name twice
+/// saves us a lot of compute time. For these kinds of names we only need to
+/// save the mangled name and have the encoding set to "MangledOnly".
+///
+/// If a mangled obejct has only a demangled name, then we save only that string
+/// and have the encoding set to "DemangledOnly".
+///
+/// Some mangled objects have both mangled and demangled names, but the
+/// demangled name can not be computed from the mangled name. This is often used
+/// for runtime named, like Objective C runtime V2 and V3 names. Both these
+/// names must be saved and the encoding is set to "MangledAndDemangled".
+///
+/// For a Mangled object with no names, we only need to set the encoding to
+/// "Empty" and not store any string values.
+void Mangled::Encode(llvm::gsym::FileWriter &file) const {
+  MangledEncoding encoding = Empty;
+  if (m_mangled) {
+    encoding = MangledOnly;
+    if (m_demangled) {
+      // We have both mangled and demangled names. If the demangled name is the
+      // counterpart of the mangled name, then we only need to save the mangled
+      // named. If they are different, we need to save both.
+      ConstString s;
+      if (!(m_mangled.GetMangledCounterpart(s) && s == m_demangled))
+        encoding = MangledAndDemangled;
+    }
+  } else if (m_demangled) {
+    encoding = DemangledOnly;
+  }
+  file.writeU8(encoding);
+  switch (encoding) {
+    case Empty:
+      break;
+    case DemangledOnly:
+      file.writeNullTerminated(m_demangled.GetStringRef());
+      break;
+    case MangledOnly:
+      file.writeNullTerminated(m_mangled.GetStringRef());
+      break;
+    case MangledAndDemangled:
+      file.writeNullTerminated(m_mangled.GetStringRef());
+      file.writeNullTerminated(m_demangled.GetStringRef());
+      break;
+  }
+}

lldb/source/Core/Module.cpp

 #include "lldb/Host/windows/PosixApi.h"
 #endif
 
 #include "Plugins/Language/CPlusPlus/CPlusPlusLanguage.h"
 #include "Plugins/Language/ObjC/ObjCLanguage.h"
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/Compiler.h"
+#include "llvm/Support/DJB.h"
 #include "llvm/Support/FileSystem.h"
+#include "llvm/Support/FormatVariadic.h"
+#include "llvm/Support/JSON.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/raw_ostream.h"
 
+
 #include <cassert>
 #include <cinttypes>
 #include <cstdarg>
 #include <cstdint>
 #include <cstring>
 #include <map>
 #include <type_traits>
 #include <utility>

 bool Module::GetIsDynamicLinkEditor() {
   ObjectFile *obj_file = GetObjectFile();
 
   if (obj_file)
     return obj_file->GetIsDynamicLinkEditor();
 
   return false;
 }
+
+uint32_t Module::Hash() {
+  std::string identifier;
+  llvm::raw_string_ostream id_strm(identifier);
+  id_strm << m_file.GetPath() << m_arch.GetTriple().str();
+  if (m_object_name)
+    id_strm << m_object_name.GetStringRef();
+  if (m_object_offset > 0)
+    id_strm << m_object_offset;
+  const auto mtime = llvm::sys::toTimeT(m_object_mod_time);
+  if (mtime > 0)
+    id_strm << mtime;
+  return llvm::djbHash(id_strm.str());
+}
+
+llvm::Optional<FileSpec> Module::GetCacheDirectory() {
+  using namespace llvm;
+  std::lock_guard<std::recursive_mutex> guard(m_mutex);
+  if (!ModuleList::GetGlobalModuleListProperties().GetEnableLLDBModulesCache())
+    return None;
+  // Check the cache directory has a value _and_ if the filespec that was stored
+  // there is valid. If the optional has a value and the FileSpec is empty, it
+  // means something went wrong when trying to create the cache directory and we
+  // don't want to keep trying to create the directory over and over.
+  if (m_cache_directory.hasValue()) {
+    // Check if the FileSpec is not empty and if so return the cached value.
+    if (*m_cache_directory)
+      return m_cache_directory;
+    // The FileSpec is invalid, so return None.
+    return None;
+  }
+  // Initialize the optional value with an empty FileSpec in case anything goes
+  // wrong. If something goes wrong, then the next time this function is called
+  // we will enter the above if statement and return the cached value or
+  // None if the cache directory is empty.
+  m_cache_directory = FileSpec();
+  FileSpec cache_dir =
+      ModuleList::GetGlobalModuleListProperties().GetLLDBModulesCachePath();
+  // Append the file basename to the path as a directory.
+  cache_dir.AppendPathComponent(GetFileSpec().GetFilename().GetStringRef());
+  // Append the object name to the path as a directory. The object name will be
+  // valid if we have an object file from a BSD archive like "foo.a(bar.o)".
+  if (m_object_name)
+    cache_dir.AppendPathComponent(m_object_name.GetStringRef());
+  // Append the hash as a directory in case a file on disk contains multiple
+  // architectures.
+  std::string str;
+  raw_string_ostream strm(str);
+  strm << format_hex(Hash(), 10);
+  cache_dir.AppendPathComponent(strm.str());
+
+  // Create the directories needed for this module cache path.
+  FileSystem &fs = FileSystem::Instance();
+  if (fs.CreateDirectory(cache_dir).Fail())
+    return None;
+  sys::TimePoint<> module_mtime, cache_mtime;
+  FileSpec info_file(cache_dir);
+  module_mtime = GetModificationTime();
+  constexpr StringRef info_basename("info.json");
+  info_file.AppendPathComponent(info_basename);
+  if (fs.Exists(info_file)) {
+    cache_mtime = fs.GetModificationTime(info_file);
+    if (cache_mtime != module_mtime) {
+      // Module has been updated and doesn't match the cached information.
+      // Delete all files except the info file in the cache directory.
+      fs.EnumerateDirectory(
+          cache_dir.GetPath(),
+          /*find_directories=*/false,
+          /*file_files=*/true,
+          /*find_other=*/false,
+          [](void *baton,
+             sys::fs::file_type ft,
+             StringRef path) -> FileSystem::EnumerateDirectoryResult {
+            if (!path.endswith("info.json"))
+              FileSystem::Instance().Remove(path);
+            return FileSystem::EnumerateDirectoryResult::eEnumerateDirectoryResultNext;
+          },
+          nullptr);
+      // Update the modification time on the info file.
+      if (!fs.SetAccessAndModificationTime(info_file, module_mtime))
+        return None;
+    }
+  } else {
+    // Create the info file in the module cache directory and set its
+    // modification time to match the module's modification time.
+    auto file_or_err = fs.Open(
+        info_file,
+        File::OpenOptions::eOpenOptionWriteOnly |
+        File::OpenOptions::eOpenOptionCanCreateNewOnly,
+        lldb::eFilePermissionsUserRead | lldb::eFilePermissionsUserWrite,
+        /*should_close_fd=*/true);
+    if (!file_or_err) {
+      consumeError(file_or_err.takeError());
+      return None;
+    }
+    lldb_private::File *file = file_or_err->get();
+    // Create the context of the "info.json" file with all of the information
+    // needed to fill out a ModuleSpec for the module that is being cached in
+    // this directory. This can later be used by cache management and purging
+    // commands by allowing us to check if the file still exists. The
+    // modification time of the file in "path" will be set to the modification
+    // time of the "info.json" file to allow quick and easy testing to see if
+    // the cache is up to date.
+    json::Object info{
+      {"path", GetFileSpec().GetPath() },
+      {"triple", GetArchitecture().GetTriple().str() }
+    };
+    if (m_object_name)
+      info.try_emplace("object-name", m_object_name.GetStringRef());
+    if (m_object_offset > 0)
+      info.try_emplace("object-offset", m_object_offset);
+    const auto mtime = llvm::sys::toTimeT(m_object_mod_time);
+    if (mtime > 0)
+      info.try_emplace("object-mtime", mtime);
+
+    std::string json_str(formatv("{0:2}\n", json::Value(std::move(info))).str());
+    size_t count = json_str.size();
+    if (file->Write(json_str.data(), count).Fail() || count != json_str.size())
+      return None;
+    file->Close();
+    // Update the modification time on the info file.
+    if (!fs.SetAccessAndModificationTime(info_file, module_mtime))
+      return None;
+  }
+  // Everything went well, set the cache directory to the successfully
+  // created cache directory.
+  m_cache_directory = cache_dir;
+  return m_cache_directory;
+}

lldb/source/Core/ModuleList.cpp

ModuleListProperties::ModuleListProperties() {
   m_collection_sp->Initialize(g_modulelist_properties);
   m_collection_sp->SetValueChangedCallback(ePropertySymLinkPaths,
                                            [this] { UpdateSymlinkMappings(); });
 
   llvm::SmallString<128> path;
   if (clang::driver::Driver::getDefaultModuleCachePath(path)) {
     lldbassert(SetClangModulesCachePath(FileSpec(path)));
   }
+
+  path.clear();
+  if (llvm::sys::path::cache_directory(path)) {
+    llvm::sys::path::append(path, "lldb");
+    llvm::sys::path::append(path, "ModuleCache");
+    lldbassert(SetLLDBModulesCachePath(FileSpec(path)));
+  }
 }
 
 bool ModuleListProperties::GetEnableExternalLookup() const {
   const uint32_t idx = ePropertyEnableExternalLookup;
   return m_collection_sp->GetPropertyAtIndexAsBoolean(
       nullptr, idx, g_modulelist_properties[idx].default_uint_value != 0);
 }
 
return m_collection_sp
       ->GetCurrentValue();
 }
 
 bool ModuleListProperties::SetClangModulesCachePath(const FileSpec &path) {
   return m_collection_sp->SetPropertyAtIndexAsFileSpec(
       nullptr, ePropertyClangModulesCachePath, path);
 }
 
+FileSpec ModuleListProperties::GetLLDBModulesCachePath() const {
+  return m_collection_sp
+      ->GetPropertyAtIndexAsOptionValueFileSpec(nullptr, false,
+                                                ePropertyLLDBModulesCachePath)
+      ->GetCurrentValue();
+}
+
+bool ModuleListProperties::SetLLDBModulesCachePath(const FileSpec &path) {
+  return m_collection_sp->SetPropertyAtIndexAsFileSpec(
+      nullptr, ePropertyLLDBModulesCachePath, path);
+}
+
+bool ModuleListProperties::GetEnableLLDBModulesCache() const {
+  const uint32_t idx = ePropertyEnableLLDBModulesCache;
+  return m_collection_sp->GetPropertyAtIndexAsBoolean(
+      nullptr, idx, g_modulelist_properties[idx].default_uint_value != 0);
+}
+
+bool ModuleListProperties::SetEnableLLDBModulesCache(bool new_value) {
+  return m_collection_sp->SetPropertyAtIndexAsBoolean(
+      nullptr, ePropertyEnableLLDBModulesCache, new_value);
+}
+
 void ModuleListProperties::UpdateSymlinkMappings() {
   FileSpecList list = m_collection_sp
                           ->GetPropertyAtIndexAsOptionValueFileSpecList(
                               nullptr, false, ePropertySymLinkPaths)
                           ->GetCurrentValue();
   llvm::sys::ScopedWriter lock(m_symlink_paths_mutex);
   const bool notify = false;
   m_symlink_paths.Clear(notify);

lldb/source/Host/common/FileSystem.cpp

 
 sys::TimePoint<> FileSystem::GetModificationTime(const Twine &path) const {
   ErrorOr<vfs::Status> status = m_fs->status(path);
   if (!status)
     return sys::TimePoint<>();
   return status->getLastModificationTime();
 }
 
+bool
+FileSystem::SetAccessAndModificationTime(const FileSpec &file_spec,
+                                         sys::TimePoint<> time) {
+  if (!file_spec)
+    return false;
+  auto file_or_err = Open(
+      file_spec,
+      File::OpenOptions::eOpenOptionReadWrite,
+      lldb::eFilePermissionsUserRead | lldb::eFilePermissionsUserWrite,
+      /*should_close_fd=*/true);
+  if (file_or_err)
+    return !llvm::sys::fs::setLastAccessAndModificationTime(
+        (*file_or_err)->GetDescriptor(), time);
+  consumeError(file_or_err.takeError());
+  return false;
+}
+
 uint64_t FileSystem::GetByteSize(const FileSpec &file_spec) const {
   if (!file_spec)
     return 0;
   return GetByteSize(file_spec.GetPath());
 }
 
 uint64_t FileSystem::GetByteSize(const Twine &path) const {
   ErrorOr<vfs::Status> status = m_fs->status(path);
if (llvm::sys::fs::is_directory(file))
     m_collector->addDirectory(file);
   else
     m_collector->addFile(file);
 }
 
 void FileSystem::SetHomeDirectory(std::string home_directory) {
   m_home_directory = std::move(home_directory);
 }
+
+Status FileSystem::CreateDirectory(const FileSpec &file_spec) {
+  return CreateDirectory(file_spec.GetPath());
+}
+
+Status FileSystem::CreateDirectory(const llvm::Twine &path) {
+  return Status(llvm::sys::fs::create_directories(path));
+}
+
+Status FileSystem::RemoveDirectory(const FileSpec &file_spec) {
+  return RemoveDirectory(file_spec.GetPath());
+}
+
+Status FileSystem::RemoveDirectory(const llvm::Twine &path) {
+  Status error;
+  if (!IsDirectory(path))
+    error.SetErrorStringWithFormatv("\"{0}\" is a not a directory",
+                                    path.str().c_str());
+  else
+    error = Status(llvm::sys::fs::remove_directories(path));
+  return error;
+}
+
+Status FileSystem::Remove(const FileSpec &file_spec) {
+  return Remove(file_spec.GetPath());
+}
+
+Status FileSystem::Remove(const llvm::Twine &path) {
+  Status error;
+  if (IsDirectory(path))
+    error.SetErrorStringWithFormatv("\"{0}\" is a directory",
+                                    path.str().c_str());
+  else
+    error = Status(llvm::sys::fs::remove(path));
+  return error;
+}

lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

if (m_symtab_up == nullptr) {
     // tables, one named ".symtab", and the other ".dynsym". The dynsym is a
     // smaller version of the symtab that only contains global symbols. The
     // information found in the dynsym is therefore also found in the symtab,
     // while the reverse is not necessarily true.
     Section *symtab =
         section_list->FindSectionByType(eSectionTypeELFSymbolTable, true).get();
     if (symtab) {
       m_symtab_up = std::make_unique<Symtab>(symtab->GetObjectFile());
+      if (m_symtab_up->LoadFromCache())
+        return m_symtab_up.get();
       symbol_id += ParseSymbolTable(m_symtab_up.get(), symbol_id, symtab);
     }
 
     // The symtab section is non-allocable and can be stripped, while the
     // .dynsym section which should always be always be there. To support the
     // minidebuginfo case we parse .dynsym when there's a .gnu_debuginfo
     // section, nomatter if .symtab was already parsed or not. This is because
     // minidebuginfo normally removes the .symtab symbols which have their
if (CalculateType() == eTypeExecutable) {
         } else {
           m_address_class_map[entry_point_file_addr] = AddressClass::eCode;
         }
         m_symtab_up->AddSymbol(symbol);
       }
     }
 
     m_symtab_up->CalculateSymbolSizes();
+    m_symtab_up->SaveToCache();
   }
 
   return m_symtab_up.get();
 }
 
 void ObjectFileELF::RelocateSection(lldb_private::Section *section)
 {
   static const char *debug_prefix = ".debug";

lldb/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp

Symtab *ObjectFileMachO::GetSymtab() {
   ModuleSP module_sp(GetModule());
   if (module_sp) {
     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
     if (m_symtab_up == nullptr) {
       ElapsedTime elapsed(module_sp->GetSymtabParseTime());
       m_symtab_up = std::make_unique<Symtab>(this);
       std::lock_guard<std::recursive_mutex> symtab_guard(
           m_symtab_up->GetMutex());
+      if (m_symtab_up->LoadFromCache())
+        return m_symtab_up.get();
       ParseSymtab();
       m_symtab_up->Finalize();
+      m_symtab_up->SaveToCache();
     }
   }
   return m_symtab_up.get();
 }
 
 bool ObjectFileMachO::IsStripped() {
   if (m_dysymtab.cmd == 0) {
     ModuleSP module_sp(GetModule());
if (process && m_header.filetype != llvm::MachO::MH_OBJECT &&
 
     nlist_data.SetData(m_data, symtab_load_command.symoff,
                        nlist_data_byte_size);
     strtab_data.SetData(m_data, symtab_load_command.stroff,
                         strtab_data_byte_size);
 
     // We shouldn't have exports data from both the LC_DYLD_INFO command
     // AND the LC_DYLD_EXPORTS_TRIE command in the same binary:
-    lldbassert(!((dyld_info.export_size > 0) 
+    lldbassert(!((dyld_info.export_size > 0)
                  && (exports_trie_load_command.datasize > 0)));
     if (dyld_info.export_size > 0) {
       dyld_trie_data.SetData(m_data, dyld_info.export_off,
                              dyld_info.export_size);
     } else if (exports_trie_load_command.datasize > 0) {
       dyld_trie_data.SetData(m_data, exports_trie_load_command.dataoff,
                              exports_trie_load_command.datasize);
     }

lldb/source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp

 Symtab *ObjectFilePECOFF::GetSymtab() {
   ModuleSP module_sp(GetModule());
   if (module_sp) {
     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
     if (m_symtab_up == nullptr) {
       ElapsedTime elapsed(module_sp->GetSymtabParseTime());
       SectionList *sect_list = GetSectionList();
       m_symtab_up = std::make_unique<Symtab>(this);
+      if (m_symtab_up->LoadFromCache())
+        return m_symtab_up.get();
       std::lock_guard<std::recursive_mutex> guard(m_symtab_up->GetMutex());
 
       const uint32_t num_syms = m_coff_header.nsyms;
 
       if (m_file && num_syms > 0 && m_coff_header.symoff > 0) {
         const uint32_t symbol_size = 18;
         const size_t symbol_data_size = num_syms * symbol_size;
         // Include the 4-byte string table size at the end of the symbols
if (m_symtab_up == nullptr) {
                               sect_list);
           symbols[i].GetMangled().SetValue(ConstString(symbol_name.c_str()));
           symbols[i].GetAddressRef() = symbol_addr;
           symbols[i].SetType(lldb::eSymbolTypeCode);
           symbols[i].SetDebug(true);
         }
       }
       m_symtab_up->CalculateSymbolSizes();
+      m_symtab_up->SaveToCache();
     }
   }
   return m_symtab_up.get();
 }
 
 std::unique_ptr<CallFrameInfo> ObjectFilePECOFF::CreateCallFrameInfo() {
   if (coff_data_dir_exception_table >= m_coff_header_opt.data_dirs.size())
     return {};

lldb/source/Symbol/CMakeLists.txt

LINK_LIBS
     lldbCore
     lldbExpression
     lldbHost
     lldbTarget
     lldbUtility
 
   LINK_COMPONENTS
     Support
+    DebugInfoGSYM
   )

lldb/source/Symbol/ObjectFile.cpp

 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/DataBuffer.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Timer.h"
 #include "lldb/lldb-private.h"
 
+#include "llvm/Support/DJB.h"
+
 using namespace lldb;
 using namespace lldb_private;
 
 char ObjectFile::ID;
 
 static ObjectFileSP
 CreateObjectFromContainer(const lldb::ModuleSP &module_sp, const FileSpec *file,
                           lldb::offset_t file_offset, lldb::offset_t file_size,
void llvm::format_provider<ObjectFile::Strata>::format(
   case ObjectFile::eStrataRawImage:
     OS << "raw image";
     break;
   case ObjectFile::eStrataJIT:
     OS << "jit";
     break;
   }
 }
+
+uint32_t ObjectFile::GetCacheHash() {
+  if (m_cache_hash)
+    return *m_cache_hash;
+  StreamString strm;
+  strm.Format("{0}-{1}-{2}", m_file, GetType(), GetStrata());
+  m_cache_hash = llvm::djbHash(strm.GetString());
+  return *m_cache_hash;
+}

lldb/source/Symbol/Symbol.cpp

 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Symbol/Symtab.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/Stream.h"
 
+#include "llvm/DebugInfo/GSYM/FileWriter.h"
+
 using namespace lldb;
 using namespace lldb_private;
 
 Symbol::Symbol()
     : SymbolContextScope(), m_type_data_resolved(false), m_is_synthetic(false),
       m_is_debug(false), m_is_external(false), m_size_is_sibling(false),
       m_size_is_synthesized(false), m_size_is_valid(false),
       m_demangled_is_synthesized(false), m_contains_linker_annotations(false),
if (m_is_synthetic && !m_mangled) {
     // sessions, to understand crashes in those symbols and to reliably set
     // breakpoints on them.
     llvm::SmallString<256> name;
     llvm::raw_svector_ostream os(name);
     os << GetSyntheticSymbolPrefix() << GetID();
     m_mangled.SetDemangledName(ConstString(os.str()));
   }
 }
+
+bool Symbol::Decode(const DataExtractor &data, lldb::offset_t *offset_ptr,
+                    const SectionList *section_list) {
+  if (!data.ValidOffsetForDataOfSize(*offset_ptr, 8))
+    return false;
+  m_uid = data.GetU32(offset_ptr);
+  m_type_data = data.GetU16(offset_ptr);
+  (&m_type_data)[1] = data.GetU16(offset_ptr);
+  if (!m_mangled.Decode(data, offset_ptr))
+    return false;
+  if (!data.ValidOffsetForDataOfSize(*offset_ptr, 20))
+    return false;
+  const bool is_addr = data.GetU8(offset_ptr) != 0;
+  const uint64_t value = data.GetU64(offset_ptr);
+  if (is_addr) {
+    m_addr_range.GetBaseAddress().ResolveAddressUsingFileSections(
+        value, section_list);
+  } else {
+    m_addr_range.GetBaseAddress().Clear();
+    m_addr_range.GetBaseAddress().SetOffset(value);
+  }
+  m_addr_range.SetByteSize(data.GetU64(offset_ptr));
+  m_flags =  data.GetU32(offset_ptr);
+  return true;
+}
+
+/// The encoding format for the symbol is as follows:
+///
+/// uint32_t m_uid;
+/// uint16_t m_type_data;
+/// uint16_t bitfield_data;
+/// Mangled mangled;
+/// uint8_t is_addr;
+/// uint64_t file_addr_or_value;
+/// uint64_t size;
+/// uint32_t flags;
+///
+/// The only tricky thing in this encoding is encoding all of the bits in the
+/// bitfields. We use a trick to store all bitfields as a 16 bit value and we
+/// do the same thing when decoding the symbol. There are test that ensure this
+/// encoding works for each individual bit. Everything else is very easy to
+/// store.
+void Symbol::Encode(llvm::gsym::FileWriter &file) const {
+  file.writeU32(m_uid);
+  file.writeU16(m_type_data);
+  file.writeU16((&m_type_data)[1]);
+  m_mangled.Encode(file);
+  // A symbol's value might be an address, or it might be a constant. If the
+  // symbol's base address doesn't have a section, then it is a constant value.
+  // If it does have a section, we will encode the file address and re-resolve
+  // the address when we decode it.
+  bool is_addr = m_addr_range.GetBaseAddress().GetSection().get() != NULL;
+  file.writeU8(is_addr);
+  file.writeU64(m_addr_range.GetBaseAddress().GetFileAddress());
+  file.writeU64(m_addr_range.GetByteSize());
+  file.writeU32(m_flags);
+}
+
+bool Symbol::operator==(const Symbol &rhs) const {
+  if (m_uid != rhs.m_uid)
+    return false;
+  if (m_type_data != rhs.m_type_data)
+    return false;
+  if (m_type_data_resolved != rhs.m_type_data_resolved)
+    return false;
+  if (m_is_synthetic != rhs.m_is_synthetic)
+    return false;
+  if (m_is_debug != rhs.m_is_debug)
+    return false;
+  if (m_is_external != rhs.m_is_external)
+    return false;
+  if (m_size_is_sibling != rhs.m_size_is_sibling)
+    return false;
+  if (m_size_is_synthesized != rhs.m_size_is_synthesized)
+    return false;
+  if (m_size_is_valid != rhs.m_size_is_valid)
+    return false;
+  if (m_demangled_is_synthesized != rhs.m_demangled_is_synthesized)
+    return false;
+  if (m_contains_linker_annotations != rhs.m_contains_linker_annotations)
+    return false;
+  if (m_is_weak != rhs.m_is_weak)
+    return false;
+  if (m_type != rhs.m_type)
+    return false;
+  if (m_mangled != rhs.m_mangled)
+    return false;
+  if (m_addr_range.GetBaseAddress() != rhs.m_addr_range.GetBaseAddress())
+    return false;
+  if (m_addr_range.GetByteSize() != rhs.m_addr_range.GetByteSize())
+    return false;
+  if (m_flags != rhs.m_flags)
+    return false;
+  return true;
+}

lldb/source/Symbol/Symtab.cpp

 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Symbol/Symtab.h"
 #include "lldb/Target/Language.h"
 #include "lldb/Utility/RegularExpression.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/Timer.h"
 
 #include "llvm/ADT/StringRef.h"
+#include "llvm/DebugInfo/GSYM/FileWriter.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 Symtab::Symtab(ObjectFile *objfile)
     : m_objfile(objfile), m_symbols(), m_file_addr_to_index(*this),
       m_name_to_symbol_indices(), m_mutex(),
       m_file_addr_to_index_computed(false), m_name_indexes_computed(false) {
for (uint32_t idx = child_idx - 1; idx != UINT32_MAX; --idx) {
       const Symbol *symbol = SymbolAtIndex(idx);
       const uint32_t sibling_idx = symbol->GetSiblingIndex();
       if (sibling_idx != UINT32_MAX && sibling_idx > child_idx)
         return symbol;
     }
   }
   return nullptr;
 }
+
+llvm::Optional<FileSpec> Symtab::GetSymtabCacheFile() {
+  // This function might return no path if caching is disabled or the module
+  // isn't suitable for caching.
+  if (auto file = m_objfile->GetModule()->GetCacheDirectory()) {
+    StreamString strm;
+    strm.Format("symtab-{0}", m_objfile->GetCacheHash());
+    FileSpec cache_file(*file);
+    cache_file.AppendPathComponent(strm.GetString());
+    return cache_file;
+  }
+  return llvm::None;
+}
+
+void Symtab::SaveToCache() {
+  using namespace llvm;
+  llvm::Optional<FileSpec> cache_file = GetSymtabCacheFile();
+  if (!cache_file)
+    return;
+  std::error_code strm_err;
+  raw_fd_ostream strm(cache_file->GetPath(), strm_err);
+  if (!strm_err) {
+    const auto byte_order = llvm::support::endian::system_endianness();
+    gsym::FileWriter file(strm, byte_order);
+    Encode(file);
+  }
+}
+
+#define CURRENT_CACHE_VERSION 1
+/// The encoding format for the symbol table is as follows:
+///
+/// uint32_t version;
+/// uint32_t num_symbols;
+/// std::vector<symbols>;
+///
+/// Symbol objects are encoded into the stream by encoding each symbol in the
+/// symbol table in the order they were contained in.
+void Symtab::Encode(llvm::gsym::FileWriter &file) const {
+  file.writeU32(CURRENT_CACHE_VERSION);
+  file.writeU32(m_symbols.size());
+  for (const auto &symbol: m_symbols)
+    symbol.Encode(file);
+}
+
+bool Symtab::Decode(const DataExtractor &data, lldb::offset_t *offset_ptr) {
+  if (!data.ValidOffsetForDataOfSize(*offset_ptr, 8))
+    return false;
+  const uint32_t version = data.GetU32(offset_ptr);
+  if (version != CURRENT_CACHE_VERSION)
+    return false;
+  const uint32_t num_symbols = data.GetU32(offset_ptr);
+  if (num_symbols == 0)
+    return true;
+  m_symbols.resize(num_symbols);
+  SectionList *sections = nullptr;
+  if (m_objfile)
+    sections = m_objfile->GetModule()->GetSectionList();
+  for (uint32_t i=0; i<num_symbols; ++i) {
+    if (!m_symbols[i].Decode(data, offset_ptr, sections))
+      return false;
+  }
+  return true;
+}
+
+bool Symtab::LoadFromCache() {
+  llvm::Optional<FileSpec> cache_file = GetSymtabCacheFile();
+  if (!cache_file)
+    return false;
+  if (!FileSystem::Instance().Exists(*cache_file))
+    return false;
+  auto data_sp = FileSystem::Instance().CreateDataBuffer(cache_file->GetPath());
+  if (!data_sp)
+    return false;
+  DataExtractor data(data_sp, m_objfile->GetByteOrder(),
+                     m_objfile->GetAddressByteSize());
+  lldb::offset_t offset = 0;
+  return Decode(data, &offset);
+}

lldb/test/API/functionalities/module_cache/bsd/Makefile

+C_SOURCES := main.c a.c b.c c.c
+EXE :=  # Define a.out explicitly
+MAKE_DSYM := NO
+
+all: a.out
+
+a.out: main.o libfoo.a
+  $(LD) $(LDFLAGS) $^ -o $@
+
+lib_ab.a: a.o b.o
+  $(AR) $(ARFLAGS) $@ $^
+  $(RM) $^
+
+# Here we make a .a file that has two a.o files with different modification
+# times and different content by first creating libfoo.a with only a.o and b.o,
+# then we sleep for 2 seconds, touch c.o to ensure it has a different
+# modification time, and then rename c.o to a.o and then add it to the .a file
+# again. This is to help test that the module cache will create different
+# directories for the two different a.o files.
+libfoo.a: lib_ab.a c.o
+  sleep 2
+  touch c.o
+  mv c.o a.o
+  $(AR) $(ARFLAGS) $@ lib_ab.a a.o
+  $(RM) a.o
+
+include Makefile.rules

lldb/test/API/functionalities/module_cache/bsd/TestModuleCacheBSD.py

+"""Test the LLDB module cache funcionality."""
+
+import glob
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+import os
+import time
+
+
+class ModuleCacheTestcase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    def setUp(self):
+        # Call super's setUp().
+        TestBase.setUp(self)
+        # Find the line number in a(int) to break at.
+        self.line_a = line_number(
+            'a.c', '// Set file and line breakpoint inside a().')
+        self.line_b = line_number(
+            'b.c', '// Set file and line breakpoint inside b().')
+        self.line_c = line_number(
+            'c.c', '// Set file and line breakpoint inside c().')
+        self.cache_dir = os.path.join(self.getBuildDir(), 'lldb-module-cache')
+        # Set the lldb module cache directory to a directory inside the build
+        # artifacts directory so no other tests are interfered with.
+        self.runCmd('settings set symbols.lldb-modules-cache-path "%s"' % (self.cache_dir))
+        self.runCmd('settings set symbols.enable-lldb-modules-cache true')
+        self.build()
+
+
+    def get_module_cache_dirs(self, basename, object):
+        module_cache_glob = os.path.join(self.cache_dir, basename, object, "*")
+        return glob.glob(module_cache_glob)
+
+
+    # Requires no dSYM, so we let the Makefile make the right stuff for us
+    @no_debug_info_test
+    @skipUnlessDarwin
+    def test(self):
+        """
+            Test module cache functionality for bsd archive object files.
+
+            This will test that if we enable the module cache, we have a
+            corresponding cache entry for the .o files in libfoo.a.
+
+            The static library has two entries for "a.o":
+            - one from a.c
+            - one from c.c which had c.o renamed to a.o and then put into the
+              libfoo.a as an extra .o file with different contents from the
+              original a.o
+
+            We do this to test that we can correctly cache duplicate .o files
+            that appear in .a files.
+
+            This test only works on darwin because of the way DWARF is stored
+            where the debug map will refer to .o files inside of .a files.
+        """
+        exe = self.getBuildArtifact("a.out")
+
+        # Create a module with no depedencies.
+        target = self.createTestTarget(load_dependent_modules=False)
+
+        self.runCmd('breakpoint set -f a.c -l %d' % (self.line_a))
+        self.runCmd('breakpoint set -f b.c -l %d' % (self.line_b))
+        self.runCmd('breakpoint set -f c.c -l %d' % (self.line_c))
+
+        # Get the executable module and get the number of symbols to make
+        # sure the symbol table gets parsed and cached. The module cache is
+        # enabled in the setUp() function.
+        main_module = target.GetModuleAtIndex(0)
+        self.assertTrue(main_module.IsValid())
+        # Make sure the symbol table gets loaded and cached
+        main_module.GetNumSymbols()
+        a_o_cache_dirs = self.get_module_cache_dirs("libfoo.a", "a.o")
+        b_o_cache_dirs = self.get_module_cache_dirs("libfoo.a", "b.o")
+        # We expect the directory for a.o to have two cache directories:
+        # - 1 for the a.o with a earlier mod time
+        # - 1 for the a.o that was renamed from c.o that should be 2 seconds older
+        self.assertEqual(len(a_o_cache_dirs), 2,
+                "make sure there are two files in the module cache directory for libfoo.a(a.o)")
+        self.assertEqual(len(b_o_cache_dirs), 1,
+                "make sure there are two files in the module cache directory for libfoo.a(b.o)")

lldb/test/API/functionalities/module_cache/bsd/a.c

+int __a_global = 1;
+
+int a(int arg) {
+    int result = arg + __a_global;
+    return result; // Set file and line breakpoint inside a().
+}

lldb/test/API/functionalities/module_cache/bsd/b.c

+static int __b_global = 2;
+
+int b(int arg) {
+    int result = arg + __b_global;
+    return result; // Set file and line breakpoint inside b().
+}

lldb/test/API/functionalities/module_cache/bsd/c.c

+static int __c_global = 3;
+
+int c(int arg) {
+    int result = arg + __c_global;
+    return result; // Set file and line breakpoint inside c().
+}

lldb/test/API/functionalities/module_cache/bsd/main.c

+#include <stdio.h>
+
+extern int a(int);
+extern int b(int);
+extern int c(int);
+int main (int argc, char const *argv[])
+{
+    printf ("a(1) returns %d\n", a(1));
+    printf ("b(2) returns %d\n", b(2));
+    printf ("c(2) returns %d\n", c(2));
+}

lldb/test/API/functionalities/module_cache/simple_exe/Makefile

+C_SOURCES := main.c
+
+include Makefile.rules

lldb/test/API/functionalities/module_cache/simple_exe/TestModuleCacheSimple.py

+"""Test the LLDB module cache funcionality."""
+
+import glob
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+import os
+import time
+
+
+class ModuleCacheTestcase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    def setUp(self):
+        # Call super's setUp().
+        TestBase.setUp(self)
+        # Find the line number in a(int) to break at.
+        self.cache_dir = os.path.join(self.getBuildDir(), 'lldb-module-cache')
+        # Set the lldb module cache directory to a directory inside the build
+        # artifacts directory so no other tests are interfered with.
+        self.runCmd('settings set symbols.lldb-modules-cache-path "%s"' % (self.cache_dir))
+        self.runCmd('settings set symbols.enable-lldb-modules-cache true')
+        self.build()
+
+
+    def get_module_cache_dir(self, basename):
+        module_cache_glob = os.path.join(self.cache_dir, basename, "*")
+        module_cache_files = glob.glob(module_cache_glob)
+        self.assertEqual(len(module_cache_files), 1,
+                "make sure the module cache has only 1 directory")
+        return module_cache_files[0]
+
+
+    # Doesn't depend on any specific debug information.
+    @no_debug_info_test
+    def test(self):
+        """
+            Test module cache functionality for a simple object file.
+
+            This will test that if we enable the module cache, we have a
+            corresponding cache entry for the executable with a "info.json" file
+            that has a modification time that matches that of the executable and
+            that there is a symbol table cache created as well. It also removes
+            the executable, rebuilds so that the modification time of the binary
+            gets updated, and then creates a new target and causes the cache to
+            get updated.
+        """
+        exe = self.getBuildArtifact("a.out")
+
+        # Create a module with no depedencies.
+        target = self.createTestTarget(load_dependent_modules=False)
+
+        # Get the executable module and get the number of symbols to make
+        # sure the symbol table gets parsed and cached. The module cache is
+        # enabled in the setUp() function.
+        main_module = target.GetModuleAtIndex(0)
+        self.assertTrue(main_module.IsValid())
+        # Make sure the symbol table gets loaded and cached
+        main_module.GetNumSymbols()
+        cache_dir = self.get_module_cache_dir("a.out")
+        cache_dir_files = os.listdir(cache_dir)
+        self.assertEqual(len(cache_dir_files), 2,
+                "make sure there are two files in the module cache directory")
+        # Make sure the "info.json" file is in the cache directory
+        info_json_path = None
+        symtab_cache_path = None
+        found_info_json = False
+        found_symtab_cache = False
+        for basename in cache_dir_files:
+            if basename == "info.json":
+                found_info_json = True
+                info_json_path = os.path.join(cache_dir, basename)
+            if basename.startswith("symtab-"):
+                found_symtab_cache = True
+                symtab_cache_path = os.path.join(cache_dir, basename)
+
+        self.assertEqual(found_info_json, True,
+                         "check for info.json in executable cache dir")
+        self.assertEqual(found_symtab_cache, True,
+                         "check for info.json in executable cache dir")
+        exe_mtime_1 = os.path.getmtime(exe)
+        info_mtime_1 = os.path.getmtime(info_json_path)
+        symtab_mtime_1 = os.path.getmtime(symtab_cache_path)
+        self.assertEqual(exe_mtime_1,
+                         info_mtime_1,
+                         "check that the 'info.json' modification time matches the executable modification time")
+        # Now remove the executable and sleep for a few seconds to make sure we
+        # get a different creation and modification time for the file since some
+        # OSs store the modification time in seconds since Jan 1, 1970.
+        os.remove(exe)
+        self.assertEqual(os.path.exists(exe), False,
+                         'make sure we were able to remove the executable')
+        time.sleep(2)
+        # Now rebuild the binary so it has a different modification time.
+        self.build()
+        self.assertEqual(os.path.exists(exe), True,
+                         'make sure executable exists after rebuild')
+        # Make sure the modification time has changed or this test will fail.
+        exe_mtime_2 = os.path.getmtime(exe)
+        self.assertNotEqual(
+                exe_mtime_1,
+                exe_mtime_2,
+                "make sure the modification time of the executable has changed")
+        # Makre sure the module cache still has an out of date cache.
+        self.assertNotEqual(exe_mtime_2,
+                            os.path.getmtime(info_json_path),
+                            "check that the 'info.json' modification time doesn't match the executable modification time after rebuild")
+        # Create a new target and get the symbols again, and make sure the cache
+        # gets updated. All files in the module cache except the "info.json"
+        # file should get deleted and re-created.
+        target = self.createTestTarget(load_dependent_modules=False)
+        main_module = target.GetModuleAtIndex(0)
+        self.assertTrue(main_module.IsValid())
+        main_module.GetNumSymbols()
+        self.assertEqual(os.path.exists(info_json_path), True,
+                         'make sure "info.json" exists after cache is updated')
+        self.assertEqual(os.path.exists(symtab_cache_path), True,
+                         'make sure "info.json" exists after cache is updated')
+
+        info_mtime_2 = os.path.getmtime(info_json_path)
+        symtab_mtime_2 = os.path.getmtime(symtab_cache_path)
+
+        self.assertNotEqual(
+                info_mtime_1,
+                info_mtime_2,
+                'make sure modification time of "info.json" changed')
+        self.assertNotEqual(
+                symtab_mtime_1,
+                symtab_mtime_2,
+                'make sure modification time of "symtab-..." changed')
+        self.assertEqual(
+                info_mtime_2,
+                exe_mtime_2,
+                "check that the 'info.json' modification time matches the executable modification time after rebuild and cache update")

lldb/test/API/functionalities/module_cache/simple_exe/main.c

+int main (int argc, char const *argv[]) {
+}

lldb/test/API/functionalities/module_cache/universal/Makefile

+EXE := testit
+
+include Makefile.rules
+
+all: testit
+
+testit: testit.x86_64 testit.arm64
+  lipo -create -o testit $^
+
+testit.arm64: testit.arm64.o
+  $(CC) -isysroot $(SDKROOT) -target arm64-apple-macosx10.9 -o testit.arm64 $<
+
+testit.x86_64: testit.x86_64.o
+  $(CC) -isysroot $(SDKROOT) -target x86_64-apple-macosx10.9 -o testit.x86_64 $<
+
+testit.arm64.o: main.c
+  $(CC) -isysroot $(SDKROOT) -g -O0 -target arm64-apple-macosx10.9 -c -o testit.arm64.o $<
+
+testit.x86_64.o: main.c
+  $(CC) -isysroot $(SDKROOT) -g -O0 -target x86_64-apple-macosx10.9 -c -o testit.x86_64.o $<

lldb/test/API/functionalities/module_cache/universal/TestModuleCacheUniversal.py

+"""Test the LLDB module cache funcionality for universal mach-o files."""
+
+import glob
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+import os
+import time
+
+
+class ModuleCacheTestcaseUniversal(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    def setUp(self):
+        # Call super's setUp().
+        TestBase.setUp(self)
+        # Find the line number in a(int) to break at.
+        self.cache_dir = os.path.join(self.getBuildDir(), 'lldb-module-cache')
+        print('build-dir: ' + self.getBuildDir())
+        # Set the lldb module cache directory to a directory inside the build
+        # artifacts directory so no other tests are interfered with.
+        self.runCmd('settings set symbols.lldb-modules-cache-path "%s"' % (self.cache_dir))
+        self.runCmd('settings set symbols.enable-lldb-modules-cache true')
+        self.build()
+
+
+    def get_module_cache_dirs(self, basename):
+        module_cache_glob = os.path.join(self.cache_dir, basename, "*")
+        return glob.glob(module_cache_glob)
+
+
+    # Doesn't depend on any specific debug information.
+    @no_debug_info_test
+    @skipUnlessDarwin
+    @skipIfDarwinEmbedded # this test file assumes we're targetting an x86 system
+    def test(self):
+        """
+            Test module cache functionality for a universal mach-o files.
+
+            This will test that if we enable the module cache, we can create
+            lldb module caches for each slice of a universal mach-o file and
+            they will each have a unique directory.
+        """
+        exe_basename = "testit"
+        exe = self.getBuildArtifact(exe_basename)
+
+        # Create a module with no depedencies.
+        self.runCmd('target create -d --arch x86_64 %s' % (exe))
+        self.runCmd('image dump symtab %s' % (exe_basename))
+        self.runCmd('target create -d --arch arm64 %s' % (exe))
+        self.runCmd('image dump symtab %s' % (exe_basename))
+
+        cache_dirs = self.get_module_cache_dirs(exe_basename)
+
+        self.assertEqual(len(cache_dirs), 2,
+                "make sure there are two files in the module cache directory for %s" % (exe_basename))

lldb/test/API/functionalities/module_cache/universal/main.c

 #include <stdio.h>
 #include <unistd.h>
 #include <string.h>
 
 void
 call_me()
 {
   sleep(1);
 }
 
 int
 main (int argc, char **argv)
 {
   printf ("Hello there!\n"); // Set break point at this line.
   if (argc == 2 && strcmp(argv[1], "keep_waiting") == 0)
     while (1)
       {
         call_me();
       }
   return 0;
 }

lldb/test/API/macosx/universal/main.c

-#include <stdio.h>
-#include <unistd.h>
-#include <string.h>
-
-void
-call_me()
-{
-  sleep(1);
-}
-
-int
-main (int argc, char **argv)
-{
-  printf ("Hello there!\n"); // Set break point at this line.
-  if (argc == 2 && strcmp(argv[1], "keep_waiting") == 0)
-    while (1)
-      {
-        call_me();
-      }
+int main (int argc, char **argv) {
   return 0;
 }

lldb/unittests/Symbol/CMakeLists.txt

 add_lldb_unittest(SymbolTests
   LocateSymbolFileTest.cpp
   PostfixExpressionTest.cpp
+  SymbolTest.cpp
   TestTypeSystem.cpp
   TestTypeSystemClang.cpp
   TestClangASTImporter.cpp
   TestDWARFCallFrameInfo.cpp
   TestType.cpp
   TestLineEntry.cpp
 
   LINK_LIBS

lldb/unittests/Symbol/SymbolTest.cpp

+//===-- SymbolTest.cpp ----------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "gtest/gtest.h"
+
+#include "lldb/Core/Section.h"
+#include "lldb/Symbol/Symbol.h"
+#include "lldb/Symbol/Symtab.h"
+#include "lldb/Utility/DataExtractor.h"
+
+#include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/DebugInfo/GSYM/FileWriter.h"
+#include "llvm/Support/raw_ostream.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+static llvm::support::endianness GetLLVMByteOrder(bool little_endian) {
+  return little_endian ? llvm::support::little : llvm::support::big;
+}
+
+static ByteOrder GetLLDBByteOrder(bool little_endian) {
+  return little_endian ? eByteOrderLittle : eByteOrderBig;
+}
+
+static void EncodeDecode(const Symbol &object, const SectionList *sect_list,
+                         bool little_endian) {
+  llvm::SmallString<512> str;
+  llvm::raw_svector_ostream strm(str);
+  llvm::gsym::FileWriter file(strm, GetLLVMByteOrder(little_endian));
+  object.Encode(file);
+  llvm::StringRef bytes = strm.str();
+  DataExtractor data(bytes.data(), bytes.size(),
+                     GetLLDBByteOrder(little_endian), 4);
+  Symbol decoded_object;
+  offset_t data_offset = 0;
+  decoded_object.Decode(data, &data_offset, sect_list);
+  EXPECT_EQ(object, decoded_object);
+}
+
+static void EncodeDecode(const Symbol &object, const SectionList *sect_list) {
+  EncodeDecode(object, sect_list, /*little_endian=*/true);
+  EncodeDecode(object, sect_list, /*little_endian=*/false);
+}
+
+TEST(SymbolTest, EncodeDecodeSymbol) {
+
+  SectionSP sect_sp(new Section(
+      /*module_sp=*/ModuleSP(),
+      /*obj_file=*/nullptr,
+      /*sect_id=*/1,
+      /*name=*/ConstString(".text"),
+      /*sect_type=*/eSectionTypeCode,
+      /*file_vm_addr=*/0x1000,
+      /*vm_size=*/0x1000,
+      /*file_offset=*/0,
+      /*file_size=*/0,
+      /*log2align=*/5,
+      /*flags=*/0x10203040));
+
+  SectionList sect_list;
+  sect_list.AddSection(sect_sp);
+
+  Symbol symbol(
+      /*symID=*/0x10203040,
+      /*name=*/"main",
+      /*type=*/eSymbolTypeCode,
+      /*bool external=*/false,
+      /*bool is_debug=*/false,
+      /*bool is_trampoline=*/false,
+      /*bool is_artificial=*/false,
+      /*section_sp=*/sect_sp,
+      /*offset=*/0x0,
+      /*size=*/0x100,
+      /*size_is_valid=*/true,
+      /*contains_linker_annotations=*/false,
+      /*flags=*/0x11223344);
+
+  // Test encoding a symbol with an address.
+  EncodeDecode(symbol, &sect_list);
+
+  // Test that encoding the bits in the bitfield works for all endianness
+  // combos.
+
+  // Test Symbol.m_is_synthetic
+  symbol.SetIsSynthetic(true);
+  EncodeDecode(symbol, &sect_list);
+  symbol.SetIsSynthetic(false);
+
+  // Test Symbol.m_is_debug
+  symbol.SetDebug(true);
+  EncodeDecode(symbol, &sect_list);
+  symbol.SetDebug(false);
+
+  // Test Symbol.m_is_external
+  symbol.SetExternal(true);
+  EncodeDecode(symbol, &sect_list);
+  symbol.SetExternal(false);
+
+  // Test Symbol.m_size_is_sibling
+  symbol.SetSizeIsSibling(true);
+  EncodeDecode(symbol, &sect_list);
+  symbol.SetSizeIsSibling(false);
+
+  // Test Symbol.m_size_is_synthesized
+  symbol.SetSizeIsSynthesized(true);
+  EncodeDecode(symbol, &sect_list);
+  symbol.SetSizeIsSynthesized(false);
+
+  // Test Symbol.m_size_is_synthesized
+  symbol.SetByteSize(0);
+  EncodeDecode(symbol, &sect_list);
+  symbol.SetByteSize(0x100);
+
+  // Test Symbol.m_demangled_is_synthesized
+  symbol.SetDemangledNameIsSynthesized(true);
+  EncodeDecode(symbol, &sect_list);
+  symbol.SetDemangledNameIsSynthesized(false);
+
+  // Test Symbol.m_contains_linker_annotations
+  symbol.SetContainsLinkerAnnotations(true);
+  EncodeDecode(symbol, &sect_list);
+  symbol.SetContainsLinkerAnnotations(false);
+
+  // Test Symbol.m_is_weak
+  symbol.SetIsWeak(true);
+  EncodeDecode(symbol, &sect_list);
+  symbol.SetIsWeak(false);
+
+  // Test encoding a symbol with no address.
+  symbol.GetAddressRef().SetSection(SectionSP());
+  EncodeDecode(symbol, &sect_list);
+}
+
+static void EncodeDecode(const Mangled &object, bool little_endian) {
+  llvm::SmallString<512> str;
+  llvm::raw_svector_ostream strm(str);
+  llvm::gsym::FileWriter file(strm, GetLLVMByteOrder(little_endian));
+  object.Encode(file);
+  llvm::StringRef bytes = strm.str();
+  DataExtractor data(bytes.data(), bytes.size(),
+                     GetLLDBByteOrder(little_endian), 4);
+  Mangled decoded_object;
+  offset_t data_offset = 0;
+  decoded_object.Decode(data, &data_offset);
+  EXPECT_EQ(object, decoded_object);
+}
+
+static void EncodeDecode(const Mangled &object) {
+  EncodeDecode(object, /*little_endian=*/true);
+  EncodeDecode(object, /*little_endian=*/false);
+}
+
+TEST(SymbolTest, EncodeDecodeMangled) {
+  Mangled mangled;
+  // Test encoding and decoding an empty mangled object.
+  EncodeDecode(mangled);
+
+  // Test encoding a mangled object that hasn't demangled its name yet.
+  mangled.SetMangledName(ConstString("_Z3fooi"));
+  EncodeDecode(mangled);
+
+  // Test encoding a mangled object that has demangled its name by computing it.
+  mangled.GetDemangledName();
+  // EncodeDecode(mangled);
+
+  // Test encoding a mangled object that has just a demangled name
+  mangled.SetMangledName(ConstString());
+  mangled.SetDemangledName(ConstString("hello"));
+  EncodeDecode(mangled);
+
+  // Test encoding a mangled name that has both a mangled and demangled name
+  // that are not mangled/demangled counterparts of each other.
+  mangled.SetMangledName(ConstString("world"));
+  EncodeDecode(mangled);
+}
+
+static void EncodeDecode(const Symtab &object, bool little_endian) {
+  llvm::SmallString<512> str;
+  llvm::raw_svector_ostream strm(str);
+  llvm::gsym::FileWriter file(strm, GetLLVMByteOrder(little_endian));
+  object.Encode(file);
+  llvm::StringRef bytes = strm.str();
+  DataExtractor data(bytes.data(), bytes.size(),
+                     GetLLDBByteOrder(little_endian), 4);
+  Symtab decoded_object(nullptr);
+  offset_t data_offset = 0;
+  decoded_object.Decode(data, &data_offset);
+  ASSERT_EQ(object.GetNumSymbols(), decoded_object.GetNumSymbols());
+  for (size_t i = 0; i < object.GetNumSymbols(); ++i)
+    EXPECT_EQ(*object.SymbolAtIndex(i), *decoded_object.SymbolAtIndex(i));
+}
+
+static void EncodeDecode(const Symtab &object) {
+  EncodeDecode(object, /*little_endian=*/true);
+  EncodeDecode(object, /*little_endian=*/false);
+}
+
+TEST(SymbolTest, EncodeDecodeSymtab) {
+  Symtab symtab(/*objfile=*/nullptr);
+
+  Symbol symbol1(
+      /*symID=*/1,
+      /*name=*/"symbol1",
+      /*type=*/eSymbolTypeCode,
+      /*bool external=*/false,
+      /*bool is_debug=*/false,
+      /*bool is_trampoline=*/false,
+      /*bool is_artificial=*/false,
+      /*section_sp=*/SectionSP(),
+      /*value=*/0x1001101010000000,
+      /*size=*/0,
+      /*size_is_valid=*/false,
+      /*contains_linker_annotations=*/false,
+      /*flags=*/0x10011010);
+
+  Symbol symbol2(
+      /*symID=*/2,
+      /*name=*/"symbol2",
+      /*type=*/eSymbolTypeData,
+      /*bool external=*/false,
+      /*bool is_debug=*/false,
+      /*bool is_trampoline=*/false,
+      /*bool is_artificial=*/false,
+      /*section_sp=*/SectionSP(),
+      /*value=*/0x2002202020000000,
+      /*size=*/0,
+      /*size_is_valid=*/false,
+      /*contains_linker_annotations=*/false,
+      /*flags=*/0x20022020);
+
+  Symbol symbol3(
+      /*symID=*/3,
+      /*name=*/"symbol3",
+      /*type=*/eSymbolTypeCode,
+      /*bool external=*/false,
+      /*bool is_debug=*/false,
+      /*bool is_trampoline=*/false,
+      /*bool is_artificial=*/false,
+      /*section_sp=*/SectionSP(),
+      /*value=*/0x3003303030000000,
+      /*size=*/0,
+      /*size_is_valid=*/false,
+      /*contains_linker_annotations=*/false,
+      /*flags=*/0x30033030);
+
+  // Test encoding and decoding an empty symbol table.
+  EncodeDecode(symtab);
+
+  symtab.AddSymbol(symbol1);
+  symtab.AddSymbol(symbol2);
+  symtab.AddSymbol(symbol3);
+  // Test encoding and decoding a symbol table with 3 symbols.
+  EncodeDecode(symtab);
+}