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