[lldb] Add a SymbolFileProvider to record and replay calls to dsymForUUID

[JDevlieghere]

Summary

When replaying a reproducer captured from a core file, we always use dsymForUUID for the kernel binary. When enabled, we also use it to find kexts. Since these files are already contained in the reproducer, there's no reason to call out to an external tool. If the tool returns a different result, e.g. because the dSYM got garbage collected, it will break reproducer replay. The SymbolFileProvider solves the issue by mapping UUIDs to module and symbol paths in the reproducer.

[JDevlieghere]

I wasn't sure how to test this but Jason told me I can set LLDB_APPLE_DSYMFORUUID_EXECUTABLE.

[JDevlieghere]

• Add test.
• Implement dump method.

Unfortunately, the yaml2obj roundtrip does not preserve the UUID, so the test uses the binary.

[jasonmolenda]

Looks good!

[teemperor]

Pretty sure this broke some tests http://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake/23476/

Note: Google Test filter = SymbolsTest.LocateExecutableSymbolFileForUnknownExecutableAndMissingSymbolFile
[==========] Running 1 test from 1 test case.
[----------] Global test environment set-up.
[----------] 1 test from SymbolsTest
[ RUN      ] SymbolsTest.LocateExecutableSymbolFileForUnknownExecutableAndMissingSymbolFile
Assertion failed: (hasVal), function getValue, file /Users/buildslave/jenkins/workspace/lldb-cmake@2/llvm-project/llvm/include/llvm/ADT/Optional.h, line 73.
0  SymbolTests              0x000000010943f8a5 llvm::sys::PrintStackTrace(llvm::raw_ostream&) + 37
1  SymbolTests              0x000000010943e836 llvm::sys::RunSignalHandlers() + 198
2  SymbolTests              0x000000010943fe86 SignalHandler(int) + 262
3  libsystem_platform.dylib 0x00007fff6e8b35fd _sigtramp + 29
4  libsystem_platform.dylib 0xaaaaaaaaaaaaaaaa _sigtramp + 12297688647425029322
5  libsystem_c.dylib        0x00007fff6e785808 abort + 120
6  libsystem_c.dylib        0x00007fff6e784ac6 err + 0
7  SymbolTests              0x000000010a8f0bf5 lldb_private::repro::Reproducer::Instance() + 133
8  SymbolTests              0x00000001094a7261 LocateMacOSXFilesUsingDebugSymbols(lldb_private::ModuleSpec const&, lldb_private::ModuleSpec&) + 433
9  SymbolTests              0x00000001094894dd lldb_private::Symbols::LocateExecutableSymbolFile(lldb_private::ModuleSpec const&, lldb_private::FileSpecList const&) + 5741
10 SymbolTests              0x000000010932f232 SymbolsTest_LocateExecutableSymbolFileForUnknownExecutableAndMissingSymbolFile_Test::TestBody() + 274
11 SymbolTests              0x000000010944869f testing::Test::Run() + 527
12 SymbolTests              0x0000000109449516 testing::TestInfo::Run() + 566
13 SymbolTests              0x0000000109449d47 testing::TestCase::Run() + 247
14 SymbolTests              0x0000000109452877 testing::internal::UnitTestImpl::RunAllTests() + 1287
15 SymbolTests              0x00000001094522fb testing::UnitTest::Run() + 171
16 SymbolTests              0x0000000109441209 main + 121
17 libdyld.dylib            0x00007fff6e6b6cc9 start + 1
18 libdyld.dylib            0x0000000000000002 start + 18446603338663629626

[teemperor]

Seems like this were just some missing calls to initialize/terminate. I added them in an ugly hotfix commit.

lldb/include/lldb/Utility/Reproducer.h

 #include "llvm/Support/YAMLTraits.h"
 
 #include <mutex>
 #include <string>
 #include <utility>
 #include <vector>
 
 namespace lldb_private {
+class UUID;
 namespace repro {
 
 class Reproducer;
 
 enum class ReproducerMode {
   Capture,
   Replay,
   PassiveReplay,

lldb/include/lldb/Utility/ReproducerProvider.h

 //===-- Reproducer.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_UTILITY_REPRODUCER_PROVIDER_H
 #define LLDB_UTILITY_REPRODUCER_PROVIDER_H
 
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/ProcessInfo.h"
 #include "lldb/Utility/Reproducer.h"
+#include "lldb/Utility/UUID.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/FileCollector.h"
 #include "llvm/Support/YAMLTraits.h"
 
 #include <string>
 #include <utility>
 #include <vector>
public:
   }
   struct Info {
     static const char *name;
     static const char *file;
   };
   static char ID;
 };
 
+/// Provider for mapping UUIDs to symbol and executable files.
+class SymbolFileProvider : public Provider<SymbolFileProvider> {
+public:
+  SymbolFileProvider(const FileSpec &directory)
+      : Provider(directory), m_symbol_files() {}
+
+  void AddSymbolFile(const UUID *uuid, const FileSpec &module_path,
+                     const FileSpec &symbol_path);
+  void Keep() override;
+
+  struct Entry {
+    Entry() = default;
+    Entry(std::string uuid) : uuid(std::move(uuid)) {}
+    Entry(std::string uuid, std::string module_path, std::string symbol_path)
+        : uuid(std::move(uuid)), module_path(std::move(module_path)),
+          symbol_path(std::move(symbol_path)) {}
+
+    bool operator==(const Entry &rhs) const { return uuid == rhs.uuid; }
+    bool operator<(const Entry &rhs) const { return uuid < rhs.uuid; }
+
+    std::string uuid;
+    std::string module_path;
+    std::string symbol_path;
+  };
+
+  struct Info {
+    static const char *name;
+    static const char *file;
+  };
+  static char ID;
+
+private:
+  std::vector<Entry> m_symbol_files;
+};
+
 /// The MultiProvider is a provider that hands out recorder which can be used
 /// to capture data for different instances of the same object. The recorders
 /// can be passed around or stored as an instance member.
 ///
 /// The Info::file for the MultiProvider contains an index of files for every
 /// recorder. Use the MultiLoader to read the index and get the individual
 /// files.
 template <typename T, typename V>
llvm::Optional<std::string> GetNextFile() {
     return m_files[m_index++];
   }
 
 private:
   std::vector<std::string> m_files;
   unsigned m_index = 0;
 };
 
+class SymbolFileLoader {
+public:
+  SymbolFileLoader(Loader *loader);
+  std::pair<FileSpec, FileSpec> GetPaths(const UUID *uuid) const;
+
+private:
+  // Sorted list of UUID to path mappings.
+  std::vector<SymbolFileProvider::Entry> m_symbol_files;
+};
+
 /// Helper to read directories written by the DirectoryProvider.
 template <typename T>
 llvm::Expected<std::string> GetDirectoryFrom(repro::Loader *loader) {
   llvm::Expected<std::string> dir = loader->LoadBuffer<T>();
   if (!dir)
     return dir.takeError();
   return std::string(llvm::StringRef(*dir).rtrim());
 }
 
 } // namespace repro
 } // namespace lldb_private
 
+LLVM_YAML_IS_SEQUENCE_VECTOR(lldb_private::repro::SymbolFileProvider::Entry)
+
+namespace llvm {
+namespace yaml {
+template <>
+struct MappingTraits<lldb_private::repro::SymbolFileProvider::Entry> {
+  static void mapping(IO &io,
+                      lldb_private::repro::SymbolFileProvider::Entry &entry) {
+    io.mapRequired("uuid", entry.uuid);
+    io.mapRequired("module-path", entry.module_path);
+    io.mapRequired("symbol-path", entry.symbol_path);
+  }
+};
+} // namespace yaml
+} // namespace llvm
+
 #endif // LLDB_UTILITY_REPRODUCER_PROVIDER_H

lldb/source/Commands/CommandObjectReproducer.cpp

 using namespace lldb;
 using namespace llvm;
 using namespace lldb_private;
 using namespace lldb_private::repro;
 
 enum ReproducerProvider {
   eReproducerProviderCommands,
   eReproducerProviderFiles,
+  eReproducerProviderSymbolFiles,
   eReproducerProviderGDB,
   eReproducerProviderProcessInfo,
   eReproducerProviderVersion,
   eReproducerProviderWorkingDirectory,
   eReproducerProviderHomeDirectory,
   eReproducerProviderNone
 };
 
 static constexpr OptionEnumValueElement g_reproducer_provider_type[] = {
     {
         eReproducerProviderCommands,
         "commands",
         "Command Interpreter Commands",
     },
     {
         eReproducerProviderFiles,
         "files",
         "Files",
     },
     {
+        eReproducerProviderSymbolFiles,
+        "symbol-files",
+        "Symbol Files",
+    },
+    {
         eReproducerProviderGDB,
         "gdb",
         "GDB Remote Packets",
     },
     {
         eReproducerProviderProcessInfo,
         "processes",
         "Process Info",
case eReproducerProviderFiles: {
       static_cast<vfs::RedirectingFileSystem &>(*vfs).dump(os);
       os.flush();
 
       // Return the string.
       result.AppendMessage(str);
       result.SetStatus(eReturnStatusSuccessFinishResult);
       return true;
     }
+    case eReproducerProviderSymbolFiles: {
+      Expected<std::string> symbol_files =
+          loader->LoadBuffer<SymbolFileProvider>();
+      if (!symbol_files) {
+        SetError(result, symbol_files.takeError());
+        return false;
+      }
+
+      std::vector<SymbolFileProvider::Entry> entries;
+      llvm::yaml::Input yin(*symbol_files);
+      yin >> entries;
+
+      for (const auto &entry : entries) {
+        result.AppendMessageWithFormat("- uuid:        %s\n",
+                                       entry.uuid.c_str());
+        result.AppendMessageWithFormat("  module path: %s\n",
+                                       entry.module_path.c_str());
+        result.AppendMessageWithFormat("  symbol path: %s\n",
+                                       entry.symbol_path.c_str());
+      }
+      result.SetStatus(eReturnStatusSuccessFinishResult);
+      return true;
+    }
     case eReproducerProviderVersion: {
       Expected<std::string> version = loader->LoadBuffer<VersionProvider>();
       if (!version) {
         SetError(result, version.takeError());
         return false;
       }
       result.AppendMessage(*version);
       result.SetStatus(eReturnStatusSuccessFinishResult);

lldb/source/Symbol/LocateSymbolFile.cpp

 #include "lldb/Core/ModuleList.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/DataBuffer.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/Reproducer.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/Timer.h"
 #include "lldb/Utility/UUID.h"
 
 #include "llvm/Support/FileSystem.h"
 
 // From MacOSX system header "mach/machine.h"
 typedef int cpu_type_t;
static FileSpec LocateExecutableSymbolFileDsym(const ModuleSpec &module_spec) {
   // First try and find the dSYM in the same directory as the executable or in
   // an appropriate parent directory
   if (!LocateDSYMInVincinityOfExecutable(module_spec, symbol_fspec)) {
     // We failed to easily find the dSYM above, so use DebugSymbols
     LocateMacOSXFilesUsingDebugSymbols(module_spec, dsym_module_spec);
   } else {
     dsym_module_spec.GetSymbolFileSpec() = symbol_fspec;
   }
+
   return dsym_module_spec.GetSymbolFileSpec();
 }
 
 ModuleSpec Symbols::LocateExecutableObjectFile(const ModuleSpec &module_spec) {
   ModuleSpec result;
   const FileSpec &exec_fspec = module_spec.GetFileSpec();
   const ArchSpec *arch = module_spec.GetArchitecturePtr();
   const UUID *uuid = module_spec.GetUUIDPtr();
   static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
   Timer scoped_timer(
       func_cat, "LocateExecutableObjectFile (file = %s, arch = %s, uuid = %p)",
       exec_fspec ? exec_fspec.GetFilename().AsCString("<NULL>") : "<NULL>",
       arch ? arch->GetArchitectureName() : "<NULL>", (const void *)uuid);
 
   ModuleSpecList module_specs;
   ModuleSpec matched_module_spec;
   if (exec_fspec &&
       ObjectFile::GetModuleSpecifications(exec_fspec, 0, 0, module_specs) &&
       module_specs.FindMatchingModuleSpec(module_spec, matched_module_spec)) {
     result.GetFileSpec() = exec_fspec;
   } else {
     LocateMacOSXFilesUsingDebugSymbols(module_spec, result);
   }
+
   return result;
 }
 
 // Keep "symbols.enable-external-lookup" description in sync with this function.
 
 FileSpec
 Symbols::LocateExecutableSymbolFile(const ModuleSpec &module_spec,
                                     const FileSpecList &default_search_paths) {

lldb/source/Symbol/LocateSymbolFileMacOSX.cpp

 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/DataBuffer.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/ReproducerProvider.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/Timer.h"
 #include "lldb/Utility/UUID.h"
 #include "mach/machine.h"
 
 #include "llvm/ADT/ScopeExit.h"
 #include "llvm/Support/FileSystem.h"
 
if (!ModuleList::GetGlobalModuleListProperties().GetEnableExternalLookup()) {
     LLDB_LOGF(log, "Spotlight lookup for .dSYM bundles is disabled.");
     return 0;
   }
 
   return_module_spec = module_spec;
   return_module_spec.GetFileSpec().Clear();
   return_module_spec.GetSymbolFileSpec().Clear();
 
+  const UUID *uuid = module_spec.GetUUIDPtr();
+  const ArchSpec *arch = module_spec.GetArchitecturePtr();
+
+  if (repro::Loader *l = repro::Reproducer::Instance().GetLoader()) {
+    static repro::SymbolFileLoader symbol_file_loader(l);
+    std::pair<FileSpec, FileSpec> paths = symbol_file_loader.GetPaths(uuid);
+    return_module_spec.GetFileSpec() = paths.first;
+    return_module_spec.GetSymbolFileSpec() = paths.second;
+    return 1;
+  }
+
   int items_found = 0;
 
   if (g_dlsym_DBGCopyFullDSYMURLForUUID == nullptr ||
       g_dlsym_DBGCopyDSYMPropertyLists == nullptr) {
     void *handle = dlopen ("/System/Library/PrivateFrameworks/DebugSymbols.framework/DebugSymbols", RTLD_LAZY | RTLD_LOCAL);
     if (handle) {
       g_dlsym_DBGCopyFullDSYMURLForUUID = (CFURLRef (*)(CFUUIDRef, CFURLRef)) dlsym (handle, "DBGCopyFullDSYMURLForUUID");
       g_dlsym_DBGCopyDSYMPropertyLists = (CFDictionaryRef (*)(CFURLRef)) dlsym (handle, "DBGCopyDSYMPropertyLists");
     }
   }
 
   if (g_dlsym_DBGCopyFullDSYMURLForUUID == nullptr ||
       g_dlsym_DBGCopyDSYMPropertyLists == nullptr) {
     return items_found;
   }
 
-  const UUID *uuid = module_spec.GetUUIDPtr();
-  const ArchSpec *arch = module_spec.GetArchitecturePtr();
-
   if (uuid && uuid->IsValid()) {
     // Try and locate the dSYM file using DebugSymbols first
     llvm::ArrayRef<uint8_t> module_uuid = uuid->GetBytes();
     if (module_uuid.size() == 16) {
       CFCReleaser<CFUUIDRef> module_uuid_ref(::CFUUIDCreateWithBytes(
           NULL, module_uuid[0], module_uuid[1], module_uuid[2], module_uuid[3],
           module_uuid[4], module_uuid[5], module_uuid[6], module_uuid[7],
           module_uuid[8], module_uuid[9], module_uuid[10], module_uuid[11],
if (module_uuid.size() == 16) {
               }
             }
           }
         }
       }
     }
   }
 
+  if (repro::Generator *g = repro::Reproducer::Instance().GetGenerator()) {
+    g->GetOrCreate<repro::SymbolFileProvider>().AddSymbolFile(
+        uuid, return_module_spec.GetFileSpec(),
+        return_module_spec.GetSymbolFileSpec());
+  }
+
   return items_found;
 }
 
 FileSpec Symbols::FindSymbolFileInBundle(const FileSpec &dsym_bundle_fspec,
                                          const lldb_private::UUID *uuid,
                                          const ArchSpec *arch) {
   std::string dsym_bundle_path = dsym_bundle_fspec.GetPath();
   llvm::SmallString<128> buffer(dsym_bundle_path);

 }
 
 bool Symbols::DownloadObjectAndSymbolFile(ModuleSpec &module_spec,
                                           bool force_lookup) {
   bool success = false;
   const UUID *uuid_ptr = module_spec.GetUUIDPtr();
   const FileSpec *file_spec_ptr = module_spec.GetFileSpecPtr();
 
+  if (repro::Loader *l = repro::Reproducer::Instance().GetLoader()) {
+    static repro::SymbolFileLoader symbol_file_loader(l);
+    std::pair<FileSpec, FileSpec> paths = symbol_file_loader.GetPaths(uuid_ptr);
+    if (paths.first)
+      module_spec.GetFileSpec() = paths.first;
+    if (paths.second)
+      module_spec.GetSymbolFileSpec() = paths.second;
+    return true;
+  }
+
+  // Lambda to capture the state of module_spec before returning from this
+  // function.
+  auto RecordResult = [&]() {
+    if (repro::Generator *g = repro::Reproducer::Instance().GetGenerator()) {
+      g->GetOrCreate<repro::SymbolFileProvider>().AddSymbolFile(
+          uuid_ptr, module_spec.GetFileSpec(), module_spec.GetSymbolFileSpec());
+    }
+  };
+
   // It's expensive to check for the DBGShellCommands defaults setting, only do
   // it once per lldb run and cache the result.
   static bool g_have_checked_for_dbgshell_command = false;
   static const char *g_dbgshell_command = NULL;
   if (!g_have_checked_for_dbgshell_command) {
     g_have_checked_for_dbgshell_command = true;
     CFTypeRef defaults_setting = CFPreferencesCopyAppValue(
         CFSTR("DBGShellCommands"), CFSTR("com.apple.DebugSymbols"));
if (!g_have_checked_for_dbgshell_command) {
     if (defaults_setting) {
       CFRelease(defaults_setting);
     }
   }
 
   // When g_dbgshell_command is NULL, the user has not enabled the use of an
   // external program to find the symbols, don't run it for them.
   if (!force_lookup && g_dbgshell_command == NULL) {
+    RecordResult();
     return false;
   }
 
   if (uuid_ptr ||
       (file_spec_ptr && FileSystem::Instance().Exists(*file_spec_ptr))) {
     static bool g_located_dsym_for_uuid_exe = false;
     static bool g_dsym_for_uuid_exe_exists = false;
     static char g_dsym_for_uuid_exe_path[PATH_MAX];
if (g_dsym_for_uuid_exe_exists) {
             } else {
               const CFIndex num_values = ::CFDictionaryGetCount(plist.get());
               if (num_values > 0) {
                 std::vector<CFStringRef> keys(num_values, NULL);
                 std::vector<CFDictionaryRef> values(num_values, NULL);
                 ::CFDictionaryGetKeysAndValues(plist.get(), NULL,
                                                (const void **)&values[0]);
                 if (num_values == 1) {
-                  return GetModuleSpecInfoFromUUIDDictionary(values[0],
+                  success = GetModuleSpecInfoFromUUIDDictionary(values[0],
                                                                 module_spec);
+                  RecordResult();
+                  return success;
                 } else {
                   for (CFIndex i = 0; i < num_values; ++i) {
                     ModuleSpec curr_module_spec;
                     if (GetModuleSpecInfoFromUUIDDictionary(values[i],
                                                             curr_module_spec)) {
                       if (module_spec.GetArchitecture().IsCompatibleMatch(
                               curr_module_spec.GetArchitecture())) {
                         module_spec = curr_module_spec;
+                        RecordResult();
                         return true;
                       }
                     }
                   }
                 }
               }
             }
           }
         } else {
           if (log) {
             if (!uuid_str.empty())
               LLDB_LOGF(log, "Called %s on %s, no matches",
                         g_dsym_for_uuid_exe_path, uuid_str.c_str());
             else if (file_path[0] != '\0')
               LLDB_LOGF(log, "Called %s on %s, no matches",
                         g_dsym_for_uuid_exe_path, file_path);
           }
         }
       }
     }
   }
+  RecordResult();
   return success;
 }

lldb/source/Utility/ReproducerProvider.cpp

 void ProcessInfoRecorder::Record(const ProcessInstanceInfoList &process_infos) {
   if (!m_record)
     return;
   llvm::yaml::Output yout(m_os);
   yout << const_cast<ProcessInstanceInfoList &>(process_infos);
   m_os.flush();
 }
 
+void SymbolFileProvider::AddSymbolFile(const UUID *uuid,
+                                       const FileSpec &module_file,
+                                       const FileSpec &symbol_file) {
+  if (!uuid || (!module_file && !symbol_file))
+    return;
+  m_symbol_files.emplace_back(uuid->GetAsString(), module_file.GetPath(),
+                              symbol_file.GetPath());
+}
+
+void SymbolFileProvider::Keep() {
+  FileSpec file = this->GetRoot().CopyByAppendingPathComponent(Info::file);
+  std::error_code ec;
+  llvm::raw_fd_ostream os(file.GetPath(), ec, llvm::sys::fs::OF_Text);
+  if (ec)
+    return;
+
+  // Remove duplicates.
+  llvm::sort(m_symbol_files.begin(), m_symbol_files.end());
+  m_symbol_files.erase(
+      std::unique(m_symbol_files.begin(), m_symbol_files.end()),
+      m_symbol_files.end());
+
+  llvm::yaml::Output yout(os);
+  yout << m_symbol_files;
+}
+
+SymbolFileLoader::SymbolFileLoader(Loader *loader) {
+  if (!loader)
+    return;
+
+  FileSpec file = loader->GetFile<SymbolFileProvider::Info>();
+  if (!file)
+    return;
+
+  auto error_or_file = llvm::MemoryBuffer::getFile(file.GetPath());
+  if (auto err = error_or_file.getError())
+    return;
+
+  llvm::yaml::Input yin((*error_or_file)->getBuffer());
+  yin >> m_symbol_files;
+}
+
+std::pair<FileSpec, FileSpec>
+SymbolFileLoader::GetPaths(const UUID *uuid) const {
+  if (!uuid)
+    return {};
+
+  auto it = std::lower_bound(m_symbol_files.begin(), m_symbol_files.end(),
+                             SymbolFileProvider::Entry(uuid->GetAsString()));
+  if (it == m_symbol_files.end())
+    return {};
+  return std::make_pair<FileSpec, FileSpec>(FileSpec(it->module_path),
+                                            FileSpec(it->symbol_path));
+}
+
 void ProviderBase::anchor() {}
 char CommandProvider::ID = 0;
 char FileProvider::ID = 0;
 char ProviderBase::ID = 0;
 char VersionProvider::ID = 0;
 char WorkingDirectoryProvider::ID = 0;
 char HomeDirectoryProvider::ID = 0;
 char ProcessInfoProvider::ID = 0;
+char SymbolFileProvider::ID = 0;
 const char *CommandProvider::Info::file = "command-interpreter.yaml";
 const char *CommandProvider::Info::name = "command-interpreter";
 const char *FileProvider::Info::file = "files.yaml";
 const char *FileProvider::Info::name = "files";
 const char *VersionProvider::Info::file = "version.txt";
 const char *VersionProvider::Info::name = "version";
 const char *WorkingDirectoryProvider::Info::file = "cwd.txt";
 const char *WorkingDirectoryProvider::Info::name = "cwd";
 const char *HomeDirectoryProvider::Info::file = "home.txt";
 const char *HomeDirectoryProvider::Info::name = "home";
 const char *ProcessInfoProvider::Info::file = "process-info.yaml";
 const char *ProcessInfoProvider::Info::name = "process-info";
+const char *SymbolFileProvider::Info::file = "symbol-files.yaml";
+const char *SymbolFileProvider::Info::name = "symbol-files";

lldb/test/Shell/Reproducer/Inputs/dsymforuuid.sh

+#!/usr/bin/env bash
+
+echo "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
+echo "<!DOCTYPE plist PUBLIC \"-//Apple//DTD PLIST 1.0//ENhttp://www.apple.com/DTDs/PropertyList-1.0.dtd\">"
+echo "<plist version=\"1.0\">"
+echo "<dict>"
+echo "    <key>AD52358C-94F8-3796-ADD6-B20FFAC00E5C</key>"
+echo "    <dict>"
+echo "        <key>DBGArchitecture</key>"
+echo "        <string>x86_64</string>"
+echo "        <key>DBGBuildSourcePath</key>"
+echo "        <string>/path/to/build/sources</string>"
+echo "        <key>DBGSourcePath</key>"
+echo "        <string>/path/to/actual/sources</string>"
+echo "        <key>DBGDSYMPath</key>"
+echo "        <string>/path/to/foo.dSYM/Contents/Resources/DWARF/foo</string>"
+echo "        <key>DBGSymbolRichExecutable</key>"
+echo "        <string>/path/to/unstripped/executable</string>"
+echo "    </dict>"
+echo "</dict>"
+echo "</plist>"

lldb/test/Shell/Reproducer/TestDebugSymbols.test

+# REQUIRES: system-darwin
+
+# RUN: rm -rf %t.repro
+# RUN: env LLDB_APPLE_DSYMFORUUID_EXECUTABLE=%S/Inputs/dsymforuuid.sh %lldb --capture --capture-path %t.repro -c %S/Inputs/core -o 'reproducer generate'
+
+# RUN: cat %t.repro/symbol-files.yaml | FileCheck %s --check-prefix YAML
+# YAML: AD52358C-94F8-3796-ADD6-B20FFAC00E5C
+# YAML: /path/to/unstripped/executable
+# YAML: /path/to/foo.dSYM/Contents/Resources/DWARF/foo
+
+# RUN: %lldb -b -o 'reproducer dump -p symbol-files -f %t.repro' | FileCheck %s --check-prefix DUMP
+# DUMP: uuid: AD52358C-94F8-3796-ADD6-B20FFAC00E5C
+# DUMP-NEXT: module path: /path/to/unstripped/executable
+# DUMP-NEXT: symbol path: /path/to/foo.dSYM/Contents/Resources/DWARF/foo