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