lldb/source/Symbol/ObjectFile.cpp

   1 //===-- ObjectFile.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 "lldb/Symbol/ObjectFile.h"
  10 #include "lldb/Core/Module.h"
  11 #include "lldb/Core/ModuleSpec.h"
  12 #include "lldb/Core/PluginManager.h"
  13 #include "lldb/Core/Section.h"
  14 #include "lldb/Symbol/CallFrameInfo.h"
  15 #include "lldb/Symbol/ObjectContainer.h"
  16 #include "lldb/Symbol/SymbolFile.h"
  17 #include "lldb/Target/Process.h"
  18 #include "lldb/Target/SectionLoadList.h"
  19 #include "lldb/Target/Target.h"
  20 #include "lldb/Utility/DataBuffer.h"
  21 #include "lldb/Utility/DataBufferHeap.h"
  22 #include "lldb/Utility/LLDBLog.h"
  23 #include "lldb/Utility/Log.h"
  24 #include "lldb/Utility/Timer.h"
  25 #include "lldb/lldb-private.h"
  26
  27 #include "llvm/Support/DJB.h"
  28
  29 using namespace lldb;
  30 using namespace lldb_private;
  31
  32 char ObjectFile::ID;
  33 size_t ObjectFile::g_initial_bytes_to_read = 512;
  34
  35 static ObjectFileSP
  36 CreateObjectFromContainer(const lldb::ModuleSP &module_sp, const FileSpec *file,
  37                           lldb::offset_t file_offset, lldb::offset_t file_size,
  38                           DataBufferSP data_sp, lldb::offset_t &data_offset) {
  39   ObjectContainerCreateInstance callback;
  40   for (uint32_t idx = 0;
  41        (callback = PluginManager::GetObjectContainerCreateCallbackAtIndex(
  42             idx)) != nullptr;
  43        ++idx) {
  44     std::unique_ptr<ObjectContainer> object_container_up(callback(
  45         module_sp, data_sp, data_offset, file, file_offset, file_size));
  46     if (object_container_up)
  47       return object_container_up->GetObjectFile(file);
  48   }
  49   return {};
  50 }
  51
  52 ObjectFileSP
  53 ObjectFile::FindPlugin(const lldb::ModuleSP &module_sp, const FileSpec *file,
  54                        lldb::offset_t file_offset, lldb::offset_t file_size,
  55                        DataBufferSP &data_sp, lldb::offset_t &data_offset) {
  56   LLDB_SCOPED_TIMERF(
  57       "ObjectFile::FindPlugin (module = %s, file = %p, file_offset = "
  58       "0x%8.8" PRIx64 ", file_size = 0x%8.8" PRIx64 ")",
  59       module_sp->GetFileSpec().GetPath().c_str(),
  60       static_cast<const void *>(file), static_cast<uint64_t>(file_offset),
  61       static_cast<uint64_t>(file_size));
  62
  63   if (!module_sp)
  64     return {};
  65
  66   if (!file)
  67     return {};
  68
  69   if (!data_sp) {
  70     const bool file_exists = FileSystem::Instance().Exists(*file);
  71     // We have an object name which most likely means we have a .o file in
  72     // a static archive (.a file). Try and see if we have a cached archive
  73     // first without reading any data first
  74     if (file_exists && module_sp->GetObjectName()) {
  75       ObjectFileSP object_file_sp = CreateObjectFromContainer(
  76           module_sp, file, file_offset, file_size, data_sp, data_offset);
  77       if (object_file_sp)
  78         return object_file_sp;
  79     }
  80     // Ok, we didn't find any containers that have a named object, now lets
  81     // read the first 512 bytes from the file so the object file and object
  82     // container plug-ins can use these bytes to see if they can parse this
  83     // file.
  84     if (file_size > 0) {
  85       data_sp = FileSystem::Instance().CreateDataBuffer(
  86           file->GetPath(), g_initial_bytes_to_read, file_offset);
  87       data_offset = 0;
  88     }
  89   }
  90
  91   if (!data_sp || data_sp->GetByteSize() == 0) {
  92     // Check for archive file with format "/path/to/archive.a(object.o)"
  93     llvm::SmallString<256> path_with_object;
  94     module_sp->GetFileSpec().GetPath(path_with_object);
  95
  96     FileSpec archive_file;
  97     ConstString archive_object;
  98     const bool must_exist = true;
  99     if (ObjectFile::SplitArchivePathWithObject(path_with_object, archive_file,
 100                                                archive_object, must_exist)) {
 101       file_size = FileSystem::Instance().GetByteSize(archive_file);
 102       if (file_size > 0) {
 103         file = &archive_file;
 104         module_sp->SetFileSpecAndObjectName(archive_file, archive_object);
 105         // Check if this is a object container by iterating through all
 106         // object container plugin instances and then trying to get an
 107         // object file from the container plugins since we had a name.
 108         // Also, don't read
 109         // ANY data in case there is data cached in the container plug-ins
 110         // (like BSD archives caching the contained objects within an
 111         // file).
 112         ObjectFileSP object_file_sp = CreateObjectFromContainer(
 113             module_sp, file, file_offset, file_size, data_sp, data_offset);
 114         if (object_file_sp)
 115           return object_file_sp;
 116         // We failed to find any cached object files in the container plug-
 117         // ins, so lets read the first 512 bytes and try again below...
 118         data_sp = FileSystem::Instance().CreateDataBuffer(
 119             archive_file.GetPath(), g_initial_bytes_to_read, file_offset);
 120       }
 121     }
 122   }
 123
 124   if (data_sp && data_sp->GetByteSize() > 0) {
 125     // Check if this is a normal object file by iterating through all
 126     // object file plugin instances.
 127     ObjectFileCreateInstance callback;
 128     for (uint32_t idx = 0;
 129          (callback = PluginManager::GetObjectFileCreateCallbackAtIndex(idx)) !=
 130          nullptr;
 131          ++idx) {
 132       ObjectFileSP object_file_sp(callback(module_sp, data_sp, data_offset,
 133                                            file, file_offset, file_size));
 134       if (object_file_sp.get())
 135         return object_file_sp;
 136     }
 137
 138     // Check if this is a object container by iterating through all object
 139     // container plugin instances and then trying to get an object file
 140     // from the container.
 141     ObjectFileSP object_file_sp = CreateObjectFromContainer(
 142         module_sp, file, file_offset, file_size, data_sp, data_offset);
 143     if (object_file_sp)
 144       return object_file_sp;
 145   }
 146
 147   // We didn't find it, so clear our shared pointer in case it contains
 148   // anything and return an empty shared pointer
 149   return {};
 150 }
 151
 152 ObjectFileSP ObjectFile::FindPlugin(const lldb::ModuleSP &module_sp,
 153                                     const ProcessSP &process_sp,
 154                                     lldb::addr_t header_addr,
 155                                     WritableDataBufferSP data_sp) {
 156   ObjectFileSP object_file_sp;
 157
 158   if (module_sp) {
 159     LLDB_SCOPED_TIMERF("ObjectFile::FindPlugin (module = "
 160                        "%s, process = %p, header_addr = "
 161                        "0x%" PRIx64 ")",
 162                        module_sp->GetFileSpec().GetPath().c_str(),
 163                        static_cast<void *>(process_sp.get()), header_addr);
 164     uint32_t idx;
 165
 166     // Check if this is a normal object file by iterating through all object
 167     // file plugin instances.
 168     ObjectFileCreateMemoryInstance create_callback;
 169     for (idx = 0;
 170          (create_callback =
 171               PluginManager::GetObjectFileCreateMemoryCallbackAtIndex(idx)) !=
 172          nullptr;
 173          ++idx) {
 174       object_file_sp.reset(
 175           create_callback(module_sp, data_sp, process_sp, header_addr));
 176       if (object_file_sp.get())
 177         return object_file_sp;
 178     }
 179   }
 180
 181   // We didn't find it, so clear our shared pointer in case it contains
 182   // anything and return an empty shared pointer
 183   object_file_sp.reset();
 184   return object_file_sp;
 185 }
 186
 187 bool ObjectFile::IsObjectFile(lldb_private::FileSpec file_spec) {
 188   DataBufferSP data_sp;
 189   offset_t data_offset = 0;
 190   ModuleSP module_sp = std::make_shared<Module>(file_spec);
 191   return static_cast<bool>(ObjectFile::FindPlugin(
 192       module_sp, &file_spec, 0, FileSystem::Instance().GetByteSize(file_spec),
 193       data_sp, data_offset));
 194 }
 195
 196 size_t ObjectFile::GetModuleSpecifications(const FileSpec &file,
 197                                            lldb::offset_t file_offset,
 198                                            lldb::offset_t file_size,
 199                                            ModuleSpecList &specs,
 200                                            DataBufferSP data_sp) {
 201   if (!data_sp)
 202     data_sp = FileSystem::Instance().CreateDataBuffer(
 203         file.GetPath(), g_initial_bytes_to_read, file_offset);
 204   if (data_sp) {
 205     if (file_size == 0) {
 206       const lldb::offset_t actual_file_size =
 207           FileSystem::Instance().GetByteSize(file);
 208       if (actual_file_size > file_offset)
 209         file_size = actual_file_size - file_offset;
 210     }
 211     return ObjectFile::GetModuleSpecifications(file,        // file spec
 212                                                data_sp,     // data bytes
 213                                                0,           // data offset
 214                                                file_offset, // file offset
 215                                                file_size,   // file length
 216                                                specs);
 217   }
 218   return 0;
 219 }
 220
 221 size_t ObjectFile::GetModuleSpecifications(
 222     const lldb_private::FileSpec &file, lldb::DataBufferSP &data_sp,
 223     lldb::offset_t data_offset, lldb::offset_t file_offset,
 224     lldb::offset_t file_size, lldb_private::ModuleSpecList &specs) {
 225   const size_t initial_count = specs.GetSize();
 226   ObjectFileGetModuleSpecifications callback;
 227   uint32_t i;
 228   // Try the ObjectFile plug-ins
 229   for (i = 0;
 230        (callback =
 231             PluginManager::GetObjectFileGetModuleSpecificationsCallbackAtIndex(
 232                 i)) != nullptr;
 233        ++i) {
 234     if (callback(file, data_sp, data_offset, file_offset, file_size, specs) > 0)
 235       return specs.GetSize() - initial_count;
 236   }
 237
 238   // Try the ObjectContainer plug-ins
 239   for (i = 0;
 240        (callback = PluginManager::
 241             GetObjectContainerGetModuleSpecificationsCallbackAtIndex(i)) !=
 242        nullptr;
 243        ++i) {
 244     if (callback(file, data_sp, data_offset, file_offset, file_size, specs) > 0)
 245       return specs.GetSize() - initial_count;
 246   }
 247   return 0;
 248 }
 249
 250 ObjectFile::ObjectFile(const lldb::ModuleSP &module_sp,
 251                        const FileSpec *file_spec_ptr,
 252                        lldb::offset_t file_offset, lldb::offset_t length,
 253                        lldb::DataBufferSP data_sp, lldb::offset_t data_offset)
 254     : ModuleChild(module_sp),
 255       m_file(), // This file could be different from the original module's file
 256       m_type(eTypeInvalid), m_strata(eStrataInvalid),
 257       m_file_offset(file_offset), m_length(length), m_data(), m_process_wp(),
 258       m_memory_addr(LLDB_INVALID_ADDRESS), m_sections_up(), m_symtab_up(),
 259       m_symtab_once_up(new llvm::once_flag()) {
 260   if (file_spec_ptr)
 261     m_file = *file_spec_ptr;
 262   if (data_sp)
 263     m_data.SetData(data_sp, data_offset, length);
 264   Log *log = GetLog(LLDBLog::Object);
 265   LLDB_LOGF(log,
 266             "%p ObjectFile::ObjectFile() module = %p (%s), file = %s, "
 267             "file_offset = 0x%8.8" PRIx64 ", size = %" PRIu64,
 268             static_cast<void *>(this), static_cast<void *>(module_sp.get()),
 269             module_sp->GetSpecificationDescription().c_str(),
 270             m_file ? m_file.GetPath().c_str() : "<NULL>", m_file_offset,
 271             m_length);
 272 }
 273
 274 ObjectFile::ObjectFile(const lldb::ModuleSP &module_sp,
 275                        const ProcessSP &process_sp, lldb::addr_t header_addr,
 276                        DataBufferSP header_data_sp)
 277     : ModuleChild(module_sp), m_file(), m_type(eTypeInvalid),
 278       m_strata(eStrataInvalid), m_file_offset(0), m_length(0), m_data(),
 279       m_process_wp(process_sp), m_memory_addr(header_addr), m_sections_up(),
 280       m_symtab_up(), m_symtab_once_up(new llvm::once_flag()) {
 281   if (header_data_sp)
 282     m_data.SetData(header_data_sp, 0, header_data_sp->GetByteSize());
 283   Log *log = GetLog(LLDBLog::Object);
 284   LLDB_LOGF(log,
 285             "%p ObjectFile::ObjectFile() module = %p (%s), process = %p, "
 286             "header_addr = 0x%" PRIx64,
 287             static_cast<void *>(this), static_cast<void *>(module_sp.get()),
 288             module_sp->GetSpecificationDescription().c_str(),
 289             static_cast<void *>(process_sp.get()), m_memory_addr);
 290 }
 291
 292 ObjectFile::~ObjectFile() {
 293   Log *log = GetLog(LLDBLog::Object);
 294   LLDB_LOGF(log, "%p ObjectFile::~ObjectFile ()\n", static_cast<void *>(this));
 295 }
 296
 297 bool ObjectFile::SetModulesArchitecture(const ArchSpec &new_arch) {
 298   ModuleSP module_sp(GetModule());
 299   if (module_sp)
 300     return module_sp->SetArchitecture(new_arch);
 301   return false;
 302 }
 303
 304 AddressClass ObjectFile::GetAddressClass(addr_t file_addr) {
 305   Symtab *symtab = GetSymtab();
 306   if (symtab) {
 307     Symbol *symbol = symtab->FindSymbolContainingFileAddress(file_addr);
 308     if (symbol) {
 309       if (symbol->ValueIsAddress()) {
 310         const SectionSP section_sp(symbol->GetAddressRef().GetSection());
 311         if (section_sp) {
 312           const SectionType section_type = section_sp->GetType();
 313           switch (section_type) {
 314           case eSectionTypeInvalid:
 315             return AddressClass::eUnknown;
 316           case eSectionTypeCode:
 317             return AddressClass::eCode;
 318           case eSectionTypeContainer:
 319             return AddressClass::eUnknown;
 320           case eSectionTypeData:
 321           case eSectionTypeDataCString:
 322           case eSectionTypeDataCStringPointers:
 323           case eSectionTypeDataSymbolAddress:
 324           case eSectionTypeData4:
 325           case eSectionTypeData8:
 326           case eSectionTypeData16:
 327           case eSectionTypeDataPointers:
 328           case eSectionTypeZeroFill:
 329           case eSectionTypeDataObjCMessageRefs:
 330           case eSectionTypeDataObjCCFStrings:
 331           case eSectionTypeGoSymtab:
 332             return AddressClass::eData;
 333           case eSectionTypeDebug:
 334           case eSectionTypeDWARFDebugAbbrev:
 335           case eSectionTypeDWARFDebugAbbrevDwo:
 336           case eSectionTypeDWARFDebugAddr:
 337           case eSectionTypeDWARFDebugAranges:
 338           case eSectionTypeDWARFDebugCuIndex:
 339           case eSectionTypeDWARFDebugFrame:
 340           case eSectionTypeDWARFDebugInfo:
 341           case eSectionTypeDWARFDebugInfoDwo:
 342           case eSectionTypeDWARFDebugLine:
 343           case eSectionTypeDWARFDebugLineStr:
 344           case eSectionTypeDWARFDebugLoc:
 345           case eSectionTypeDWARFDebugLocDwo:
 346           case eSectionTypeDWARFDebugLocLists:
 347           case eSectionTypeDWARFDebugLocListsDwo:
 348           case eSectionTypeDWARFDebugMacInfo:
 349           case eSectionTypeDWARFDebugMacro:
 350           case eSectionTypeDWARFDebugNames:
 351           case eSectionTypeDWARFDebugPubNames:
 352           case eSectionTypeDWARFDebugPubTypes:
 353           case eSectionTypeDWARFDebugRanges:
 354           case eSectionTypeDWARFDebugRngLists:
 355           case eSectionTypeDWARFDebugRngListsDwo:
 356           case eSectionTypeDWARFDebugStr:
 357           case eSectionTypeDWARFDebugStrDwo:
 358           case eSectionTypeDWARFDebugStrOffsets:
 359           case eSectionTypeDWARFDebugStrOffsetsDwo:
 360           case eSectionTypeDWARFDebugTuIndex:
 361           case eSectionTypeDWARFDebugTypes:
 362           case eSectionTypeDWARFDebugTypesDwo:
 363           case eSectionTypeDWARFAppleNames:
 364           case eSectionTypeDWARFAppleTypes:
 365           case eSectionTypeDWARFAppleNamespaces:
 366           case eSectionTypeDWARFAppleObjC:
 367           case eSectionTypeDWARFGNUDebugAltLink:
 368           case eSectionTypeCTF:
 369           case eSectionTypeSwiftModules:
 370             return AddressClass::eDebug;
 371           case eSectionTypeEHFrame:
 372           case eSectionTypeARMexidx:
 373           case eSectionTypeARMextab:
 374           case eSectionTypeCompactUnwind:
 375             return AddressClass::eRuntime;
 376           case eSectionTypeELFSymbolTable:
 377           case eSectionTypeELFDynamicSymbols:
 378           case eSectionTypeELFRelocationEntries:
 379           case eSectionTypeELFDynamicLinkInfo:
 380           case eSectionTypeOther:
 381             return AddressClass::eUnknown;
 382           case eSectionTypeAbsoluteAddress:
 383             // In case of absolute sections decide the address class based on
 384             // the symbol type because the section type isn't specify if it is
 385             // a code or a data section.
 386             break;
 387           }
 388         }
 389       }
 390
 391       const SymbolType symbol_type = symbol->GetType();
 392       switch (symbol_type) {
 393       case eSymbolTypeAny:
 394         return AddressClass::eUnknown;
 395       case eSymbolTypeAbsolute:
 396         return AddressClass::eUnknown;
 397       case eSymbolTypeCode:
 398         return AddressClass::eCode;
 399       case eSymbolTypeTrampoline:
 400         return AddressClass::eCode;
 401       case eSymbolTypeResolver:
 402         return AddressClass::eCode;
 403       case eSymbolTypeData:
 404         return AddressClass::eData;
 405       case eSymbolTypeRuntime:
 406         return AddressClass::eRuntime;
 407       case eSymbolTypeException:
 408         return AddressClass::eRuntime;
 409       case eSymbolTypeSourceFile:
 410         return AddressClass::eDebug;
 411       case eSymbolTypeHeaderFile:
 412         return AddressClass::eDebug;
 413       case eSymbolTypeObjectFile:
 414         return AddressClass::eDebug;
 415       case eSymbolTypeCommonBlock:
 416         return AddressClass::eDebug;
 417       case eSymbolTypeBlock:
 418         return AddressClass::eDebug;
 419       case eSymbolTypeLocal:
 420         return AddressClass::eData;
 421       case eSymbolTypeParam:
 422         return AddressClass::eData;
 423       case eSymbolTypeVariable:
 424         return AddressClass::eData;
 425       case eSymbolTypeVariableType:
 426         return AddressClass::eDebug;
 427       case eSymbolTypeLineEntry:
 428         return AddressClass::eDebug;
 429       case eSymbolTypeLineHeader:
 430         return AddressClass::eDebug;
 431       case eSymbolTypeScopeBegin:
 432         return AddressClass::eDebug;
 433       case eSymbolTypeScopeEnd:
 434         return AddressClass::eDebug;
 435       case eSymbolTypeAdditional:
 436         return AddressClass::eUnknown;
 437       case eSymbolTypeCompiler:
 438         return AddressClass::eDebug;
 439       case eSymbolTypeInstrumentation:
 440         return AddressClass::eDebug;
 441       case eSymbolTypeUndefined:
 442         return AddressClass::eUnknown;
 443       case eSymbolTypeObjCClass:
 444         return AddressClass::eRuntime;
 445       case eSymbolTypeObjCMetaClass:
 446         return AddressClass::eRuntime;
 447       case eSymbolTypeObjCIVar:
 448         return AddressClass::eRuntime;
 449       case eSymbolTypeReExported:
 450         return AddressClass::eRuntime;
 451       }
 452     }
 453   }
 454   return AddressClass::eUnknown;
 455 }
 456
 457 WritableDataBufferSP ObjectFile::ReadMemory(const ProcessSP &process_sp,
 458                                             lldb::addr_t addr,
 459                                             size_t byte_size) {
 460   WritableDataBufferSP data_sp;
 461   if (process_sp) {
 462     std::unique_ptr<DataBufferHeap> data_up(new DataBufferHeap(byte_size, 0));
 463     Status error;
 464     const size_t bytes_read = process_sp->ReadMemory(
 465         addr, data_up->GetBytes(), data_up->GetByteSize(), error);
 466     if (bytes_read == byte_size)
 467       data_sp.reset(data_up.release());
 468   }
 469   return data_sp;
 470 }
 471
 472 size_t ObjectFile::GetData(lldb::offset_t offset, size_t length,
 473                            DataExtractor &data) const {
 474   // The entire file has already been mmap'ed into m_data, so just copy from
 475   // there as the back mmap buffer will be shared with shared pointers.
 476   return data.SetData(m_data, offset, length);
 477 }
 478
 479 size_t ObjectFile::CopyData(lldb::offset_t offset, size_t length,
 480                             void *dst) const {
 481   // The entire file has already been mmap'ed into m_data, so just copy from
 482   // there Note that the data remains in target byte order.
 483   return m_data.CopyData(offset, length, dst);
 484 }
 485
 486 size_t ObjectFile::ReadSectionData(Section *section,
 487                                    lldb::offset_t section_offset, void *dst,
 488                                    size_t dst_len) {
 489   assert(section);
 490   section_offset *= section->GetTargetByteSize();
 491
 492   // If some other objectfile owns this data, pass this to them.
 493   if (section->GetObjectFile() != this)
 494     return section->GetObjectFile()->ReadSectionData(section, section_offset,
 495                                                      dst, dst_len);
 496
 497   if (!section->IsRelocated())
 498     RelocateSection(section);
 499
 500   if (IsInMemory()) {
 501     ProcessSP process_sp(m_process_wp.lock());
 502     if (process_sp) {
 503       Status error;
 504       const addr_t base_load_addr =
 505           section->GetLoadBaseAddress(&process_sp->GetTarget());
 506       if (base_load_addr != LLDB_INVALID_ADDRESS)
 507         return process_sp->ReadMemory(base_load_addr + section_offset, dst,
 508                                       dst_len, error);
 509     }
 510   } else {
 511     const lldb::offset_t section_file_size = section->GetFileSize();
 512     if (section_offset < section_file_size) {
 513       const size_t section_bytes_left = section_file_size - section_offset;
 514       size_t section_dst_len = dst_len;
 515       if (section_dst_len > section_bytes_left)
 516         section_dst_len = section_bytes_left;
 517       return CopyData(section->GetFileOffset() + section_offset,
 518                       section_dst_len, dst);
 519     } else {
 520       if (section->GetType() == eSectionTypeZeroFill) {
 521         const uint64_t section_size = section->GetByteSize();
 522         const uint64_t section_bytes_left = section_size - section_offset;
 523         uint64_t section_dst_len = dst_len;
 524         if (section_dst_len > section_bytes_left)
 525           section_dst_len = section_bytes_left;
 526         memset(dst, 0, section_dst_len);
 527         return section_dst_len;
 528       }
 529     }
 530   }
 531   return 0;
 532 }
 533
 534 // Get the section data the file on disk
 535 size_t ObjectFile::ReadSectionData(Section *section,
 536                                    DataExtractor &section_data) {
 537   // If some other objectfile owns this data, pass this to them.
 538   if (section->GetObjectFile() != this)
 539     return section->GetObjectFile()->ReadSectionData(section, section_data);
 540
 541   if (!section->IsRelocated())
 542     RelocateSection(section);
 543
 544   if (IsInMemory()) {
 545     ProcessSP process_sp(m_process_wp.lock());
 546     if (process_sp) {
 547       const addr_t base_load_addr =
 548           section->GetLoadBaseAddress(&process_sp->GetTarget());
 549       if (base_load_addr != LLDB_INVALID_ADDRESS) {
 550         DataBufferSP data_sp(
 551             ReadMemory(process_sp, base_load_addr, section->GetByteSize()));
 552         if (data_sp) {
 553           section_data.SetData(data_sp, 0, data_sp->GetByteSize());
 554           section_data.SetByteOrder(process_sp->GetByteOrder());
 555           section_data.SetAddressByteSize(process_sp->GetAddressByteSize());
 556           return section_data.GetByteSize();
 557         }
 558       }
 559     }
 560   }
 561
 562   // The object file now contains a full mmap'ed copy of the object file
 563   // data, so just use this
 564   return GetData(section->GetFileOffset(), GetSectionDataSize(section),
 565                  section_data);
 566 }
 567
 568 bool ObjectFile::SplitArchivePathWithObject(llvm::StringRef path_with_object,
 569                                             FileSpec &archive_file,
 570                                             ConstString &archive_object,
 571                                             bool must_exist) {
 572   size_t len = path_with_object.size();
 573   if (len < 2 || path_with_object.back() != ')')
 574     return false;
 575   llvm::StringRef archive = path_with_object.substr(0, path_with_object.rfind('('));
 576   if (archive.empty())
 577     return false;
 578   llvm::StringRef object = path_with_object.substr(archive.size() + 1).drop_back();
 579   archive_file.SetFile(archive, FileSpec::Style::native);
 580   if (must_exist && !FileSystem::Instance().Exists(archive_file))
 581     return false;
 582   archive_object.SetString(object);
 583   return true;
 584 }
 585
 586 void ObjectFile::ClearSymtab() {
 587   ModuleSP module_sp(GetModule());
 588   if (module_sp) {
 589     Log *log = GetLog(LLDBLog::Object);
 590     LLDB_LOGF(log, "%p ObjectFile::ClearSymtab () symtab = %p",
 591               static_cast<void *>(this),
 592               static_cast<void *>(m_symtab_up.get()));
 593     // Since we need to clear the symbol table, we need a new llvm::once_flag
 594     // instance so we can safely create another symbol table
 595     m_symtab_once_up.reset(new llvm::once_flag());
 596     m_symtab_up.reset();
 597   }
 598 }
 599
 600 SectionList *ObjectFile::GetSectionList(bool update_module_section_list) {
 601   if (m_sections_up == nullptr) {
 602     if (update_module_section_list) {
 603       ModuleSP module_sp(GetModule());
 604       if (module_sp) {
 605         std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
 606         CreateSections(*module_sp->GetUnifiedSectionList());
 607       }
 608     } else {
 609       SectionList unified_section_list;
 610       CreateSections(unified_section_list);
 611     }
 612   }
 613   return m_sections_up.get();
 614 }
 615
 616 lldb::SymbolType
 617 ObjectFile::GetSymbolTypeFromName(llvm::StringRef name,
 618                                   lldb::SymbolType symbol_type_hint) {
 619   if (!name.empty()) {
 620     if (name.starts_with("_OBJC_")) {
 621       // ObjC
 622       if (name.starts_with("_OBJC_CLASS_$_"))
 623         return lldb::eSymbolTypeObjCClass;
 624       if (name.starts_with("_OBJC_METACLASS_$_"))
 625         return lldb::eSymbolTypeObjCMetaClass;
 626       if (name.starts_with("_OBJC_IVAR_$_"))
 627         return lldb::eSymbolTypeObjCIVar;
 628     } else if (name.starts_with(".objc_class_name_")) {
 629       // ObjC v1
 630       return lldb::eSymbolTypeObjCClass;
 631     }
 632   }
 633   return symbol_type_hint;
 634 }
 635
 636 std::vector<ObjectFile::LoadableData>
 637 ObjectFile::GetLoadableData(Target &target) {
 638   std::vector<LoadableData> loadables;
 639   SectionList *section_list = GetSectionList();
 640   if (!section_list)
 641     return loadables;
 642   // Create a list of loadable data from loadable sections
 643   size_t section_count = section_list->GetNumSections(0);
 644   for (size_t i = 0; i < section_count; ++i) {
 645     LoadableData loadable;
 646     SectionSP section_sp = section_list->GetSectionAtIndex(i);
 647     loadable.Dest =
 648         target.GetSectionLoadList().GetSectionLoadAddress(section_sp);
 649     if (loadable.Dest == LLDB_INVALID_ADDRESS)
 650       continue;
 651     // We can skip sections like bss
 652     if (section_sp->GetFileSize() == 0)
 653       continue;
 654     DataExtractor section_data;
 655     section_sp->GetSectionData(section_data);
 656     loadable.Contents = llvm::ArrayRef<uint8_t>(section_data.GetDataStart(),
 657                                                 section_data.GetByteSize());
 658     loadables.push_back(loadable);
 659   }
 660   return loadables;
 661 }
 662
 663 std::unique_ptr<CallFrameInfo> ObjectFile::CreateCallFrameInfo() {
 664   return {};
 665 }
 666
 667 void ObjectFile::RelocateSection(lldb_private::Section *section)
 668 {
 669 }
 670
 671 DataBufferSP ObjectFile::MapFileData(const FileSpec &file, uint64_t Size,
 672                                      uint64_t Offset) {
 673   return FileSystem::Instance().CreateDataBuffer(file.GetPath(), Size, Offset);
 674 }
 675
 676 void llvm::format_provider<ObjectFile::Type>::format(
 677     const ObjectFile::Type &type, raw_ostream &OS, StringRef Style) {
 678   switch (type) {
 679   case ObjectFile::eTypeInvalid:
 680     OS << "invalid";
 681     break;
 682   case ObjectFile::eTypeCoreFile:
 683     OS << "core file";
 684     break;
 685   case ObjectFile::eTypeExecutable:
 686     OS << "executable";
 687     break;
 688   case ObjectFile::eTypeDebugInfo:
 689     OS << "debug info";
 690     break;
 691   case ObjectFile::eTypeDynamicLinker:
 692     OS << "dynamic linker";
 693     break;
 694   case ObjectFile::eTypeObjectFile:
 695     OS << "object file";
 696     break;
 697   case ObjectFile::eTypeSharedLibrary:
 698     OS << "shared library";
 699     break;
 700   case ObjectFile::eTypeStubLibrary:
 701     OS << "stub library";
 702     break;
 703   case ObjectFile::eTypeJIT:
 704     OS << "jit";
 705     break;
 706   case ObjectFile::eTypeUnknown:
 707     OS << "unknown";
 708     break;
 709   }
 710 }
 711
 712 void llvm::format_provider<ObjectFile::Strata>::format(
 713     const ObjectFile::Strata &strata, raw_ostream &OS, StringRef Style) {
 714   switch (strata) {
 715   case ObjectFile::eStrataInvalid:
 716     OS << "invalid";
 717     break;
 718   case ObjectFile::eStrataUnknown:
 719     OS << "unknown";
 720     break;
 721   case ObjectFile::eStrataUser:
 722     OS << "user";
 723     break;
 724   case ObjectFile::eStrataKernel:
 725     OS << "kernel";
 726     break;
 727   case ObjectFile::eStrataRawImage:
 728     OS << "raw image";
 729     break;
 730   case ObjectFile::eStrataJIT:
 731     OS << "jit";
 732     break;
 733   }
 734 }
 735
 736
 737 Symtab *ObjectFile::GetSymtab() {
 738   ModuleSP module_sp(GetModule());
 739   if (module_sp) {
 740     // We can't take the module lock in ObjectFile::GetSymtab() or we can
 741     // deadlock in DWARF indexing when any file asks for the symbol table from
 742     // an object file. This currently happens in the preloading of symbols in
 743     // SymbolFileDWARF::PreloadSymbols() because the main thread will take the
 744     // module lock, and then threads will be spun up to index the DWARF and
 745     // any of those threads might end up trying to relocate items in the DWARF
 746     // sections which causes ObjectFile::GetSectionData(...) to relocate section
 747     // data which requires the symbol table.
 748     //
 749     // So to work around this, we create the symbol table one time using
 750     // llvm::once_flag, lock it, and then set the unique pointer. Any other
 751     // thread that gets ahold of the symbol table before parsing is done, will
 752     // not be able to access the symbol table contents since all APIs in Symtab
 753     // are protected by a mutex in the Symtab object itself.
 754     llvm::call_once(*m_symtab_once_up, [&]() {
 755       Symtab *symtab = new Symtab(this);
 756       std::lock_guard<std::recursive_mutex> symtab_guard(symtab->GetMutex());
 757       m_symtab_up.reset(symtab);
 758       if (!m_symtab_up->LoadFromCache()) {
 759         ElapsedTime elapsed(module_sp->GetSymtabParseTime());
 760         ParseSymtab(*m_symtab_up);
 761         m_symtab_up->Finalize();
 762       }
 763     });
 764   }
 765   return m_symtab_up.get();
 766 }
 767
 768 uint32_t ObjectFile::GetCacheHash() {
 769   if (m_cache_hash)
 770     return *m_cache_hash;
 771   StreamString strm;
 772   strm.Format("{0}-{1}-{2}", m_file, GetType(), GetStrata());
 773   m_cache_hash = llvm::djbHash(strm.GetString());
 774   return *m_cache_hash;
 775 }
 776
 777 namespace llvm {
 778 namespace json {
 779
 780 bool fromJSON(const llvm::json::Value &value,
 781               lldb_private::ObjectFile::Type &type, llvm::json::Path path) {
 782   if (auto str = value.getAsString()) {
 783     type = llvm::StringSwitch<ObjectFile::Type>(*str)
 784                .Case("corefile", ObjectFile::eTypeCoreFile)
 785                .Case("executable", ObjectFile::eTypeExecutable)
 786                .Case("debuginfo", ObjectFile::eTypeDebugInfo)
 787                .Case("dynamiclinker", ObjectFile::eTypeDynamicLinker)
 788                .Case("objectfile", ObjectFile::eTypeObjectFile)
 789                .Case("sharedlibrary", ObjectFile::eTypeSharedLibrary)
 790                .Case("stublibrary", ObjectFile::eTypeStubLibrary)
 791                .Case("jit", ObjectFile::eTypeJIT)
 792                .Case("unknown", ObjectFile::eTypeUnknown)
 793                .Default(ObjectFile::eTypeInvalid);
 794
 795     if (type == ObjectFile::eTypeInvalid) {
 796       path.report("invalid object type");
 797       return false;
 798     }
 799
 800     return true;
 801   }
 802   path.report("expected string");
 803   return false;
 804 }
 805 } // namespace json
 806 } // namespace llvm