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

   1 //===-- ObjectContainerMachOFileset.cpp -----------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "ObjectContainerMachOFileset.h"
  10 #include "lldb/Core/Module.h"
  11 #include "lldb/Core/ModuleSpec.h"
  12 #include "lldb/Core/PluginManager.h"
  13 #include "lldb/Symbol/ObjectFile.h"
  14 #include "lldb/Target/Target.h"
  15 #include "lldb/Utility/ArchSpec.h"
  16 #include "lldb/Utility/DataBuffer.h"
  17 #include "lldb/Utility/Stream.h"
  18 #include <optional>
  19
  20 using namespace lldb;
  21 using namespace lldb_private;
  22 using namespace llvm::MachO;
  23
  24 LLDB_PLUGIN_DEFINE(ObjectContainerMachOFileset)
  25
  26 void ObjectContainerMachOFileset::Initialize() {
  27   PluginManager::RegisterPlugin(GetPluginNameStatic(),
  28                                 GetPluginDescriptionStatic(), CreateInstance,
  29                                 GetModuleSpecifications, CreateMemoryInstance);
  30 }
  31
  32 void ObjectContainerMachOFileset::Terminate() {
  33   PluginManager::UnregisterPlugin(CreateInstance);
  34 }
  35
  36 ObjectContainerMachOFileset::ObjectContainerMachOFileset(
  37     const lldb::ModuleSP &module_sp, lldb::DataBufferSP &data_sp,
  38     lldb::offset_t data_offset, const lldb_private::FileSpec *file,
  39     lldb::offset_t offset, lldb::offset_t length)
  40     : ObjectContainer(module_sp, file, offset, length, data_sp, data_offset),
  41       m_memory_addr(LLDB_INVALID_ADDRESS) {}
  42
  43 ObjectContainerMachOFileset::ObjectContainerMachOFileset(
  44     const lldb::ModuleSP &module_sp, lldb::WritableDataBufferSP data_sp,
  45     const lldb::ProcessSP &process_sp, lldb::addr_t header_addr)
  46     : ObjectContainer(module_sp, nullptr, 0, data_sp->GetByteSize(), data_sp,
  47                       0),
  48       m_process_wp(process_sp), m_memory_addr(header_addr) {}
  49
  50 ObjectContainer *ObjectContainerMachOFileset::CreateInstance(
  51     const lldb::ModuleSP &module_sp, DataBufferSP &data_sp,
  52     lldb::offset_t data_offset, const FileSpec *file,
  53     lldb::offset_t file_offset, lldb::offset_t length) {
  54   if (!data_sp)
  55     return {};
  56
  57   DataExtractor data;
  58   data.SetData(data_sp, data_offset, length);
  59   if (!MagicBytesMatch(data))
  60     return {};
  61
  62   auto container_up = std::make_unique<ObjectContainerMachOFileset>(
  63       module_sp, data_sp, data_offset, file, file_offset, length);
  64   if (!container_up->ParseHeader())
  65     return {};
  66
  67   return container_up.release();
  68 }
  69
  70 ObjectContainer *ObjectContainerMachOFileset::CreateMemoryInstance(
  71     const lldb::ModuleSP &module_sp, lldb::WritableDataBufferSP data_sp,
  72     const lldb::ProcessSP &process_sp, lldb::addr_t header_addr) {
  73   if (!MagicBytesMatch(data_sp, 0, data_sp->GetByteSize()))
  74     return {};
  75
  76   auto container_up = std::make_unique<ObjectContainerMachOFileset>(
  77       module_sp, data_sp, process_sp, header_addr);
  78   if (!container_up->ParseHeader())
  79     return {};
  80
  81   return container_up.release();
  82 }
  83
  84 ObjectContainerMachOFileset::~ObjectContainerMachOFileset() = default;
  85
  86 static uint32_t MachHeaderSizeFromMagic(uint32_t magic) {
  87   switch (magic) {
  88   case MH_MAGIC:
  89   case MH_CIGAM:
  90     return sizeof(struct mach_header);
  91   case MH_MAGIC_64:
  92   case MH_CIGAM_64:
  93     return sizeof(struct mach_header_64);
  94   default:
  95     return 0;
  96   }
  97 }
  98
  99 static std::optional<mach_header> ParseMachOHeader(DataExtractor &data) {
 100   lldb::offset_t offset = 0;
 101   mach_header header;
 102   header.magic = data.GetU32(&offset);
 103   switch (header.magic) {
 104   case MH_MAGIC:
 105     data.SetByteOrder(endian::InlHostByteOrder());
 106     data.SetAddressByteSize(4);
 107     break;
 108   case MH_MAGIC_64:
 109     data.SetByteOrder(endian::InlHostByteOrder());
 110     data.SetAddressByteSize(8);
 111     break;
 112   case MH_CIGAM:
 113     data.SetByteOrder(endian::InlHostByteOrder() == eByteOrderBig
 114                           ? eByteOrderLittle
 115                           : eByteOrderBig);
 116     data.SetAddressByteSize(4);
 117     break;
 118   case MH_CIGAM_64:
 119     data.SetByteOrder(endian::InlHostByteOrder() == eByteOrderBig
 120                           ? eByteOrderLittle
 121                           : eByteOrderBig);
 122     data.SetAddressByteSize(8);
 123     break;
 124   default:
 125     return {};
 126   }
 127
 128   header.cputype = data.GetU32(&offset);
 129   header.cpusubtype = data.GetU32(&offset);
 130   header.filetype = data.GetU32(&offset);
 131   header.ncmds = data.GetU32(&offset);
 132   header.sizeofcmds = data.GetU32(&offset);
 133   return header;
 134 }
 135
 136 static bool
 137 ParseFileset(DataExtractor &data, mach_header header,
 138              std::vector<ObjectContainerMachOFileset::Entry> &entries,
 139              std::optional<lldb::addr_t> load_addr = std::nullopt) {
 140   lldb::offset_t offset = MachHeaderSizeFromMagic(header.magic);
 141   lldb::offset_t slide = 0;
 142   for (uint32_t i = 0; i < header.ncmds; ++i) {
 143     const lldb::offset_t load_cmd_offset = offset;
 144     load_command lc = {};
 145     if (data.GetU32(&offset, &lc.cmd, 2) == nullptr)
 146       break;
 147
 148     // If we know the load address we can compute the slide.
 149     if (load_addr) {
 150       if (lc.cmd == llvm::MachO::LC_SEGMENT_64) {
 151         segment_command_64 segment;
 152         data.CopyData(load_cmd_offset, sizeof(segment_command_64), &segment);
 153         if (llvm::StringRef(segment.segname) == "__TEXT")
 154           slide = *load_addr - segment.vmaddr;
 155       }
 156     }
 157
 158     if (lc.cmd == LC_FILESET_ENTRY) {
 159       fileset_entry_command entry;
 160       data.CopyData(load_cmd_offset, sizeof(fileset_entry_command), &entry);
 161       lldb::offset_t entry_id_offset = load_cmd_offset + entry.entry_id.offset;
 162       const char *id = data.GetCStr(&entry_id_offset);
 163       entries.emplace_back(entry.vmaddr + slide, entry.fileoff,
 164                            std::string(id));
 165     }
 166
 167     offset = load_cmd_offset + lc.cmdsize;
 168   }
 169
 170   return true;
 171 }
 172
 173 bool ObjectContainerMachOFileset::ParseHeader(
 174     DataExtractor &data, const lldb_private::FileSpec &file,
 175     lldb::offset_t file_offset, std::vector<Entry> &entries) {
 176   std::optional<mach_header> header = ParseMachOHeader(data);
 177
 178   if (!header)
 179     return false;
 180
 181   const size_t header_size = MachHeaderSizeFromMagic(header->magic);
 182   const size_t header_and_lc_size = header_size + header->sizeofcmds;
 183
 184   if (data.GetByteSize() < header_and_lc_size) {
 185     DataBufferSP data_sp =
 186         ObjectFile::MapFileData(file, header_and_lc_size, file_offset);
 187     data.SetData(data_sp);
 188   }
 189
 190   return ParseFileset(data, *header, entries);
 191 }
 192
 193 bool ObjectContainerMachOFileset::ParseHeader() {
 194   ModuleSP module_sp(GetModule());
 195   if (!module_sp)
 196     return false;
 197
 198   std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
 199
 200   std::optional<mach_header> header = ParseMachOHeader(m_data);
 201   if (!header)
 202     return false;
 203
 204   const size_t header_size = MachHeaderSizeFromMagic(header->magic);
 205   const size_t header_and_lc_size = header_size + header->sizeofcmds;
 206
 207   if (m_data.GetByteSize() < header_and_lc_size) {
 208     ProcessSP process_sp(m_process_wp.lock());
 209     DataBufferSP data_sp =
 210         process_sp
 211             ? ObjectFile::ReadMemory(process_sp, m_memory_addr,
 212                                      header_and_lc_size)
 213             : ObjectFile::MapFileData(m_file, header_and_lc_size, m_offset);
 214     m_data.SetData(data_sp);
 215   }
 216
 217   return ParseFileset(m_data, *header, m_entries, m_memory_addr);
 218 }
 219
 220 size_t ObjectContainerMachOFileset::GetModuleSpecifications(
 221     const lldb_private::FileSpec &file, lldb::DataBufferSP &data_sp,
 222     lldb::offset_t data_offset, lldb::offset_t file_offset,
 223     lldb::offset_t file_size, lldb_private::ModuleSpecList &specs) {
 224   const size_t initial_count = specs.GetSize();
 225
 226   DataExtractor data;
 227   data.SetData(data_sp, data_offset, data_sp->GetByteSize());
 228
 229   if (MagicBytesMatch(data)) {
 230     std::vector<Entry> entries;
 231     if (ParseHeader(data, file, file_offset, entries)) {
 232       for (const Entry &entry : entries) {
 233         const lldb::offset_t entry_offset = entry.fileoff + file_offset;
 234         if (ObjectFile::GetModuleSpecifications(
 235                 file, entry_offset, file_size - entry_offset, specs)) {
 236           ModuleSpec &spec = specs.GetModuleSpecRefAtIndex(specs.GetSize() - 1);
 237           spec.GetObjectName() = ConstString(entry.id);
 238         }
 239       }
 240     }
 241   }
 242   return specs.GetSize() - initial_count;
 243 }
 244
 245 bool ObjectContainerMachOFileset::MagicBytesMatch(DataBufferSP data_sp,
 246                                                   lldb::addr_t data_offset,
 247                                                   lldb::addr_t data_length) {
 248   DataExtractor data;
 249   data.SetData(data_sp, data_offset, data_length);
 250   return MagicBytesMatch(data);
 251 }
 252
 253 bool ObjectContainerMachOFileset::MagicBytesMatch(const DataExtractor &data) {
 254   lldb::offset_t offset = 0;
 255   uint32_t magic = data.GetU32(&offset);
 256   switch (magic) {
 257   case MH_MAGIC:
 258   case MH_CIGAM:
 259   case MH_MAGIC_64:
 260   case MH_CIGAM_64:
 261     break;
 262   default:
 263     return false;
 264   }
 265   offset += 4; // cputype
 266   offset += 4; // cpusubtype
 267   uint32_t filetype = data.GetU32(&offset);
 268   return filetype == MH_FILESET;
 269 }
 270
 271 ObjectFileSP
 272 ObjectContainerMachOFileset::GetObjectFile(const lldb_private::FileSpec *file) {
 273   ModuleSP module_sp(GetModule());
 274   if (!module_sp)
 275     return {};
 276
 277   ConstString object_name = module_sp->GetObjectName();
 278   if (!object_name)
 279     return {};
 280
 281   Entry *entry = FindEntry(object_name.GetCString());
 282   if (!entry)
 283     return {};
 284
 285   DataBufferSP data_sp;
 286   lldb::offset_t data_offset = 0;
 287   return ObjectFile::FindPlugin(module_sp, file, m_offset + entry->fileoff,
 288                                 m_data.GetByteSize() - entry->fileoff, data_sp,
 289                                 data_offset);
 290 }
 291
 292 ObjectContainerMachOFileset::Entry *
 293 ObjectContainerMachOFileset::FindEntry(llvm::StringRef id) {
 294   for (Entry &entry : m_entries) {
 295     if (entry.id == id)
 296       return &entry;
 297   }
 298   return nullptr;
 299 }