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