1 //===-- ObjectFileELF.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 "ObjectFileELF.h" 10 11 #include <algorithm> 12 #include <cassert> 13 #include <unordered_map> 14 15 #include "lldb/Core/FileSpecList.h" 16 #include "lldb/Core/Module.h" 17 #include "lldb/Core/ModuleSpec.h" 18 #include "lldb/Core/PluginManager.h" 19 #include "lldb/Core/Progress.h" 20 #include "lldb/Core/Section.h" 21 #include "lldb/Host/FileSystem.h" 22 #include "lldb/Host/LZMA.h" 23 #include "lldb/Symbol/DWARFCallFrameInfo.h" 24 #include "lldb/Symbol/SymbolContext.h" 25 #include "lldb/Target/SectionLoadList.h" 26 #include "lldb/Target/Target.h" 27 #include "lldb/Utility/ArchSpec.h" 28 #include "lldb/Utility/DataBufferHeap.h" 29 #include "lldb/Utility/LLDBLog.h" 30 #include "lldb/Utility/Log.h" 31 #include "lldb/Utility/RangeMap.h" 32 #include "lldb/Utility/Status.h" 33 #include "lldb/Utility/Stream.h" 34 #include "lldb/Utility/Timer.h" 35 #include "llvm/ADT/IntervalMap.h" 36 #include "llvm/ADT/PointerUnion.h" 37 #include "llvm/ADT/StringRef.h" 38 #include "llvm/BinaryFormat/ELF.h" 39 #include "llvm/Object/Decompressor.h" 40 #include "llvm/Support/ARMBuildAttributes.h" 41 #include "llvm/Support/CRC.h" 42 #include "llvm/Support/FormatVariadic.h" 43 #include "llvm/Support/MathExtras.h" 44 #include "llvm/Support/MemoryBuffer.h" 45 #include "llvm/Support/MipsABIFlags.h" 46 47 #define CASE_AND_STREAM(s, def, width) \ 48 case def: \ 49 s->Printf("%-*s", width, #def); \ 50 break; 51 52 using namespace lldb; 53 using namespace lldb_private; 54 using namespace elf; 55 using namespace llvm::ELF; 56 57 LLDB_PLUGIN_DEFINE(ObjectFileELF) 58 59 // ELF note owner definitions 60 static const char *const LLDB_NT_OWNER_FREEBSD = "FreeBSD"; 61 static const char *const LLDB_NT_OWNER_GNU = "GNU"; 62 static const char *const LLDB_NT_OWNER_NETBSD = "NetBSD"; 63 static const char *const LLDB_NT_OWNER_NETBSDCORE = "NetBSD-CORE"; 64 static const char *const LLDB_NT_OWNER_OPENBSD = "OpenBSD"; 65 static const char *const LLDB_NT_OWNER_ANDROID = "Android"; 66 static const char *const LLDB_NT_OWNER_CORE = "CORE"; 67 static const char *const LLDB_NT_OWNER_LINUX = "LINUX"; 68 69 // ELF note type definitions 70 static const elf_word LLDB_NT_FREEBSD_ABI_TAG = 0x01; 71 static const elf_word LLDB_NT_FREEBSD_ABI_SIZE = 4; 72 73 static const elf_word LLDB_NT_GNU_ABI_TAG = 0x01; 74 static const elf_word LLDB_NT_GNU_ABI_SIZE = 16; 75 76 static const elf_word LLDB_NT_GNU_BUILD_ID_TAG = 0x03; 77 78 static const elf_word LLDB_NT_NETBSD_IDENT_TAG = 1; 79 static const elf_word LLDB_NT_NETBSD_IDENT_DESCSZ = 4; 80 static const elf_word LLDB_NT_NETBSD_IDENT_NAMESZ = 7; 81 static const elf_word LLDB_NT_NETBSD_PROCINFO = 1; 82 83 // GNU ABI note OS constants 84 static const elf_word LLDB_NT_GNU_ABI_OS_LINUX = 0x00; 85 static const elf_word LLDB_NT_GNU_ABI_OS_HURD = 0x01; 86 static const elf_word LLDB_NT_GNU_ABI_OS_SOLARIS = 0x02; 87 88 namespace { 89 90 //===----------------------------------------------------------------------===// 91 /// \class ELFRelocation 92 /// Generic wrapper for ELFRel and ELFRela. 93 /// 94 /// This helper class allows us to parse both ELFRel and ELFRela relocation 95 /// entries in a generic manner. 96 class ELFRelocation { 97 public: 98 /// Constructs an ELFRelocation entry with a personality as given by @p 99 /// type. 100 /// 101 /// \param type Either DT_REL or DT_RELA. Any other value is invalid. 102 ELFRelocation(unsigned type); 103 104 ~ELFRelocation(); 105 106 bool Parse(const lldb_private::DataExtractor &data, lldb::offset_t *offset); 107 108 static unsigned RelocType32(const ELFRelocation &rel); 109 110 static unsigned RelocType64(const ELFRelocation &rel); 111 112 static unsigned RelocSymbol32(const ELFRelocation &rel); 113 114 static unsigned RelocSymbol64(const ELFRelocation &rel); 115 116 static unsigned RelocOffset32(const ELFRelocation &rel); 117 118 static unsigned RelocOffset64(const ELFRelocation &rel); 119 120 static unsigned RelocAddend32(const ELFRelocation &rel); 121 122 static unsigned RelocAddend64(const ELFRelocation &rel); 123 124 private: 125 typedef llvm::PointerUnion<ELFRel *, ELFRela *> RelocUnion; 126 127 RelocUnion reloc; 128 }; 129 } // end anonymous namespace 130 131 ELFRelocation::ELFRelocation(unsigned type) { 132 if (type == DT_REL || type == SHT_REL) 133 reloc = new ELFRel(); 134 else if (type == DT_RELA || type == SHT_RELA) 135 reloc = new ELFRela(); 136 else { 137 assert(false && "unexpected relocation type"); 138 reloc = static_cast<ELFRel *>(nullptr); 139 } 140 } 141 142 ELFRelocation::~ELFRelocation() { 143 if (reloc.is<ELFRel *>()) 144 delete reloc.get<ELFRel *>(); 145 else 146 delete reloc.get<ELFRela *>(); 147 } 148 149 bool ELFRelocation::Parse(const lldb_private::DataExtractor &data, 150 lldb::offset_t *offset) { 151 if (reloc.is<ELFRel *>()) 152 return reloc.get<ELFRel *>()->Parse(data, offset); 153 else 154 return reloc.get<ELFRela *>()->Parse(data, offset); 155 } 156 157 unsigned ELFRelocation::RelocType32(const ELFRelocation &rel) { 158 if (rel.reloc.is<ELFRel *>()) 159 return ELFRel::RelocType32(*rel.reloc.get<ELFRel *>()); 160 else 161 return ELFRela::RelocType32(*rel.reloc.get<ELFRela *>()); 162 } 163 164 unsigned ELFRelocation::RelocType64(const ELFRelocation &rel) { 165 if (rel.reloc.is<ELFRel *>()) 166 return ELFRel::RelocType64(*rel.reloc.get<ELFRel *>()); 167 else 168 return ELFRela::RelocType64(*rel.reloc.get<ELFRela *>()); 169 } 170 171 unsigned ELFRelocation::RelocSymbol32(const ELFRelocation &rel) { 172 if (rel.reloc.is<ELFRel *>()) 173 return ELFRel::RelocSymbol32(*rel.reloc.get<ELFRel *>()); 174 else 175 return ELFRela::RelocSymbol32(*rel.reloc.get<ELFRela *>()); 176 } 177 178 unsigned ELFRelocation::RelocSymbol64(const ELFRelocation &rel) { 179 if (rel.reloc.is<ELFRel *>()) 180 return ELFRel::RelocSymbol64(*rel.reloc.get<ELFRel *>()); 181 else 182 return ELFRela::RelocSymbol64(*rel.reloc.get<ELFRela *>()); 183 } 184 185 unsigned ELFRelocation::RelocOffset32(const ELFRelocation &rel) { 186 if (rel.reloc.is<ELFRel *>()) 187 return rel.reloc.get<ELFRel *>()->r_offset; 188 else 189 return rel.reloc.get<ELFRela *>()->r_offset; 190 } 191 192 unsigned ELFRelocation::RelocOffset64(const ELFRelocation &rel) { 193 if (rel.reloc.is<ELFRel *>()) 194 return rel.reloc.get<ELFRel *>()->r_offset; 195 else 196 return rel.reloc.get<ELFRela *>()->r_offset; 197 } 198 199 unsigned ELFRelocation::RelocAddend32(const ELFRelocation &rel) { 200 if (rel.reloc.is<ELFRel *>()) 201 return 0; 202 else 203 return rel.reloc.get<ELFRela *>()->r_addend; 204 } 205 206 unsigned ELFRelocation::RelocAddend64(const ELFRelocation &rel) { 207 if (rel.reloc.is<ELFRel *>()) 208 return 0; 209 else 210 return rel.reloc.get<ELFRela *>()->r_addend; 211 } 212 213 static user_id_t SegmentID(size_t PHdrIndex) { 214 return ~user_id_t(PHdrIndex); 215 } 216 217 bool ELFNote::Parse(const DataExtractor &data, lldb::offset_t *offset) { 218 // Read all fields. 219 if (data.GetU32(offset, &n_namesz, 3) == nullptr) 220 return false; 221 222 // The name field is required to be nul-terminated, and n_namesz includes the 223 // terminating nul in observed implementations (contrary to the ELF-64 spec). 224 // A special case is needed for cores generated by some older Linux versions, 225 // which write a note named "CORE" without a nul terminator and n_namesz = 4. 226 if (n_namesz == 4) { 227 char buf[4]; 228 if (data.ExtractBytes(*offset, 4, data.GetByteOrder(), buf) != 4) 229 return false; 230 if (strncmp(buf, "CORE", 4) == 0) { 231 n_name = "CORE"; 232 *offset += 4; 233 return true; 234 } 235 } 236 237 const char *cstr = data.GetCStr(offset, llvm::alignTo(n_namesz, 4)); 238 if (cstr == nullptr) { 239 Log *log = GetLog(LLDBLog::Symbols); 240 LLDB_LOGF(log, "Failed to parse note name lacking nul terminator"); 241 242 return false; 243 } 244 n_name = cstr; 245 return true; 246 } 247 248 static uint32_t mipsVariantFromElfFlags (const elf::ELFHeader &header) { 249 const uint32_t mips_arch = header.e_flags & llvm::ELF::EF_MIPS_ARCH; 250 uint32_t endian = header.e_ident[EI_DATA]; 251 uint32_t arch_variant = ArchSpec::eMIPSSubType_unknown; 252 uint32_t fileclass = header.e_ident[EI_CLASS]; 253 254 // If there aren't any elf flags available (e.g core elf file) then return 255 // default 256 // 32 or 64 bit arch (without any architecture revision) based on object file's class. 257 if (header.e_type == ET_CORE) { 258 switch (fileclass) { 259 case llvm::ELF::ELFCLASS32: 260 return (endian == ELFDATA2LSB) ? ArchSpec::eMIPSSubType_mips32el 261 : ArchSpec::eMIPSSubType_mips32; 262 case llvm::ELF::ELFCLASS64: 263 return (endian == ELFDATA2LSB) ? ArchSpec::eMIPSSubType_mips64el 264 : ArchSpec::eMIPSSubType_mips64; 265 default: 266 return arch_variant; 267 } 268 } 269 270 switch (mips_arch) { 271 case llvm::ELF::EF_MIPS_ARCH_1: 272 case llvm::ELF::EF_MIPS_ARCH_2: 273 case llvm::ELF::EF_MIPS_ARCH_32: 274 return (endian == ELFDATA2LSB) ? ArchSpec::eMIPSSubType_mips32el 275 : ArchSpec::eMIPSSubType_mips32; 276 case llvm::ELF::EF_MIPS_ARCH_32R2: 277 return (endian == ELFDATA2LSB) ? ArchSpec::eMIPSSubType_mips32r2el 278 : ArchSpec::eMIPSSubType_mips32r2; 279 case llvm::ELF::EF_MIPS_ARCH_32R6: 280 return (endian == ELFDATA2LSB) ? ArchSpec::eMIPSSubType_mips32r6el 281 : ArchSpec::eMIPSSubType_mips32r6; 282 case llvm::ELF::EF_MIPS_ARCH_3: 283 case llvm::ELF::EF_MIPS_ARCH_4: 284 case llvm::ELF::EF_MIPS_ARCH_5: 285 case llvm::ELF::EF_MIPS_ARCH_64: 286 return (endian == ELFDATA2LSB) ? ArchSpec::eMIPSSubType_mips64el 287 : ArchSpec::eMIPSSubType_mips64; 288 case llvm::ELF::EF_MIPS_ARCH_64R2: 289 return (endian == ELFDATA2LSB) ? ArchSpec::eMIPSSubType_mips64r2el 290 : ArchSpec::eMIPSSubType_mips64r2; 291 case llvm::ELF::EF_MIPS_ARCH_64R6: 292 return (endian == ELFDATA2LSB) ? ArchSpec::eMIPSSubType_mips64r6el 293 : ArchSpec::eMIPSSubType_mips64r6; 294 default: 295 break; 296 } 297 298 return arch_variant; 299 } 300 301 static uint32_t riscvVariantFromElfFlags(const elf::ELFHeader &header) { 302 uint32_t fileclass = header.e_ident[EI_CLASS]; 303 switch (fileclass) { 304 case llvm::ELF::ELFCLASS32: 305 return ArchSpec::eRISCVSubType_riscv32; 306 case llvm::ELF::ELFCLASS64: 307 return ArchSpec::eRISCVSubType_riscv64; 308 default: 309 return ArchSpec::eRISCVSubType_unknown; 310 } 311 } 312 313 static uint32_t subTypeFromElfHeader(const elf::ELFHeader &header) { 314 if (header.e_machine == llvm::ELF::EM_MIPS) 315 return mipsVariantFromElfFlags(header); 316 else if (header.e_machine == llvm::ELF::EM_RISCV) 317 return riscvVariantFromElfFlags(header); 318 319 return LLDB_INVALID_CPUTYPE; 320 } 321 322 char ObjectFileELF::ID; 323 324 // Arbitrary constant used as UUID prefix for core files. 325 const uint32_t ObjectFileELF::g_core_uuid_magic(0xE210C); 326 327 // Static methods. 328 void ObjectFileELF::Initialize() { 329 PluginManager::RegisterPlugin(GetPluginNameStatic(), 330 GetPluginDescriptionStatic(), CreateInstance, 331 CreateMemoryInstance, GetModuleSpecifications); 332 } 333 334 void ObjectFileELF::Terminate() { 335 PluginManager::UnregisterPlugin(CreateInstance); 336 } 337 338 ObjectFile *ObjectFileELF::CreateInstance(const lldb::ModuleSP &module_sp, 339 DataBufferSP &data_sp, 340 lldb::offset_t data_offset, 341 const lldb_private::FileSpec *file, 342 lldb::offset_t file_offset, 343 lldb::offset_t length) { 344 if (!data_sp) { 345 data_sp = MapFileData(*file, length, file_offset); 346 if (!data_sp) 347 return nullptr; 348 data_offset = 0; 349 } 350 351 assert(data_sp); 352 353 if (data_sp->GetByteSize() <= (llvm::ELF::EI_NIDENT + data_offset)) 354 return nullptr; 355 356 const uint8_t *magic = data_sp->GetBytes() + data_offset; 357 if (!ELFHeader::MagicBytesMatch(magic)) 358 return nullptr; 359 360 // Update the data to contain the entire file if it doesn't already 361 if (data_sp->GetByteSize() < length) { 362 data_sp = MapFileData(*file, length, file_offset); 363 if (!data_sp) 364 return nullptr; 365 data_offset = 0; 366 magic = data_sp->GetBytes(); 367 } 368 369 unsigned address_size = ELFHeader::AddressSizeInBytes(magic); 370 if (address_size == 4 || address_size == 8) { 371 std::unique_ptr<ObjectFileELF> objfile_up(new ObjectFileELF( 372 module_sp, data_sp, data_offset, file, file_offset, length)); 373 ArchSpec spec = objfile_up->GetArchitecture(); 374 if (spec && objfile_up->SetModulesArchitecture(spec)) 375 return objfile_up.release(); 376 } 377 378 return nullptr; 379 } 380 381 ObjectFile *ObjectFileELF::CreateMemoryInstance( 382 const lldb::ModuleSP &module_sp, DataBufferSP &data_sp, 383 const lldb::ProcessSP &process_sp, lldb::addr_t header_addr) { 384 if (data_sp && data_sp->GetByteSize() > (llvm::ELF::EI_NIDENT)) { 385 const uint8_t *magic = data_sp->GetBytes(); 386 if (ELFHeader::MagicBytesMatch(magic)) { 387 unsigned address_size = ELFHeader::AddressSizeInBytes(magic); 388 if (address_size == 4 || address_size == 8) { 389 std::unique_ptr<ObjectFileELF> objfile_up( 390 new ObjectFileELF(module_sp, data_sp, process_sp, header_addr)); 391 ArchSpec spec = objfile_up->GetArchitecture(); 392 if (spec && objfile_up->SetModulesArchitecture(spec)) 393 return objfile_up.release(); 394 } 395 } 396 } 397 return nullptr; 398 } 399 400 bool ObjectFileELF::MagicBytesMatch(DataBufferSP &data_sp, 401 lldb::addr_t data_offset, 402 lldb::addr_t data_length) { 403 if (data_sp && 404 data_sp->GetByteSize() > (llvm::ELF::EI_NIDENT + data_offset)) { 405 const uint8_t *magic = data_sp->GetBytes() + data_offset; 406 return ELFHeader::MagicBytesMatch(magic); 407 } 408 return false; 409 } 410 411 static uint32_t calc_crc32(uint32_t init, const DataExtractor &data) { 412 return llvm::crc32( 413 init, llvm::makeArrayRef(data.GetDataStart(), data.GetByteSize())); 414 } 415 416 uint32_t ObjectFileELF::CalculateELFNotesSegmentsCRC32( 417 const ProgramHeaderColl &program_headers, DataExtractor &object_data) { 418 419 uint32_t core_notes_crc = 0; 420 421 for (const ELFProgramHeader &H : program_headers) { 422 if (H.p_type == llvm::ELF::PT_NOTE) { 423 const elf_off ph_offset = H.p_offset; 424 const size_t ph_size = H.p_filesz; 425 426 DataExtractor segment_data; 427 if (segment_data.SetData(object_data, ph_offset, ph_size) != ph_size) { 428 // The ELF program header contained incorrect data, probably corefile 429 // is incomplete or corrupted. 430 break; 431 } 432 433 core_notes_crc = calc_crc32(core_notes_crc, segment_data); 434 } 435 } 436 437 return core_notes_crc; 438 } 439 440 static const char *OSABIAsCString(unsigned char osabi_byte) { 441 #define _MAKE_OSABI_CASE(x) \ 442 case x: \ 443 return #x 444 switch (osabi_byte) { 445 _MAKE_OSABI_CASE(ELFOSABI_NONE); 446 _MAKE_OSABI_CASE(ELFOSABI_HPUX); 447 _MAKE_OSABI_CASE(ELFOSABI_NETBSD); 448 _MAKE_OSABI_CASE(ELFOSABI_GNU); 449 _MAKE_OSABI_CASE(ELFOSABI_HURD); 450 _MAKE_OSABI_CASE(ELFOSABI_SOLARIS); 451 _MAKE_OSABI_CASE(ELFOSABI_AIX); 452 _MAKE_OSABI_CASE(ELFOSABI_IRIX); 453 _MAKE_OSABI_CASE(ELFOSABI_FREEBSD); 454 _MAKE_OSABI_CASE(ELFOSABI_TRU64); 455 _MAKE_OSABI_CASE(ELFOSABI_MODESTO); 456 _MAKE_OSABI_CASE(ELFOSABI_OPENBSD); 457 _MAKE_OSABI_CASE(ELFOSABI_OPENVMS); 458 _MAKE_OSABI_CASE(ELFOSABI_NSK); 459 _MAKE_OSABI_CASE(ELFOSABI_AROS); 460 _MAKE_OSABI_CASE(ELFOSABI_FENIXOS); 461 _MAKE_OSABI_CASE(ELFOSABI_C6000_ELFABI); 462 _MAKE_OSABI_CASE(ELFOSABI_C6000_LINUX); 463 _MAKE_OSABI_CASE(ELFOSABI_ARM); 464 _MAKE_OSABI_CASE(ELFOSABI_STANDALONE); 465 default: 466 return "<unknown-osabi>"; 467 } 468 #undef _MAKE_OSABI_CASE 469 } 470 471 // 472 // WARNING : This function is being deprecated 473 // It's functionality has moved to ArchSpec::SetArchitecture This function is 474 // only being kept to validate the move. 475 // 476 // TODO : Remove this function 477 static bool GetOsFromOSABI(unsigned char osabi_byte, 478 llvm::Triple::OSType &ostype) { 479 switch (osabi_byte) { 480 case ELFOSABI_AIX: 481 ostype = llvm::Triple::OSType::AIX; 482 break; 483 case ELFOSABI_FREEBSD: 484 ostype = llvm::Triple::OSType::FreeBSD; 485 break; 486 case ELFOSABI_GNU: 487 ostype = llvm::Triple::OSType::Linux; 488 break; 489 case ELFOSABI_NETBSD: 490 ostype = llvm::Triple::OSType::NetBSD; 491 break; 492 case ELFOSABI_OPENBSD: 493 ostype = llvm::Triple::OSType::OpenBSD; 494 break; 495 case ELFOSABI_SOLARIS: 496 ostype = llvm::Triple::OSType::Solaris; 497 break; 498 default: 499 ostype = llvm::Triple::OSType::UnknownOS; 500 } 501 return ostype != llvm::Triple::OSType::UnknownOS; 502 } 503 504 size_t ObjectFileELF::GetModuleSpecifications( 505 const lldb_private::FileSpec &file, lldb::DataBufferSP &data_sp, 506 lldb::offset_t data_offset, lldb::offset_t file_offset, 507 lldb::offset_t length, lldb_private::ModuleSpecList &specs) { 508 Log *log = GetLog(LLDBLog::Modules); 509 510 const size_t initial_count = specs.GetSize(); 511 512 if (ObjectFileELF::MagicBytesMatch(data_sp, 0, data_sp->GetByteSize())) { 513 DataExtractor data; 514 data.SetData(data_sp); 515 elf::ELFHeader header; 516 lldb::offset_t header_offset = data_offset; 517 if (header.Parse(data, &header_offset)) { 518 if (data_sp) { 519 ModuleSpec spec(file); 520 521 const uint32_t sub_type = subTypeFromElfHeader(header); 522 spec.GetArchitecture().SetArchitecture( 523 eArchTypeELF, header.e_machine, sub_type, header.e_ident[EI_OSABI]); 524 525 if (spec.GetArchitecture().IsValid()) { 526 llvm::Triple::OSType ostype; 527 llvm::Triple::VendorType vendor; 528 llvm::Triple::OSType spec_ostype = 529 spec.GetArchitecture().GetTriple().getOS(); 530 531 LLDB_LOGF(log, "ObjectFileELF::%s file '%s' module OSABI: %s", 532 __FUNCTION__, file.GetPath().c_str(), 533 OSABIAsCString(header.e_ident[EI_OSABI])); 534 535 // SetArchitecture should have set the vendor to unknown 536 vendor = spec.GetArchitecture().GetTriple().getVendor(); 537 assert(vendor == llvm::Triple::UnknownVendor); 538 UNUSED_IF_ASSERT_DISABLED(vendor); 539 540 // 541 // Validate it is ok to remove GetOsFromOSABI 542 GetOsFromOSABI(header.e_ident[EI_OSABI], ostype); 543 assert(spec_ostype == ostype); 544 if (spec_ostype != llvm::Triple::OSType::UnknownOS) { 545 LLDB_LOGF(log, 546 "ObjectFileELF::%s file '%s' set ELF module OS type " 547 "from ELF header OSABI.", 548 __FUNCTION__, file.GetPath().c_str()); 549 } 550 551 if (data_sp->GetByteSize() < length) 552 data_sp = MapFileData(file, -1, file_offset); 553 if (data_sp) 554 data.SetData(data_sp); 555 // In case there is header extension in the section #0, the header we 556 // parsed above could have sentinel values for e_phnum, e_shnum, and 557 // e_shstrndx. In this case we need to reparse the header with a 558 // bigger data source to get the actual values. 559 if (header.HasHeaderExtension()) { 560 lldb::offset_t header_offset = data_offset; 561 header.Parse(data, &header_offset); 562 } 563 564 uint32_t gnu_debuglink_crc = 0; 565 std::string gnu_debuglink_file; 566 SectionHeaderColl section_headers; 567 lldb_private::UUID &uuid = spec.GetUUID(); 568 569 GetSectionHeaderInfo(section_headers, data, header, uuid, 570 gnu_debuglink_file, gnu_debuglink_crc, 571 spec.GetArchitecture()); 572 573 llvm::Triple &spec_triple = spec.GetArchitecture().GetTriple(); 574 575 LLDB_LOGF(log, 576 "ObjectFileELF::%s file '%s' module set to triple: %s " 577 "(architecture %s)", 578 __FUNCTION__, file.GetPath().c_str(), 579 spec_triple.getTriple().c_str(), 580 spec.GetArchitecture().GetArchitectureName()); 581 582 if (!uuid.IsValid()) { 583 uint32_t core_notes_crc = 0; 584 585 if (!gnu_debuglink_crc) { 586 LLDB_SCOPED_TIMERF( 587 "Calculating module crc32 %s with size %" PRIu64 " KiB", 588 file.GetLastPathComponent().AsCString(), 589 (length - file_offset) / 1024); 590 591 // For core files - which usually don't happen to have a 592 // gnu_debuglink, and are pretty bulky - calculating whole 593 // contents crc32 would be too much of luxury. Thus we will need 594 // to fallback to something simpler. 595 if (header.e_type == llvm::ELF::ET_CORE) { 596 ProgramHeaderColl program_headers; 597 GetProgramHeaderInfo(program_headers, data, header); 598 599 core_notes_crc = 600 CalculateELFNotesSegmentsCRC32(program_headers, data); 601 } else { 602 gnu_debuglink_crc = calc_crc32(0, data); 603 } 604 } 605 using u32le = llvm::support::ulittle32_t; 606 if (gnu_debuglink_crc) { 607 // Use 4 bytes of crc from the .gnu_debuglink section. 608 u32le data(gnu_debuglink_crc); 609 uuid = UUID::fromData(&data, sizeof(data)); 610 } else if (core_notes_crc) { 611 // Use 8 bytes - first 4 bytes for *magic* prefix, mainly to make 612 // it look different form .gnu_debuglink crc followed by 4 bytes 613 // of note segments crc. 614 u32le data[] = {u32le(g_core_uuid_magic), u32le(core_notes_crc)}; 615 uuid = UUID::fromData(data, sizeof(data)); 616 } 617 } 618 619 specs.Append(spec); 620 } 621 } 622 } 623 } 624 625 return specs.GetSize() - initial_count; 626 } 627 628 // ObjectFile protocol 629 630 ObjectFileELF::ObjectFileELF(const lldb::ModuleSP &module_sp, 631 DataBufferSP &data_sp, lldb::offset_t data_offset, 632 const FileSpec *file, lldb::offset_t file_offset, 633 lldb::offset_t length) 634 : ObjectFile(module_sp, file, file_offset, length, data_sp, data_offset) { 635 if (file) 636 m_file = *file; 637 } 638 639 ObjectFileELF::ObjectFileELF(const lldb::ModuleSP &module_sp, 640 DataBufferSP &header_data_sp, 641 const lldb::ProcessSP &process_sp, 642 addr_t header_addr) 643 : ObjectFile(module_sp, process_sp, header_addr, header_data_sp) {} 644 645 bool ObjectFileELF::IsExecutable() const { 646 return ((m_header.e_type & ET_EXEC) != 0) || (m_header.e_entry != 0); 647 } 648 649 bool ObjectFileELF::SetLoadAddress(Target &target, lldb::addr_t value, 650 bool value_is_offset) { 651 ModuleSP module_sp = GetModule(); 652 if (module_sp) { 653 size_t num_loaded_sections = 0; 654 SectionList *section_list = GetSectionList(); 655 if (section_list) { 656 if (!value_is_offset) { 657 addr_t base = GetBaseAddress().GetFileAddress(); 658 if (base == LLDB_INVALID_ADDRESS) 659 return false; 660 value -= base; 661 } 662 663 const size_t num_sections = section_list->GetSize(); 664 size_t sect_idx = 0; 665 666 for (sect_idx = 0; sect_idx < num_sections; ++sect_idx) { 667 // Iterate through the object file sections to find all of the sections 668 // that have SHF_ALLOC in their flag bits. 669 SectionSP section_sp(section_list->GetSectionAtIndex(sect_idx)); 670 if (section_sp->Test(SHF_ALLOC) || 671 section_sp->GetType() == eSectionTypeContainer) { 672 lldb::addr_t load_addr = section_sp->GetFileAddress(); 673 // We don't want to update the load address of a section with type 674 // eSectionTypeAbsoluteAddress as they already have the absolute load 675 // address already specified 676 if (section_sp->GetType() != eSectionTypeAbsoluteAddress) 677 load_addr += value; 678 679 // On 32-bit systems the load address have to fit into 4 bytes. The 680 // rest of the bytes are the overflow from the addition. 681 if (GetAddressByteSize() == 4) 682 load_addr &= 0xFFFFFFFF; 683 684 if (target.GetSectionLoadList().SetSectionLoadAddress(section_sp, 685 load_addr)) 686 ++num_loaded_sections; 687 } 688 } 689 return num_loaded_sections > 0; 690 } 691 } 692 return false; 693 } 694 695 ByteOrder ObjectFileELF::GetByteOrder() const { 696 if (m_header.e_ident[EI_DATA] == ELFDATA2MSB) 697 return eByteOrderBig; 698 if (m_header.e_ident[EI_DATA] == ELFDATA2LSB) 699 return eByteOrderLittle; 700 return eByteOrderInvalid; 701 } 702 703 uint32_t ObjectFileELF::GetAddressByteSize() const { 704 return m_data.GetAddressByteSize(); 705 } 706 707 AddressClass ObjectFileELF::GetAddressClass(addr_t file_addr) { 708 Symtab *symtab = GetSymtab(); 709 if (!symtab) 710 return AddressClass::eUnknown; 711 712 // The address class is determined based on the symtab. Ask it from the 713 // object file what contains the symtab information. 714 ObjectFile *symtab_objfile = symtab->GetObjectFile(); 715 if (symtab_objfile != nullptr && symtab_objfile != this) 716 return symtab_objfile->GetAddressClass(file_addr); 717 718 auto res = ObjectFile::GetAddressClass(file_addr); 719 if (res != AddressClass::eCode) 720 return res; 721 722 auto ub = m_address_class_map.upper_bound(file_addr); 723 if (ub == m_address_class_map.begin()) { 724 // No entry in the address class map before the address. Return default 725 // address class for an address in a code section. 726 return AddressClass::eCode; 727 } 728 729 // Move iterator to the address class entry preceding address 730 --ub; 731 732 return ub->second; 733 } 734 735 size_t ObjectFileELF::SectionIndex(const SectionHeaderCollIter &I) { 736 return std::distance(m_section_headers.begin(), I); 737 } 738 739 size_t ObjectFileELF::SectionIndex(const SectionHeaderCollConstIter &I) const { 740 return std::distance(m_section_headers.begin(), I); 741 } 742 743 bool ObjectFileELF::ParseHeader() { 744 lldb::offset_t offset = 0; 745 return m_header.Parse(m_data, &offset); 746 } 747 748 UUID ObjectFileELF::GetUUID() { 749 // Need to parse the section list to get the UUIDs, so make sure that's been 750 // done. 751 if (!ParseSectionHeaders() && GetType() != ObjectFile::eTypeCoreFile) 752 return UUID(); 753 754 if (!m_uuid) { 755 using u32le = llvm::support::ulittle32_t; 756 if (GetType() == ObjectFile::eTypeCoreFile) { 757 uint32_t core_notes_crc = 0; 758 759 if (!ParseProgramHeaders()) 760 return UUID(); 761 762 core_notes_crc = 763 CalculateELFNotesSegmentsCRC32(m_program_headers, m_data); 764 765 if (core_notes_crc) { 766 // Use 8 bytes - first 4 bytes for *magic* prefix, mainly to make it 767 // look different form .gnu_debuglink crc - followed by 4 bytes of note 768 // segments crc. 769 u32le data[] = {u32le(g_core_uuid_magic), u32le(core_notes_crc)}; 770 m_uuid = UUID::fromData(data, sizeof(data)); 771 } 772 } else { 773 if (!m_gnu_debuglink_crc) 774 m_gnu_debuglink_crc = calc_crc32(0, m_data); 775 if (m_gnu_debuglink_crc) { 776 // Use 4 bytes of crc from the .gnu_debuglink section. 777 u32le data(m_gnu_debuglink_crc); 778 m_uuid = UUID::fromData(&data, sizeof(data)); 779 } 780 } 781 } 782 783 return m_uuid; 784 } 785 786 llvm::Optional<FileSpec> ObjectFileELF::GetDebugLink() { 787 if (m_gnu_debuglink_file.empty()) 788 return llvm::None; 789 return FileSpec(m_gnu_debuglink_file); 790 } 791 792 uint32_t ObjectFileELF::GetDependentModules(FileSpecList &files) { 793 size_t num_modules = ParseDependentModules(); 794 uint32_t num_specs = 0; 795 796 for (unsigned i = 0; i < num_modules; ++i) { 797 if (files.AppendIfUnique(m_filespec_up->GetFileSpecAtIndex(i))) 798 num_specs++; 799 } 800 801 return num_specs; 802 } 803 804 Address ObjectFileELF::GetImageInfoAddress(Target *target) { 805 if (!ParseDynamicSymbols()) 806 return Address(); 807 808 SectionList *section_list = GetSectionList(); 809 if (!section_list) 810 return Address(); 811 812 // Find the SHT_DYNAMIC (.dynamic) section. 813 SectionSP dynsym_section_sp( 814 section_list->FindSectionByType(eSectionTypeELFDynamicLinkInfo, true)); 815 if (!dynsym_section_sp) 816 return Address(); 817 assert(dynsym_section_sp->GetObjectFile() == this); 818 819 user_id_t dynsym_id = dynsym_section_sp->GetID(); 820 const ELFSectionHeaderInfo *dynsym_hdr = GetSectionHeaderByIndex(dynsym_id); 821 if (!dynsym_hdr) 822 return Address(); 823 824 for (size_t i = 0; i < m_dynamic_symbols.size(); ++i) { 825 ELFDynamic &symbol = m_dynamic_symbols[i]; 826 827 if (symbol.d_tag == DT_DEBUG) { 828 // Compute the offset as the number of previous entries plus the size of 829 // d_tag. 830 addr_t offset = i * dynsym_hdr->sh_entsize + GetAddressByteSize(); 831 return Address(dynsym_section_sp, offset); 832 } 833 // MIPS executables uses DT_MIPS_RLD_MAP_REL to support PIE. DT_MIPS_RLD_MAP 834 // exists in non-PIE. 835 else if ((symbol.d_tag == DT_MIPS_RLD_MAP || 836 symbol.d_tag == DT_MIPS_RLD_MAP_REL) && 837 target) { 838 addr_t offset = i * dynsym_hdr->sh_entsize + GetAddressByteSize(); 839 addr_t dyn_base = dynsym_section_sp->GetLoadBaseAddress(target); 840 if (dyn_base == LLDB_INVALID_ADDRESS) 841 return Address(); 842 843 Status error; 844 if (symbol.d_tag == DT_MIPS_RLD_MAP) { 845 // DT_MIPS_RLD_MAP tag stores an absolute address of the debug pointer. 846 Address addr; 847 if (target->ReadPointerFromMemory(dyn_base + offset, error, addr, true)) 848 return addr; 849 } 850 if (symbol.d_tag == DT_MIPS_RLD_MAP_REL) { 851 // DT_MIPS_RLD_MAP_REL tag stores the offset to the debug pointer, 852 // relative to the address of the tag. 853 uint64_t rel_offset; 854 rel_offset = target->ReadUnsignedIntegerFromMemory( 855 dyn_base + offset, GetAddressByteSize(), UINT64_MAX, error, true); 856 if (error.Success() && rel_offset != UINT64_MAX) { 857 Address addr; 858 addr_t debug_ptr_address = 859 dyn_base + (offset - GetAddressByteSize()) + rel_offset; 860 addr.SetOffset(debug_ptr_address); 861 return addr; 862 } 863 } 864 } 865 } 866 867 return Address(); 868 } 869 870 lldb_private::Address ObjectFileELF::GetEntryPointAddress() { 871 if (m_entry_point_address.IsValid()) 872 return m_entry_point_address; 873 874 if (!ParseHeader() || !IsExecutable()) 875 return m_entry_point_address; 876 877 SectionList *section_list = GetSectionList(); 878 addr_t offset = m_header.e_entry; 879 880 if (!section_list) 881 m_entry_point_address.SetOffset(offset); 882 else 883 m_entry_point_address.ResolveAddressUsingFileSections(offset, section_list); 884 return m_entry_point_address; 885 } 886 887 Address ObjectFileELF::GetBaseAddress() { 888 for (const auto &EnumPHdr : llvm::enumerate(ProgramHeaders())) { 889 const ELFProgramHeader &H = EnumPHdr.value(); 890 if (H.p_type != PT_LOAD) 891 continue; 892 893 return Address( 894 GetSectionList()->FindSectionByID(SegmentID(EnumPHdr.index())), 0); 895 } 896 return LLDB_INVALID_ADDRESS; 897 } 898 899 // ParseDependentModules 900 size_t ObjectFileELF::ParseDependentModules() { 901 if (m_filespec_up) 902 return m_filespec_up->GetSize(); 903 904 m_filespec_up = std::make_unique<FileSpecList>(); 905 906 if (!ParseSectionHeaders()) 907 return 0; 908 909 SectionList *section_list = GetSectionList(); 910 if (!section_list) 911 return 0; 912 913 // Find the SHT_DYNAMIC section. 914 Section *dynsym = 915 section_list->FindSectionByType(eSectionTypeELFDynamicLinkInfo, true) 916 .get(); 917 if (!dynsym) 918 return 0; 919 assert(dynsym->GetObjectFile() == this); 920 921 const ELFSectionHeaderInfo *header = GetSectionHeaderByIndex(dynsym->GetID()); 922 if (!header) 923 return 0; 924 // sh_link: section header index of string table used by entries in the 925 // section. 926 Section *dynstr = section_list->FindSectionByID(header->sh_link).get(); 927 if (!dynstr) 928 return 0; 929 930 DataExtractor dynsym_data; 931 DataExtractor dynstr_data; 932 if (ReadSectionData(dynsym, dynsym_data) && 933 ReadSectionData(dynstr, dynstr_data)) { 934 ELFDynamic symbol; 935 const lldb::offset_t section_size = dynsym_data.GetByteSize(); 936 lldb::offset_t offset = 0; 937 938 // The only type of entries we are concerned with are tagged DT_NEEDED, 939 // yielding the name of a required library. 940 while (offset < section_size) { 941 if (!symbol.Parse(dynsym_data, &offset)) 942 break; 943 944 if (symbol.d_tag != DT_NEEDED) 945 continue; 946 947 uint32_t str_index = static_cast<uint32_t>(symbol.d_val); 948 const char *lib_name = dynstr_data.PeekCStr(str_index); 949 FileSpec file_spec(lib_name); 950 FileSystem::Instance().Resolve(file_spec); 951 m_filespec_up->Append(file_spec); 952 } 953 } 954 955 return m_filespec_up->GetSize(); 956 } 957 958 // GetProgramHeaderInfo 959 size_t ObjectFileELF::GetProgramHeaderInfo(ProgramHeaderColl &program_headers, 960 DataExtractor &object_data, 961 const ELFHeader &header) { 962 // We have already parsed the program headers 963 if (!program_headers.empty()) 964 return program_headers.size(); 965 966 // If there are no program headers to read we are done. 967 if (header.e_phnum == 0) 968 return 0; 969 970 program_headers.resize(header.e_phnum); 971 if (program_headers.size() != header.e_phnum) 972 return 0; 973 974 const size_t ph_size = header.e_phnum * header.e_phentsize; 975 const elf_off ph_offset = header.e_phoff; 976 DataExtractor data; 977 if (data.SetData(object_data, ph_offset, ph_size) != ph_size) 978 return 0; 979 980 uint32_t idx; 981 lldb::offset_t offset; 982 for (idx = 0, offset = 0; idx < header.e_phnum; ++idx) { 983 if (!program_headers[idx].Parse(data, &offset)) 984 break; 985 } 986 987 if (idx < program_headers.size()) 988 program_headers.resize(idx); 989 990 return program_headers.size(); 991 } 992 993 // ParseProgramHeaders 994 bool ObjectFileELF::ParseProgramHeaders() { 995 return GetProgramHeaderInfo(m_program_headers, m_data, m_header) != 0; 996 } 997 998 lldb_private::Status 999 ObjectFileELF::RefineModuleDetailsFromNote(lldb_private::DataExtractor &data, 1000 lldb_private::ArchSpec &arch_spec, 1001 lldb_private::UUID &uuid) { 1002 Log *log = GetLog(LLDBLog::Modules); 1003 Status error; 1004 1005 lldb::offset_t offset = 0; 1006 1007 while (true) { 1008 // Parse the note header. If this fails, bail out. 1009 const lldb::offset_t note_offset = offset; 1010 ELFNote note = ELFNote(); 1011 if (!note.Parse(data, &offset)) { 1012 // We're done. 1013 return error; 1014 } 1015 1016 LLDB_LOGF(log, "ObjectFileELF::%s parsing note name='%s', type=%" PRIu32, 1017 __FUNCTION__, note.n_name.c_str(), note.n_type); 1018 1019 // Process FreeBSD ELF notes. 1020 if ((note.n_name == LLDB_NT_OWNER_FREEBSD) && 1021 (note.n_type == LLDB_NT_FREEBSD_ABI_TAG) && 1022 (note.n_descsz == LLDB_NT_FREEBSD_ABI_SIZE)) { 1023 // Pull out the min version info. 1024 uint32_t version_info; 1025 if (data.GetU32(&offset, &version_info, 1) == nullptr) { 1026 error.SetErrorString("failed to read FreeBSD ABI note payload"); 1027 return error; 1028 } 1029 1030 // Convert the version info into a major/minor number. 1031 const uint32_t version_major = version_info / 100000; 1032 const uint32_t version_minor = (version_info / 1000) % 100; 1033 1034 char os_name[32]; 1035 snprintf(os_name, sizeof(os_name), "freebsd%" PRIu32 ".%" PRIu32, 1036 version_major, version_minor); 1037 1038 // Set the elf OS version to FreeBSD. Also clear the vendor. 1039 arch_spec.GetTriple().setOSName(os_name); 1040 arch_spec.GetTriple().setVendor(llvm::Triple::VendorType::UnknownVendor); 1041 1042 LLDB_LOGF(log, 1043 "ObjectFileELF::%s detected FreeBSD %" PRIu32 ".%" PRIu32 1044 ".%" PRIu32, 1045 __FUNCTION__, version_major, version_minor, 1046 static_cast<uint32_t>(version_info % 1000)); 1047 } 1048 // Process GNU ELF notes. 1049 else if (note.n_name == LLDB_NT_OWNER_GNU) { 1050 switch (note.n_type) { 1051 case LLDB_NT_GNU_ABI_TAG: 1052 if (note.n_descsz == LLDB_NT_GNU_ABI_SIZE) { 1053 // Pull out the min OS version supporting the ABI. 1054 uint32_t version_info[4]; 1055 if (data.GetU32(&offset, &version_info[0], note.n_descsz / 4) == 1056 nullptr) { 1057 error.SetErrorString("failed to read GNU ABI note payload"); 1058 return error; 1059 } 1060 1061 // Set the OS per the OS field. 1062 switch (version_info[0]) { 1063 case LLDB_NT_GNU_ABI_OS_LINUX: 1064 arch_spec.GetTriple().setOS(llvm::Triple::OSType::Linux); 1065 arch_spec.GetTriple().setVendor( 1066 llvm::Triple::VendorType::UnknownVendor); 1067 LLDB_LOGF(log, 1068 "ObjectFileELF::%s detected Linux, min version %" PRIu32 1069 ".%" PRIu32 ".%" PRIu32, 1070 __FUNCTION__, version_info[1], version_info[2], 1071 version_info[3]); 1072 // FIXME we have the minimal version number, we could be propagating 1073 // that. version_info[1] = OS Major, version_info[2] = OS Minor, 1074 // version_info[3] = Revision. 1075 break; 1076 case LLDB_NT_GNU_ABI_OS_HURD: 1077 arch_spec.GetTriple().setOS(llvm::Triple::OSType::UnknownOS); 1078 arch_spec.GetTriple().setVendor( 1079 llvm::Triple::VendorType::UnknownVendor); 1080 LLDB_LOGF(log, 1081 "ObjectFileELF::%s detected Hurd (unsupported), min " 1082 "version %" PRIu32 ".%" PRIu32 ".%" PRIu32, 1083 __FUNCTION__, version_info[1], version_info[2], 1084 version_info[3]); 1085 break; 1086 case LLDB_NT_GNU_ABI_OS_SOLARIS: 1087 arch_spec.GetTriple().setOS(llvm::Triple::OSType::Solaris); 1088 arch_spec.GetTriple().setVendor( 1089 llvm::Triple::VendorType::UnknownVendor); 1090 LLDB_LOGF(log, 1091 "ObjectFileELF::%s detected Solaris, min version %" PRIu32 1092 ".%" PRIu32 ".%" PRIu32, 1093 __FUNCTION__, version_info[1], version_info[2], 1094 version_info[3]); 1095 break; 1096 default: 1097 LLDB_LOGF(log, 1098 "ObjectFileELF::%s unrecognized OS in note, id %" PRIu32 1099 ", min version %" PRIu32 ".%" PRIu32 ".%" PRIu32, 1100 __FUNCTION__, version_info[0], version_info[1], 1101 version_info[2], version_info[3]); 1102 break; 1103 } 1104 } 1105 break; 1106 1107 case LLDB_NT_GNU_BUILD_ID_TAG: 1108 // Only bother processing this if we don't already have the uuid set. 1109 if (!uuid.IsValid()) { 1110 // 16 bytes is UUID|MD5, 20 bytes is SHA1. Other linkers may produce a 1111 // build-id of a different length. Accept it as long as it's at least 1112 // 4 bytes as it will be better than our own crc32. 1113 if (note.n_descsz >= 4) { 1114 if (const uint8_t *buf = data.PeekData(offset, note.n_descsz)) { 1115 // Save the build id as the UUID for the module. 1116 uuid = UUID::fromData(buf, note.n_descsz); 1117 } else { 1118 error.SetErrorString("failed to read GNU_BUILD_ID note payload"); 1119 return error; 1120 } 1121 } 1122 } 1123 break; 1124 } 1125 if (arch_spec.IsMIPS() && 1126 arch_spec.GetTriple().getOS() == llvm::Triple::OSType::UnknownOS) 1127 // The note.n_name == LLDB_NT_OWNER_GNU is valid for Linux platform 1128 arch_spec.GetTriple().setOS(llvm::Triple::OSType::Linux); 1129 } 1130 // Process NetBSD ELF executables and shared libraries 1131 else if ((note.n_name == LLDB_NT_OWNER_NETBSD) && 1132 (note.n_type == LLDB_NT_NETBSD_IDENT_TAG) && 1133 (note.n_descsz == LLDB_NT_NETBSD_IDENT_DESCSZ) && 1134 (note.n_namesz == LLDB_NT_NETBSD_IDENT_NAMESZ)) { 1135 // Pull out the version info. 1136 uint32_t version_info; 1137 if (data.GetU32(&offset, &version_info, 1) == nullptr) { 1138 error.SetErrorString("failed to read NetBSD ABI note payload"); 1139 return error; 1140 } 1141 // Convert the version info into a major/minor/patch number. 1142 // #define __NetBSD_Version__ MMmmrrpp00 1143 // 1144 // M = major version 1145 // m = minor version; a minor number of 99 indicates current. 1146 // r = 0 (since NetBSD 3.0 not used) 1147 // p = patchlevel 1148 const uint32_t version_major = version_info / 100000000; 1149 const uint32_t version_minor = (version_info % 100000000) / 1000000; 1150 const uint32_t version_patch = (version_info % 10000) / 100; 1151 // Set the elf OS version to NetBSD. Also clear the vendor. 1152 arch_spec.GetTriple().setOSName( 1153 llvm::formatv("netbsd{0}.{1}.{2}", version_major, version_minor, 1154 version_patch).str()); 1155 arch_spec.GetTriple().setVendor(llvm::Triple::VendorType::UnknownVendor); 1156 } 1157 // Process NetBSD ELF core(5) notes 1158 else if ((note.n_name == LLDB_NT_OWNER_NETBSDCORE) && 1159 (note.n_type == LLDB_NT_NETBSD_PROCINFO)) { 1160 // Set the elf OS version to NetBSD. Also clear the vendor. 1161 arch_spec.GetTriple().setOS(llvm::Triple::OSType::NetBSD); 1162 arch_spec.GetTriple().setVendor(llvm::Triple::VendorType::UnknownVendor); 1163 } 1164 // Process OpenBSD ELF notes. 1165 else if (note.n_name == LLDB_NT_OWNER_OPENBSD) { 1166 // Set the elf OS version to OpenBSD. Also clear the vendor. 1167 arch_spec.GetTriple().setOS(llvm::Triple::OSType::OpenBSD); 1168 arch_spec.GetTriple().setVendor(llvm::Triple::VendorType::UnknownVendor); 1169 } else if (note.n_name == LLDB_NT_OWNER_ANDROID) { 1170 arch_spec.GetTriple().setOS(llvm::Triple::OSType::Linux); 1171 arch_spec.GetTriple().setEnvironment( 1172 llvm::Triple::EnvironmentType::Android); 1173 } else if (note.n_name == LLDB_NT_OWNER_LINUX) { 1174 // This is sometimes found in core files and usually contains extended 1175 // register info 1176 arch_spec.GetTriple().setOS(llvm::Triple::OSType::Linux); 1177 } else if (note.n_name == LLDB_NT_OWNER_CORE) { 1178 // Parse the NT_FILE to look for stuff in paths to shared libraries 1179 // The contents look like this in a 64 bit ELF core file: 1180 // 1181 // count = 0x000000000000000a (10) 1182 // page_size = 0x0000000000001000 (4096) 1183 // Index start end file_ofs path 1184 // ===== ------------------ ------------------ ------------------ ------------------------------------- 1185 // [ 0] 0x0000000000401000 0x0000000000000000 /tmp/a.out 1186 // [ 1] 0x0000000000600000 0x0000000000601000 0x0000000000000000 /tmp/a.out 1187 // [ 2] 0x0000000000601000 0x0000000000602000 0x0000000000000001 /tmp/a.out 1188 // [ 3] 0x00007fa79c9ed000 0x00007fa79cba8000 0x0000000000000000 /lib/x86_64-linux-gnu/libc-2.19.so 1189 // [ 4] 0x00007fa79cba8000 0x00007fa79cda7000 0x00000000000001bb /lib/x86_64-linux-gnu/libc-2.19.so 1190 // [ 5] 0x00007fa79cda7000 0x00007fa79cdab000 0x00000000000001ba /lib/x86_64-linux-gnu/libc-2.19.so 1191 // [ 6] 0x00007fa79cdab000 0x00007fa79cdad000 0x00000000000001be /lib/x86_64-linux-gnu/libc-2.19.so 1192 // [ 7] 0x00007fa79cdb2000 0x00007fa79cdd5000 0x0000000000000000 /lib/x86_64-linux-gnu/ld-2.19.so 1193 // [ 8] 0x00007fa79cfd4000 0x00007fa79cfd5000 0x0000000000000022 /lib/x86_64-linux-gnu/ld-2.19.so 1194 // [ 9] 0x00007fa79cfd5000 0x00007fa79cfd6000 0x0000000000000023 /lib/x86_64-linux-gnu/ld-2.19.so 1195 // 1196 // In the 32 bit ELFs the count, page_size, start, end, file_ofs are 1197 // uint32_t. 1198 // 1199 // For reference: see readelf source code (in binutils). 1200 if (note.n_type == NT_FILE) { 1201 uint64_t count = data.GetAddress(&offset); 1202 const char *cstr; 1203 data.GetAddress(&offset); // Skip page size 1204 offset += count * 3 * 1205 data.GetAddressByteSize(); // Skip all start/end/file_ofs 1206 for (size_t i = 0; i < count; ++i) { 1207 cstr = data.GetCStr(&offset); 1208 if (cstr == nullptr) { 1209 error.SetErrorStringWithFormat("ObjectFileELF::%s trying to read " 1210 "at an offset after the end " 1211 "(GetCStr returned nullptr)", 1212 __FUNCTION__); 1213 return error; 1214 } 1215 llvm::StringRef path(cstr); 1216 if (path.contains("/lib/x86_64-linux-gnu") || path.contains("/lib/i386-linux-gnu")) { 1217 arch_spec.GetTriple().setOS(llvm::Triple::OSType::Linux); 1218 break; 1219 } 1220 } 1221 if (arch_spec.IsMIPS() && 1222 arch_spec.GetTriple().getOS() == llvm::Triple::OSType::UnknownOS) 1223 // In case of MIPSR6, the LLDB_NT_OWNER_GNU note is missing for some 1224 // cases (e.g. compile with -nostdlib) Hence set OS to Linux 1225 arch_spec.GetTriple().setOS(llvm::Triple::OSType::Linux); 1226 } 1227 } 1228 1229 // Calculate the offset of the next note just in case "offset" has been 1230 // used to poke at the contents of the note data 1231 offset = note_offset + note.GetByteSize(); 1232 } 1233 1234 return error; 1235 } 1236 1237 void ObjectFileELF::ParseARMAttributes(DataExtractor &data, uint64_t length, 1238 ArchSpec &arch_spec) { 1239 lldb::offset_t Offset = 0; 1240 1241 uint8_t FormatVersion = data.GetU8(&Offset); 1242 if (FormatVersion != llvm::ELFAttrs::Format_Version) 1243 return; 1244 1245 Offset = Offset + sizeof(uint32_t); // Section Length 1246 llvm::StringRef VendorName = data.GetCStr(&Offset); 1247 1248 if (VendorName != "aeabi") 1249 return; 1250 1251 if (arch_spec.GetTriple().getEnvironment() == 1252 llvm::Triple::UnknownEnvironment) 1253 arch_spec.GetTriple().setEnvironment(llvm::Triple::EABI); 1254 1255 while (Offset < length) { 1256 uint8_t Tag = data.GetU8(&Offset); 1257 uint32_t Size = data.GetU32(&Offset); 1258 1259 if (Tag != llvm::ARMBuildAttrs::File || Size == 0) 1260 continue; 1261 1262 while (Offset < length) { 1263 uint64_t Tag = data.GetULEB128(&Offset); 1264 switch (Tag) { 1265 default: 1266 if (Tag < 32) 1267 data.GetULEB128(&Offset); 1268 else if (Tag % 2 == 0) 1269 data.GetULEB128(&Offset); 1270 else 1271 data.GetCStr(&Offset); 1272 1273 break; 1274 1275 case llvm::ARMBuildAttrs::CPU_raw_name: 1276 case llvm::ARMBuildAttrs::CPU_name: 1277 data.GetCStr(&Offset); 1278 1279 break; 1280 1281 case llvm::ARMBuildAttrs::ABI_VFP_args: { 1282 uint64_t VFPArgs = data.GetULEB128(&Offset); 1283 1284 if (VFPArgs == llvm::ARMBuildAttrs::BaseAAPCS) { 1285 if (arch_spec.GetTriple().getEnvironment() == 1286 llvm::Triple::UnknownEnvironment || 1287 arch_spec.GetTriple().getEnvironment() == llvm::Triple::EABIHF) 1288 arch_spec.GetTriple().setEnvironment(llvm::Triple::EABI); 1289 1290 arch_spec.SetFlags(ArchSpec::eARM_abi_soft_float); 1291 } else if (VFPArgs == llvm::ARMBuildAttrs::HardFPAAPCS) { 1292 if (arch_spec.GetTriple().getEnvironment() == 1293 llvm::Triple::UnknownEnvironment || 1294 arch_spec.GetTriple().getEnvironment() == llvm::Triple::EABI) 1295 arch_spec.GetTriple().setEnvironment(llvm::Triple::EABIHF); 1296 1297 arch_spec.SetFlags(ArchSpec::eARM_abi_hard_float); 1298 } 1299 1300 break; 1301 } 1302 } 1303 } 1304 } 1305 } 1306 1307 // GetSectionHeaderInfo 1308 size_t ObjectFileELF::GetSectionHeaderInfo(SectionHeaderColl §ion_headers, 1309 DataExtractor &object_data, 1310 const elf::ELFHeader &header, 1311 lldb_private::UUID &uuid, 1312 std::string &gnu_debuglink_file, 1313 uint32_t &gnu_debuglink_crc, 1314 ArchSpec &arch_spec) { 1315 // Don't reparse the section headers if we already did that. 1316 if (!section_headers.empty()) 1317 return section_headers.size(); 1318 1319 // Only initialize the arch_spec to okay defaults if they're not already set. 1320 // We'll refine this with note data as we parse the notes. 1321 if (arch_spec.GetTriple().getOS() == llvm::Triple::OSType::UnknownOS) { 1322 llvm::Triple::OSType ostype; 1323 llvm::Triple::OSType spec_ostype; 1324 const uint32_t sub_type = subTypeFromElfHeader(header); 1325 arch_spec.SetArchitecture(eArchTypeELF, header.e_machine, sub_type, 1326 header.e_ident[EI_OSABI]); 1327 1328 // Validate if it is ok to remove GetOsFromOSABI. Note, that now the OS is 1329 // determined based on EI_OSABI flag and the info extracted from ELF notes 1330 // (see RefineModuleDetailsFromNote). However in some cases that still 1331 // might be not enough: for example a shared library might not have any 1332 // notes at all and have EI_OSABI flag set to System V, as result the OS 1333 // will be set to UnknownOS. 1334 GetOsFromOSABI(header.e_ident[EI_OSABI], ostype); 1335 spec_ostype = arch_spec.GetTriple().getOS(); 1336 assert(spec_ostype == ostype); 1337 UNUSED_IF_ASSERT_DISABLED(spec_ostype); 1338 } 1339 1340 if (arch_spec.GetMachine() == llvm::Triple::mips || 1341 arch_spec.GetMachine() == llvm::Triple::mipsel || 1342 arch_spec.GetMachine() == llvm::Triple::mips64 || 1343 arch_spec.GetMachine() == llvm::Triple::mips64el) { 1344 switch (header.e_flags & llvm::ELF::EF_MIPS_ARCH_ASE) { 1345 case llvm::ELF::EF_MIPS_MICROMIPS: 1346 arch_spec.SetFlags(ArchSpec::eMIPSAse_micromips); 1347 break; 1348 case llvm::ELF::EF_MIPS_ARCH_ASE_M16: 1349 arch_spec.SetFlags(ArchSpec::eMIPSAse_mips16); 1350 break; 1351 case llvm::ELF::EF_MIPS_ARCH_ASE_MDMX: 1352 arch_spec.SetFlags(ArchSpec::eMIPSAse_mdmx); 1353 break; 1354 default: 1355 break; 1356 } 1357 } 1358 1359 if (arch_spec.GetMachine() == llvm::Triple::arm || 1360 arch_spec.GetMachine() == llvm::Triple::thumb) { 1361 if (header.e_flags & llvm::ELF::EF_ARM_SOFT_FLOAT) 1362 arch_spec.SetFlags(ArchSpec::eARM_abi_soft_float); 1363 else if (header.e_flags & llvm::ELF::EF_ARM_VFP_FLOAT) 1364 arch_spec.SetFlags(ArchSpec::eARM_abi_hard_float); 1365 } 1366 1367 // If there are no section headers we are done. 1368 if (header.e_shnum == 0) 1369 return 0; 1370 1371 Log *log = GetLog(LLDBLog::Modules); 1372 1373 section_headers.resize(header.e_shnum); 1374 if (section_headers.size() != header.e_shnum) 1375 return 0; 1376 1377 const size_t sh_size = header.e_shnum * header.e_shentsize; 1378 const elf_off sh_offset = header.e_shoff; 1379 DataExtractor sh_data; 1380 if (sh_data.SetData(object_data, sh_offset, sh_size) != sh_size) 1381 return 0; 1382 1383 uint32_t idx; 1384 lldb::offset_t offset; 1385 for (idx = 0, offset = 0; idx < header.e_shnum; ++idx) { 1386 if (!section_headers[idx].Parse(sh_data, &offset)) 1387 break; 1388 } 1389 if (idx < section_headers.size()) 1390 section_headers.resize(idx); 1391 1392 const unsigned strtab_idx = header.e_shstrndx; 1393 if (strtab_idx && strtab_idx < section_headers.size()) { 1394 const ELFSectionHeaderInfo &sheader = section_headers[strtab_idx]; 1395 const size_t byte_size = sheader.sh_size; 1396 const Elf64_Off offset = sheader.sh_offset; 1397 lldb_private::DataExtractor shstr_data; 1398 1399 if (shstr_data.SetData(object_data, offset, byte_size) == byte_size) { 1400 for (SectionHeaderCollIter I = section_headers.begin(); 1401 I != section_headers.end(); ++I) { 1402 static ConstString g_sect_name_gnu_debuglink(".gnu_debuglink"); 1403 const ELFSectionHeaderInfo &sheader = *I; 1404 const uint64_t section_size = 1405 sheader.sh_type == SHT_NOBITS ? 0 : sheader.sh_size; 1406 ConstString name(shstr_data.PeekCStr(I->sh_name)); 1407 1408 I->section_name = name; 1409 1410 if (arch_spec.IsMIPS()) { 1411 uint32_t arch_flags = arch_spec.GetFlags(); 1412 DataExtractor data; 1413 if (sheader.sh_type == SHT_MIPS_ABIFLAGS) { 1414 1415 if (section_size && (data.SetData(object_data, sheader.sh_offset, 1416 section_size) == section_size)) { 1417 // MIPS ASE Mask is at offset 12 in MIPS.abiflags section 1418 lldb::offset_t offset = 12; // MIPS ABI Flags Version: 0 1419 arch_flags |= data.GetU32(&offset); 1420 1421 // The floating point ABI is at offset 7 1422 offset = 7; 1423 switch (data.GetU8(&offset)) { 1424 case llvm::Mips::Val_GNU_MIPS_ABI_FP_ANY: 1425 arch_flags |= lldb_private::ArchSpec::eMIPS_ABI_FP_ANY; 1426 break; 1427 case llvm::Mips::Val_GNU_MIPS_ABI_FP_DOUBLE: 1428 arch_flags |= lldb_private::ArchSpec::eMIPS_ABI_FP_DOUBLE; 1429 break; 1430 case llvm::Mips::Val_GNU_MIPS_ABI_FP_SINGLE: 1431 arch_flags |= lldb_private::ArchSpec::eMIPS_ABI_FP_SINGLE; 1432 break; 1433 case llvm::Mips::Val_GNU_MIPS_ABI_FP_SOFT: 1434 arch_flags |= lldb_private::ArchSpec::eMIPS_ABI_FP_SOFT; 1435 break; 1436 case llvm::Mips::Val_GNU_MIPS_ABI_FP_OLD_64: 1437 arch_flags |= lldb_private::ArchSpec::eMIPS_ABI_FP_OLD_64; 1438 break; 1439 case llvm::Mips::Val_GNU_MIPS_ABI_FP_XX: 1440 arch_flags |= lldb_private::ArchSpec::eMIPS_ABI_FP_XX; 1441 break; 1442 case llvm::Mips::Val_GNU_MIPS_ABI_FP_64: 1443 arch_flags |= lldb_private::ArchSpec::eMIPS_ABI_FP_64; 1444 break; 1445 case llvm::Mips::Val_GNU_MIPS_ABI_FP_64A: 1446 arch_flags |= lldb_private::ArchSpec::eMIPS_ABI_FP_64A; 1447 break; 1448 } 1449 } 1450 } 1451 // Settings appropriate ArchSpec ABI Flags 1452 switch (header.e_flags & llvm::ELF::EF_MIPS_ABI) { 1453 case llvm::ELF::EF_MIPS_ABI_O32: 1454 arch_flags |= lldb_private::ArchSpec::eMIPSABI_O32; 1455 break; 1456 case EF_MIPS_ABI_O64: 1457 arch_flags |= lldb_private::ArchSpec::eMIPSABI_O64; 1458 break; 1459 case EF_MIPS_ABI_EABI32: 1460 arch_flags |= lldb_private::ArchSpec::eMIPSABI_EABI32; 1461 break; 1462 case EF_MIPS_ABI_EABI64: 1463 arch_flags |= lldb_private::ArchSpec::eMIPSABI_EABI64; 1464 break; 1465 default: 1466 // ABI Mask doesn't cover N32 and N64 ABI. 1467 if (header.e_ident[EI_CLASS] == llvm::ELF::ELFCLASS64) 1468 arch_flags |= lldb_private::ArchSpec::eMIPSABI_N64; 1469 else if (header.e_flags & llvm::ELF::EF_MIPS_ABI2) 1470 arch_flags |= lldb_private::ArchSpec::eMIPSABI_N32; 1471 break; 1472 } 1473 arch_spec.SetFlags(arch_flags); 1474 } 1475 1476 if (arch_spec.GetMachine() == llvm::Triple::arm || 1477 arch_spec.GetMachine() == llvm::Triple::thumb) { 1478 DataExtractor data; 1479 1480 if (sheader.sh_type == SHT_ARM_ATTRIBUTES && section_size != 0 && 1481 data.SetData(object_data, sheader.sh_offset, section_size) == section_size) 1482 ParseARMAttributes(data, section_size, arch_spec); 1483 } 1484 1485 if (name == g_sect_name_gnu_debuglink) { 1486 DataExtractor data; 1487 if (section_size && (data.SetData(object_data, sheader.sh_offset, 1488 section_size) == section_size)) { 1489 lldb::offset_t gnu_debuglink_offset = 0; 1490 gnu_debuglink_file = data.GetCStr(&gnu_debuglink_offset); 1491 gnu_debuglink_offset = llvm::alignTo(gnu_debuglink_offset, 4); 1492 data.GetU32(&gnu_debuglink_offset, &gnu_debuglink_crc, 1); 1493 } 1494 } 1495 1496 // Process ELF note section entries. 1497 bool is_note_header = (sheader.sh_type == SHT_NOTE); 1498 1499 // The section header ".note.android.ident" is stored as a 1500 // PROGBITS type header but it is actually a note header. 1501 static ConstString g_sect_name_android_ident(".note.android.ident"); 1502 if (!is_note_header && name == g_sect_name_android_ident) 1503 is_note_header = true; 1504 1505 if (is_note_header) { 1506 // Allow notes to refine module info. 1507 DataExtractor data; 1508 if (section_size && (data.SetData(object_data, sheader.sh_offset, 1509 section_size) == section_size)) { 1510 Status error = RefineModuleDetailsFromNote(data, arch_spec, uuid); 1511 if (error.Fail()) { 1512 LLDB_LOGF(log, "ObjectFileELF::%s ELF note processing failed: %s", 1513 __FUNCTION__, error.AsCString()); 1514 } 1515 } 1516 } 1517 } 1518 1519 // Make any unknown triple components to be unspecified unknowns. 1520 if (arch_spec.GetTriple().getVendor() == llvm::Triple::UnknownVendor) 1521 arch_spec.GetTriple().setVendorName(llvm::StringRef()); 1522 if (arch_spec.GetTriple().getOS() == llvm::Triple::UnknownOS) 1523 arch_spec.GetTriple().setOSName(llvm::StringRef()); 1524 1525 return section_headers.size(); 1526 } 1527 } 1528 1529 section_headers.clear(); 1530 return 0; 1531 } 1532 1533 llvm::StringRef 1534 ObjectFileELF::StripLinkerSymbolAnnotations(llvm::StringRef symbol_name) const { 1535 size_t pos = symbol_name.find('@'); 1536 return symbol_name.substr(0, pos); 1537 } 1538 1539 // ParseSectionHeaders 1540 size_t ObjectFileELF::ParseSectionHeaders() { 1541 return GetSectionHeaderInfo(m_section_headers, m_data, m_header, m_uuid, 1542 m_gnu_debuglink_file, m_gnu_debuglink_crc, 1543 m_arch_spec); 1544 } 1545 1546 const ObjectFileELF::ELFSectionHeaderInfo * 1547 ObjectFileELF::GetSectionHeaderByIndex(lldb::user_id_t id) { 1548 if (!ParseSectionHeaders()) 1549 return nullptr; 1550 1551 if (id < m_section_headers.size()) 1552 return &m_section_headers[id]; 1553 1554 return nullptr; 1555 } 1556 1557 lldb::user_id_t ObjectFileELF::GetSectionIndexByName(const char *name) { 1558 if (!name || !name[0] || !ParseSectionHeaders()) 1559 return 0; 1560 for (size_t i = 1; i < m_section_headers.size(); ++i) 1561 if (m_section_headers[i].section_name == ConstString(name)) 1562 return i; 1563 return 0; 1564 } 1565 1566 static SectionType GetSectionTypeFromName(llvm::StringRef Name) { 1567 if (Name.consume_front(".debug_") || Name.consume_front(".zdebug_")) { 1568 return llvm::StringSwitch<SectionType>(Name) 1569 .Case("abbrev", eSectionTypeDWARFDebugAbbrev) 1570 .Case("abbrev.dwo", eSectionTypeDWARFDebugAbbrevDwo) 1571 .Case("addr", eSectionTypeDWARFDebugAddr) 1572 .Case("aranges", eSectionTypeDWARFDebugAranges) 1573 .Case("cu_index", eSectionTypeDWARFDebugCuIndex) 1574 .Case("frame", eSectionTypeDWARFDebugFrame) 1575 .Case("info", eSectionTypeDWARFDebugInfo) 1576 .Case("info.dwo", eSectionTypeDWARFDebugInfoDwo) 1577 .Cases("line", "line.dwo", eSectionTypeDWARFDebugLine) 1578 .Cases("line_str", "line_str.dwo", eSectionTypeDWARFDebugLineStr) 1579 .Case("loc", eSectionTypeDWARFDebugLoc) 1580 .Case("loc.dwo", eSectionTypeDWARFDebugLocDwo) 1581 .Case("loclists", eSectionTypeDWARFDebugLocLists) 1582 .Case("loclists.dwo", eSectionTypeDWARFDebugLocListsDwo) 1583 .Case("macinfo", eSectionTypeDWARFDebugMacInfo) 1584 .Cases("macro", "macro.dwo", eSectionTypeDWARFDebugMacro) 1585 .Case("names", eSectionTypeDWARFDebugNames) 1586 .Case("pubnames", eSectionTypeDWARFDebugPubNames) 1587 .Case("pubtypes", eSectionTypeDWARFDebugPubTypes) 1588 .Case("ranges", eSectionTypeDWARFDebugRanges) 1589 .Case("rnglists", eSectionTypeDWARFDebugRngLists) 1590 .Case("rnglists.dwo", eSectionTypeDWARFDebugRngListsDwo) 1591 .Case("str", eSectionTypeDWARFDebugStr) 1592 .Case("str.dwo", eSectionTypeDWARFDebugStrDwo) 1593 .Case("str_offsets", eSectionTypeDWARFDebugStrOffsets) 1594 .Case("str_offsets.dwo", eSectionTypeDWARFDebugStrOffsetsDwo) 1595 .Case("tu_index", eSectionTypeDWARFDebugTuIndex) 1596 .Case("types", eSectionTypeDWARFDebugTypes) 1597 .Case("types.dwo", eSectionTypeDWARFDebugTypesDwo) 1598 .Default(eSectionTypeOther); 1599 } 1600 return llvm::StringSwitch<SectionType>(Name) 1601 .Case(".ARM.exidx", eSectionTypeARMexidx) 1602 .Case(".ARM.extab", eSectionTypeARMextab) 1603 .Cases(".bss", ".tbss", eSectionTypeZeroFill) 1604 .Cases(".data", ".tdata", eSectionTypeData) 1605 .Case(".eh_frame", eSectionTypeEHFrame) 1606 .Case(".gnu_debugaltlink", eSectionTypeDWARFGNUDebugAltLink) 1607 .Case(".gosymtab", eSectionTypeGoSymtab) 1608 .Case(".text", eSectionTypeCode) 1609 .Default(eSectionTypeOther); 1610 } 1611 1612 SectionType ObjectFileELF::GetSectionType(const ELFSectionHeaderInfo &H) const { 1613 switch (H.sh_type) { 1614 case SHT_PROGBITS: 1615 if (H.sh_flags & SHF_EXECINSTR) 1616 return eSectionTypeCode; 1617 break; 1618 case SHT_SYMTAB: 1619 return eSectionTypeELFSymbolTable; 1620 case SHT_DYNSYM: 1621 return eSectionTypeELFDynamicSymbols; 1622 case SHT_RELA: 1623 case SHT_REL: 1624 return eSectionTypeELFRelocationEntries; 1625 case SHT_DYNAMIC: 1626 return eSectionTypeELFDynamicLinkInfo; 1627 } 1628 return GetSectionTypeFromName(H.section_name.GetStringRef()); 1629 } 1630 1631 static uint32_t GetTargetByteSize(SectionType Type, const ArchSpec &arch) { 1632 switch (Type) { 1633 case eSectionTypeData: 1634 case eSectionTypeZeroFill: 1635 return arch.GetDataByteSize(); 1636 case eSectionTypeCode: 1637 return arch.GetCodeByteSize(); 1638 default: 1639 return 1; 1640 } 1641 } 1642 1643 static Permissions GetPermissions(const ELFSectionHeader &H) { 1644 Permissions Perm = Permissions(0); 1645 if (H.sh_flags & SHF_ALLOC) 1646 Perm |= ePermissionsReadable; 1647 if (H.sh_flags & SHF_WRITE) 1648 Perm |= ePermissionsWritable; 1649 if (H.sh_flags & SHF_EXECINSTR) 1650 Perm |= ePermissionsExecutable; 1651 return Perm; 1652 } 1653 1654 static Permissions GetPermissions(const ELFProgramHeader &H) { 1655 Permissions Perm = Permissions(0); 1656 if (H.p_flags & PF_R) 1657 Perm |= ePermissionsReadable; 1658 if (H.p_flags & PF_W) 1659 Perm |= ePermissionsWritable; 1660 if (H.p_flags & PF_X) 1661 Perm |= ePermissionsExecutable; 1662 return Perm; 1663 } 1664 1665 namespace { 1666 1667 using VMRange = lldb_private::Range<addr_t, addr_t>; 1668 1669 struct SectionAddressInfo { 1670 SectionSP Segment; 1671 VMRange Range; 1672 }; 1673 1674 // (Unlinked) ELF object files usually have 0 for every section address, meaning 1675 // we need to compute synthetic addresses in order for "file addresses" from 1676 // different sections to not overlap. This class handles that logic. 1677 class VMAddressProvider { 1678 using VMMap = llvm::IntervalMap<addr_t, SectionSP, 4, 1679 llvm::IntervalMapHalfOpenInfo<addr_t>>; 1680 1681 ObjectFile::Type ObjectType; 1682 addr_t NextVMAddress = 0; 1683 VMMap::Allocator Alloc; 1684 VMMap Segments{Alloc}; 1685 VMMap Sections{Alloc}; 1686 lldb_private::Log *Log = GetLog(LLDBLog::Modules); 1687 size_t SegmentCount = 0; 1688 std::string SegmentName; 1689 1690 VMRange GetVMRange(const ELFSectionHeader &H) { 1691 addr_t Address = H.sh_addr; 1692 addr_t Size = H.sh_flags & SHF_ALLOC ? H.sh_size : 0; 1693 if (ObjectType == ObjectFile::Type::eTypeObjectFile && Segments.empty() && (H.sh_flags & SHF_ALLOC)) { 1694 NextVMAddress = 1695 llvm::alignTo(NextVMAddress, std::max<addr_t>(H.sh_addralign, 1)); 1696 Address = NextVMAddress; 1697 NextVMAddress += Size; 1698 } 1699 return VMRange(Address, Size); 1700 } 1701 1702 public: 1703 VMAddressProvider(ObjectFile::Type Type, llvm::StringRef SegmentName) 1704 : ObjectType(Type), SegmentName(std::string(SegmentName)) {} 1705 1706 std::string GetNextSegmentName() const { 1707 return llvm::formatv("{0}[{1}]", SegmentName, SegmentCount).str(); 1708 } 1709 1710 llvm::Optional<VMRange> GetAddressInfo(const ELFProgramHeader &H) { 1711 if (H.p_memsz == 0) { 1712 LLDB_LOG(Log, "Ignoring zero-sized {0} segment. Corrupt object file?", 1713 SegmentName); 1714 return llvm::None; 1715 } 1716 1717 if (Segments.overlaps(H.p_vaddr, H.p_vaddr + H.p_memsz)) { 1718 LLDB_LOG(Log, "Ignoring overlapping {0} segment. Corrupt object file?", 1719 SegmentName); 1720 return llvm::None; 1721 } 1722 return VMRange(H.p_vaddr, H.p_memsz); 1723 } 1724 1725 llvm::Optional<SectionAddressInfo> GetAddressInfo(const ELFSectionHeader &H) { 1726 VMRange Range = GetVMRange(H); 1727 SectionSP Segment; 1728 auto It = Segments.find(Range.GetRangeBase()); 1729 if ((H.sh_flags & SHF_ALLOC) && It.valid()) { 1730 addr_t MaxSize; 1731 if (It.start() <= Range.GetRangeBase()) { 1732 MaxSize = It.stop() - Range.GetRangeBase(); 1733 Segment = *It; 1734 } else 1735 MaxSize = It.start() - Range.GetRangeBase(); 1736 if (Range.GetByteSize() > MaxSize) { 1737 LLDB_LOG(Log, "Shortening section crossing segment boundaries. " 1738 "Corrupt object file?"); 1739 Range.SetByteSize(MaxSize); 1740 } 1741 } 1742 if (Range.GetByteSize() > 0 && 1743 Sections.overlaps(Range.GetRangeBase(), Range.GetRangeEnd())) { 1744 LLDB_LOG(Log, "Ignoring overlapping section. Corrupt object file?"); 1745 return llvm::None; 1746 } 1747 if (Segment) 1748 Range.Slide(-Segment->GetFileAddress()); 1749 return SectionAddressInfo{Segment, Range}; 1750 } 1751 1752 void AddSegment(const VMRange &Range, SectionSP Seg) { 1753 Segments.insert(Range.GetRangeBase(), Range.GetRangeEnd(), std::move(Seg)); 1754 ++SegmentCount; 1755 } 1756 1757 void AddSection(SectionAddressInfo Info, SectionSP Sect) { 1758 if (Info.Range.GetByteSize() == 0) 1759 return; 1760 if (Info.Segment) 1761 Info.Range.Slide(Info.Segment->GetFileAddress()); 1762 Sections.insert(Info.Range.GetRangeBase(), Info.Range.GetRangeEnd(), 1763 std::move(Sect)); 1764 } 1765 }; 1766 } 1767 1768 void ObjectFileELF::CreateSections(SectionList &unified_section_list) { 1769 if (m_sections_up) 1770 return; 1771 1772 m_sections_up = std::make_unique<SectionList>(); 1773 VMAddressProvider regular_provider(GetType(), "PT_LOAD"); 1774 VMAddressProvider tls_provider(GetType(), "PT_TLS"); 1775 1776 for (const auto &EnumPHdr : llvm::enumerate(ProgramHeaders())) { 1777 const ELFProgramHeader &PHdr = EnumPHdr.value(); 1778 if (PHdr.p_type != PT_LOAD && PHdr.p_type != PT_TLS) 1779 continue; 1780 1781 VMAddressProvider &provider = 1782 PHdr.p_type == PT_TLS ? tls_provider : regular_provider; 1783 auto InfoOr = provider.GetAddressInfo(PHdr); 1784 if (!InfoOr) 1785 continue; 1786 1787 uint32_t Log2Align = llvm::Log2_64(std::max<elf_xword>(PHdr.p_align, 1)); 1788 SectionSP Segment = std::make_shared<Section>( 1789 GetModule(), this, SegmentID(EnumPHdr.index()), 1790 ConstString(provider.GetNextSegmentName()), eSectionTypeContainer, 1791 InfoOr->GetRangeBase(), InfoOr->GetByteSize(), PHdr.p_offset, 1792 PHdr.p_filesz, Log2Align, /*flags*/ 0); 1793 Segment->SetPermissions(GetPermissions(PHdr)); 1794 Segment->SetIsThreadSpecific(PHdr.p_type == PT_TLS); 1795 m_sections_up->AddSection(Segment); 1796 1797 provider.AddSegment(*InfoOr, std::move(Segment)); 1798 } 1799 1800 ParseSectionHeaders(); 1801 if (m_section_headers.empty()) 1802 return; 1803 1804 for (SectionHeaderCollIter I = std::next(m_section_headers.begin()); 1805 I != m_section_headers.end(); ++I) { 1806 const ELFSectionHeaderInfo &header = *I; 1807 1808 ConstString &name = I->section_name; 1809 const uint64_t file_size = 1810 header.sh_type == SHT_NOBITS ? 0 : header.sh_size; 1811 1812 VMAddressProvider &provider = 1813 header.sh_flags & SHF_TLS ? tls_provider : regular_provider; 1814 auto InfoOr = provider.GetAddressInfo(header); 1815 if (!InfoOr) 1816 continue; 1817 1818 SectionType sect_type = GetSectionType(header); 1819 1820 const uint32_t target_bytes_size = 1821 GetTargetByteSize(sect_type, m_arch_spec); 1822 1823 elf::elf_xword log2align = 1824 (header.sh_addralign == 0) ? 0 : llvm::Log2_64(header.sh_addralign); 1825 1826 SectionSP section_sp(new Section( 1827 InfoOr->Segment, GetModule(), // Module to which this section belongs. 1828 this, // ObjectFile to which this section belongs and should 1829 // read section data from. 1830 SectionIndex(I), // Section ID. 1831 name, // Section name. 1832 sect_type, // Section type. 1833 InfoOr->Range.GetRangeBase(), // VM address. 1834 InfoOr->Range.GetByteSize(), // VM size in bytes of this section. 1835 header.sh_offset, // Offset of this section in the file. 1836 file_size, // Size of the section as found in the file. 1837 log2align, // Alignment of the section 1838 header.sh_flags, // Flags for this section. 1839 target_bytes_size)); // Number of host bytes per target byte 1840 1841 section_sp->SetPermissions(GetPermissions(header)); 1842 section_sp->SetIsThreadSpecific(header.sh_flags & SHF_TLS); 1843 (InfoOr->Segment ? InfoOr->Segment->GetChildren() : *m_sections_up) 1844 .AddSection(section_sp); 1845 provider.AddSection(std::move(*InfoOr), std::move(section_sp)); 1846 } 1847 1848 // For eTypeDebugInfo files, the Symbol Vendor will take care of updating the 1849 // unified section list. 1850 if (GetType() != eTypeDebugInfo) 1851 unified_section_list = *m_sections_up; 1852 1853 // If there's a .gnu_debugdata section, we'll try to read the .symtab that's 1854 // embedded in there and replace the one in the original object file (if any). 1855 // If there's none in the orignal object file, we add it to it. 1856 if (auto gdd_obj_file = GetGnuDebugDataObjectFile()) { 1857 if (auto gdd_objfile_section_list = gdd_obj_file->GetSectionList()) { 1858 if (SectionSP symtab_section_sp = 1859 gdd_objfile_section_list->FindSectionByType( 1860 eSectionTypeELFSymbolTable, true)) { 1861 SectionSP module_section_sp = unified_section_list.FindSectionByType( 1862 eSectionTypeELFSymbolTable, true); 1863 if (module_section_sp) 1864 unified_section_list.ReplaceSection(module_section_sp->GetID(), 1865 symtab_section_sp); 1866 else 1867 unified_section_list.AddSection(symtab_section_sp); 1868 } 1869 } 1870 } 1871 } 1872 1873 std::shared_ptr<ObjectFileELF> ObjectFileELF::GetGnuDebugDataObjectFile() { 1874 if (m_gnu_debug_data_object_file != nullptr) 1875 return m_gnu_debug_data_object_file; 1876 1877 SectionSP section = 1878 GetSectionList()->FindSectionByName(ConstString(".gnu_debugdata")); 1879 if (!section) 1880 return nullptr; 1881 1882 if (!lldb_private::lzma::isAvailable()) { 1883 GetModule()->ReportWarning( 1884 "No LZMA support found for reading .gnu_debugdata section"); 1885 return nullptr; 1886 } 1887 1888 // Uncompress the data 1889 DataExtractor data; 1890 section->GetSectionData(data); 1891 llvm::SmallVector<uint8_t, 0> uncompressedData; 1892 auto err = lldb_private::lzma::uncompress(data.GetData(), uncompressedData); 1893 if (err) { 1894 GetModule()->ReportWarning( 1895 "An error occurred while decompression the section %s: %s", 1896 section->GetName().AsCString(), llvm::toString(std::move(err)).c_str()); 1897 return nullptr; 1898 } 1899 1900 // Construct ObjectFileELF object from decompressed buffer 1901 DataBufferSP gdd_data_buf( 1902 new DataBufferHeap(uncompressedData.data(), uncompressedData.size())); 1903 auto fspec = GetFileSpec().CopyByAppendingPathComponent( 1904 llvm::StringRef("gnu_debugdata")); 1905 m_gnu_debug_data_object_file.reset(new ObjectFileELF( 1906 GetModule(), gdd_data_buf, 0, &fspec, 0, gdd_data_buf->GetByteSize())); 1907 1908 // This line is essential; otherwise a breakpoint can be set but not hit. 1909 m_gnu_debug_data_object_file->SetType(ObjectFile::eTypeDebugInfo); 1910 1911 ArchSpec spec = m_gnu_debug_data_object_file->GetArchitecture(); 1912 if (spec && m_gnu_debug_data_object_file->SetModulesArchitecture(spec)) 1913 return m_gnu_debug_data_object_file; 1914 1915 return nullptr; 1916 } 1917 1918 // Find the arm/aarch64 mapping symbol character in the given symbol name. 1919 // Mapping symbols have the form of "$<char>[.<any>]*". Additionally we 1920 // recognize cases when the mapping symbol prefixed by an arbitrary string 1921 // because if a symbol prefix added to each symbol in the object file with 1922 // objcopy then the mapping symbols are also prefixed. 1923 static char FindArmAarch64MappingSymbol(const char *symbol_name) { 1924 if (!symbol_name) 1925 return '\0'; 1926 1927 const char *dollar_pos = ::strchr(symbol_name, '$'); 1928 if (!dollar_pos || dollar_pos[1] == '\0') 1929 return '\0'; 1930 1931 if (dollar_pos[2] == '\0' || dollar_pos[2] == '.') 1932 return dollar_pos[1]; 1933 return '\0'; 1934 } 1935 1936 #define STO_MIPS_ISA (3 << 6) 1937 #define STO_MICROMIPS (2 << 6) 1938 #define IS_MICROMIPS(ST_OTHER) (((ST_OTHER)&STO_MIPS_ISA) == STO_MICROMIPS) 1939 1940 // private 1941 unsigned ObjectFileELF::ParseSymbols(Symtab *symtab, user_id_t start_id, 1942 SectionList *section_list, 1943 const size_t num_symbols, 1944 const DataExtractor &symtab_data, 1945 const DataExtractor &strtab_data) { 1946 ELFSymbol symbol; 1947 lldb::offset_t offset = 0; 1948 1949 static ConstString text_section_name(".text"); 1950 static ConstString init_section_name(".init"); 1951 static ConstString fini_section_name(".fini"); 1952 static ConstString ctors_section_name(".ctors"); 1953 static ConstString dtors_section_name(".dtors"); 1954 1955 static ConstString data_section_name(".data"); 1956 static ConstString rodata_section_name(".rodata"); 1957 static ConstString rodata1_section_name(".rodata1"); 1958 static ConstString data2_section_name(".data1"); 1959 static ConstString bss_section_name(".bss"); 1960 static ConstString opd_section_name(".opd"); // For ppc64 1961 1962 // On Android the oatdata and the oatexec symbols in the oat and odex files 1963 // covers the full .text section what causes issues with displaying unusable 1964 // symbol name to the user and very slow unwinding speed because the 1965 // instruction emulation based unwind plans try to emulate all instructions 1966 // in these symbols. Don't add these symbols to the symbol list as they have 1967 // no use for the debugger and they are causing a lot of trouble. Filtering 1968 // can't be restricted to Android because this special object file don't 1969 // contain the note section specifying the environment to Android but the 1970 // custom extension and file name makes it highly unlikely that this will 1971 // collide with anything else. 1972 ConstString file_extension = m_file.GetFileNameExtension(); 1973 bool skip_oatdata_oatexec = 1974 file_extension == ".oat" || file_extension == ".odex"; 1975 1976 ArchSpec arch = GetArchitecture(); 1977 ModuleSP module_sp(GetModule()); 1978 SectionList *module_section_list = 1979 module_sp ? module_sp->GetSectionList() : nullptr; 1980 1981 // Local cache to avoid doing a FindSectionByName for each symbol. The "const 1982 // char*" key must came from a ConstString object so they can be compared by 1983 // pointer 1984 std::unordered_map<const char *, lldb::SectionSP> section_name_to_section; 1985 1986 unsigned i; 1987 for (i = 0; i < num_symbols; ++i) { 1988 if (!symbol.Parse(symtab_data, &offset)) 1989 break; 1990 1991 const char *symbol_name = strtab_data.PeekCStr(symbol.st_name); 1992 if (!symbol_name) 1993 symbol_name = ""; 1994 1995 // No need to add non-section symbols that have no names 1996 if (symbol.getType() != STT_SECTION && 1997 (symbol_name == nullptr || symbol_name[0] == '\0')) 1998 continue; 1999 2000 // Skipping oatdata and oatexec sections if it is requested. See details 2001 // above the definition of skip_oatdata_oatexec for the reasons. 2002 if (skip_oatdata_oatexec && (::strcmp(symbol_name, "oatdata") == 0 || 2003 ::strcmp(symbol_name, "oatexec") == 0)) 2004 continue; 2005 2006 SectionSP symbol_section_sp; 2007 SymbolType symbol_type = eSymbolTypeInvalid; 2008 Elf64_Half shndx = symbol.st_shndx; 2009 2010 switch (shndx) { 2011 case SHN_ABS: 2012 symbol_type = eSymbolTypeAbsolute; 2013 break; 2014 case SHN_UNDEF: 2015 symbol_type = eSymbolTypeUndefined; 2016 break; 2017 default: 2018 symbol_section_sp = section_list->FindSectionByID(shndx); 2019 break; 2020 } 2021 2022 // If a symbol is undefined do not process it further even if it has a STT 2023 // type 2024 if (symbol_type != eSymbolTypeUndefined) { 2025 switch (symbol.getType()) { 2026 default: 2027 case STT_NOTYPE: 2028 // The symbol's type is not specified. 2029 break; 2030 2031 case STT_OBJECT: 2032 // The symbol is associated with a data object, such as a variable, an 2033 // array, etc. 2034 symbol_type = eSymbolTypeData; 2035 break; 2036 2037 case STT_FUNC: 2038 // The symbol is associated with a function or other executable code. 2039 symbol_type = eSymbolTypeCode; 2040 break; 2041 2042 case STT_SECTION: 2043 // The symbol is associated with a section. Symbol table entries of 2044 // this type exist primarily for relocation and normally have STB_LOCAL 2045 // binding. 2046 break; 2047 2048 case STT_FILE: 2049 // Conventionally, the symbol's name gives the name of the source file 2050 // associated with the object file. A file symbol has STB_LOCAL 2051 // binding, its section index is SHN_ABS, and it precedes the other 2052 // STB_LOCAL symbols for the file, if it is present. 2053 symbol_type = eSymbolTypeSourceFile; 2054 break; 2055 2056 case STT_GNU_IFUNC: 2057 // The symbol is associated with an indirect function. The actual 2058 // function will be resolved if it is referenced. 2059 symbol_type = eSymbolTypeResolver; 2060 break; 2061 } 2062 } 2063 2064 if (symbol_type == eSymbolTypeInvalid && symbol.getType() != STT_SECTION) { 2065 if (symbol_section_sp) { 2066 ConstString sect_name = symbol_section_sp->GetName(); 2067 if (sect_name == text_section_name || sect_name == init_section_name || 2068 sect_name == fini_section_name || sect_name == ctors_section_name || 2069 sect_name == dtors_section_name) { 2070 symbol_type = eSymbolTypeCode; 2071 } else if (sect_name == data_section_name || 2072 sect_name == data2_section_name || 2073 sect_name == rodata_section_name || 2074 sect_name == rodata1_section_name || 2075 sect_name == bss_section_name) { 2076 symbol_type = eSymbolTypeData; 2077 } 2078 } 2079 } 2080 2081 int64_t symbol_value_offset = 0; 2082 uint32_t additional_flags = 0; 2083 2084 if (arch.IsValid()) { 2085 if (arch.GetMachine() == llvm::Triple::arm) { 2086 if (symbol.getBinding() == STB_LOCAL) { 2087 char mapping_symbol = FindArmAarch64MappingSymbol(symbol_name); 2088 if (symbol_type == eSymbolTypeCode) { 2089 switch (mapping_symbol) { 2090 case 'a': 2091 // $a[.<any>]* - marks an ARM instruction sequence 2092 m_address_class_map[symbol.st_value] = AddressClass::eCode; 2093 break; 2094 case 'b': 2095 case 't': 2096 // $b[.<any>]* - marks a THUMB BL instruction sequence 2097 // $t[.<any>]* - marks a THUMB instruction sequence 2098 m_address_class_map[symbol.st_value] = 2099 AddressClass::eCodeAlternateISA; 2100 break; 2101 case 'd': 2102 // $d[.<any>]* - marks a data item sequence (e.g. lit pool) 2103 m_address_class_map[symbol.st_value] = AddressClass::eData; 2104 break; 2105 } 2106 } 2107 if (mapping_symbol) 2108 continue; 2109 } 2110 } else if (arch.GetMachine() == llvm::Triple::aarch64) { 2111 if (symbol.getBinding() == STB_LOCAL) { 2112 char mapping_symbol = FindArmAarch64MappingSymbol(symbol_name); 2113 if (symbol_type == eSymbolTypeCode) { 2114 switch (mapping_symbol) { 2115 case 'x': 2116 // $x[.<any>]* - marks an A64 instruction sequence 2117 m_address_class_map[symbol.st_value] = AddressClass::eCode; 2118 break; 2119 case 'd': 2120 // $d[.<any>]* - marks a data item sequence (e.g. lit pool) 2121 m_address_class_map[symbol.st_value] = AddressClass::eData; 2122 break; 2123 } 2124 } 2125 if (mapping_symbol) 2126 continue; 2127 } 2128 } 2129 2130 if (arch.GetMachine() == llvm::Triple::arm) { 2131 if (symbol_type == eSymbolTypeCode) { 2132 if (symbol.st_value & 1) { 2133 // Subtracting 1 from the address effectively unsets the low order 2134 // bit, which results in the address actually pointing to the 2135 // beginning of the symbol. This delta will be used below in 2136 // conjunction with symbol.st_value to produce the final 2137 // symbol_value that we store in the symtab. 2138 symbol_value_offset = -1; 2139 m_address_class_map[symbol.st_value ^ 1] = 2140 AddressClass::eCodeAlternateISA; 2141 } else { 2142 // This address is ARM 2143 m_address_class_map[symbol.st_value] = AddressClass::eCode; 2144 } 2145 } 2146 } 2147 2148 /* 2149 * MIPS: 2150 * The bit #0 of an address is used for ISA mode (1 for microMIPS, 0 for 2151 * MIPS). 2152 * This allows processor to switch between microMIPS and MIPS without any 2153 * need 2154 * for special mode-control register. However, apart from .debug_line, 2155 * none of 2156 * the ELF/DWARF sections set the ISA bit (for symbol or section). Use 2157 * st_other 2158 * flag to check whether the symbol is microMIPS and then set the address 2159 * class 2160 * accordingly. 2161 */ 2162 if (arch.IsMIPS()) { 2163 if (IS_MICROMIPS(symbol.st_other)) 2164 m_address_class_map[symbol.st_value] = AddressClass::eCodeAlternateISA; 2165 else if ((symbol.st_value & 1) && (symbol_type == eSymbolTypeCode)) { 2166 symbol.st_value = symbol.st_value & (~1ull); 2167 m_address_class_map[symbol.st_value] = AddressClass::eCodeAlternateISA; 2168 } else { 2169 if (symbol_type == eSymbolTypeCode) 2170 m_address_class_map[symbol.st_value] = AddressClass::eCode; 2171 else if (symbol_type == eSymbolTypeData) 2172 m_address_class_map[symbol.st_value] = AddressClass::eData; 2173 else 2174 m_address_class_map[symbol.st_value] = AddressClass::eUnknown; 2175 } 2176 } 2177 } 2178 2179 // symbol_value_offset may contain 0 for ARM symbols or -1 for THUMB 2180 // symbols. See above for more details. 2181 uint64_t symbol_value = symbol.st_value + symbol_value_offset; 2182 2183 if (symbol_section_sp == nullptr && shndx == SHN_ABS && 2184 symbol.st_size != 0) { 2185 // We don't have a section for a symbol with non-zero size. Create a new 2186 // section for it so the address range covered by the symbol is also 2187 // covered by the module (represented through the section list). It is 2188 // needed so module lookup for the addresses covered by this symbol will 2189 // be successfull. This case happens for absolute symbols. 2190 ConstString fake_section_name(std::string(".absolute.") + symbol_name); 2191 symbol_section_sp = 2192 std::make_shared<Section>(module_sp, this, SHN_ABS, fake_section_name, 2193 eSectionTypeAbsoluteAddress, symbol_value, 2194 symbol.st_size, 0, 0, 0, SHF_ALLOC); 2195 2196 module_section_list->AddSection(symbol_section_sp); 2197 section_list->AddSection(symbol_section_sp); 2198 } 2199 2200 if (symbol_section_sp && 2201 CalculateType() != ObjectFile::Type::eTypeObjectFile) 2202 symbol_value -= symbol_section_sp->GetFileAddress(); 2203 2204 if (symbol_section_sp && module_section_list && 2205 module_section_list != section_list) { 2206 ConstString sect_name = symbol_section_sp->GetName(); 2207 auto section_it = section_name_to_section.find(sect_name.GetCString()); 2208 if (section_it == section_name_to_section.end()) 2209 section_it = 2210 section_name_to_section 2211 .emplace(sect_name.GetCString(), 2212 module_section_list->FindSectionByName(sect_name)) 2213 .first; 2214 if (section_it->second) 2215 symbol_section_sp = section_it->second; 2216 } 2217 2218 bool is_global = symbol.getBinding() == STB_GLOBAL; 2219 uint32_t flags = symbol.st_other << 8 | symbol.st_info | additional_flags; 2220 llvm::StringRef symbol_ref(symbol_name); 2221 2222 // Symbol names may contain @VERSION suffixes. Find those and strip them 2223 // temporarily. 2224 size_t version_pos = symbol_ref.find('@'); 2225 bool has_suffix = version_pos != llvm::StringRef::npos; 2226 llvm::StringRef symbol_bare = symbol_ref.substr(0, version_pos); 2227 Mangled mangled(symbol_bare); 2228 2229 // Now append the suffix back to mangled and unmangled names. Only do it if 2230 // the demangling was successful (string is not empty). 2231 if (has_suffix) { 2232 llvm::StringRef suffix = symbol_ref.substr(version_pos); 2233 2234 llvm::StringRef mangled_name = mangled.GetMangledName().GetStringRef(); 2235 if (!mangled_name.empty()) 2236 mangled.SetMangledName(ConstString((mangled_name + suffix).str())); 2237 2238 ConstString demangled = mangled.GetDemangledName(); 2239 llvm::StringRef demangled_name = demangled.GetStringRef(); 2240 if (!demangled_name.empty()) 2241 mangled.SetDemangledName(ConstString((demangled_name + suffix).str())); 2242 } 2243 2244 // In ELF all symbol should have a valid size but it is not true for some 2245 // function symbols coming from hand written assembly. As none of the 2246 // function symbol should have 0 size we try to calculate the size for 2247 // these symbols in the symtab with saying that their original size is not 2248 // valid. 2249 bool symbol_size_valid = 2250 symbol.st_size != 0 || symbol.getType() != STT_FUNC; 2251 2252 Symbol dc_symbol( 2253 i + start_id, // ID is the original symbol table index. 2254 mangled, 2255 symbol_type, // Type of this symbol 2256 is_global, // Is this globally visible? 2257 false, // Is this symbol debug info? 2258 false, // Is this symbol a trampoline? 2259 false, // Is this symbol artificial? 2260 AddressRange(symbol_section_sp, // Section in which this symbol is 2261 // defined or null. 2262 symbol_value, // Offset in section or symbol value. 2263 symbol.st_size), // Size in bytes of this symbol. 2264 symbol_size_valid, // Symbol size is valid 2265 has_suffix, // Contains linker annotations? 2266 flags); // Symbol flags. 2267 if (symbol.getBinding() == STB_WEAK) 2268 dc_symbol.SetIsWeak(true); 2269 symtab->AddSymbol(dc_symbol); 2270 } 2271 return i; 2272 } 2273 2274 unsigned ObjectFileELF::ParseSymbolTable(Symtab *symbol_table, 2275 user_id_t start_id, 2276 lldb_private::Section *symtab) { 2277 if (symtab->GetObjectFile() != this) { 2278 // If the symbol table section is owned by a different object file, have it 2279 // do the parsing. 2280 ObjectFileELF *obj_file_elf = 2281 static_cast<ObjectFileELF *>(symtab->GetObjectFile()); 2282 return obj_file_elf->ParseSymbolTable(symbol_table, start_id, symtab); 2283 } 2284 2285 // Get section list for this object file. 2286 SectionList *section_list = m_sections_up.get(); 2287 if (!section_list) 2288 return 0; 2289 2290 user_id_t symtab_id = symtab->GetID(); 2291 const ELFSectionHeaderInfo *symtab_hdr = GetSectionHeaderByIndex(symtab_id); 2292 assert(symtab_hdr->sh_type == SHT_SYMTAB || 2293 symtab_hdr->sh_type == SHT_DYNSYM); 2294 2295 // sh_link: section header index of associated string table. 2296 user_id_t strtab_id = symtab_hdr->sh_link; 2297 Section *strtab = section_list->FindSectionByID(strtab_id).get(); 2298 2299 if (symtab && strtab) { 2300 assert(symtab->GetObjectFile() == this); 2301 assert(strtab->GetObjectFile() == this); 2302 2303 DataExtractor symtab_data; 2304 DataExtractor strtab_data; 2305 if (ReadSectionData(symtab, symtab_data) && 2306 ReadSectionData(strtab, strtab_data)) { 2307 size_t num_symbols = symtab_data.GetByteSize() / symtab_hdr->sh_entsize; 2308 2309 return ParseSymbols(symbol_table, start_id, section_list, num_symbols, 2310 symtab_data, strtab_data); 2311 } 2312 } 2313 2314 return 0; 2315 } 2316 2317 size_t ObjectFileELF::ParseDynamicSymbols() { 2318 if (m_dynamic_symbols.size()) 2319 return m_dynamic_symbols.size(); 2320 2321 SectionList *section_list = GetSectionList(); 2322 if (!section_list) 2323 return 0; 2324 2325 // Find the SHT_DYNAMIC section. 2326 Section *dynsym = 2327 section_list->FindSectionByType(eSectionTypeELFDynamicLinkInfo, true) 2328 .get(); 2329 if (!dynsym) 2330 return 0; 2331 assert(dynsym->GetObjectFile() == this); 2332 2333 ELFDynamic symbol; 2334 DataExtractor dynsym_data; 2335 if (ReadSectionData(dynsym, dynsym_data)) { 2336 const lldb::offset_t section_size = dynsym_data.GetByteSize(); 2337 lldb::offset_t cursor = 0; 2338 2339 while (cursor < section_size) { 2340 if (!symbol.Parse(dynsym_data, &cursor)) 2341 break; 2342 2343 m_dynamic_symbols.push_back(symbol); 2344 } 2345 } 2346 2347 return m_dynamic_symbols.size(); 2348 } 2349 2350 const ELFDynamic *ObjectFileELF::FindDynamicSymbol(unsigned tag) { 2351 if (!ParseDynamicSymbols()) 2352 return nullptr; 2353 2354 DynamicSymbolCollIter I = m_dynamic_symbols.begin(); 2355 DynamicSymbolCollIter E = m_dynamic_symbols.end(); 2356 for (; I != E; ++I) { 2357 ELFDynamic *symbol = &*I; 2358 2359 if (symbol->d_tag == tag) 2360 return symbol; 2361 } 2362 2363 return nullptr; 2364 } 2365 2366 unsigned ObjectFileELF::PLTRelocationType() { 2367 // DT_PLTREL 2368 // This member specifies the type of relocation entry to which the 2369 // procedure linkage table refers. The d_val member holds DT_REL or 2370 // DT_RELA, as appropriate. All relocations in a procedure linkage table 2371 // must use the same relocation. 2372 const ELFDynamic *symbol = FindDynamicSymbol(DT_PLTREL); 2373 2374 if (symbol) 2375 return symbol->d_val; 2376 2377 return 0; 2378 } 2379 2380 // Returns the size of the normal plt entries and the offset of the first 2381 // normal plt entry. The 0th entry in the plt table is usually a resolution 2382 // entry which have different size in some architectures then the rest of the 2383 // plt entries. 2384 static std::pair<uint64_t, uint64_t> 2385 GetPltEntrySizeAndOffset(const ELFSectionHeader *rel_hdr, 2386 const ELFSectionHeader *plt_hdr) { 2387 const elf_xword num_relocations = rel_hdr->sh_size / rel_hdr->sh_entsize; 2388 2389 // Clang 3.3 sets entsize to 4 for 32-bit binaries, but the plt entries are 2390 // 16 bytes. So round the entsize up by the alignment if addralign is set. 2391 elf_xword plt_entsize = 2392 plt_hdr->sh_addralign 2393 ? llvm::alignTo(plt_hdr->sh_entsize, plt_hdr->sh_addralign) 2394 : plt_hdr->sh_entsize; 2395 2396 // Some linkers e.g ld for arm, fill plt_hdr->sh_entsize field incorrectly. 2397 // PLT entries relocation code in general requires multiple instruction and 2398 // should be greater than 4 bytes in most cases. Try to guess correct size 2399 // just in case. 2400 if (plt_entsize <= 4) { 2401 // The linker haven't set the plt_hdr->sh_entsize field. Try to guess the 2402 // size of the plt entries based on the number of entries and the size of 2403 // the plt section with the assumption that the size of the 0th entry is at 2404 // least as big as the size of the normal entries and it isn't much bigger 2405 // then that. 2406 if (plt_hdr->sh_addralign) 2407 plt_entsize = plt_hdr->sh_size / plt_hdr->sh_addralign / 2408 (num_relocations + 1) * plt_hdr->sh_addralign; 2409 else 2410 plt_entsize = plt_hdr->sh_size / (num_relocations + 1); 2411 } 2412 2413 elf_xword plt_offset = plt_hdr->sh_size - num_relocations * plt_entsize; 2414 2415 return std::make_pair(plt_entsize, plt_offset); 2416 } 2417 2418 static unsigned ParsePLTRelocations( 2419 Symtab *symbol_table, user_id_t start_id, unsigned rel_type, 2420 const ELFHeader *hdr, const ELFSectionHeader *rel_hdr, 2421 const ELFSectionHeader *plt_hdr, const ELFSectionHeader *sym_hdr, 2422 const lldb::SectionSP &plt_section_sp, DataExtractor &rel_data, 2423 DataExtractor &symtab_data, DataExtractor &strtab_data) { 2424 ELFRelocation rel(rel_type); 2425 ELFSymbol symbol; 2426 lldb::offset_t offset = 0; 2427 2428 uint64_t plt_offset, plt_entsize; 2429 std::tie(plt_entsize, plt_offset) = 2430 GetPltEntrySizeAndOffset(rel_hdr, plt_hdr); 2431 const elf_xword num_relocations = rel_hdr->sh_size / rel_hdr->sh_entsize; 2432 2433 typedef unsigned (*reloc_info_fn)(const ELFRelocation &rel); 2434 reloc_info_fn reloc_type; 2435 reloc_info_fn reloc_symbol; 2436 2437 if (hdr->Is32Bit()) { 2438 reloc_type = ELFRelocation::RelocType32; 2439 reloc_symbol = ELFRelocation::RelocSymbol32; 2440 } else { 2441 reloc_type = ELFRelocation::RelocType64; 2442 reloc_symbol = ELFRelocation::RelocSymbol64; 2443 } 2444 2445 unsigned slot_type = hdr->GetRelocationJumpSlotType(); 2446 unsigned i; 2447 for (i = 0; i < num_relocations; ++i) { 2448 if (!rel.Parse(rel_data, &offset)) 2449 break; 2450 2451 if (reloc_type(rel) != slot_type) 2452 continue; 2453 2454 lldb::offset_t symbol_offset = reloc_symbol(rel) * sym_hdr->sh_entsize; 2455 if (!symbol.Parse(symtab_data, &symbol_offset)) 2456 break; 2457 2458 const char *symbol_name = strtab_data.PeekCStr(symbol.st_name); 2459 uint64_t plt_index = plt_offset + i * plt_entsize; 2460 2461 Symbol jump_symbol( 2462 i + start_id, // Symbol table index 2463 symbol_name, // symbol name. 2464 eSymbolTypeTrampoline, // Type of this symbol 2465 false, // Is this globally visible? 2466 false, // Is this symbol debug info? 2467 true, // Is this symbol a trampoline? 2468 true, // Is this symbol artificial? 2469 plt_section_sp, // Section in which this symbol is defined or null. 2470 plt_index, // Offset in section or symbol value. 2471 plt_entsize, // Size in bytes of this symbol. 2472 true, // Size is valid 2473 false, // Contains linker annotations? 2474 0); // Symbol flags. 2475 2476 symbol_table->AddSymbol(jump_symbol); 2477 } 2478 2479 return i; 2480 } 2481 2482 unsigned 2483 ObjectFileELF::ParseTrampolineSymbols(Symtab *symbol_table, user_id_t start_id, 2484 const ELFSectionHeaderInfo *rel_hdr, 2485 user_id_t rel_id) { 2486 assert(rel_hdr->sh_type == SHT_RELA || rel_hdr->sh_type == SHT_REL); 2487 2488 // The link field points to the associated symbol table. 2489 user_id_t symtab_id = rel_hdr->sh_link; 2490 2491 // If the link field doesn't point to the appropriate symbol name table then 2492 // try to find it by name as some compiler don't fill in the link fields. 2493 if (!symtab_id) 2494 symtab_id = GetSectionIndexByName(".dynsym"); 2495 2496 // Get PLT section. We cannot use rel_hdr->sh_info, since current linkers 2497 // point that to the .got.plt or .got section instead of .plt. 2498 user_id_t plt_id = GetSectionIndexByName(".plt"); 2499 2500 if (!symtab_id || !plt_id) 2501 return 0; 2502 2503 const ELFSectionHeaderInfo *plt_hdr = GetSectionHeaderByIndex(plt_id); 2504 if (!plt_hdr) 2505 return 0; 2506 2507 const ELFSectionHeaderInfo *sym_hdr = GetSectionHeaderByIndex(symtab_id); 2508 if (!sym_hdr) 2509 return 0; 2510 2511 SectionList *section_list = m_sections_up.get(); 2512 if (!section_list) 2513 return 0; 2514 2515 Section *rel_section = section_list->FindSectionByID(rel_id).get(); 2516 if (!rel_section) 2517 return 0; 2518 2519 SectionSP plt_section_sp(section_list->FindSectionByID(plt_id)); 2520 if (!plt_section_sp) 2521 return 0; 2522 2523 Section *symtab = section_list->FindSectionByID(symtab_id).get(); 2524 if (!symtab) 2525 return 0; 2526 2527 // sh_link points to associated string table. 2528 Section *strtab = section_list->FindSectionByID(sym_hdr->sh_link).get(); 2529 if (!strtab) 2530 return 0; 2531 2532 DataExtractor rel_data; 2533 if (!ReadSectionData(rel_section, rel_data)) 2534 return 0; 2535 2536 DataExtractor symtab_data; 2537 if (!ReadSectionData(symtab, symtab_data)) 2538 return 0; 2539 2540 DataExtractor strtab_data; 2541 if (!ReadSectionData(strtab, strtab_data)) 2542 return 0; 2543 2544 unsigned rel_type = PLTRelocationType(); 2545 if (!rel_type) 2546 return 0; 2547 2548 return ParsePLTRelocations(symbol_table, start_id, rel_type, &m_header, 2549 rel_hdr, plt_hdr, sym_hdr, plt_section_sp, 2550 rel_data, symtab_data, strtab_data); 2551 } 2552 2553 unsigned ObjectFileELF::ApplyRelocations( 2554 Symtab *symtab, const ELFHeader *hdr, const ELFSectionHeader *rel_hdr, 2555 const ELFSectionHeader *symtab_hdr, const ELFSectionHeader *debug_hdr, 2556 DataExtractor &rel_data, DataExtractor &symtab_data, 2557 DataExtractor &debug_data, Section *rel_section) { 2558 ELFRelocation rel(rel_hdr->sh_type); 2559 lldb::addr_t offset = 0; 2560 const unsigned num_relocations = rel_hdr->sh_size / rel_hdr->sh_entsize; 2561 typedef unsigned (*reloc_info_fn)(const ELFRelocation &rel); 2562 reloc_info_fn reloc_type; 2563 reloc_info_fn reloc_symbol; 2564 2565 if (hdr->Is32Bit()) { 2566 reloc_type = ELFRelocation::RelocType32; 2567 reloc_symbol = ELFRelocation::RelocSymbol32; 2568 } else { 2569 reloc_type = ELFRelocation::RelocType64; 2570 reloc_symbol = ELFRelocation::RelocSymbol64; 2571 } 2572 2573 for (unsigned i = 0; i < num_relocations; ++i) { 2574 if (!rel.Parse(rel_data, &offset)) 2575 break; 2576 2577 Symbol *symbol = nullptr; 2578 2579 if (hdr->Is32Bit()) { 2580 switch (reloc_type(rel)) { 2581 case R_386_32: 2582 case R_386_PC32: 2583 default: 2584 // FIXME: This asserts with this input: 2585 // 2586 // foo.cpp 2587 // int main(int argc, char **argv) { return 0; } 2588 // 2589 // clang++.exe --target=i686-unknown-linux-gnu -g -c foo.cpp -o foo.o 2590 // 2591 // and running this on the foo.o module. 2592 assert(false && "unexpected relocation type"); 2593 } 2594 } else { 2595 switch (reloc_type(rel)) { 2596 case R_AARCH64_ABS64: 2597 case R_X86_64_64: { 2598 symbol = symtab->FindSymbolByID(reloc_symbol(rel)); 2599 if (symbol) { 2600 addr_t value = symbol->GetAddressRef().GetFileAddress(); 2601 DataBufferSP &data_buffer_sp = debug_data.GetSharedDataBuffer(); 2602 uint64_t *dst = reinterpret_cast<uint64_t *>( 2603 data_buffer_sp->GetBytes() + rel_section->GetFileOffset() + 2604 ELFRelocation::RelocOffset64(rel)); 2605 uint64_t val_offset = value + ELFRelocation::RelocAddend64(rel); 2606 memcpy(dst, &val_offset, sizeof(uint64_t)); 2607 } 2608 break; 2609 } 2610 case R_X86_64_32: 2611 case R_X86_64_32S: 2612 case R_AARCH64_ABS32: { 2613 symbol = symtab->FindSymbolByID(reloc_symbol(rel)); 2614 if (symbol) { 2615 addr_t value = symbol->GetAddressRef().GetFileAddress(); 2616 value += ELFRelocation::RelocAddend32(rel); 2617 if ((reloc_type(rel) == R_X86_64_32 && (value > UINT32_MAX)) || 2618 (reloc_type(rel) == R_X86_64_32S && 2619 ((int64_t)value > INT32_MAX && (int64_t)value < INT32_MIN)) || 2620 (reloc_type(rel) == R_AARCH64_ABS32 && 2621 ((int64_t)value > INT32_MAX && (int64_t)value < INT32_MIN))) { 2622 Log *log = GetLog(LLDBLog::Modules); 2623 LLDB_LOGF(log, "Failed to apply debug info relocations"); 2624 break; 2625 } 2626 uint32_t truncated_addr = (value & 0xFFFFFFFF); 2627 DataBufferSP &data_buffer_sp = debug_data.GetSharedDataBuffer(); 2628 uint32_t *dst = reinterpret_cast<uint32_t *>( 2629 data_buffer_sp->GetBytes() + rel_section->GetFileOffset() + 2630 ELFRelocation::RelocOffset32(rel)); 2631 memcpy(dst, &truncated_addr, sizeof(uint32_t)); 2632 } 2633 break; 2634 } 2635 case R_X86_64_PC32: 2636 default: 2637 assert(false && "unexpected relocation type"); 2638 } 2639 } 2640 } 2641 2642 return 0; 2643 } 2644 2645 unsigned ObjectFileELF::RelocateDebugSections(const ELFSectionHeader *rel_hdr, 2646 user_id_t rel_id, 2647 lldb_private::Symtab *thetab) { 2648 assert(rel_hdr->sh_type == SHT_RELA || rel_hdr->sh_type == SHT_REL); 2649 2650 // Parse in the section list if needed. 2651 SectionList *section_list = GetSectionList(); 2652 if (!section_list) 2653 return 0; 2654 2655 user_id_t symtab_id = rel_hdr->sh_link; 2656 user_id_t debug_id = rel_hdr->sh_info; 2657 2658 const ELFSectionHeader *symtab_hdr = GetSectionHeaderByIndex(symtab_id); 2659 if (!symtab_hdr) 2660 return 0; 2661 2662 const ELFSectionHeader *debug_hdr = GetSectionHeaderByIndex(debug_id); 2663 if (!debug_hdr) 2664 return 0; 2665 2666 Section *rel = section_list->FindSectionByID(rel_id).get(); 2667 if (!rel) 2668 return 0; 2669 2670 Section *symtab = section_list->FindSectionByID(symtab_id).get(); 2671 if (!symtab) 2672 return 0; 2673 2674 Section *debug = section_list->FindSectionByID(debug_id).get(); 2675 if (!debug) 2676 return 0; 2677 2678 DataExtractor rel_data; 2679 DataExtractor symtab_data; 2680 DataExtractor debug_data; 2681 2682 if (GetData(rel->GetFileOffset(), rel->GetFileSize(), rel_data) && 2683 GetData(symtab->GetFileOffset(), symtab->GetFileSize(), symtab_data) && 2684 GetData(debug->GetFileOffset(), debug->GetFileSize(), debug_data)) { 2685 ApplyRelocations(thetab, &m_header, rel_hdr, symtab_hdr, debug_hdr, 2686 rel_data, symtab_data, debug_data, debug); 2687 } 2688 2689 return 0; 2690 } 2691 2692 void ObjectFileELF::ParseSymtab(Symtab &lldb_symtab) { 2693 ModuleSP module_sp(GetModule()); 2694 if (!module_sp) 2695 return; 2696 2697 Progress progress( 2698 llvm::formatv("Parsing symbol table for {0}", 2699 m_file.GetFilename().AsCString("<Unknown>"))); 2700 ElapsedTime elapsed(module_sp->GetSymtabParseTime()); 2701 2702 // We always want to use the main object file so we (hopefully) only have one 2703 // cached copy of our symtab, dynamic sections, etc. 2704 ObjectFile *module_obj_file = module_sp->GetObjectFile(); 2705 if (module_obj_file && module_obj_file != this) 2706 return module_obj_file->ParseSymtab(lldb_symtab); 2707 2708 SectionList *section_list = module_sp->GetSectionList(); 2709 if (!section_list) 2710 return; 2711 2712 uint64_t symbol_id = 0; 2713 2714 // Sharable objects and dynamic executables usually have 2 distinct symbol 2715 // tables, one named ".symtab", and the other ".dynsym". The dynsym is a 2716 // smaller version of the symtab that only contains global symbols. The 2717 // information found in the dynsym is therefore also found in the symtab, 2718 // while the reverse is not necessarily true. 2719 Section *symtab = 2720 section_list->FindSectionByType(eSectionTypeELFSymbolTable, true).get(); 2721 if (symtab) 2722 symbol_id += ParseSymbolTable(&lldb_symtab, symbol_id, symtab); 2723 2724 // The symtab section is non-allocable and can be stripped, while the 2725 // .dynsym section which should always be always be there. To support the 2726 // minidebuginfo case we parse .dynsym when there's a .gnu_debuginfo 2727 // section, nomatter if .symtab was already parsed or not. This is because 2728 // minidebuginfo normally removes the .symtab symbols which have their 2729 // matching .dynsym counterparts. 2730 if (!symtab || 2731 GetSectionList()->FindSectionByName(ConstString(".gnu_debugdata"))) { 2732 Section *dynsym = 2733 section_list->FindSectionByType(eSectionTypeELFDynamicSymbols, true) 2734 .get(); 2735 if (dynsym) 2736 symbol_id += ParseSymbolTable(&lldb_symtab, symbol_id, dynsym); 2737 } 2738 2739 // DT_JMPREL 2740 // If present, this entry's d_ptr member holds the address of 2741 // relocation 2742 // entries associated solely with the procedure linkage table. 2743 // Separating 2744 // these relocation entries lets the dynamic linker ignore them during 2745 // process initialization, if lazy binding is enabled. If this entry is 2746 // present, the related entries of types DT_PLTRELSZ and DT_PLTREL must 2747 // also be present. 2748 const ELFDynamic *symbol = FindDynamicSymbol(DT_JMPREL); 2749 if (symbol) { 2750 // Synthesize trampoline symbols to help navigate the PLT. 2751 addr_t addr = symbol->d_ptr; 2752 Section *reloc_section = 2753 section_list->FindSectionContainingFileAddress(addr).get(); 2754 if (reloc_section) { 2755 user_id_t reloc_id = reloc_section->GetID(); 2756 const ELFSectionHeaderInfo *reloc_header = 2757 GetSectionHeaderByIndex(reloc_id); 2758 if (reloc_header) 2759 ParseTrampolineSymbols(&lldb_symtab, symbol_id, reloc_header, reloc_id); 2760 } 2761 } 2762 2763 if (DWARFCallFrameInfo *eh_frame = 2764 GetModule()->GetUnwindTable().GetEHFrameInfo()) { 2765 ParseUnwindSymbols(&lldb_symtab, eh_frame); 2766 } 2767 2768 // In the event that there's no symbol entry for the entry point we'll 2769 // artificially create one. We delegate to the symtab object the figuring 2770 // out of the proper size, this will usually make it span til the next 2771 // symbol it finds in the section. This means that if there are missing 2772 // symbols the entry point might span beyond its function definition. 2773 // We're fine with this as it doesn't make it worse than not having a 2774 // symbol entry at all. 2775 if (CalculateType() == eTypeExecutable) { 2776 ArchSpec arch = GetArchitecture(); 2777 auto entry_point_addr = GetEntryPointAddress(); 2778 bool is_valid_entry_point = 2779 entry_point_addr.IsValid() && entry_point_addr.IsSectionOffset(); 2780 addr_t entry_point_file_addr = entry_point_addr.GetFileAddress(); 2781 if (is_valid_entry_point && !lldb_symtab.FindSymbolContainingFileAddress( 2782 entry_point_file_addr)) { 2783 uint64_t symbol_id = lldb_symtab.GetNumSymbols(); 2784 // Don't set the name for any synthetic symbols, the Symbol 2785 // object will generate one if needed when the name is accessed 2786 // via accessors. 2787 SectionSP section_sp = entry_point_addr.GetSection(); 2788 Symbol symbol( 2789 /*symID=*/symbol_id, 2790 /*name=*/llvm::StringRef(), // Name will be auto generated. 2791 /*type=*/eSymbolTypeCode, 2792 /*external=*/true, 2793 /*is_debug=*/false, 2794 /*is_trampoline=*/false, 2795 /*is_artificial=*/true, 2796 /*section_sp=*/section_sp, 2797 /*offset=*/0, 2798 /*size=*/0, // FDE can span multiple symbols so don't use its size. 2799 /*size_is_valid=*/false, 2800 /*contains_linker_annotations=*/false, 2801 /*flags=*/0); 2802 // When the entry point is arm thumb we need to explicitly set its 2803 // class address to reflect that. This is important because expression 2804 // evaluation relies on correctly setting a breakpoint at this 2805 // address. 2806 if (arch.GetMachine() == llvm::Triple::arm && 2807 (entry_point_file_addr & 1)) { 2808 symbol.GetAddressRef().SetOffset(entry_point_addr.GetOffset() ^ 1); 2809 m_address_class_map[entry_point_file_addr ^ 1] = 2810 AddressClass::eCodeAlternateISA; 2811 } else { 2812 m_address_class_map[entry_point_file_addr] = AddressClass::eCode; 2813 } 2814 lldb_symtab.AddSymbol(symbol); 2815 } 2816 } 2817 } 2818 2819 void ObjectFileELF::RelocateSection(lldb_private::Section *section) 2820 { 2821 static const char *debug_prefix = ".debug"; 2822 2823 // Set relocated bit so we stop getting called, regardless of whether we 2824 // actually relocate. 2825 section->SetIsRelocated(true); 2826 2827 // We only relocate in ELF relocatable files 2828 if (CalculateType() != eTypeObjectFile) 2829 return; 2830 2831 const char *section_name = section->GetName().GetCString(); 2832 // Can't relocate that which can't be named 2833 if (section_name == nullptr) 2834 return; 2835 2836 // We don't relocate non-debug sections at the moment 2837 if (strncmp(section_name, debug_prefix, strlen(debug_prefix))) 2838 return; 2839 2840 // Relocation section names to look for 2841 std::string needle = std::string(".rel") + section_name; 2842 std::string needlea = std::string(".rela") + section_name; 2843 2844 for (SectionHeaderCollIter I = m_section_headers.begin(); 2845 I != m_section_headers.end(); ++I) { 2846 if (I->sh_type == SHT_RELA || I->sh_type == SHT_REL) { 2847 const char *hay_name = I->section_name.GetCString(); 2848 if (hay_name == nullptr) 2849 continue; 2850 if (needle == hay_name || needlea == hay_name) { 2851 const ELFSectionHeader &reloc_header = *I; 2852 user_id_t reloc_id = SectionIndex(I); 2853 RelocateDebugSections(&reloc_header, reloc_id, GetSymtab()); 2854 break; 2855 } 2856 } 2857 } 2858 } 2859 2860 void ObjectFileELF::ParseUnwindSymbols(Symtab *symbol_table, 2861 DWARFCallFrameInfo *eh_frame) { 2862 SectionList *section_list = GetSectionList(); 2863 if (!section_list) 2864 return; 2865 2866 // First we save the new symbols into a separate list and add them to the 2867 // symbol table after we collected all symbols we want to add. This is 2868 // neccessary because adding a new symbol invalidates the internal index of 2869 // the symtab what causing the next lookup to be slow because it have to 2870 // recalculate the index first. 2871 std::vector<Symbol> new_symbols; 2872 2873 size_t num_symbols = symbol_table->GetNumSymbols(); 2874 uint64_t last_symbol_id = 2875 num_symbols ? symbol_table->SymbolAtIndex(num_symbols - 1)->GetID() : 0; 2876 eh_frame->ForEachFDEEntries([&](lldb::addr_t file_addr, uint32_t size, 2877 dw_offset_t) { 2878 Symbol *symbol = symbol_table->FindSymbolAtFileAddress(file_addr); 2879 if (symbol) { 2880 if (!symbol->GetByteSizeIsValid()) { 2881 symbol->SetByteSize(size); 2882 symbol->SetSizeIsSynthesized(true); 2883 } 2884 } else { 2885 SectionSP section_sp = 2886 section_list->FindSectionContainingFileAddress(file_addr); 2887 if (section_sp) { 2888 addr_t offset = file_addr - section_sp->GetFileAddress(); 2889 uint64_t symbol_id = ++last_symbol_id; 2890 // Don't set the name for any synthetic symbols, the Symbol 2891 // object will generate one if needed when the name is accessed 2892 // via accessors. 2893 Symbol eh_symbol( 2894 /*symID=*/symbol_id, 2895 /*name=*/llvm::StringRef(), // Name will be auto generated. 2896 /*type=*/eSymbolTypeCode, 2897 /*external=*/true, 2898 /*is_debug=*/false, 2899 /*is_trampoline=*/false, 2900 /*is_artificial=*/true, 2901 /*section_sp=*/section_sp, 2902 /*offset=*/offset, 2903 /*size=*/0, // FDE can span multiple symbols so don't use its size. 2904 /*size_is_valid=*/false, 2905 /*contains_linker_annotations=*/false, 2906 /*flags=*/0); 2907 new_symbols.push_back(eh_symbol); 2908 } 2909 } 2910 return true; 2911 }); 2912 2913 for (const Symbol &s : new_symbols) 2914 symbol_table->AddSymbol(s); 2915 } 2916 2917 bool ObjectFileELF::IsStripped() { 2918 // TODO: determine this for ELF 2919 return false; 2920 } 2921 2922 //===----------------------------------------------------------------------===// 2923 // Dump 2924 // 2925 // Dump the specifics of the runtime file container (such as any headers 2926 // segments, sections, etc). 2927 void ObjectFileELF::Dump(Stream *s) { 2928 ModuleSP module_sp(GetModule()); 2929 if (!module_sp) { 2930 return; 2931 } 2932 2933 std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex()); 2934 s->Printf("%p: ", static_cast<void *>(this)); 2935 s->Indent(); 2936 s->PutCString("ObjectFileELF"); 2937 2938 ArchSpec header_arch = GetArchitecture(); 2939 2940 *s << ", file = '" << m_file 2941 << "', arch = " << header_arch.GetArchitectureName() << "\n"; 2942 2943 DumpELFHeader(s, m_header); 2944 s->EOL(); 2945 DumpELFProgramHeaders(s); 2946 s->EOL(); 2947 DumpELFSectionHeaders(s); 2948 s->EOL(); 2949 SectionList *section_list = GetSectionList(); 2950 if (section_list) 2951 section_list->Dump(s->AsRawOstream(), s->GetIndentLevel(), nullptr, true, 2952 UINT32_MAX); 2953 Symtab *symtab = GetSymtab(); 2954 if (symtab) 2955 symtab->Dump(s, nullptr, eSortOrderNone); 2956 s->EOL(); 2957 DumpDependentModules(s); 2958 s->EOL(); 2959 } 2960 2961 // DumpELFHeader 2962 // 2963 // Dump the ELF header to the specified output stream 2964 void ObjectFileELF::DumpELFHeader(Stream *s, const ELFHeader &header) { 2965 s->PutCString("ELF Header\n"); 2966 s->Printf("e_ident[EI_MAG0 ] = 0x%2.2x\n", header.e_ident[EI_MAG0]); 2967 s->Printf("e_ident[EI_MAG1 ] = 0x%2.2x '%c'\n", header.e_ident[EI_MAG1], 2968 header.e_ident[EI_MAG1]); 2969 s->Printf("e_ident[EI_MAG2 ] = 0x%2.2x '%c'\n", header.e_ident[EI_MAG2], 2970 header.e_ident[EI_MAG2]); 2971 s->Printf("e_ident[EI_MAG3 ] = 0x%2.2x '%c'\n", header.e_ident[EI_MAG3], 2972 header.e_ident[EI_MAG3]); 2973 2974 s->Printf("e_ident[EI_CLASS ] = 0x%2.2x\n", header.e_ident[EI_CLASS]); 2975 s->Printf("e_ident[EI_DATA ] = 0x%2.2x ", header.e_ident[EI_DATA]); 2976 DumpELFHeader_e_ident_EI_DATA(s, header.e_ident[EI_DATA]); 2977 s->Printf("\ne_ident[EI_VERSION] = 0x%2.2x\n", header.e_ident[EI_VERSION]); 2978 s->Printf("e_ident[EI_PAD ] = 0x%2.2x\n", header.e_ident[EI_PAD]); 2979 2980 s->Printf("e_type = 0x%4.4x ", header.e_type); 2981 DumpELFHeader_e_type(s, header.e_type); 2982 s->Printf("\ne_machine = 0x%4.4x\n", header.e_machine); 2983 s->Printf("e_version = 0x%8.8x\n", header.e_version); 2984 s->Printf("e_entry = 0x%8.8" PRIx64 "\n", header.e_entry); 2985 s->Printf("e_phoff = 0x%8.8" PRIx64 "\n", header.e_phoff); 2986 s->Printf("e_shoff = 0x%8.8" PRIx64 "\n", header.e_shoff); 2987 s->Printf("e_flags = 0x%8.8x\n", header.e_flags); 2988 s->Printf("e_ehsize = 0x%4.4x\n", header.e_ehsize); 2989 s->Printf("e_phentsize = 0x%4.4x\n", header.e_phentsize); 2990 s->Printf("e_phnum = 0x%8.8x\n", header.e_phnum); 2991 s->Printf("e_shentsize = 0x%4.4x\n", header.e_shentsize); 2992 s->Printf("e_shnum = 0x%8.8x\n", header.e_shnum); 2993 s->Printf("e_shstrndx = 0x%8.8x\n", header.e_shstrndx); 2994 } 2995 2996 // DumpELFHeader_e_type 2997 // 2998 // Dump an token value for the ELF header member e_type 2999 void ObjectFileELF::DumpELFHeader_e_type(Stream *s, elf_half e_type) { 3000 switch (e_type) { 3001 case ET_NONE: 3002 *s << "ET_NONE"; 3003 break; 3004 case ET_REL: 3005 *s << "ET_REL"; 3006 break; 3007 case ET_EXEC: 3008 *s << "ET_EXEC"; 3009 break; 3010 case ET_DYN: 3011 *s << "ET_DYN"; 3012 break; 3013 case ET_CORE: 3014 *s << "ET_CORE"; 3015 break; 3016 default: 3017 break; 3018 } 3019 } 3020 3021 // DumpELFHeader_e_ident_EI_DATA 3022 // 3023 // Dump an token value for the ELF header member e_ident[EI_DATA] 3024 void ObjectFileELF::DumpELFHeader_e_ident_EI_DATA(Stream *s, 3025 unsigned char ei_data) { 3026 switch (ei_data) { 3027 case ELFDATANONE: 3028 *s << "ELFDATANONE"; 3029 break; 3030 case ELFDATA2LSB: 3031 *s << "ELFDATA2LSB - Little Endian"; 3032 break; 3033 case ELFDATA2MSB: 3034 *s << "ELFDATA2MSB - Big Endian"; 3035 break; 3036 default: 3037 break; 3038 } 3039 } 3040 3041 // DumpELFProgramHeader 3042 // 3043 // Dump a single ELF program header to the specified output stream 3044 void ObjectFileELF::DumpELFProgramHeader(Stream *s, 3045 const ELFProgramHeader &ph) { 3046 DumpELFProgramHeader_p_type(s, ph.p_type); 3047 s->Printf(" %8.8" PRIx64 " %8.8" PRIx64 " %8.8" PRIx64, ph.p_offset, 3048 ph.p_vaddr, ph.p_paddr); 3049 s->Printf(" %8.8" PRIx64 " %8.8" PRIx64 " %8.8x (", ph.p_filesz, ph.p_memsz, 3050 ph.p_flags); 3051 3052 DumpELFProgramHeader_p_flags(s, ph.p_flags); 3053 s->Printf(") %8.8" PRIx64, ph.p_align); 3054 } 3055 3056 // DumpELFProgramHeader_p_type 3057 // 3058 // Dump an token value for the ELF program header member p_type which describes 3059 // the type of the program header 3060 void ObjectFileELF::DumpELFProgramHeader_p_type(Stream *s, elf_word p_type) { 3061 const int kStrWidth = 15; 3062 switch (p_type) { 3063 CASE_AND_STREAM(s, PT_NULL, kStrWidth); 3064 CASE_AND_STREAM(s, PT_LOAD, kStrWidth); 3065 CASE_AND_STREAM(s, PT_DYNAMIC, kStrWidth); 3066 CASE_AND_STREAM(s, PT_INTERP, kStrWidth); 3067 CASE_AND_STREAM(s, PT_NOTE, kStrWidth); 3068 CASE_AND_STREAM(s, PT_SHLIB, kStrWidth); 3069 CASE_AND_STREAM(s, PT_PHDR, kStrWidth); 3070 CASE_AND_STREAM(s, PT_TLS, kStrWidth); 3071 CASE_AND_STREAM(s, PT_GNU_EH_FRAME, kStrWidth); 3072 default: 3073 s->Printf("0x%8.8x%*s", p_type, kStrWidth - 10, ""); 3074 break; 3075 } 3076 } 3077 3078 // DumpELFProgramHeader_p_flags 3079 // 3080 // Dump an token value for the ELF program header member p_flags 3081 void ObjectFileELF::DumpELFProgramHeader_p_flags(Stream *s, elf_word p_flags) { 3082 *s << ((p_flags & PF_X) ? "PF_X" : " ") 3083 << (((p_flags & PF_X) && (p_flags & PF_W)) ? '+' : ' ') 3084 << ((p_flags & PF_W) ? "PF_W" : " ") 3085 << (((p_flags & PF_W) && (p_flags & PF_R)) ? '+' : ' ') 3086 << ((p_flags & PF_R) ? "PF_R" : " "); 3087 } 3088 3089 // DumpELFProgramHeaders 3090 // 3091 // Dump all of the ELF program header to the specified output stream 3092 void ObjectFileELF::DumpELFProgramHeaders(Stream *s) { 3093 if (!ParseProgramHeaders()) 3094 return; 3095 3096 s->PutCString("Program Headers\n"); 3097 s->PutCString("IDX p_type p_offset p_vaddr p_paddr " 3098 "p_filesz p_memsz p_flags p_align\n"); 3099 s->PutCString("==== --------------- -------- -------- -------- " 3100 "-------- -------- ------------------------- --------\n"); 3101 3102 for (const auto &H : llvm::enumerate(m_program_headers)) { 3103 s->Format("[{0,2}] ", H.index()); 3104 ObjectFileELF::DumpELFProgramHeader(s, H.value()); 3105 s->EOL(); 3106 } 3107 } 3108 3109 // DumpELFSectionHeader 3110 // 3111 // Dump a single ELF section header to the specified output stream 3112 void ObjectFileELF::DumpELFSectionHeader(Stream *s, 3113 const ELFSectionHeaderInfo &sh) { 3114 s->Printf("%8.8x ", sh.sh_name); 3115 DumpELFSectionHeader_sh_type(s, sh.sh_type); 3116 s->Printf(" %8.8" PRIx64 " (", sh.sh_flags); 3117 DumpELFSectionHeader_sh_flags(s, sh.sh_flags); 3118 s->Printf(") %8.8" PRIx64 " %8.8" PRIx64 " %8.8" PRIx64, sh.sh_addr, 3119 sh.sh_offset, sh.sh_size); 3120 s->Printf(" %8.8x %8.8x", sh.sh_link, sh.sh_info); 3121 s->Printf(" %8.8" PRIx64 " %8.8" PRIx64, sh.sh_addralign, sh.sh_entsize); 3122 } 3123 3124 // DumpELFSectionHeader_sh_type 3125 // 3126 // Dump an token value for the ELF section header member sh_type which 3127 // describes the type of the section 3128 void ObjectFileELF::DumpELFSectionHeader_sh_type(Stream *s, elf_word sh_type) { 3129 const int kStrWidth = 12; 3130 switch (sh_type) { 3131 CASE_AND_STREAM(s, SHT_NULL, kStrWidth); 3132 CASE_AND_STREAM(s, SHT_PROGBITS, kStrWidth); 3133 CASE_AND_STREAM(s, SHT_SYMTAB, kStrWidth); 3134 CASE_AND_STREAM(s, SHT_STRTAB, kStrWidth); 3135 CASE_AND_STREAM(s, SHT_RELA, kStrWidth); 3136 CASE_AND_STREAM(s, SHT_HASH, kStrWidth); 3137 CASE_AND_STREAM(s, SHT_DYNAMIC, kStrWidth); 3138 CASE_AND_STREAM(s, SHT_NOTE, kStrWidth); 3139 CASE_AND_STREAM(s, SHT_NOBITS, kStrWidth); 3140 CASE_AND_STREAM(s, SHT_REL, kStrWidth); 3141 CASE_AND_STREAM(s, SHT_SHLIB, kStrWidth); 3142 CASE_AND_STREAM(s, SHT_DYNSYM, kStrWidth); 3143 CASE_AND_STREAM(s, SHT_LOPROC, kStrWidth); 3144 CASE_AND_STREAM(s, SHT_HIPROC, kStrWidth); 3145 CASE_AND_STREAM(s, SHT_LOUSER, kStrWidth); 3146 CASE_AND_STREAM(s, SHT_HIUSER, kStrWidth); 3147 default: 3148 s->Printf("0x%8.8x%*s", sh_type, kStrWidth - 10, ""); 3149 break; 3150 } 3151 } 3152 3153 // DumpELFSectionHeader_sh_flags 3154 // 3155 // Dump an token value for the ELF section header member sh_flags 3156 void ObjectFileELF::DumpELFSectionHeader_sh_flags(Stream *s, 3157 elf_xword sh_flags) { 3158 *s << ((sh_flags & SHF_WRITE) ? "WRITE" : " ") 3159 << (((sh_flags & SHF_WRITE) && (sh_flags & SHF_ALLOC)) ? '+' : ' ') 3160 << ((sh_flags & SHF_ALLOC) ? "ALLOC" : " ") 3161 << (((sh_flags & SHF_ALLOC) && (sh_flags & SHF_EXECINSTR)) ? '+' : ' ') 3162 << ((sh_flags & SHF_EXECINSTR) ? "EXECINSTR" : " "); 3163 } 3164 3165 // DumpELFSectionHeaders 3166 // 3167 // Dump all of the ELF section header to the specified output stream 3168 void ObjectFileELF::DumpELFSectionHeaders(Stream *s) { 3169 if (!ParseSectionHeaders()) 3170 return; 3171 3172 s->PutCString("Section Headers\n"); 3173 s->PutCString("IDX name type flags " 3174 "addr offset size link info addralgn " 3175 "entsize Name\n"); 3176 s->PutCString("==== -------- ------------ -------------------------------- " 3177 "-------- -------- -------- -------- -------- -------- " 3178 "-------- ====================\n"); 3179 3180 uint32_t idx = 0; 3181 for (SectionHeaderCollConstIter I = m_section_headers.begin(); 3182 I != m_section_headers.end(); ++I, ++idx) { 3183 s->Printf("[%2u] ", idx); 3184 ObjectFileELF::DumpELFSectionHeader(s, *I); 3185 const char *section_name = I->section_name.AsCString(""); 3186 if (section_name) 3187 *s << ' ' << section_name << "\n"; 3188 } 3189 } 3190 3191 void ObjectFileELF::DumpDependentModules(lldb_private::Stream *s) { 3192 size_t num_modules = ParseDependentModules(); 3193 3194 if (num_modules > 0) { 3195 s->PutCString("Dependent Modules:\n"); 3196 for (unsigned i = 0; i < num_modules; ++i) { 3197 const FileSpec &spec = m_filespec_up->GetFileSpecAtIndex(i); 3198 s->Printf(" %s\n", spec.GetFilename().GetCString()); 3199 } 3200 } 3201 } 3202 3203 ArchSpec ObjectFileELF::GetArchitecture() { 3204 if (!ParseHeader()) 3205 return ArchSpec(); 3206 3207 if (m_section_headers.empty()) { 3208 // Allow elf notes to be parsed which may affect the detected architecture. 3209 ParseSectionHeaders(); 3210 } 3211 3212 if (CalculateType() == eTypeCoreFile && 3213 !m_arch_spec.TripleOSWasSpecified()) { 3214 // Core files don't have section headers yet they have PT_NOTE program 3215 // headers that might shed more light on the architecture 3216 for (const elf::ELFProgramHeader &H : ProgramHeaders()) { 3217 if (H.p_type != PT_NOTE || H.p_offset == 0 || H.p_filesz == 0) 3218 continue; 3219 DataExtractor data; 3220 if (data.SetData(m_data, H.p_offset, H.p_filesz) == H.p_filesz) { 3221 UUID uuid; 3222 RefineModuleDetailsFromNote(data, m_arch_spec, uuid); 3223 } 3224 } 3225 } 3226 return m_arch_spec; 3227 } 3228 3229 ObjectFile::Type ObjectFileELF::CalculateType() { 3230 switch (m_header.e_type) { 3231 case llvm::ELF::ET_NONE: 3232 // 0 - No file type 3233 return eTypeUnknown; 3234 3235 case llvm::ELF::ET_REL: 3236 // 1 - Relocatable file 3237 return eTypeObjectFile; 3238 3239 case llvm::ELF::ET_EXEC: 3240 // 2 - Executable file 3241 return eTypeExecutable; 3242 3243 case llvm::ELF::ET_DYN: 3244 // 3 - Shared object file 3245 return eTypeSharedLibrary; 3246 3247 case ET_CORE: 3248 // 4 - Core file 3249 return eTypeCoreFile; 3250 3251 default: 3252 break; 3253 } 3254 return eTypeUnknown; 3255 } 3256 3257 ObjectFile::Strata ObjectFileELF::CalculateStrata() { 3258 switch (m_header.e_type) { 3259 case llvm::ELF::ET_NONE: 3260 // 0 - No file type 3261 return eStrataUnknown; 3262 3263 case llvm::ELF::ET_REL: 3264 // 1 - Relocatable file 3265 return eStrataUnknown; 3266 3267 case llvm::ELF::ET_EXEC: 3268 // 2 - Executable file 3269 // TODO: is there any way to detect that an executable is a kernel 3270 // related executable by inspecting the program headers, section headers, 3271 // symbols, or any other flag bits??? 3272 return eStrataUser; 3273 3274 case llvm::ELF::ET_DYN: 3275 // 3 - Shared object file 3276 // TODO: is there any way to detect that an shared library is a kernel 3277 // related executable by inspecting the program headers, section headers, 3278 // symbols, or any other flag bits??? 3279 return eStrataUnknown; 3280 3281 case ET_CORE: 3282 // 4 - Core file 3283 // TODO: is there any way to detect that an core file is a kernel 3284 // related executable by inspecting the program headers, section headers, 3285 // symbols, or any other flag bits??? 3286 return eStrataUnknown; 3287 3288 default: 3289 break; 3290 } 3291 return eStrataUnknown; 3292 } 3293 3294 size_t ObjectFileELF::ReadSectionData(Section *section, 3295 lldb::offset_t section_offset, void *dst, 3296 size_t dst_len) { 3297 // If some other objectfile owns this data, pass this to them. 3298 if (section->GetObjectFile() != this) 3299 return section->GetObjectFile()->ReadSectionData(section, section_offset, 3300 dst, dst_len); 3301 3302 if (!section->Test(SHF_COMPRESSED)) 3303 return ObjectFile::ReadSectionData(section, section_offset, dst, dst_len); 3304 3305 // For compressed sections we need to read to full data to be able to 3306 // decompress. 3307 DataExtractor data; 3308 ReadSectionData(section, data); 3309 return data.CopyData(section_offset, dst_len, dst); 3310 } 3311 3312 size_t ObjectFileELF::ReadSectionData(Section *section, 3313 DataExtractor §ion_data) { 3314 // If some other objectfile owns this data, pass this to them. 3315 if (section->GetObjectFile() != this) 3316 return section->GetObjectFile()->ReadSectionData(section, section_data); 3317 3318 size_t result = ObjectFile::ReadSectionData(section, section_data); 3319 if (result == 0 || !llvm::object::Decompressor::isCompressedELFSection( 3320 section->Get(), section->GetName().GetStringRef())) 3321 return result; 3322 3323 auto Decompressor = llvm::object::Decompressor::create( 3324 section->GetName().GetStringRef(), 3325 {reinterpret_cast<const char *>(section_data.GetDataStart()), 3326 size_t(section_data.GetByteSize())}, 3327 GetByteOrder() == eByteOrderLittle, GetAddressByteSize() == 8); 3328 if (!Decompressor) { 3329 GetModule()->ReportWarning( 3330 "Unable to initialize decompressor for section '%s': %s", 3331 section->GetName().GetCString(), 3332 llvm::toString(Decompressor.takeError()).c_str()); 3333 section_data.Clear(); 3334 return 0; 3335 } 3336 3337 auto buffer_sp = 3338 std::make_shared<DataBufferHeap>(Decompressor->getDecompressedSize(), 0); 3339 if (auto error = Decompressor->decompress( 3340 {reinterpret_cast<char *>(buffer_sp->GetBytes()), 3341 size_t(buffer_sp->GetByteSize())})) { 3342 GetModule()->ReportWarning( 3343 "Decompression of section '%s' failed: %s", 3344 section->GetName().GetCString(), 3345 llvm::toString(std::move(error)).c_str()); 3346 section_data.Clear(); 3347 return 0; 3348 } 3349 3350 section_data.SetData(buffer_sp); 3351 return buffer_sp->GetByteSize(); 3352 } 3353 3354 llvm::ArrayRef<ELFProgramHeader> ObjectFileELF::ProgramHeaders() { 3355 ParseProgramHeaders(); 3356 return m_program_headers; 3357 } 3358 3359 DataExtractor ObjectFileELF::GetSegmentData(const ELFProgramHeader &H) { 3360 return DataExtractor(m_data, H.p_offset, H.p_filesz); 3361 } 3362 3363 bool ObjectFileELF::AnySegmentHasPhysicalAddress() { 3364 for (const ELFProgramHeader &H : ProgramHeaders()) { 3365 if (H.p_paddr != 0) 3366 return true; 3367 } 3368 return false; 3369 } 3370 3371 std::vector<ObjectFile::LoadableData> 3372 ObjectFileELF::GetLoadableData(Target &target) { 3373 // Create a list of loadable data from loadable segments, using physical 3374 // addresses if they aren't all null 3375 std::vector<LoadableData> loadables; 3376 bool should_use_paddr = AnySegmentHasPhysicalAddress(); 3377 for (const ELFProgramHeader &H : ProgramHeaders()) { 3378 LoadableData loadable; 3379 if (H.p_type != llvm::ELF::PT_LOAD) 3380 continue; 3381 loadable.Dest = should_use_paddr ? H.p_paddr : H.p_vaddr; 3382 if (loadable.Dest == LLDB_INVALID_ADDRESS) 3383 continue; 3384 if (H.p_filesz == 0) 3385 continue; 3386 auto segment_data = GetSegmentData(H); 3387 loadable.Contents = llvm::ArrayRef<uint8_t>(segment_data.GetDataStart(), 3388 segment_data.GetByteSize()); 3389 loadables.push_back(loadable); 3390 } 3391 return loadables; 3392 } 3393