[lldb] Computer and apply the slide to the fileset entry's vmaddr

[JDevlieghere]

Summary

Computer and apply the slide to the fileset entry's vmaddr when reading a fileset from memory.

[jasonmolenda]

LGTM.

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

public:
 
   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/source/Plugins/ObjectContainer/Mach-O-Fileset/ObjectContainerMachOFileset.cpp

static llvm::Optional<mach_header> ParseMachOHeader(DataExtractor &data) {
   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) {
+             std::vector<ObjectContainerMachOFileset::Entry> &entries,
+             llvm::Optional<lldb::addr_t> load_addr = llvm::None) {
   lldb::offset_t offset = MachHeaderSizeFromMagic(header.magic);
+  lldb::offset_t slide = 0;
   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 we know the load address we can compute the slide.
+    if (load_addr) {
+      if (lc.cmd == llvm::MachO::LC_SEGMENT_64) {
+        segment_command_64 segment;
+        data.CopyData(load_cmd_offset, sizeof(segment_command_64), &segment);
+        if (llvm::StringRef(segment.segname) == "__TEXT")
+          slide = *load_addr - segment.vmaddr;
+      }
+    }
+
     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));
+      entries.emplace_back(entry.vmaddr + slide, entry.fileoff,
+                           std::string(id));
     }
+
     offset = load_cmd_offset + lc.cmdsize;
   }
 
   return true;
 }
 
 bool ObjectContainerMachOFileset::ParseHeader(
     DataExtractor &data, const lldb_private::FileSpec &file,
if (m_data.GetByteSize() < header_and_lc_size) {
     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);
+  return ParseFileset(m_data, *header, m_entries, m_memory_addr);
 }
 
 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();