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