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 29using namespace lldb; 30using namespace lldb_private; 31 32char ObjectFile::ID; 33size_t ObjectFile::g_initial_bytes_to_read = 512; 34 35static ObjectFileSP 36CreateObjectFromContainer(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 52ObjectFileSP 53ObjectFile::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 152ObjectFileSP 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 187size_t ObjectFile::GetModuleSpecifications(const FileSpec &file, 188 lldb::offset_t file_offset, 189 lldb::offset_t file_size, 190 ModuleSpecList &specs, 191 DataBufferSP data_sp) { 192 if (!data_sp) 193 data_sp = FileSystem::Instance().CreateDataBuffer( 194 file.GetPath(), g_initial_bytes_to_read, file_offset); 195 if (data_sp) { 196 if (file_size == 0) { 197 const lldb::offset_t actual_file_size = 198 FileSystem::Instance().GetByteSize(file); 199 if (actual_file_size > file_offset) 200 file_size = actual_file_size - file_offset; 201 } 202 return ObjectFile::GetModuleSpecifications(file, // file spec 203 data_sp, // data bytes 204 0, // data offset 205 file_offset, // file offset 206 file_size, // file length 207 specs); 208 } 209 return 0; 210} 211 212size_t ObjectFile::GetModuleSpecifications( 213 const lldb_private::FileSpec &file, lldb::DataBufferSP &data_sp, 214 lldb::offset_t data_offset, lldb::offset_t file_offset, 215 lldb::offset_t file_size, lldb_private::ModuleSpecList &specs) { 216 const size_t initial_count = specs.GetSize(); 217 ObjectFileGetModuleSpecifications callback; 218 uint32_t i; 219 // Try the ObjectFile plug-ins 220 for (i = 0; 221 (callback = 222 PluginManager::GetObjectFileGetModuleSpecificationsCallbackAtIndex( 223 i)) != nullptr; 224 ++i) { 225 if (callback(file, data_sp, data_offset, file_offset, file_size, specs) > 0) 226 return specs.GetSize() - initial_count; 227 } 228 229 // Try the ObjectContainer plug-ins 230 for (i = 0; 231 (callback = PluginManager:: 232 GetObjectContainerGetModuleSpecificationsCallbackAtIndex(i)) != 233 nullptr; 234 ++i) { 235 if (callback(file, data_sp, data_offset, file_offset, file_size, specs) > 0) 236 return specs.GetSize() - initial_count; 237 } 238 return 0; 239} 240 241ObjectFile::ObjectFile(const lldb::ModuleSP &module_sp, 242 const FileSpec *file_spec_ptr, 243 lldb::offset_t file_offset, lldb::offset_t length, 244 lldb::DataBufferSP data_sp, 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 265ObjectFile::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 283ObjectFile::~ObjectFile() { 284 Log *log = GetLog(LLDBLog::Object); 285 LLDB_LOGF(log, "%p ObjectFile::~ObjectFile ()\n", static_cast<void *>(this)); 286} 287 288bool 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 295AddressClass 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 case eSectionTypeCTF: 360 case eSectionTypeSwiftModules: 361 return AddressClass::eDebug; 362 case eSectionTypeEHFrame: 363 case eSectionTypeARMexidx: 364 case eSectionTypeARMextab: 365 case eSectionTypeCompactUnwind: 366 return AddressClass::eRuntime; 367 case eSectionTypeELFSymbolTable: 368 case eSectionTypeELFDynamicSymbols: 369 case eSectionTypeELFRelocationEntries: 370 case eSectionTypeELFDynamicLinkInfo: 371 case eSectionTypeOther: 372 return AddressClass::eUnknown; 373 case eSectionTypeAbsoluteAddress: 374 // In case of absolute sections decide the address class based on 375 // the symbol type because the section type isn't specify if it is 376 // a code or a data section. 377 break; 378 } 379 } 380 } 381 382 const SymbolType symbol_type = symbol->GetType(); 383 switch (symbol_type) { 384 case eSymbolTypeAny: 385 return AddressClass::eUnknown; 386 case eSymbolTypeAbsolute: 387 return AddressClass::eUnknown; 388 case eSymbolTypeCode: 389 return AddressClass::eCode; 390 case eSymbolTypeTrampoline: 391 return AddressClass::eCode; 392 case eSymbolTypeResolver: 393 return AddressClass::eCode; 394 case eSymbolTypeData: 395 return AddressClass::eData; 396 case eSymbolTypeRuntime: 397 return AddressClass::eRuntime; 398 case eSymbolTypeException: 399 return AddressClass::eRuntime; 400 case eSymbolTypeSourceFile: 401 return AddressClass::eDebug; 402 case eSymbolTypeHeaderFile: 403 return AddressClass::eDebug; 404 case eSymbolTypeObjectFile: 405 return AddressClass::eDebug; 406 case eSymbolTypeCommonBlock: 407 return AddressClass::eDebug; 408 case eSymbolTypeBlock: 409 return AddressClass::eDebug; 410 case eSymbolTypeLocal: 411 return AddressClass::eData; 412 case eSymbolTypeParam: 413 return AddressClass::eData; 414 case eSymbolTypeVariable: 415 return AddressClass::eData; 416 case eSymbolTypeVariableType: 417 return AddressClass::eDebug; 418 case eSymbolTypeLineEntry: 419 return AddressClass::eDebug; 420 case eSymbolTypeLineHeader: 421 return AddressClass::eDebug; 422 case eSymbolTypeScopeBegin: 423 return AddressClass::eDebug; 424 case eSymbolTypeScopeEnd: 425 return AddressClass::eDebug; 426 case eSymbolTypeAdditional: 427 return AddressClass::eUnknown; 428 case eSymbolTypeCompiler: 429 return AddressClass::eDebug; 430 case eSymbolTypeInstrumentation: 431 return AddressClass::eDebug; 432 case eSymbolTypeUndefined: 433 return AddressClass::eUnknown; 434 case eSymbolTypeObjCClass: 435 return AddressClass::eRuntime; 436 case eSymbolTypeObjCMetaClass: 437 return AddressClass::eRuntime; 438 case eSymbolTypeObjCIVar: 439 return AddressClass::eRuntime; 440 case eSymbolTypeReExported: 441 return AddressClass::eRuntime; 442 } 443 } 444 } 445 return AddressClass::eUnknown; 446} 447 448DataBufferSP ObjectFile::ReadMemory(const ProcessSP &process_sp, 449 lldb::addr_t addr, size_t byte_size) { 450 DataBufferSP data_sp; 451 if (process_sp) { 452 std::unique_ptr<DataBufferHeap> data_up(new DataBufferHeap(byte_size, 0)); 453 Status error; 454 const size_t bytes_read = process_sp->ReadMemory( 455 addr, data_up->GetBytes(), data_up->GetByteSize(), error); 456 if (bytes_read == byte_size) 457 data_sp.reset(data_up.release()); 458 } 459 return data_sp; 460} 461 462size_t ObjectFile::GetData(lldb::offset_t offset, size_t length, 463 DataExtractor &data) const { 464 // The entire file has already been mmap'ed into m_data, so just copy from 465 // there as the back mmap buffer will be shared with shared pointers. 466 return data.SetData(m_data, offset, length); 467} 468 469size_t ObjectFile::CopyData(lldb::offset_t offset, size_t length, 470 void *dst) const { 471 // The entire file has already been mmap'ed into m_data, so just copy from 472 // there Note that the data remains in target byte order. 473 return m_data.CopyData(offset, length, dst); 474} 475 476size_t ObjectFile::ReadSectionData(Section *section, 477 lldb::offset_t section_offset, void *dst, 478 size_t dst_len) { 479 assert(section); 480 section_offset *= section->GetTargetByteSize(); 481 482 // If some other objectfile owns this data, pass this to them. 483 if (section->GetObjectFile() != this) 484 return section->GetObjectFile()->ReadSectionData(section, section_offset, 485 dst, dst_len); 486 487 if (!section->IsRelocated()) 488 RelocateSection(section); 489 490 if (IsInMemory()) { 491 ProcessSP process_sp(m_process_wp.lock()); 492 if (process_sp) { 493 Status error; 494 const addr_t base_load_addr = 495 section->GetLoadBaseAddress(&process_sp->GetTarget()); 496 if (base_load_addr != LLDB_INVALID_ADDRESS) 497 return process_sp->ReadMemory(base_load_addr + section_offset, dst, 498 dst_len, error); 499 } 500 } else { 501 const lldb::offset_t section_file_size = section->GetFileSize(); 502 if (section_offset < section_file_size) { 503 const size_t section_bytes_left = section_file_size - section_offset; 504 size_t section_dst_len = dst_len; 505 if (section_dst_len > section_bytes_left) 506 section_dst_len = section_bytes_left; 507 return CopyData(section->GetFileOffset() + section_offset, 508 section_dst_len, dst); 509 } else { 510 if (section->GetType() == eSectionTypeZeroFill) { 511 const uint64_t section_size = section->GetByteSize(); 512 const uint64_t section_bytes_left = section_size - section_offset; 513 uint64_t section_dst_len = dst_len; 514 if (section_dst_len > section_bytes_left) 515 section_dst_len = section_bytes_left; 516 memset(dst, 0, section_dst_len); 517 return section_dst_len; 518 } 519 } 520 } 521 return 0; 522} 523 524// Get the section data the file on disk 525size_t ObjectFile::ReadSectionData(Section *section, 526 DataExtractor §ion_data) { 527 // If some other objectfile owns this data, pass this to them. 528 if (section->GetObjectFile() != this) 529 return section->GetObjectFile()->ReadSectionData(section, section_data); 530 531 if (!section->IsRelocated()) 532 RelocateSection(section); 533 534 if (IsInMemory()) { 535 ProcessSP process_sp(m_process_wp.lock()); 536 if (process_sp) { 537 const addr_t base_load_addr = 538 section->GetLoadBaseAddress(&process_sp->GetTarget()); 539 if (base_load_addr != LLDB_INVALID_ADDRESS) { 540 DataBufferSP data_sp( 541 ReadMemory(process_sp, base_load_addr, section->GetByteSize())); 542 if (data_sp) { 543 section_data.SetData(data_sp, 0, data_sp->GetByteSize()); 544 section_data.SetByteOrder(process_sp->GetByteOrder()); 545 section_data.SetAddressByteSize(process_sp->GetAddressByteSize()); 546 return section_data.GetByteSize(); 547 } 548 } 549 } 550 } 551 552 // The object file now contains a full mmap'ed copy of the object file 553 // data, so just use this 554 return GetData(section->GetFileOffset(), GetSectionDataSize(section), 555 section_data); 556} 557 558bool ObjectFile::SplitArchivePathWithObject(llvm::StringRef path_with_object, 559 FileSpec &archive_file, 560 ConstString &archive_object, 561 bool must_exist) { 562 size_t len = path_with_object.size(); 563 if (len < 2 || path_with_object.back() != ')') 564 return false; 565 llvm::StringRef archive = path_with_object.substr(0, path_with_object.rfind('(')); 566 if (archive.empty()) 567 return false; 568 llvm::StringRef object = path_with_object.substr(archive.size() + 1).drop_back(); 569 archive_file.SetFile(archive, FileSpec::Style::native); 570 if (must_exist && !FileSystem::Instance().Exists(archive_file)) 571 return false; 572 archive_object.SetString(object); 573 return true; 574} 575 576void ObjectFile::ClearSymtab() { 577 ModuleSP module_sp(GetModule()); 578 if (module_sp) { 579 Log *log = GetLog(LLDBLog::Object); 580 LLDB_LOGF(log, "%p ObjectFile::ClearSymtab () symtab = %p", 581 static_cast<void *>(this), 582 static_cast<void *>(m_symtab_up.get())); 583 // Since we need to clear the symbol table, we need a new llvm::once_flag 584 // instance so we can safely create another symbol table 585 m_symtab_once_up.reset(new llvm::once_flag()); 586 m_symtab_up.reset(); 587 } 588} 589 590SectionList *ObjectFile::GetSectionList(bool update_module_section_list) { 591 if (m_sections_up == nullptr) { 592 if (update_module_section_list) { 593 ModuleSP module_sp(GetModule()); 594 if (module_sp) { 595 std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex()); 596 CreateSections(*module_sp->GetUnifiedSectionList()); 597 } 598 } else { 599 SectionList unified_section_list; 600 CreateSections(unified_section_list); 601 } 602 } 603 return m_sections_up.get(); 604} 605 606lldb::SymbolType 607ObjectFile::GetSymbolTypeFromName(llvm::StringRef name, 608 lldb::SymbolType symbol_type_hint) { 609 if (!name.empty()) { 610 if (name.starts_with("_OBJC_")) { 611 // ObjC 612 if (name.starts_with("_OBJC_CLASS_$_")) 613 return lldb::eSymbolTypeObjCClass; 614 if (name.starts_with("_OBJC_METACLASS_$_")) 615 return lldb::eSymbolTypeObjCMetaClass; 616 if (name.starts_with("_OBJC_IVAR_$_")) 617 return lldb::eSymbolTypeObjCIVar; 618 } else if (name.starts_with(".objc_class_name_")) { 619 // ObjC v1 620 return lldb::eSymbolTypeObjCClass; 621 } 622 } 623 return symbol_type_hint; 624} 625 626std::vector<ObjectFile::LoadableData> 627ObjectFile::GetLoadableData(Target &target) { 628 std::vector<LoadableData> loadables; 629 SectionList *section_list = GetSectionList(); 630 if (!section_list) 631 return loadables; 632 // Create a list of loadable data from loadable sections 633 size_t section_count = section_list->GetNumSections(0); 634 for (size_t i = 0; i < section_count; ++i) { 635 LoadableData loadable; 636 SectionSP section_sp = section_list->GetSectionAtIndex(i); 637 loadable.Dest = 638 target.GetSectionLoadList().GetSectionLoadAddress(section_sp); 639 if (loadable.Dest == LLDB_INVALID_ADDRESS) 640 continue; 641 // We can skip sections like bss 642 if (section_sp->GetFileSize() == 0) 643 continue; 644 DataExtractor section_data; 645 section_sp->GetSectionData(section_data); 646 loadable.Contents = llvm::ArrayRef<uint8_t>(section_data.GetDataStart(), 647 section_data.GetByteSize()); 648 loadables.push_back(loadable); 649 } 650 return loadables; 651} 652 653std::unique_ptr<CallFrameInfo> ObjectFile::CreateCallFrameInfo() { 654 return {}; 655} 656 657void ObjectFile::RelocateSection(lldb_private::Section *section) 658{ 659} 660 661DataBufferSP ObjectFile::MapFileData(const FileSpec &file, uint64_t Size, 662 uint64_t Offset) { 663 return FileSystem::Instance().CreateDataBuffer(file.GetPath(), Size, Offset); 664} 665 666void llvm::format_provider<ObjectFile::Type>::format( 667 const ObjectFile::Type &type, raw_ostream &OS, StringRef Style) { 668 switch (type) { 669 case ObjectFile::eTypeInvalid: 670 OS << "invalid"; 671 break; 672 case ObjectFile::eTypeCoreFile: 673 OS << "core file"; 674 break; 675 case ObjectFile::eTypeExecutable: 676 OS << "executable"; 677 break; 678 case ObjectFile::eTypeDebugInfo: 679 OS << "debug info"; 680 break; 681 case ObjectFile::eTypeDynamicLinker: 682 OS << "dynamic linker"; 683 break; 684 case ObjectFile::eTypeObjectFile: 685 OS << "object file"; 686 break; 687 case ObjectFile::eTypeSharedLibrary: 688 OS << "shared library"; 689 break; 690 case ObjectFile::eTypeStubLibrary: 691 OS << "stub library"; 692 break; 693 case ObjectFile::eTypeJIT: 694 OS << "jit"; 695 break; 696 case ObjectFile::eTypeUnknown: 697 OS << "unknown"; 698 break; 699 } 700} 701 702void llvm::format_provider<ObjectFile::Strata>::format( 703 const ObjectFile::Strata &strata, raw_ostream &OS, StringRef Style) { 704 switch (strata) { 705 case ObjectFile::eStrataInvalid: 706 OS << "invalid"; 707 break; 708 case ObjectFile::eStrataUnknown: 709 OS << "unknown"; 710 break; 711 case ObjectFile::eStrataUser: 712 OS << "user"; 713 break; 714 case ObjectFile::eStrataKernel: 715 OS << "kernel"; 716 break; 717 case ObjectFile::eStrataRawImage: 718 OS << "raw image"; 719 break; 720 case ObjectFile::eStrataJIT: 721 OS << "jit"; 722 break; 723 } 724} 725 726 727Symtab *ObjectFile::GetSymtab() { 728 ModuleSP module_sp(GetModule()); 729 if (module_sp) { 730 // We can't take the module lock in ObjectFile::GetSymtab() or we can 731 // deadlock in DWARF indexing when any file asks for the symbol table from 732 // an object file. This currently happens in the preloading of symbols in 733 // SymbolFileDWARF::PreloadSymbols() because the main thread will take the 734 // module lock, and then threads will be spun up to index the DWARF and 735 // any of those threads might end up trying to relocate items in the DWARF 736 // sections which causes ObjectFile::GetSectionData(...) to relocate section 737 // data which requires the symbol table. 738 // 739 // So to work around this, we create the symbol table one time using 740 // llvm::once_flag, lock it, and then set the unique pointer. Any other 741 // thread that gets ahold of the symbol table before parsing is done, will 742 // not be able to access the symbol table contents since all APIs in Symtab 743 // are protected by a mutex in the Symtab object itself. 744 llvm::call_once(*m_symtab_once_up, [&]() { 745 Symtab *symtab = new Symtab(this); 746 std::lock_guard<std::recursive_mutex> symtab_guard(symtab->GetMutex()); 747 m_symtab_up.reset(symtab); 748 if (!m_symtab_up->LoadFromCache()) { 749 ElapsedTime elapsed(module_sp->GetSymtabParseTime()); 750 ParseSymtab(*m_symtab_up); 751 m_symtab_up->Finalize(); 752 } 753 }); 754 } 755 return m_symtab_up.get(); 756} 757 758uint32_t ObjectFile::GetCacheHash() { 759 if (m_cache_hash) 760 return *m_cache_hash; 761 StreamString strm; 762 strm.Format("{0}-{1}-{2}", m_file, GetType(), GetStrata()); 763 m_cache_hash = llvm::djbHash(strm.GetString()); 764 return *m_cache_hash; 765} 766 767namespace llvm { 768namespace json { 769 770bool fromJSON(const llvm::json::Value &value, 771 lldb_private::ObjectFile::Type &type, llvm::json::Path path) { 772 if (auto str = value.getAsString()) { 773 type = llvm::StringSwitch<ObjectFile::Type>(*str) 774 .Case("corefile", ObjectFile::eTypeCoreFile) 775 .Case("executable", ObjectFile::eTypeExecutable) 776 .Case("debuginfo", ObjectFile::eTypeDebugInfo) 777 .Case("dynamiclinker", ObjectFile::eTypeDynamicLinker) 778 .Case("objectfile", ObjectFile::eTypeObjectFile) 779 .Case("sharedlibrary", ObjectFile::eTypeSharedLibrary) 780 .Case("stublibrary", ObjectFile::eTypeStubLibrary) 781 .Case("jit", ObjectFile::eTypeJIT) 782 .Case("unknown", ObjectFile::eTypeUnknown) 783 .Default(ObjectFile::eTypeInvalid); 784 785 if (type == ObjectFile::eTypeInvalid) { 786 path.report("invalid object type"); 787 return false; 788 } 789 790 return true; 791 } 792 path.report("expected string"); 793 return false; 794} 795} // namespace json 796} // namespace llvm 797