[lldb] Teach LLDB about filesets

[jasonmolenda]

This all looks great.

I am working on a patch that will build on this, but I will be working with a memory image which needs the CreateMemoryInstance() ObjectFile interface implemented, and in my case, I'm very much hoping to avoid reading the entire fileset out of memory -- I'd like it if we don't read more than the mach header & load commands from the fileset, so I can query for a single entry by name in the fileset (e.g. "com.apple.kernel"). If the memory ObjectContainerMachOFileset created a memory ObjectFile for that name, that's fine, I'll be reading it from memory soon to get the UUID anyway out of the load commands. (ObjectFileMachO will only read the header + load commands for a memory module, until you touch the symbol table.)

[JDevlieghere]

• Rebase
• Support reading Filesets from memory

[jasonmolenda]

Process::ReadModuleFromMemory() takes a FileSpec and header address in memory (and a size to read, default 512 bytes). It calls through Module::GetMemoryObjectFile. That reads the 512 bytes of memory into a buffer and calls ObjectFile::FindPlugin class method for finding the correct plugin (via PluginManager's ObjectFileCreateMemoryInstance methods), finally hitting something like ObjectFileMachO::CreateMemoryInstance.

It looks like ObjectContainer is currently a pure virtual class; we'd need to add a base class method FindPlugin for working with a memory module. Process would need a Process::ReadObjectContainerFromMemory() or something? Not sure if that's the right idea - but we don't know what kind of container it is when we have a Process and a header address in memory.

lldb/source/Plugins/ObjectContainer/Mach-O-Fileset/ObjectContainerMachOFileset.cpp

202

This started with a memory buffer of the mach header in m_data, now we've read the mach header and the load commands. It seems like we should replace the original data buffer with the memory we just read. A quick look at ObjectFileMachO::ParseHeader(), it replaces the entire m_data.

256

This file has a using at the top, don't need to qualify the constant. (there's a handful of other instances, I note one of them)

[jasonmolenda]

In D132433#3747948, @jasonmolenda wrote:

Process::ReadModuleFromMemory() takes a FileSpec and header address in memory (and a size to read, default 512 bytes). It calls through Module::GetMemoryObjectFile. That reads the 512 bytes of memory into a buffer and calls ObjectFile::FindPlugin class method for finding the correct plugin (via PluginManager's ObjectFileCreateMemoryInstance methods), finally hitting something like ObjectFileMachO::CreateMemoryInstance.

Reviewed this a little too close to bed time ;) - Jonas asked me if I really needed this up at the generic Process level, and I remembered that the one use case I am writing currently for this will be down in Darwin-specific code, so I can create the memory instance of the macho fileset explicitly. This patch looks good to me.

[JDevlieghere]

I added the ability to call ObjectContainer::FindPlugin which allows you to create a Mach-O fileset from memory without actually having to know it's a fileset. I think that should cover Jason's use-case without needing to thread it through process.

lldb/include/lldb/Core/PluginManager.h

public:
   GetObjectFileCreateMemoryCallbackForPluginName(llvm::StringRef name);
 
   static Status SaveCore(const lldb::ProcessSP &process_sp,
                          const FileSpec &outfile,
                          lldb::SaveCoreStyle &core_style,
                          llvm::StringRef plugin_name);
 
   // ObjectContainer
-  static bool
-  RegisterPlugin(llvm::StringRef name, llvm::StringRef description,
-                 ObjectContainerCreateInstance create_callback,
-                 ObjectFileGetModuleSpecifications get_module_specifications);
+  static bool RegisterPlugin(
+      llvm::StringRef name, llvm::StringRef description,
+      ObjectFileGetModuleSpecifications get_module_specifications,
+      ObjectContainerCreateMemoryInstance create_memory_callback = nullptr);
 
   static bool UnregisterPlugin(ObjectContainerCreateInstance create_callback);
 
   static ObjectContainerCreateInstance
   GetObjectContainerCreateCallbackAtIndex(uint32_t idx);
 
+  static ObjectContainerCreateMemoryInstance
+  GetObjectContainerCreateMemoryCallbackAtIndex(uint32_t idx);
+
   static ObjectFileGetModuleSpecifications
   GetObjectContainerGetModuleSpecificationsCallbackAtIndex(uint32_t idx);
 
   // Platform
   static bool
   RegisterPlugin(llvm::StringRef name, llvm::StringRef description,
                  PlatformCreateInstance create_callback,
                  DebuggerInitializeCallback debugger_init_callback = nullptr);

lldb/include/lldb/Symbol/ObjectContainer.h

 public:
   /// Construct with a parent module, offset, and header data.
   ///
   /// Object files belong to modules and a valid module must be supplied upon
   /// construction. The at an offset within a file for objects that contain
   /// more than one architecture or object.
   ObjectContainer(const lldb::ModuleSP &module_sp, const FileSpec *file,
                   lldb::offset_t file_offset, lldb::offset_t length,
-                  lldb::DataBufferSP &data_sp, lldb::offset_t data_offset)
-      : ModuleChild(module_sp),
-        m_file(), // This file can be different than the module's file spec
-        m_offset(file_offset), m_length(length) {
-    if (file)
-      m_file = *file;
-    if (data_sp)
-      m_data.SetData(data_sp, data_offset, length);
-  }
+                  lldb::DataBufferSP data_sp, lldb::offset_t data_offset);
 
   /// Destructor.
   ///
   /// The destructor is virtual since this class is designed to be inherited
   /// from by the plug-in instance.
   ~ObjectContainer() override = default;
 
   /// Gets the architecture given an index.
public:
   /// information for the new architecture.
   ///
   /// \return
   ///     Returns a pointer to the object file of the requested \a
   ///     arch and optional \a name. Returns nullptr of no such object
   ///     file exists in the container.
   virtual lldb::ObjectFileSP GetObjectFile(const FileSpec *file) = 0;
 
+  static lldb::ObjectContainerSP
+  FindPlugin(const lldb::ModuleSP &module_sp, const lldb::ProcessSP &process_sp,
+             lldb::addr_t header_addr, lldb::WritableDataBufferSP file_data_sp);
+
 protected:
-  // Member variables.
-  FileSpec m_file; ///< The file that represents this container objects (which
-                   ///can be different from the module's file).
-  lldb::addr_t
-      m_offset; ///< The offset in bytes into the file, or the address in memory
-  lldb::addr_t m_length; ///< The size in bytes if known (can be zero).
-  DataExtractor
-      m_data; ///< The data for this object file so things can be parsed lazily.
+  /// The file that represents this container objects (which can be different
+  /// from the module's file).
+  FileSpec m_file;
+
+  /// The offset in bytes into the file, or the address in memory
+  lldb::addr_t m_offset;
+
+  /// The size in bytes if known (can be zero).
+  lldb::addr_t m_length;
+
+  /// The data for this object file so things can be parsed lazily.
+  DataExtractor m_data;
 
 private:
   ObjectContainer(const ObjectContainer &) = delete;
   const ObjectContainer &operator=(const ObjectContainer &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SYMBOL_OBJECTCONTAINER_H

lldb/include/lldb/Symbol/ObjectFile.h

public:
   /// 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();
 
+  static lldb::DataBufferSP MapFileData(const FileSpec &file, uint64_t Size,
+                                        uint64_t Offset);
 
 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
protected:
   /// \return
   ///     Returns \b true if the architecture was changed, \b
   ///     false otherwise.
   bool SetModulesArchitecture(const ArchSpec &new_arch);
 
   /// The number of bytes to read when going through the plugins.
   static size_t g_initial_bytes_to_read;
 
-  static lldb::DataBufferSP MapFileData(const FileSpec &file, uint64_t Size,
-                                        uint64_t Offset);
-
 private:
   ObjectFile(const ObjectFile &) = delete;
   const ObjectFile &operator=(const ObjectFile &) = delete;
 };
 
 } // namespace lldb_private
 
 namespace llvm {

lldb/include/lldb/lldb-forward.h

 typedef std::shared_ptr<lldb_private::Listener> ListenerSP;
 typedef std::weak_ptr<lldb_private::Listener> ListenerWP;
 typedef std::shared_ptr<lldb_private::MemoryHistory> MemoryHistorySP;
 typedef std::unique_ptr<lldb_private::MemoryRegionInfo> MemoryRegionInfoUP;
 typedef std::shared_ptr<lldb_private::MemoryRegionInfo> MemoryRegionInfoSP;
 typedef std::shared_ptr<lldb_private::Module> ModuleSP;
 typedef std::weak_ptr<lldb_private::Module> ModuleWP;
 typedef std::shared_ptr<lldb_private::ObjectFile> ObjectFileSP;
+typedef std::shared_ptr<lldb_private::ObjectContainer> ObjectContainerSP;
 typedef std::shared_ptr<lldb_private::ObjectFileJITDelegate>
     ObjectFileJITDelegateSP;
 typedef std::weak_ptr<lldb_private::ObjectFileJITDelegate>
     ObjectFileJITDelegateWP;
 typedef std::unique_ptr<lldb_private::OperatingSystem> OperatingSystemUP;
 typedef std::shared_ptr<lldb_private::OptionValue> OptionValueSP;
 typedef std::weak_ptr<lldb_private::OptionValue> OptionValueWP;
 typedef std::shared_ptr<lldb_private::OptionValueProperties>

lldb/include/lldb/lldb-private-interfaces.h

 typedef DynamicLoader *(*DynamicLoaderCreateInstance)(Process *process,
                                                       bool force);
 typedef lldb::JITLoaderSP (*JITLoaderCreateInstance)(Process *process,
                                                      bool force);
 typedef ObjectContainer *(*ObjectContainerCreateInstance)(
     const lldb::ModuleSP &module_sp, lldb::DataBufferSP &data_sp,
     lldb::offset_t data_offset, const FileSpec *file, lldb::offset_t offset,
     lldb::offset_t length);
+typedef ObjectContainer *(*ObjectContainerCreateMemoryInstance)(
+    const lldb::ModuleSP &module_sp, lldb::WritableDataBufferSP data_sp,
+    const lldb::ProcessSP &process_sp, lldb::addr_t offset);
 typedef size_t (*ObjectFileGetModuleSpecifications)(
     const FileSpec &file, lldb::DataBufferSP &data_sp,
     lldb::offset_t data_offset, lldb::offset_t file_offset,
     lldb::offset_t length, ModuleSpecList &module_specs);
 typedef ObjectFile *(*ObjectFileCreateInstance)(const lldb::ModuleSP &module_sp,
                                                 lldb::DataBufferSP data_sp,
                                                 lldb::offset_t data_offset,
                                                 const FileSpec *file,

lldb/source/Core/PluginManager.cpp

 
 #pragma mark ObjectContainer
 
 struct ObjectContainerInstance
     : public PluginInstance<ObjectContainerCreateInstance> {
   ObjectContainerInstance(
       llvm::StringRef name, llvm::StringRef description,
       CallbackType create_callback,
+      ObjectContainerCreateMemoryInstance create_memory_callback,
       ObjectFileGetModuleSpecifications get_module_specifications)
       : PluginInstance<ObjectContainerCreateInstance>(name, description,
                                                       create_callback),
+        create_memory_callback(create_memory_callback),
         get_module_specifications(get_module_specifications) {}
 
+  ObjectContainerCreateMemoryInstance create_memory_callback;
   ObjectFileGetModuleSpecifications get_module_specifications;
 };
 typedef PluginInstances<ObjectContainerInstance> ObjectContainerInstances;
 
 static ObjectContainerInstances &GetObjectContainerInstances() {
   static ObjectContainerInstances g_instances;
   return g_instances;
 }
 
 bool PluginManager::RegisterPlugin(
     llvm::StringRef name, llvm::StringRef description,
     ObjectContainerCreateInstance create_callback,
-    ObjectFileGetModuleSpecifications get_module_specifications) {
+    ObjectFileGetModuleSpecifications get_module_specifications,
+    ObjectContainerCreateMemoryInstance create_memory_callback) {
   return GetObjectContainerInstances().RegisterPlugin(
-      name, description, create_callback, get_module_specifications);
+      name, description, create_callback, create_memory_callback,
+      get_module_specifications);
 }
 
 bool PluginManager::UnregisterPlugin(
     ObjectContainerCreateInstance create_callback) {
   return GetObjectContainerInstances().UnregisterPlugin(create_callback);
 }
 
 ObjectContainerCreateInstance
 PluginManager::GetObjectContainerCreateCallbackAtIndex(uint32_t idx) {
   return GetObjectContainerInstances().GetCallbackAtIndex(idx);
 }
 
+ObjectContainerCreateMemoryInstance
+PluginManager::GetObjectContainerCreateMemoryCallbackAtIndex(uint32_t idx) {
+  const auto &instances = GetObjectContainerInstances().GetInstances();
+  if (idx < instances.size())
+    return instances[idx].create_memory_callback;
+  return nullptr;
+}
+
 ObjectFileGetModuleSpecifications
 PluginManager::GetObjectContainerGetModuleSpecificationsCallbackAtIndex(
     uint32_t idx) {
   const auto &instances = GetObjectContainerInstances().GetInstances();
   if (idx < instances.size())
     return instances[idx].get_module_specifications;
   return nullptr;
 }

lldb/source/Plugins/ObjectContainer/CMakeLists.txt

 add_subdirectory(BSD-Archive)
 add_subdirectory(Universal-Mach-O)
+add_subdirectory(Mach-O-Fileset)

lldb/source/Plugins/ObjectContainer/Mach-O-Fileset/CMakeLists.txt

+add_lldb_library(lldbPluginObjectContainerMachOFileset PLUGIN
+  ObjectContainerMachOFileset.cpp
+
+  LINK_LIBS
+    lldbCore
+    lldbHost
+    lldbSymbol
+    lldbTarget
+    lldbUtility
+  )

lldb/source/Plugins/ObjectContainer/Mach-O-Fileset/ObjectContainerMachOFileset.h

+//===-- ObjectContainerMachOFileset.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_SOURCE_PLUGINS_OBJECTCONTAINER_MACH_O_FILESET_OBJECTCONTAINERMADCHOFILESET_H
+#define LLDB_SOURCE_PLUGINS_OBJECTCONTAINER_MACH_O_FILESET_OBJECTCONTAINERMADCHOFILESET_H
+
+#include "lldb/Host/SafeMachO.h"
+#include "lldb/Symbol/ObjectContainer.h"
+#include "lldb/Utility/FileSpec.h"
+
+namespace lldb_private {
+
+class ObjectContainerMachOFileset : public lldb_private::ObjectContainer {
+public:
+  ObjectContainerMachOFileset(const lldb::ModuleSP &module_sp,
+                              lldb::DataBufferSP &data_sp,
+                              lldb::offset_t data_offset,
+                              const lldb_private::FileSpec *file,
+                              lldb::offset_t offset, lldb::offset_t length);
+
+  ObjectContainerMachOFileset(const lldb::ModuleSP &module_sp,
+                              lldb::WritableDataBufferSP data_sp,
+                              const lldb::ProcessSP &process_sp,
+                              lldb::addr_t header_addr);
+
+  ~ObjectContainerMachOFileset() override;
+
+  static void Initialize();
+  static void Terminate();
+
+  static llvm::StringRef GetPluginNameStatic() { return "mach-o-fileset"; }
+
+  static llvm::StringRef GetPluginDescriptionStatic() {
+    return "Mach-O Fileset container reader.";
+  }
+
+  static lldb_private::ObjectContainer *
+  CreateInstance(const lldb::ModuleSP &module_sp, lldb::DataBufferSP &data_sp,
+                 lldb::offset_t data_offset, const lldb_private::FileSpec *file,
+                 lldb::offset_t offset, lldb::offset_t length);
+
+  static lldb_private::ObjectContainer *CreateMemoryInstance(
+      const lldb::ModuleSP &module_sp, lldb::WritableDataBufferSP data_sp,
+      const lldb::ProcessSP &process_sp, lldb::addr_t header_addr);
+
+  static size_t GetModuleSpecifications(const lldb_private::FileSpec &file,
+                                        lldb::DataBufferSP &data_sp,
+                                        lldb::offset_t data_offset,
+                                        lldb::offset_t file_offset,
+                                        lldb::offset_t length,
+                                        lldb_private::ModuleSpecList &specs);
+
+  static bool MagicBytesMatch(const lldb_private::DataExtractor &data);
+  static bool MagicBytesMatch(lldb::DataBufferSP data_sp,
+                              lldb::addr_t data_offset,
+                              lldb::addr_t data_length);
+
+  bool ParseHeader() override;
+
+  size_t GetNumObjects() const override { return m_entries.size(); }
+
+  lldb::ObjectFileSP GetObjectFile(const lldb_private::FileSpec *file) override;
+
+  llvm::StringRef GetPluginName() override { return GetPluginNameStatic(); }
+
+  struct Entry {
+    Entry(uint64_t vmaddr, uint64_t fileoff, std::string id)
+        : vmaddr(vmaddr), fileoff(fileoff), id(id) {}
+    uint64_t vmaddr;
+    uint64_t fileoff;
+    uint64_t slide;
+    std::string id;
+  };
+
+  Entry *FindEntry(llvm::StringRef id);
+
+private:
+  static bool ParseHeader(lldb_private::DataExtractor &data,
+                          const lldb_private::FileSpec &file,
+                          lldb::offset_t file_offset,
+                          std::vector<Entry> &entries);
+
+  std::vector<Entry> m_entries;
+  lldb::ProcessWP m_process_wp;
+  const lldb::addr_t m_memory_addr;
+};
+
+} // namespace lldb_private
+
+#endif // LLDB_SOURCE_PLUGINS_OBJECTCONTAINER_MACH_O_FILESET_OBJECTCONTAINERMADCHOFILESET_H

lldb/source/Plugins/ObjectContainer/Mach-O-Fileset/ObjectContainerMachOFileset.cpp

+//===-- ObjectContainerMachOFileset.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 "ObjectContainerMachOFileset.h"
+#include "lldb/Core/Module.h"
+#include "lldb/Core/ModuleSpec.h"
+#include "lldb/Core/PluginManager.h"
+#include "lldb/Symbol/ObjectFile.h"
+#include "lldb/Target/Target.h"
+#include "lldb/Utility/ArchSpec.h"
+#include "lldb/Utility/DataBuffer.h"
+#include "lldb/Utility/Stream.h"
+
+using namespace lldb;
+using namespace lldb_private;
+using namespace llvm::MachO;
+
+LLDB_PLUGIN_DEFINE(ObjectContainerMachOFileset)
+
+void ObjectContainerMachOFileset::Initialize() {
+  PluginManager::RegisterPlugin(GetPluginNameStatic(),
+                                GetPluginDescriptionStatic(), CreateInstance,
+                                GetModuleSpecifications, CreateMemoryInstance);
+}
+
+void ObjectContainerMachOFileset::Terminate() {
+  PluginManager::UnregisterPlugin(CreateInstance);
+}
+
+ObjectContainerMachOFileset::ObjectContainerMachOFileset(
+    const lldb::ModuleSP &module_sp, lldb::DataBufferSP &data_sp,
+    lldb::offset_t data_offset, const lldb_private::FileSpec *file,
+    lldb::offset_t offset, lldb::offset_t length)
+    : ObjectContainer(module_sp, file, offset, length, data_sp, data_offset),
+      m_memory_addr(LLDB_INVALID_ADDRESS) {}
+
+ObjectContainerMachOFileset::ObjectContainerMachOFileset(
+    const lldb::ModuleSP &module_sp, lldb::WritableDataBufferSP data_sp,
+    const lldb::ProcessSP &process_sp, lldb::addr_t header_addr)
+    : ObjectContainer(module_sp, nullptr, 0, 0, data_sp, 0),
+      m_memory_addr(header_addr) {}
+
+ObjectContainer *ObjectContainerMachOFileset::CreateInstance(
+    const lldb::ModuleSP &module_sp, DataBufferSP &data_sp,
+    lldb::offset_t data_offset, const FileSpec *file,
+    lldb::offset_t file_offset, lldb::offset_t length) {
+  if (!data_sp)
+    return {};
+
+  DataExtractor data;
+  data.SetData(data_sp, data_offset, length);
+  if (!MagicBytesMatch(data))
+    return {};
+
+  auto container_up = std::make_unique<ObjectContainerMachOFileset>(
+      module_sp, data_sp, data_offset, file, file_offset, length);
+  if (!container_up->ParseHeader())
+    return {};
+
+  return container_up.release();
+}
+
+ObjectContainer *ObjectContainerMachOFileset::CreateMemoryInstance(
+    const lldb::ModuleSP &module_sp, lldb::WritableDataBufferSP data_sp,
+    const lldb::ProcessSP &process_sp, lldb::addr_t header_addr) {
+  if (!MagicBytesMatch(data_sp, 0, data_sp->GetByteSize()))
+    return {};
+
+  auto container_up = std::make_unique<ObjectContainerMachOFileset>(
+      module_sp, data_sp, process_sp, header_addr);
+  if (!container_up->ParseHeader())
+    return {};
+
+  return container_up.release();
+}
+
+ObjectContainerMachOFileset::~ObjectContainerMachOFileset() = default;
+
+static uint32_t MachHeaderSizeFromMagic(uint32_t magic) {
+  switch (magic) {
+  case MH_MAGIC:
+  case MH_CIGAM:
+    return sizeof(struct mach_header);
+  case MH_MAGIC_64:
+  case MH_CIGAM_64:
+    return sizeof(struct mach_header_64);
+  default:
+    return 0;
+  }
+}
+
+static llvm::Optional<mach_header> ParseMachOHeader(DataExtractor &data) {
+  lldb::offset_t offset = 0;
+  mach_header header;
+  header.magic = data.GetU32(&offset);
+  switch (header.magic) {
+  case MH_MAGIC:
+    data.SetByteOrder(endian::InlHostByteOrder());
+    data.SetAddressByteSize(4);
+    break;
+  case MH_MAGIC_64:
+    data.SetByteOrder(endian::InlHostByteOrder());
+    data.SetAddressByteSize(8);
+    break;
+  case MH_CIGAM:
+    data.SetByteOrder(endian::InlHostByteOrder() == eByteOrderBig
+                          ? eByteOrderLittle
+                          : eByteOrderBig);
+    data.SetAddressByteSize(4);
+    break;
+  case MH_CIGAM_64:
+    data.SetByteOrder(endian::InlHostByteOrder() == eByteOrderBig
+                          ? eByteOrderLittle
+                          : eByteOrderBig);
+    data.SetAddressByteSize(8);
+    break;
+  default:
+    return {};
+  }
+
+  header.cputype = data.GetU32(&offset);
+  header.cpusubtype = data.GetU32(&offset);
+  header.filetype = data.GetU32(&offset);
+  header.ncmds = data.GetU32(&offset);
+  header.sizeofcmds = data.GetU32(&offset);
+  return header;
+}
+
+static bool
+ParseFileset(DataExtractor &data, mach_header header,
+             std::vector<ObjectContainerMachOFileset::Entry> &entries) {
+  lldb::offset_t offset = MachHeaderSizeFromMagic(header.magic);
+  for (uint32_t i = 0; i < header.ncmds; ++i) {
+    const lldb::offset_t load_cmd_offset = offset;
+    load_command lc = {};
+    if (data.GetU32(&offset, &lc.cmd, 2) == nullptr)
+      break;
+
+    if (lc.cmd == LC_FILESET_ENTRY) {
+      fileset_entry_command entry;
+      data.CopyData(load_cmd_offset, sizeof(fileset_entry_command), &entry);
+      lldb::offset_t entry_id_offset = load_cmd_offset + entry.entry_id;
+      const char *id = data.GetCStr(&entry_id_offset);
+      entries.emplace_back(entry.vmaddr, entry.fileoff, std::string(id));
+    }
+    offset = load_cmd_offset + lc.cmdsize;
+  }
+
+  return true;
+}
+
+bool ObjectContainerMachOFileset::ParseHeader(
+    DataExtractor &data, const lldb_private::FileSpec &file,
+    lldb::offset_t file_offset, std::vector<Entry> &entries) {
+  llvm::Optional<mach_header> header = ParseMachOHeader(data);
+
+  if (!header)
+    return false;
+
+  const size_t header_size = MachHeaderSizeFromMagic(header->magic);
+  const size_t header_and_lc_size = header_size + header->sizeofcmds;
+
+  if (data.GetByteSize() < header_and_lc_size) {
+    DataBufferSP data_sp =
+        ObjectFile::MapFileData(file, header_and_lc_size, file_offset);
+    data.SetData(data_sp);
+  }
+
+  return ParseFileset(data, *header, entries);
+}
+
+bool ObjectContainerMachOFileset::ParseHeader() {
+  ModuleSP module_sp(GetModule());
+  if (!module_sp)
+    return false;
+
+  std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
+
+  llvm::Optional<mach_header> header = ParseMachOHeader(m_data);
+  if (!header)
+    return false;
+
+  const size_t header_size = MachHeaderSizeFromMagic(header->magic);
+  const size_t header_and_lc_size = header_size + header->sizeofcmds;
+
+  if (m_data.GetByteSize() < header_and_lc_size) {
+    ProcessSP process_sp(m_process_wp.lock());
+    DataBufferSP data_sp =
+        process_sp
+            ? ObjectFile::ReadMemory(process_sp, m_memory_addr,
+                                     header_and_lc_size)
+            : ObjectFile::MapFileData(m_file, header_and_lc_size, m_offset);
+    m_data.SetData(data_sp);
+  }
+
+  return ParseFileset(m_data, *header, m_entries);
+}
+
+size_t ObjectContainerMachOFileset::GetModuleSpecifications(
+    const lldb_private::FileSpec &file, lldb::DataBufferSP &data_sp,
+    lldb::offset_t data_offset, lldb::offset_t file_offset,
+    lldb::offset_t file_size, lldb_private::ModuleSpecList &specs) {
+  const size_t initial_count = specs.GetSize();
+
+  DataExtractor data;
+  data.SetData(data_sp, data_offset, data_sp->GetByteSize());
+
+  if (MagicBytesMatch(data)) {
+    std::vector<Entry> entries;
+    if (ParseHeader(data, file, file_offset, entries)) {
+      for (const Entry &entry : entries) {
+        const lldb::offset_t entry_offset = entry.fileoff + file_offset;
+        if (ObjectFile::GetModuleSpecifications(
+                file, entry_offset, file_size - entry_offset, specs)) {
+          ModuleSpec &spec = specs.GetModuleSpecRefAtIndex(specs.GetSize() - 1);
+          spec.GetObjectName() = ConstString(entry.id);
+        }
+      }
+    }
+  }
+  return specs.GetSize() - initial_count;
+}
+
+bool ObjectContainerMachOFileset::MagicBytesMatch(DataBufferSP data_sp,
+                                                  lldb::addr_t data_offset,
+                                                  lldb::addr_t data_length) {
+  DataExtractor data;
+  data.SetData(data_sp, data_offset, data_length);
+  return MagicBytesMatch(data);
+}
+
+bool ObjectContainerMachOFileset::MagicBytesMatch(const DataExtractor &data) {
+  lldb::offset_t offset = 0;
+  uint32_t magic = data.GetU32(&offset);
+  switch (magic) {
+  case MH_MAGIC:
+  case MH_CIGAM:
+  case MH_MAGIC_64:
+  case MH_CIGAM_64:
+    break;
+  default:
+    return false;
+  }
+  offset += 4; // cputype
+  offset += 4; // cpusubtype
+  uint32_t filetype = data.GetU32(&offset);
+  return filetype == MH_FILESET;
+}
+
+ObjectFileSP
+ObjectContainerMachOFileset::GetObjectFile(const lldb_private::FileSpec *file) {
+  ModuleSP module_sp(GetModule());
+  if (!module_sp)
+    return {};
+
+  ConstString object_name = module_sp->GetObjectName();
+  if (!object_name)
+    return {};
+
+  Entry *entry = FindEntry(object_name.GetCString());
+  if (!entry)
+    return {};
+
+  DataBufferSP data_sp;
+  lldb::offset_t data_offset = 0;
+  return ObjectFile::FindPlugin(module_sp, file, m_offset + entry->fileoff,
+                                m_data.GetByteSize() - entry->fileoff, data_sp,
+                                data_offset);
+}
+
+ObjectContainerMachOFileset::Entry *
+ObjectContainerMachOFileset::FindEntry(llvm::StringRef id) {
+  for (Entry &entry : m_entries) {
+    if (entry.id == id)
+      return &entry;
+  }
+  return nullptr;
+}

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

 
 bool ObjectFileMachO::MagicBytesMatch(DataBufferSP data_sp,
                                       lldb::addr_t data_offset,
                                       lldb::addr_t data_length) {
   DataExtractor data;
   data.SetData(data_sp, data_offset, data_length);
   lldb::offset_t offset = 0;
   uint32_t magic = data.GetU32(&offset);
+
+  offset += 4; // cputype
+  offset += 4; // cpusubtype
+  uint32_t filetype = data.GetU32(&offset);
+
+  // A fileset has a Mach-O header but is not an
+  // individual file and must be handled via an
+  // ObjectContainer plugin.
+  if (filetype == llvm::MachO::MH_FILESET)
+    return false;
+
   return MachHeaderSizeFromMagic(magic) != 0;
 }
 
 ObjectFileMachO::ObjectFileMachO(const lldb::ModuleSP &module_sp,
                                  DataBufferSP data_sp,
                                  lldb::offset_t data_offset,
                                  const FileSpec *file,
                                  lldb::offset_t file_offset,

lldb/source/Symbol/CMakeLists.txt

add_lldb_library(lldbSymbol
   DWARFCallFrameInfo.cpp
   DebugMacros.cpp
   DeclVendor.cpp
   FuncUnwinders.cpp
   Function.cpp
   LineEntry.cpp
   LineTable.cpp
   LocateSymbolFile.cpp
+  ObjectContainer.cpp
   ObjectFile.cpp
   PostfixExpression.cpp
   Symbol.cpp
   SymbolContext.cpp
   SymbolFile.cpp
   SymbolFileOnDemand.cpp
   SymbolVendor.cpp
   Symtab.cpp

lldb/source/Symbol/ObjectContainer.cpp

+//===-- ObjectContainer.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 "lldb/Symbol/ObjectContainer.h"
+#include "lldb/Core/Module.h"
+#include "lldb/Core/PluginManager.h"
+#include "lldb/Target/Process.h"
+#include "lldb/Utility/Timer.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+ObjectContainer::ObjectContainer(const lldb::ModuleSP &module_sp,
+                                 const FileSpec *file,
+                                 lldb::offset_t file_offset,
+                                 lldb::offset_t length,
+                                 lldb::DataBufferSP data_sp,
+                                 lldb::offset_t data_offset)
+    : ModuleChild(module_sp),
+      m_file(), // This file can be different than the module's file spec
+      m_offset(file_offset), m_length(length) {
+  if (file)
+    m_file = *file;
+  if (data_sp)
+    m_data.SetData(data_sp, data_offset, length);
+}
+
+ObjectContainerSP ObjectContainer::FindPlugin(const lldb::ModuleSP &module_sp,
+                                              const ProcessSP &process_sp,
+                                              lldb::addr_t header_addr,
+                                              WritableDataBufferSP data_sp) {
+  if (!module_sp)
+    return {};
+
+  LLDB_SCOPED_TIMERF("ObjectContainer::FindPlugin (module = "
+                     "%s, process = %p, header_addr = "
+                     "0x%" PRIx64 ")",
+                     module_sp->GetFileSpec().GetPath().c_str(),
+                     static_cast<void *>(process_sp.get()), header_addr);
+
+  ObjectContainerCreateMemoryInstance create_callback;
+  for (size_t idx = 0;
+       (create_callback =
+            PluginManager::GetObjectContainerCreateMemoryCallbackAtIndex(
+                idx)) != nullptr;
+       ++idx) {
+    ObjectContainerSP object_container_sp(
+        create_callback(module_sp, data_sp, process_sp, header_addr));
+    if (object_container_sp)
+      return object_container_sp;
+  }
+
+  return {};
+}