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 As 1179 // the contents look like this in a 64 bit ELF core file: count = 1180 // 0x000000000000000a (10) page_size = 0x0000000000001000 (4096) Index 1181 // start end file_ofs path ===== 1182 // 0x0000000000401000 0x0000000000000000 /tmp/a.out [ 1] 1183 // 0x0000000000600000 0x0000000000601000 0x0000000000000000 /tmp/a.out [ 1184 // 2] 0x0000000000601000 0x0000000000602000 0x0000000000000001 /tmp/a.out 1185 // [ 3] 0x00007fa79c9ed000 0x00007fa79cba8000 0x0000000000000000 1186 // /lib/x86_64-linux-gnu/libc-2.19.so [ 4] 0x00007fa79cba8000 1187 // 0x00007fa79cda7000 0x00000000000001bb /lib/x86_64-linux- 1188 // gnu/libc-2.19.so [ 5] 0x00007fa79cda7000 0x00007fa79cdab000 1189 // 0x00000000000001ba /lib/x86_64-linux-gnu/libc-2.19.so [ 6] 1190 // 0x00007fa79cdab000 0x00007fa79cdad000 0x00000000000001be /lib/x86_64 1191 // -linux-gnu/libc-2.19.so [ 7] 0x00007fa79cdb2000 0x00007fa79cdd5000 1192 // 0x0000000000000000 /lib/x86_64-linux-gnu/ld-2.19.so [ 8] 1193 // 0x00007fa79cfd4000 0x00007fa79cfd5000 0x0000000000000022 /lib/x86_64 1194 // -linux-gnu/ld-2.19.so [ 9] 0x00007fa79cfd5000 0x00007fa79cfd6000 1195 // 0x0000000000000023 /lib/x86_64-linux-gnu/ld-2.19.so In the 32 bit ELFs 1196 // the count, page_size, start, end, file_ofs are uint32_t For reference: 1197 // see readelf source code (in binutils). 1198 if (note.n_type == NT_FILE) { 1199 uint64_t count = data.GetAddress(&offset); 1200 const char *cstr; 1201 data.GetAddress(&offset); // Skip page size 1202 offset += count * 3 * 1203 data.GetAddressByteSize(); // Skip all start/end/file_ofs 1204 for (size_t i = 0; i < count; ++i) { 1205 cstr = data.GetCStr(&offset); 1206 if (cstr == nullptr) { 1207 error.SetErrorStringWithFormat("ObjectFileELF::%s trying to read " 1208 "at an offset after the end " 1209 "(GetCStr returned nullptr)", 1210 __FUNCTION__); 1211 return error; 1212 } 1213 llvm::StringRef path(cstr); 1214 if (path.contains("/lib/x86_64-linux-gnu") || path.contains("/lib/i386-linux-gnu")) { 1215 arch_spec.GetTriple().setOS(llvm::Triple::OSType::Linux); 1216 break; 1217 } 1218 } 1219 if (arch_spec.IsMIPS() && 1220 arch_spec.GetTriple().getOS() == llvm::Triple::OSType::UnknownOS) 1221 // In case of MIPSR6, the LLDB_NT_OWNER_GNU note is missing for some 1222 // cases (e.g. compile with -nostdlib) Hence set OS to Linux 1223 arch_spec.GetTriple().setOS(llvm::Triple::OSType::Linux); 1224 } 1225 } 1226 1227 // Calculate the offset of the next note just in case "offset" has been 1228 // used to poke at the contents of the note data 1229 offset = note_offset + note.GetByteSize(); 1230 } 1231 1232 return error; 1233 } 1234 1235 void ObjectFileELF::ParseARMAttributes(DataExtractor &data, uint64_t length, 1236 ArchSpec &arch_spec) { 1237 lldb::offset_t Offset = 0; 1238 1239 uint8_t FormatVersion = data.GetU8(&Offset); 1240 if (FormatVersion != llvm::ELFAttrs::Format_Version) 1241 return; 1242 1243 Offset = Offset + sizeof(uint32_t); // Section Length 1244 llvm::StringRef VendorName = data.GetCStr(&Offset); 1245 1246 if (VendorName != "aeabi") 1247 return; 1248 1249 if (arch_spec.GetTriple().getEnvironment() == 1250 llvm::Triple::UnknownEnvironment) 1251 arch_spec.GetTriple().setEnvironment(llvm::Triple::EABI); 1252 1253 while (Offset < length) { 1254 uint8_t Tag = data.GetU8(&Offset); 1255 uint32_t Size = data.GetU32(&Offset); 1256 1257 if (Tag != llvm::ARMBuildAttrs::File || Size == 0) 1258 continue; 1259 1260 while (Offset < length) { 1261 uint64_t Tag = data.GetULEB128(&Offset); 1262 switch (Tag) { 1263 default: 1264 if (Tag < 32) 1265 data.GetULEB128(&Offset); 1266 else if (Tag % 2 == 0) 1267 data.GetULEB128(&Offset); 1268 else 1269 data.GetCStr(&Offset); 1270 1271 break; 1272 1273 case llvm::ARMBuildAttrs::CPU_raw_name: 1274 case llvm::ARMBuildAttrs::CPU_name: 1275 data.GetCStr(&Offset); 1276 1277 break; 1278 1279 case llvm::ARMBuildAttrs::ABI_VFP_args: { 1280 uint64_t VFPArgs = data.GetULEB128(&Offset); 1281 1282 if (VFPArgs == llvm::ARMBuildAttrs::BaseAAPCS) { 1283 if (arch_spec.GetTriple().getEnvironment() == 1284 llvm::Triple::UnknownEnvironment || 1285 arch_spec.GetTriple().getEnvironment() == llvm::Triple::EABIHF) 1286 arch_spec.GetTriple().setEnvironment(llvm::Triple::EABI); 1287 1288 arch_spec.SetFlags(ArchSpec::eARM_abi_soft_float); 1289 } else if (VFPArgs == llvm::ARMBuildAttrs::HardFPAAPCS) { 1290 if (arch_spec.GetTriple().getEnvironment() == 1291 llvm::Triple::UnknownEnvironment || 1292 arch_spec.GetTriple().getEnvironment() == llvm::Triple::EABI) 1293 arch_spec.GetTriple().setEnvironment(llvm::Triple::EABIHF); 1294 1295 arch_spec.SetFlags(ArchSpec::eARM_abi_hard_float); 1296 } 1297 1298 break; 1299 } 1300 } 1301 } 1302 } 1303 } 1304 1305 // GetSectionHeaderInfo 1306 size_t ObjectFileELF::GetSectionHeaderInfo(SectionHeaderColl §ion_headers, 1307 DataExtractor &object_data, 1308 const elf::ELFHeader &header, 1309 lldb_private::UUID &uuid, 1310 std::string &gnu_debuglink_file, 1311 uint32_t &gnu_debuglink_crc, 1312 ArchSpec &arch_spec) { 1313 // Don't reparse the section headers if we already did that. 1314 if (!section_headers.empty()) 1315 return section_headers.size(); 1316 1317 // Only initialize the arch_spec to okay defaults if they're not already set. 1318 // We'll refine this with note data as we parse the notes. 1319 if (arch_spec.GetTriple().getOS() == llvm::Triple::OSType::UnknownOS) { 1320 llvm::Triple::OSType ostype; 1321 llvm::Triple::OSType spec_ostype; 1322 const uint32_t sub_type = subTypeFromElfHeader(header); 1323 arch_spec.SetArchitecture(eArchTypeELF, header.e_machine, sub_type, 1324 header.e_ident[EI_OSABI]); 1325 1326 // Validate if it is ok to remove GetOsFromOSABI. Note, that now the OS is 1327 // determined based on EI_OSABI flag and the info extracted from ELF notes 1328 // (see RefineModuleDetailsFromNote). However in some cases that still 1329 // might be not enough: for example a shared library might not have any 1330 // notes at all and have EI_OSABI flag set to System V, as result the OS 1331 // will be set to UnknownOS. 1332 GetOsFromOSABI(header.e_ident[EI_OSABI], ostype); 1333 spec_ostype = arch_spec.GetTriple().getOS(); 1334 assert(spec_ostype == ostype); 1335 UNUSED_IF_ASSERT_DISABLED(spec_ostype); 1336 } 1337 1338 if (arch_spec.GetMachine() == llvm::Triple::mips || 1339 arch_spec.GetMachine() == llvm::Triple::mipsel || 1340 arch_spec.GetMachine() == llvm::Triple::mips64 || 1341 arch_spec.GetMachine() == llvm::Triple::mips64el) { 1342 switch (header.e_flags & llvm::ELF::EF_MIPS_ARCH_ASE) { 1343 case llvm::ELF::EF_MIPS_MICROMIPS: 1344 arch_spec.SetFlags(ArchSpec::eMIPSAse_micromips); 1345 break; 1346 case llvm::ELF::EF_MIPS_ARCH_ASE_M16: 1347 arch_spec.SetFlags(ArchSpec::eMIPSAse_mips16); 1348 break; 1349 case llvm::ELF::EF_MIPS_ARCH_ASE_MDMX: 1350 arch_spec.SetFlags(ArchSpec::eMIPSAse_mdmx); 1351 break; 1352 default: 1353 break; 1354 } 1355 } 1356 1357 if (arch_spec.GetMachine() == llvm::Triple::arm || 1358 arch_spec.GetMachine() == llvm::Triple::thumb) { 1359 if (header.e_flags & llvm::ELF::EF_ARM_SOFT_FLOAT) 1360 arch_spec.SetFlags(ArchSpec::eARM_abi_soft_float); 1361 else if (header.e_flags & llvm::ELF::EF_ARM_VFP_FLOAT) 1362 arch_spec.SetFlags(ArchSpec::eARM_abi_hard_float); 1363 } 1364 1365 // If there are no section headers we are done. 1366 if (header.e_shnum == 0) 1367 return 0; 1368 1369 Log *log = GetLog(LLDBLog::Modules); 1370 1371 section_headers.resize(header.e_shnum); 1372 if (section_headers.size() != header.e_shnum) 1373 return 0; 1374 1375 const size_t sh_size = header.e_shnum * header.e_shentsize; 1376 const elf_off sh_offset = header.e_shoff; 1377 DataExtractor sh_data; 1378 if (sh_data.SetData(object_data, sh_offset, sh_size) != sh_size) 1379 return 0; 1380 1381 uint32_t idx; 1382 lldb::offset_t offset; 1383 for (idx = 0, offset = 0; idx < header.e_shnum; ++idx) { 1384 if (!section_headers[idx].Parse(sh_data, &offset)) 1385 break; 1386 } 1387 if (idx < section_headers.size()) 1388 section_headers.resize(idx); 1389 1390 const unsigned strtab_idx = header.e_shstrndx; 1391 if (strtab_idx && strtab_idx < section_headers.size()) { 1392 const ELFSectionHeaderInfo &sheader = section_headers[strtab_idx]; 1393 const size_t byte_size = sheader.sh_size; 1394 const Elf64_Off offset = sheader.sh_offset; 1395 lldb_private::DataExtractor shstr_data; 1396 1397 if (shstr_data.SetData(object_data, offset, byte_size) == byte_size) { 1398 for (SectionHeaderCollIter I = section_headers.begin(); 1399 I != section_headers.end(); ++I) { 1400 static ConstString g_sect_name_gnu_debuglink(".gnu_debuglink"); 1401 const ELFSectionHeaderInfo &sheader = *I; 1402 const uint64_t section_size = 1403 sheader.sh_type == SHT_NOBITS ? 0 : sheader.sh_size; 1404 ConstString name(shstr_data.PeekCStr(I->sh_name)); 1405 1406 I->section_name = name; 1407 1408 if (arch_spec.IsMIPS()) { 1409 uint32_t arch_flags = arch_spec.GetFlags(); 1410 DataExtractor data; 1411 if (sheader.sh_type == SHT_MIPS_ABIFLAGS) { 1412 1413 if (section_size && (data.SetData(object_data, sheader.sh_offset, 1414 section_size) == section_size)) { 1415 // MIPS ASE Mask is at offset 12 in MIPS.abiflags section 1416 lldb::offset_t offset = 12; // MIPS ABI Flags Version: 0 1417 arch_flags |= data.GetU32(&offset); 1418 1419 // The floating point ABI is at offset 7 1420 offset = 7; 1421 switch (data.GetU8(&offset)) { 1422 case llvm::Mips::Val_GNU_MIPS_ABI_FP_ANY: 1423 arch_flags |= lldb_private::ArchSpec::eMIPS_ABI_FP_ANY; 1424 break; 1425 case llvm::Mips::Val_GNU_MIPS_ABI_FP_DOUBLE: 1426 arch_flags |= lldb_private::ArchSpec::eMIPS_ABI_FP_DOUBLE; 1427 break; 1428 case llvm::Mips::Val_GNU_MIPS_ABI_FP_SINGLE: 1429 arch_flags |= lldb_private::ArchSpec::eMIPS_ABI_FP_SINGLE; 1430 break; 1431 case llvm::Mips::Val_GNU_MIPS_ABI_FP_SOFT: 1432 arch_flags |= lldb_private::ArchSpec::eMIPS_ABI_FP_SOFT; 1433 break; 1434 case llvm::Mips::Val_GNU_MIPS_ABI_FP_OLD_64: 1435 arch_flags |= lldb_private::ArchSpec::eMIPS_ABI_FP_OLD_64; 1436 break; 1437 case llvm::Mips::Val_GNU_MIPS_ABI_FP_XX: 1438 arch_flags |= lldb_private::ArchSpec::eMIPS_ABI_FP_XX; 1439 break; 1440 case llvm::Mips::Val_GNU_MIPS_ABI_FP_64: 1441 arch_flags |= lldb_private::ArchSpec::eMIPS_ABI_FP_64; 1442 break; 1443 case llvm::Mips::Val_GNU_MIPS_ABI_FP_64A: 1444 arch_flags |= lldb_private::ArchSpec::eMIPS_ABI_FP_64A; 1445 break; 1446 } 1447 } 1448 } 1449 // Settings appropriate ArchSpec ABI Flags 1450 switch (header.e_flags & llvm::ELF::EF_MIPS_ABI) { 1451 case llvm::ELF::EF_MIPS_ABI_O32: 1452 arch_flags |= lldb_private::ArchSpec::eMIPSABI_O32; 1453 break; 1454 case EF_MIPS_ABI_O64: 1455 arch_flags |= lldb_private::ArchSpec::eMIPSABI_O64; 1456 break; 1457 case EF_MIPS_ABI_EABI32: 1458 arch_flags |= lldb_private::ArchSpec::eMIPSABI_EABI32; 1459 break; 1460 case EF_MIPS_ABI_EABI64: 1461 arch_flags |= lldb_private::ArchSpec::eMIPSABI_EABI64; 1462 break; 1463 default: 1464 // ABI Mask doesn't cover N32 and N64 ABI. 1465 if (header.e_ident[EI_CLASS] == llvm::ELF::ELFCLASS64) 1466 arch_flags |= lldb_private::ArchSpec::eMIPSABI_N64; 1467 else if (header.e_flags & llvm::ELF::EF_MIPS_ABI2) 1468 arch_flags |= lldb_private::ArchSpec::eMIPSABI_N32; 1469 break; 1470 } 1471 arch_spec.SetFlags(arch_flags); 1472 } 1473 1474 if (arch_spec.GetMachine() == llvm::Triple::arm || 1475 arch_spec.GetMachine() == llvm::Triple::thumb) { 1476 DataExtractor data; 1477 1478 if (sheader.sh_type == SHT_ARM_ATTRIBUTES && section_size != 0 && 1479 data.SetData(object_data, sheader.sh_offset, section_size) == section_size) 1480 ParseARMAttributes(data, section_size, arch_spec); 1481 } 1482 1483 if (name == g_sect_name_gnu_debuglink) { 1484 DataExtractor data; 1485 if (section_size && (data.SetData(object_data, sheader.sh_offset, 1486 section_size) == section_size)) { 1487 lldb::offset_t gnu_debuglink_offset = 0; 1488 gnu_debuglink_file = data.GetCStr(&gnu_debuglink_offset); 1489 gnu_debuglink_offset = llvm::alignTo(gnu_debuglink_offset, 4); 1490 data.GetU32(&gnu_debuglink_offset, &gnu_debuglink_crc, 1); 1491 } 1492 } 1493 1494 // Process ELF note section entries. 1495 bool is_note_header = (sheader.sh_type == SHT_NOTE); 1496 1497 // The section header ".note.android.ident" is stored as a 1498 // PROGBITS type header but it is actually a note header. 1499 static ConstString g_sect_name_android_ident(".note.android.ident"); 1500 if (!is_note_header && name == g_sect_name_android_ident) 1501 is_note_header = true; 1502 1503 if (is_note_header) { 1504 // Allow notes to refine module info. 1505 DataExtractor data; 1506 if (section_size && (data.SetData(object_data, sheader.sh_offset, 1507 section_size) == section_size)) { 1508 Status error = RefineModuleDetailsFromNote(data, arch_spec, uuid); 1509 if (error.Fail()) { 1510 LLDB_LOGF(log, "ObjectFileELF::%s ELF note processing failed: %s", 1511 __FUNCTION__, error.AsCString()); 1512 } 1513 } 1514 } 1515 } 1516 1517 // Make any unknown triple components to be unspecified unknowns. 1518 if (arch_spec.GetTriple().getVendor() == llvm::Triple::UnknownVendor) 1519 arch_spec.GetTriple().setVendorName(llvm::StringRef()); 1520 if (arch_spec.GetTriple().getOS() == llvm::Triple::UnknownOS) 1521 arch_spec.GetTriple().setOSName(llvm::StringRef()); 1522 1523 return section_headers.size(); 1524 } 1525 } 1526 1527 section_headers.clear(); 1528 return 0; 1529 } 1530 1531 llvm::StringRef 1532 ObjectFileELF::StripLinkerSymbolAnnotations(llvm::StringRef symbol_name) const { 1533 size_t pos = symbol_name.find('@'); 1534 return symbol_name.substr(0, pos); 1535 } 1536 1537 // ParseSectionHeaders 1538 size_t ObjectFileELF::ParseSectionHeaders() { 1539 return GetSectionHeaderInfo(m_section_headers, m_data, m_header, m_uuid, 1540 m_gnu_debuglink_file, m_gnu_debuglink_crc, 1541 m_arch_spec); 1542 } 1543 1544 const ObjectFileELF::ELFSectionHeaderInfo * 1545 ObjectFileELF::GetSectionHeaderByIndex(lldb::user_id_t id) { 1546 if (!ParseSectionHeaders()) 1547 return nullptr; 1548 1549 if (id < m_section_headers.size()) 1550 return &m_section_headers[id]; 1551 1552 return nullptr; 1553 } 1554 1555 lldb::user_id_t ObjectFileELF::GetSectionIndexByName(const char *name) { 1556 if (!name || !name[0] || !ParseSectionHeaders()) 1557 return 0; 1558 for (size_t i = 1; i < m_section_headers.size(); ++i) 1559 if (m_section_headers[i].section_name == ConstString(name)) 1560 return i; 1561 return 0; 1562 } 1563 1564 static SectionType GetSectionTypeFromName(llvm::StringRef Name) { 1565 if (Name.consume_front(".debug_") || Name.consume_front(".zdebug_")) { 1566 return llvm::StringSwitch<SectionType>(Name) 1567 .Case("abbrev", eSectionTypeDWARFDebugAbbrev) 1568 .Case("abbrev.dwo", eSectionTypeDWARFDebugAbbrevDwo) 1569 .Case("addr", eSectionTypeDWARFDebugAddr) 1570 .Case("aranges", eSectionTypeDWARFDebugAranges) 1571 .Case("cu_index", eSectionTypeDWARFDebugCuIndex) 1572 .Case("frame", eSectionTypeDWARFDebugFrame) 1573 .Case("info", eSectionTypeDWARFDebugInfo) 1574 .Case("info.dwo", eSectionTypeDWARFDebugInfoDwo) 1575 .Cases("line", "line.dwo", eSectionTypeDWARFDebugLine) 1576 .Cases("line_str", "line_str.dwo", eSectionTypeDWARFDebugLineStr) 1577 .Case("loc", eSectionTypeDWARFDebugLoc) 1578 .Case("loc.dwo", eSectionTypeDWARFDebugLocDwo) 1579 .Case("loclists", eSectionTypeDWARFDebugLocLists) 1580 .Case("loclists.dwo", eSectionTypeDWARFDebugLocListsDwo) 1581 .Case("macinfo", eSectionTypeDWARFDebugMacInfo) 1582 .Cases("macro", "macro.dwo", eSectionTypeDWARFDebugMacro) 1583 .Case("names", eSectionTypeDWARFDebugNames) 1584 .Case("pubnames", eSectionTypeDWARFDebugPubNames) 1585 .Case("pubtypes", eSectionTypeDWARFDebugPubTypes) 1586 .Case("ranges", eSectionTypeDWARFDebugRanges) 1587 .Case("rnglists", eSectionTypeDWARFDebugRngLists) 1588 .Case("rnglists.dwo", eSectionTypeDWARFDebugRngListsDwo) 1589 .Case("str", eSectionTypeDWARFDebugStr) 1590 .Case("str.dwo", eSectionTypeDWARFDebugStrDwo) 1591 .Case("str_offsets", eSectionTypeDWARFDebugStrOffsets) 1592 .Case("str_offsets.dwo", eSectionTypeDWARFDebugStrOffsetsDwo) 1593 .Case("tu_index", eSectionTypeDWARFDebugTuIndex) 1594 .Case("types", eSectionTypeDWARFDebugTypes) 1595 .Case("types.dwo", eSectionTypeDWARFDebugTypesDwo) 1596 .Default(eSectionTypeOther); 1597 } 1598 return llvm::StringSwitch<SectionType>(Name) 1599 .Case(".ARM.exidx", eSectionTypeARMexidx) 1600 .Case(".ARM.extab", eSectionTypeARMextab) 1601 .Cases(".bss", ".tbss", eSectionTypeZeroFill) 1602 .Cases(".data", ".tdata", eSectionTypeData) 1603 .Case(".eh_frame", eSectionTypeEHFrame) 1604 .Case(".gnu_debugaltlink", eSectionTypeDWARFGNUDebugAltLink) 1605 .Case(".gosymtab", eSectionTypeGoSymtab) 1606 .Case(".text", eSectionTypeCode) 1607 .Default(eSectionTypeOther); 1608 } 1609 1610 SectionType ObjectFileELF::GetSectionType(const ELFSectionHeaderInfo &H) const { 1611 switch (H.sh_type) { 1612 case SHT_PROGBITS: 1613 if (H.sh_flags & SHF_EXECINSTR) 1614 return eSectionTypeCode; 1615 break; 1616 case SHT_SYMTAB: 1617 return eSectionTypeELFSymbolTable; 1618 case SHT_DYNSYM: 1619 return eSectionTypeELFDynamicSymbols; 1620 case SHT_RELA: 1621 case SHT_REL: 1622 return eSectionTypeELFRelocationEntries; 1623 case SHT_DYNAMIC: 1624 return eSectionTypeELFDynamicLinkInfo; 1625 } 1626 return GetSectionTypeFromName(H.section_name.GetStringRef()); 1627 } 1628 1629 static uint32_t GetTargetByteSize(SectionType Type, const ArchSpec &arch) { 1630 switch (Type) { 1631 case eSectionTypeData: 1632 case eSectionTypeZeroFill: 1633 return arch.GetDataByteSize(); 1634 case eSectionTypeCode: 1635 return arch.GetCodeByteSize(); 1636 default: 1637 return 1; 1638 } 1639 } 1640 1641 static Permissions GetPermissions(const ELFSectionHeader &H) { 1642 Permissions Perm = Permissions(0); 1643 if (H.sh_flags & SHF_ALLOC) 1644 Perm |= ePermissionsReadable; 1645 if (H.sh_flags & SHF_WRITE) 1646 Perm |= ePermissionsWritable; 1647 if (H.sh_flags & SHF_EXECINSTR) 1648 Perm |= ePermissionsExecutable; 1649 return Perm; 1650 } 1651 1652 static Permissions GetPermissions(const ELFProgramHeader &H) { 1653 Permissions Perm = Permissions(0); 1654 if (H.p_flags & PF_R) 1655 Perm |= ePermissionsReadable; 1656 if (H.p_flags & PF_W) 1657 Perm |= ePermissionsWritable; 1658 if (H.p_flags & PF_X) 1659 Perm |= ePermissionsExecutable; 1660 return Perm; 1661 } 1662 1663 namespace { 1664 1665 using VMRange = lldb_private::Range<addr_t, addr_t>; 1666 1667 struct SectionAddressInfo { 1668 SectionSP Segment; 1669 VMRange Range; 1670 }; 1671 1672 // (Unlinked) ELF object files usually have 0 for every section address, meaning 1673 // we need to compute synthetic addresses in order for "file addresses" from 1674 // different sections to not overlap. This class handles that logic. 1675 class VMAddressProvider { 1676 using VMMap = llvm::IntervalMap<addr_t, SectionSP, 4, 1677 llvm::IntervalMapHalfOpenInfo<addr_t>>; 1678 1679 ObjectFile::Type ObjectType; 1680 addr_t NextVMAddress = 0; 1681 VMMap::Allocator Alloc; 1682 VMMap Segments{Alloc}; 1683 VMMap Sections{Alloc}; 1684 lldb_private::Log *Log = GetLog(LLDBLog::Modules); 1685 size_t SegmentCount = 0; 1686 std::string SegmentName; 1687 1688 VMRange GetVMRange(const ELFSectionHeader &H) { 1689 addr_t Address = H.sh_addr; 1690 addr_t Size = H.sh_flags & SHF_ALLOC ? H.sh_size : 0; 1691 if (ObjectType == ObjectFile::Type::eTypeObjectFile && Segments.empty() && (H.sh_flags & SHF_ALLOC)) { 1692 NextVMAddress = 1693 llvm::alignTo(NextVMAddress, std::max<addr_t>(H.sh_addralign, 1)); 1694 Address = NextVMAddress; 1695 NextVMAddress += Size; 1696 } 1697 return VMRange(Address, Size); 1698 } 1699 1700 public: 1701 VMAddressProvider(ObjectFile::Type Type, llvm::StringRef SegmentName) 1702 : ObjectType(Type), SegmentName(std::string(SegmentName)) {} 1703 1704 std::string GetNextSegmentName() const { 1705 return llvm::formatv("{0}[{1}]", SegmentName, SegmentCount).str(); 1706 } 1707 1708 llvm::Optional<VMRange> GetAddressInfo(const ELFProgramHeader &H) { 1709 if (H.p_memsz == 0) { 1710 LLDB_LOG(Log, "Ignoring zero-sized {0} segment. Corrupt object file?", 1711 SegmentName); 1712 return llvm::None; 1713 } 1714 1715 if (Segments.overlaps(H.p_vaddr, H.p_vaddr + H.p_memsz)) { 1716 LLDB_LOG(Log, "Ignoring overlapping {0} segment. Corrupt object file?", 1717 SegmentName); 1718 return llvm::None; 1719 } 1720 return VMRange(H.p_vaddr, H.p_memsz); 1721 } 1722 1723 llvm::Optional<SectionAddressInfo> GetAddressInfo(const ELFSectionHeader &H) { 1724 VMRange Range = GetVMRange(H); 1725 SectionSP Segment; 1726 auto It = Segments.find(Range.GetRangeBase()); 1727 if ((H.sh_flags & SHF_ALLOC) && It.valid()) { 1728 addr_t MaxSize; 1729 if (It.start() <= Range.GetRangeBase()) { 1730 MaxSize = It.stop() - Range.GetRangeBase(); 1731 Segment = *It; 1732 } else 1733 MaxSize = It.start() - Range.GetRangeBase(); 1734 if (Range.GetByteSize() > MaxSize) { 1735 LLDB_LOG(Log, "Shortening section crossing segment boundaries. " 1736 "Corrupt object file?"); 1737 Range.SetByteSize(MaxSize); 1738 } 1739 } 1740 if (Range.GetByteSize() > 0 && 1741 Sections.overlaps(Range.GetRangeBase(), Range.GetRangeEnd())) { 1742 LLDB_LOG(Log, "Ignoring overlapping section. Corrupt object file?"); 1743 return llvm::None; 1744 } 1745 if (Segment) 1746 Range.Slide(-Segment->GetFileAddress()); 1747 return SectionAddressInfo{Segment, Range}; 1748 } 1749 1750 void AddSegment(const VMRange &Range, SectionSP Seg) { 1751 Segments.insert(Range.GetRangeBase(), Range.GetRangeEnd(), std::move(Seg)); 1752 ++SegmentCount; 1753 } 1754 1755 void AddSection(SectionAddressInfo Info, SectionSP Sect) { 1756 if (Info.Range.GetByteSize() == 0) 1757 return; 1758 if (Info.Segment) 1759 Info.Range.Slide(Info.Segment->GetFileAddress()); 1760 Sections.insert(Info.Range.GetRangeBase(), Info.Range.GetRangeEnd(), 1761 std::move(Sect)); 1762 } 1763 }; 1764 } 1765 1766 void ObjectFileELF::CreateSections(SectionList &unified_section_list) { 1767 if (m_sections_up) 1768 return; 1769 1770 m_sections_up = std::make_unique<SectionList>(); 1771 VMAddressProvider regular_provider(GetType(), "PT_LOAD"); 1772 VMAddressProvider tls_provider(GetType(), "PT_TLS"); 1773 1774 for (const auto &EnumPHdr : llvm::enumerate(ProgramHeaders())) { 1775 const ELFProgramHeader &PHdr = EnumPHdr.value(); 1776 if (PHdr.p_type != PT_LOAD && PHdr.p_type != PT_TLS) 1777 continue; 1778 1779 VMAddressProvider &provider = 1780 PHdr.p_type == PT_TLS ? tls_provider : regular_provider; 1781 auto InfoOr = provider.GetAddressInfo(PHdr); 1782 if (!InfoOr) 1783 continue; 1784 1785 uint32_t Log2Align = llvm::Log2_64(std::max<elf_xword>(PHdr.p_align, 1)); 1786 SectionSP Segment = std::make_shared<Section>( 1787 GetModule(), this, SegmentID(EnumPHdr.index()), 1788 ConstString(provider.GetNextSegmentName()), eSectionTypeContainer, 1789 InfoOr->GetRangeBase(), InfoOr->GetByteSize(), PHdr.p_offset, 1790 PHdr.p_filesz, Log2Align, /*flags*/ 0); 1791 Segment->SetPermissions(GetPermissions(PHdr)); 1792 Segment->SetIsThreadSpecific(PHdr.p_type == PT_TLS); 1793 m_sections_up->AddSection(Segment); 1794 1795 provider.AddSegment(*InfoOr, std::move(Segment)); 1796 } 1797 1798 ParseSectionHeaders(); 1799 if (m_section_headers.empty()) 1800 return; 1801 1802 for (SectionHeaderCollIter I = std::next(m_section_headers.begin()); 1803 I != m_section_headers.end(); ++I) { 1804 const ELFSectionHeaderInfo &header = *I; 1805 1806 ConstString &name = I->section_name; 1807 const uint64_t file_size = 1808 header.sh_type == SHT_NOBITS ? 0 : header.sh_size; 1809 1810 VMAddressProvider &provider = 1811 header.sh_flags & SHF_TLS ? tls_provider : regular_provider; 1812 auto InfoOr = provider.GetAddressInfo(header); 1813 if (!InfoOr) 1814 continue; 1815 1816 SectionType sect_type = GetSectionType(header); 1817 1818 const uint32_t target_bytes_size = 1819 GetTargetByteSize(sect_type, m_arch_spec); 1820 1821 elf::elf_xword log2align = 1822 (header.sh_addralign == 0) ? 0 : llvm::Log2_64(header.sh_addralign); 1823 1824 SectionSP section_sp(new Section( 1825 InfoOr->Segment, GetModule(), // Module to which this section belongs. 1826 this, // ObjectFile to which this section belongs and should 1827 // read section data from. 1828 SectionIndex(I), // Section ID. 1829 name, // Section name. 1830 sect_type, // Section type. 1831 InfoOr->Range.GetRangeBase(), // VM address. 1832 InfoOr->Range.GetByteSize(), // VM size in bytes of this section. 1833 header.sh_offset, // Offset of this section in the file. 1834 file_size, // Size of the section as found in the file. 1835 log2align, // Alignment of the section 1836 header.sh_flags, // Flags for this section. 1837 target_bytes_size)); // Number of host bytes per target byte 1838 1839 section_sp->SetPermissions(GetPermissions(header)); 1840 section_sp->SetIsThreadSpecific(header.sh_flags & SHF_TLS); 1841 (InfoOr->Segment ? InfoOr->Segment->GetChildren() : *m_sections_up) 1842 .AddSection(section_sp); 1843 provider.AddSection(std::move(*InfoOr), std::move(section_sp)); 1844 } 1845 1846 // For eTypeDebugInfo files, the Symbol Vendor will take care of updating the 1847 // unified section list. 1848 if (GetType() != eTypeDebugInfo) 1849 unified_section_list = *m_sections_up; 1850 1851 // If there's a .gnu_debugdata section, we'll try to read the .symtab that's 1852 // embedded in there and replace the one in the original object file (if any). 1853 // If there's none in the orignal object file, we add it to it. 1854 if (auto gdd_obj_file = GetGnuDebugDataObjectFile()) { 1855 if (auto gdd_objfile_section_list = gdd_obj_file->GetSectionList()) { 1856 if (SectionSP symtab_section_sp = 1857 gdd_objfile_section_list->FindSectionByType( 1858 eSectionTypeELFSymbolTable, true)) { 1859 SectionSP module_section_sp = unified_section_list.FindSectionByType( 1860 eSectionTypeELFSymbolTable, true); 1861 if (module_section_sp) 1862 unified_section_list.ReplaceSection(module_section_sp->GetID(), 1863 symtab_section_sp); 1864 else 1865 unified_section_list.AddSection(symtab_section_sp); 1866 } 1867 } 1868 } 1869 } 1870 1871 std::shared_ptr<ObjectFileELF> ObjectFileELF::GetGnuDebugDataObjectFile() { 1872 if (m_gnu_debug_data_object_file != nullptr) 1873 return m_gnu_debug_data_object_file; 1874 1875 SectionSP section = 1876 GetSectionList()->FindSectionByName(ConstString(".gnu_debugdata")); 1877 if (!section) 1878 return nullptr; 1879 1880 if (!lldb_private::lzma::isAvailable()) { 1881 GetModule()->ReportWarning( 1882 "No LZMA support found for reading .gnu_debugdata section"); 1883 return nullptr; 1884 } 1885 1886 // Uncompress the data 1887 DataExtractor data; 1888 section->GetSectionData(data); 1889 llvm::SmallVector<uint8_t, 0> uncompressedData; 1890 auto err = lldb_private::lzma::uncompress(data.GetData(), uncompressedData); 1891 if (err) { 1892 GetModule()->ReportWarning( 1893 "An error occurred while decompression the section %s: %s", 1894 section->GetName().AsCString(), llvm::toString(std::move(err)).c_str()); 1895 return nullptr; 1896 } 1897 1898 // Construct ObjectFileELF object from decompressed buffer 1899 DataBufferSP gdd_data_buf( 1900 new DataBufferHeap(uncompressedData.data(), uncompressedData.size())); 1901 auto fspec = GetFileSpec().CopyByAppendingPathComponent( 1902 llvm::StringRef("gnu_debugdata")); 1903 m_gnu_debug_data_object_file.reset(new ObjectFileELF( 1904 GetModule(), gdd_data_buf, 0, &fspec, 0, gdd_data_buf->GetByteSize())); 1905 1906 // This line is essential; otherwise a breakpoint can be set but not hit. 1907 m_gnu_debug_data_object_file->SetType(ObjectFile::eTypeDebugInfo); 1908 1909 ArchSpec spec = m_gnu_debug_data_object_file->GetArchitecture(); 1910 if (spec && m_gnu_debug_data_object_file->SetModulesArchitecture(spec)) 1911 return m_gnu_debug_data_object_file; 1912 1913 return nullptr; 1914 } 1915 1916 // Find the arm/aarch64 mapping symbol character in the given symbol name. 1917 // Mapping symbols have the form of "$<char>[.<any>]*". Additionally we 1918 // recognize cases when the mapping symbol prefixed by an arbitrary string 1919 // because if a symbol prefix added to each symbol in the object file with 1920 // objcopy then the mapping symbols are also prefixed. 1921 static char FindArmAarch64MappingSymbol(const char *symbol_name) { 1922 if (!symbol_name) 1923 return '\0'; 1924 1925 const char *dollar_pos = ::strchr(symbol_name, '$'); 1926 if (!dollar_pos || dollar_pos[1] == '\0') 1927 return '\0'; 1928 1929 if (dollar_pos[2] == '\0' || dollar_pos[2] == '.') 1930 return dollar_pos[1]; 1931 return '\0'; 1932 } 1933 1934 #define STO_MIPS_ISA (3 << 6) 1935 #define STO_MICROMIPS (2 << 6) 1936 #define IS_MICROMIPS(ST_OTHER) (((ST_OTHER)&STO_MIPS_ISA) == STO_MICROMIPS) 1937 1938 // private 1939 unsigned ObjectFileELF::ParseSymbols(Symtab *symtab, user_id_t start_id, 1940 SectionList *section_list, 1941 const size_t num_symbols, 1942 const DataExtractor &symtab_data, 1943 const DataExtractor &strtab_data) { 1944 ELFSymbol symbol; 1945 lldb::offset_t offset = 0; 1946 1947 static ConstString text_section_name(".text"); 1948 static ConstString init_section_name(".init"); 1949 static ConstString fini_section_name(".fini"); 1950 static ConstString ctors_section_name(".ctors"); 1951 static ConstString dtors_section_name(".dtors"); 1952 1953 static ConstString data_section_name(".data"); 1954 static ConstString rodata_section_name(".rodata"); 1955 static ConstString rodata1_section_name(".rodata1"); 1956 static ConstString data2_section_name(".data1"); 1957 static ConstString bss_section_name(".bss"); 1958 static ConstString opd_section_name(".opd"); // For ppc64 1959 1960 // On Android the oatdata and the oatexec symbols in the oat and odex files 1961 // covers the full .text section what causes issues with displaying unusable 1962 // symbol name to the user and very slow unwinding speed because the 1963 // instruction emulation based unwind plans try to emulate all instructions 1964 // in these symbols. Don't add these symbols to the symbol list as they have 1965 // no use for the debugger and they are causing a lot of trouble. Filtering 1966 // can't be restricted to Android because this special object file don't 1967 // contain the note section specifying the environment to Android but the 1968 // custom extension and file name makes it highly unlikely that this will 1969 // collide with anything else. 1970 ConstString file_extension = m_file.GetFileNameExtension(); 1971 bool skip_oatdata_oatexec = 1972 file_extension == ".oat" || file_extension == ".odex"; 1973 1974 ArchSpec arch = GetArchitecture(); 1975 ModuleSP module_sp(GetModule()); 1976 SectionList *module_section_list = 1977 module_sp ? module_sp->GetSectionList() : nullptr; 1978 1979 // Local cache to avoid doing a FindSectionByName for each symbol. The "const 1980 // char*" key must came from a ConstString object so they can be compared by 1981 // pointer 1982 std::unordered_map<const char *, lldb::SectionSP> section_name_to_section; 1983 1984 unsigned i; 1985 for (i = 0; i < num_symbols; ++i) { 1986 if (!symbol.Parse(symtab_data, &offset)) 1987 break; 1988 1989 const char *symbol_name = strtab_data.PeekCStr(symbol.st_name); 1990 if (!symbol_name) 1991 symbol_name = ""; 1992 1993 // No need to add non-section symbols that have no names 1994 if (symbol.getType() != STT_SECTION && 1995 (symbol_name == nullptr || symbol_name[0] == '\0')) 1996 continue; 1997 1998 // Skipping oatdata and oatexec sections if it is requested. See details 1999 // above the definition of skip_oatdata_oatexec for the reasons. 2000 if (skip_oatdata_oatexec && (::strcmp(symbol_name, "oatdata") == 0 || 2001 ::strcmp(symbol_name, "oatexec") == 0)) 2002 continue; 2003 2004 SectionSP symbol_section_sp; 2005 SymbolType symbol_type = eSymbolTypeInvalid; 2006 Elf64_Half shndx = symbol.st_shndx; 2007 2008 switch (shndx) { 2009 case SHN_ABS: 2010 symbol_type = eSymbolTypeAbsolute; 2011 break; 2012 case SHN_UNDEF: 2013 symbol_type = eSymbolTypeUndefined; 2014 break; 2015 default: 2016 symbol_section_sp = section_list->FindSectionByID(shndx); 2017 break; 2018 } 2019 2020 // If a symbol is undefined do not process it further even if it has a STT 2021 // type 2022 if (symbol_type != eSymbolTypeUndefined) { 2023 switch (symbol.getType()) { 2024 default: 2025 case STT_NOTYPE: 2026 // The symbol's type is not specified. 2027 break; 2028 2029 case STT_OBJECT: 2030 // The symbol is associated with a data object, such as a variable, an 2031 // array, etc. 2032 symbol_type = eSymbolTypeData; 2033 break; 2034 2035 case STT_FUNC: 2036 // The symbol is associated with a function or other executable code. 2037 symbol_type = eSymbolTypeCode; 2038 break; 2039 2040 case STT_SECTION: 2041 // The symbol is associated with a section. Symbol table entries of 2042 // this type exist primarily for relocation and normally have STB_LOCAL 2043 // binding. 2044 break; 2045 2046 case STT_FILE: 2047 // Conventionally, the symbol's name gives the name of the source file 2048 // associated with the object file. A file symbol has STB_LOCAL 2049 // binding, its section index is SHN_ABS, and it precedes the other 2050 // STB_LOCAL symbols for the file, if it is present. 2051 symbol_type = eSymbolTypeSourceFile; 2052 break; 2053 2054 case STT_GNU_IFUNC: 2055 // The symbol is associated with an indirect function. The actual 2056 // function will be resolved if it is referenced. 2057 symbol_type = eSymbolTypeResolver; 2058 break; 2059 } 2060 } 2061 2062 if (symbol_type == eSymbolTypeInvalid && symbol.getType() != STT_SECTION) { 2063 if (symbol_section_sp) { 2064 ConstString sect_name = symbol_section_sp->GetName(); 2065 if (sect_name == text_section_name || sect_name == init_section_name || 2066 sect_name == fini_section_name || sect_name == ctors_section_name || 2067 sect_name == dtors_section_name) { 2068 symbol_type = eSymbolTypeCode; 2069 } else if (sect_name == data_section_name || 2070 sect_name == data2_section_name || 2071 sect_name == rodata_section_name || 2072 sect_name == rodata1_section_name || 2073 sect_name == bss_section_name) { 2074 symbol_type = eSymbolTypeData; 2075 } 2076 } 2077 } 2078 2079 int64_t symbol_value_offset = 0; 2080 uint32_t additional_flags = 0; 2081 2082 if (arch.IsValid()) { 2083 if (arch.GetMachine() == llvm::Triple::arm) { 2084 if (symbol.getBinding() == STB_LOCAL) { 2085 char mapping_symbol = FindArmAarch64MappingSymbol(symbol_name); 2086 if (symbol_type == eSymbolTypeCode) { 2087 switch (mapping_symbol) { 2088 case 'a': 2089 // $a[.<any>]* - marks an ARM instruction sequence 2090 m_address_class_map[symbol.st_value] = AddressClass::eCode; 2091 break; 2092 case 'b': 2093 case 't': 2094 // $b[.<any>]* - marks a THUMB BL instruction sequence 2095 // $t[.<any>]* - marks a THUMB instruction sequence 2096 m_address_class_map[symbol.st_value] = 2097 AddressClass::eCodeAlternateISA; 2098 break; 2099 case 'd': 2100 // $d[.<any>]* - marks a data item sequence (e.g. lit pool) 2101 m_address_class_map[symbol.st_value] = AddressClass::eData; 2102 break; 2103 } 2104 } 2105 if (mapping_symbol) 2106 continue; 2107 } 2108 } else if (arch.GetMachine() == llvm::Triple::aarch64) { 2109 if (symbol.getBinding() == STB_LOCAL) { 2110 char mapping_symbol = FindArmAarch64MappingSymbol(symbol_name); 2111 if (symbol_type == eSymbolTypeCode) { 2112 switch (mapping_symbol) { 2113 case 'x': 2114 // $x[.<any>]* - marks an A64 instruction sequence 2115 m_address_class_map[symbol.st_value] = AddressClass::eCode; 2116 break; 2117 case 'd': 2118 // $d[.<any>]* - marks a data item sequence (e.g. lit pool) 2119 m_address_class_map[symbol.st_value] = AddressClass::eData; 2120 break; 2121 } 2122 } 2123 if (mapping_symbol) 2124 continue; 2125 } 2126 } 2127 2128 if (arch.GetMachine() == llvm::Triple::arm) { 2129 if (symbol_type == eSymbolTypeCode) { 2130 if (symbol.st_value & 1) { 2131 // Subtracting 1 from the address effectively unsets the low order 2132 // bit, which results in the address actually pointing to the 2133 // beginning of the symbol. This delta will be used below in 2134 // conjunction with symbol.st_value to produce the final 2135 // symbol_value that we store in the symtab. 2136 symbol_value_offset = -1; 2137 m_address_class_map[symbol.st_value ^ 1] = 2138 AddressClass::eCodeAlternateISA; 2139 } else { 2140 // This address is ARM 2141 m_address_class_map[symbol.st_value] = AddressClass::eCode; 2142 } 2143 } 2144 } 2145 2146 /* 2147 * MIPS: 2148 * The bit #0 of an address is used for ISA mode (1 for microMIPS, 0 for 2149 * MIPS). 2150 * This allows processor to switch between microMIPS and MIPS without any 2151 * need 2152 * for special mode-control register. However, apart from .debug_line, 2153 * none of 2154 * the ELF/DWARF sections set the ISA bit (for symbol or section). Use 2155 * st_other 2156 * flag to check whether the symbol is microMIPS and then set the address 2157 * class 2158 * accordingly. 2159 */ 2160 if (arch.IsMIPS()) { 2161 if (IS_MICROMIPS(symbol.st_other)) 2162 m_address_class_map[symbol.st_value] = AddressClass::eCodeAlternateISA; 2163 else if ((symbol.st_value & 1) && (symbol_type == eSymbolTypeCode)) { 2164 symbol.st_value = symbol.st_value & (~1ull); 2165 m_address_class_map[symbol.st_value] = AddressClass::eCodeAlternateISA; 2166 } else { 2167 if (symbol_type == eSymbolTypeCode) 2168 m_address_class_map[symbol.st_value] = AddressClass::eCode; 2169 else if (symbol_type == eSymbolTypeData) 2170 m_address_class_map[symbol.st_value] = AddressClass::eData; 2171 else 2172 m_address_class_map[symbol.st_value] = AddressClass::eUnknown; 2173 } 2174 } 2175 } 2176 2177 // symbol_value_offset may contain 0 for ARM symbols or -1 for THUMB 2178 // symbols. See above for more details. 2179 uint64_t symbol_value = symbol.st_value + symbol_value_offset; 2180 2181 if (symbol_section_sp == nullptr && shndx == SHN_ABS && 2182 symbol.st_size != 0) { 2183 // We don't have a section for a symbol with non-zero size. Create a new 2184 // section for it so the address range covered by the symbol is also 2185 // covered by the module (represented through the section list). It is 2186 // needed so module lookup for the addresses covered by this symbol will 2187 // be successfull. This case happens for absolute symbols. 2188 ConstString fake_section_name(std::string(".absolute.") + symbol_name); 2189 symbol_section_sp = 2190 std::make_shared<Section>(module_sp, this, SHN_ABS, fake_section_name, 2191 eSectionTypeAbsoluteAddress, symbol_value, 2192 symbol.st_size, 0, 0, 0, SHF_ALLOC); 2193 2194 module_section_list->AddSection(symbol_section_sp); 2195 section_list->AddSection(symbol_section_sp); 2196 } 2197 2198 if (symbol_section_sp && 2199 CalculateType() != ObjectFile::Type::eTypeObjectFile) 2200 symbol_value -= symbol_section_sp->GetFileAddress(); 2201 2202 if (symbol_section_sp && module_section_list && 2203 module_section_list != section_list) { 2204 ConstString sect_name = symbol_section_sp->GetName(); 2205 auto section_it = section_name_to_section.find(sect_name.GetCString()); 2206 if (section_it == section_name_to_section.end()) 2207 section_it = 2208 section_name_to_section 2209 .emplace(sect_name.GetCString(), 2210 module_section_list->FindSectionByName(sect_name)) 2211 .first; 2212 if (section_it->second) 2213 symbol_section_sp = section_it->second; 2214 } 2215 2216 bool is_global = symbol.getBinding() == STB_GLOBAL; 2217 uint32_t flags = symbol.st_other << 8 | symbol.st_info | additional_flags; 2218 llvm::StringRef symbol_ref(symbol_name); 2219 2220 // Symbol names may contain @VERSION suffixes. Find those and strip them 2221 // temporarily. 2222 size_t version_pos = symbol_ref.find('@'); 2223 bool has_suffix = version_pos != llvm::StringRef::npos; 2224 llvm::StringRef symbol_bare = symbol_ref.substr(0, version_pos); 2225 Mangled mangled(symbol_bare); 2226 2227 // Now append the suffix back to mangled and unmangled names. Only do it if 2228 // the demangling was successful (string is not empty). 2229 if (has_suffix) { 2230 llvm::StringRef suffix = symbol_ref.substr(version_pos); 2231 2232 llvm::StringRef mangled_name = mangled.GetMangledName().GetStringRef(); 2233 if (!mangled_name.empty()) 2234 mangled.SetMangledName(ConstString((mangled_name + suffix).str())); 2235 2236 ConstString demangled = mangled.GetDemangledName(); 2237 llvm::StringRef demangled_name = demangled.GetStringRef(); 2238 if (!demangled_name.empty()) 2239 mangled.SetDemangledName(ConstString((demangled_name + suffix).str())); 2240 } 2241 2242 // In ELF all symbol should have a valid size but it is not true for some 2243 // function symbols coming from hand written assembly. As none of the 2244 // function symbol should have 0 size we try to calculate the size for 2245 // these symbols in the symtab with saying that their original size is not 2246 // valid. 2247 bool symbol_size_valid = 2248 symbol.st_size != 0 || symbol.getType() != STT_FUNC; 2249 2250 Symbol dc_symbol( 2251 i + start_id, // ID is the original symbol table index. 2252 mangled, 2253 symbol_type, // Type of this symbol 2254 is_global, // Is this globally visible? 2255 false, // Is this symbol debug info? 2256 false, // Is this symbol a trampoline? 2257 false, // Is this symbol artificial? 2258 AddressRange(symbol_section_sp, // Section in which this symbol is 2259 // defined or null. 2260 symbol_value, // Offset in section or symbol value. 2261 symbol.st_size), // Size in bytes of this symbol. 2262 symbol_size_valid, // Symbol size is valid 2263 has_suffix, // Contains linker annotations? 2264 flags); // Symbol flags. 2265 if (symbol.getBinding() == STB_WEAK) 2266 dc_symbol.SetIsWeak(true); 2267 symtab->AddSymbol(dc_symbol); 2268 } 2269 return i; 2270 } 2271 2272 unsigned ObjectFileELF::ParseSymbolTable(Symtab *symbol_table, 2273 user_id_t start_id, 2274 lldb_private::Section *symtab) { 2275 if (symtab->GetObjectFile() != this) { 2276 // If the symbol table section is owned by a different object file, have it 2277 // do the parsing. 2278 ObjectFileELF *obj_file_elf = 2279 static_cast<ObjectFileELF *>(symtab->GetObjectFile()); 2280 return obj_file_elf->ParseSymbolTable(symbol_table, start_id, symtab); 2281 } 2282 2283 // Get section list for this object file. 2284 SectionList *section_list = m_sections_up.get(); 2285 if (!section_list) 2286 return 0; 2287 2288 user_id_t symtab_id = symtab->GetID(); 2289 const ELFSectionHeaderInfo *symtab_hdr = GetSectionHeaderByIndex(symtab_id); 2290 assert(symtab_hdr->sh_type == SHT_SYMTAB || 2291 symtab_hdr->sh_type == SHT_DYNSYM); 2292 2293 // sh_link: section header index of associated string table. 2294 user_id_t strtab_id = symtab_hdr->sh_link; 2295 Section *strtab = section_list->FindSectionByID(strtab_id).get(); 2296 2297 if (symtab && strtab) { 2298 assert(symtab->GetObjectFile() == this); 2299 assert(strtab->GetObjectFile() == this); 2300 2301 DataExtractor symtab_data; 2302 DataExtractor strtab_data; 2303 if (ReadSectionData(symtab, symtab_data) && 2304 ReadSectionData(strtab, strtab_data)) { 2305 size_t num_symbols = symtab_data.GetByteSize() / symtab_hdr->sh_entsize; 2306 2307 return ParseSymbols(symbol_table, start_id, section_list, num_symbols, 2308 symtab_data, strtab_data); 2309 } 2310 } 2311 2312 return 0; 2313 } 2314 2315 size_t ObjectFileELF::ParseDynamicSymbols() { 2316 if (m_dynamic_symbols.size()) 2317 return m_dynamic_symbols.size(); 2318 2319 SectionList *section_list = GetSectionList(); 2320 if (!section_list) 2321 return 0; 2322 2323 // Find the SHT_DYNAMIC section. 2324 Section *dynsym = 2325 section_list->FindSectionByType(eSectionTypeELFDynamicLinkInfo, true) 2326 .get(); 2327 if (!dynsym) 2328 return 0; 2329 assert(dynsym->GetObjectFile() == this); 2330 2331 ELFDynamic symbol; 2332 DataExtractor dynsym_data; 2333 if (ReadSectionData(dynsym, dynsym_data)) { 2334 const lldb::offset_t section_size = dynsym_data.GetByteSize(); 2335 lldb::offset_t cursor = 0; 2336 2337 while (cursor < section_size) { 2338 if (!symbol.Parse(dynsym_data, &cursor)) 2339 break; 2340 2341 m_dynamic_symbols.push_back(symbol); 2342 } 2343 } 2344 2345 return m_dynamic_symbols.size(); 2346 } 2347 2348 const ELFDynamic *ObjectFileELF::FindDynamicSymbol(unsigned tag) { 2349 if (!ParseDynamicSymbols()) 2350 return nullptr; 2351 2352 DynamicSymbolCollIter I = m_dynamic_symbols.begin(); 2353 DynamicSymbolCollIter E = m_dynamic_symbols.end(); 2354 for (; I != E; ++I) { 2355 ELFDynamic *symbol = &*I; 2356 2357 if (symbol->d_tag == tag) 2358 return symbol; 2359 } 2360 2361 return nullptr; 2362 } 2363 2364 unsigned ObjectFileELF::PLTRelocationType() { 2365 // DT_PLTREL 2366 // This member specifies the type of relocation entry to which the 2367 // procedure linkage table refers. The d_val member holds DT_REL or 2368 // DT_RELA, as appropriate. All relocations in a procedure linkage table 2369 // must use the same relocation. 2370 const ELFDynamic *symbol = FindDynamicSymbol(DT_PLTREL); 2371 2372 if (symbol) 2373 return symbol->d_val; 2374 2375 return 0; 2376 } 2377 2378 // Returns the size of the normal plt entries and the offset of the first 2379 // normal plt entry. The 0th entry in the plt table is usually a resolution 2380 // entry which have different size in some architectures then the rest of the 2381 // plt entries. 2382 static std::pair<uint64_t, uint64_t> 2383 GetPltEntrySizeAndOffset(const ELFSectionHeader *rel_hdr, 2384 const ELFSectionHeader *plt_hdr) { 2385 const elf_xword num_relocations = rel_hdr->sh_size / rel_hdr->sh_entsize; 2386 2387 // Clang 3.3 sets entsize to 4 for 32-bit binaries, but the plt entries are 2388 // 16 bytes. So round the entsize up by the alignment if addralign is set. 2389 elf_xword plt_entsize = 2390 plt_hdr->sh_addralign 2391 ? llvm::alignTo(plt_hdr->sh_entsize, plt_hdr->sh_addralign) 2392 : plt_hdr->sh_entsize; 2393 2394 // Some linkers e.g ld for arm, fill plt_hdr->sh_entsize field incorrectly. 2395 // PLT entries relocation code in general requires multiple instruction and 2396 // should be greater than 4 bytes in most cases. Try to guess correct size 2397 // just in case. 2398 if (plt_entsize <= 4) { 2399 // The linker haven't set the plt_hdr->sh_entsize field. Try to guess the 2400 // size of the plt entries based on the number of entries and the size of 2401 // the plt section with the assumption that the size of the 0th entry is at 2402 // least as big as the size of the normal entries and it isn't much bigger 2403 // then that. 2404 if (plt_hdr->sh_addralign) 2405 plt_entsize = plt_hdr->sh_size / plt_hdr->sh_addralign / 2406 (num_relocations + 1) * plt_hdr->sh_addralign; 2407 else 2408 plt_entsize = plt_hdr->sh_size / (num_relocations + 1); 2409 } 2410 2411 elf_xword plt_offset = plt_hdr->sh_size - num_relocations * plt_entsize; 2412 2413 return std::make_pair(plt_entsize, plt_offset); 2414 } 2415 2416 static unsigned ParsePLTRelocations( 2417 Symtab *symbol_table, user_id_t start_id, unsigned rel_type, 2418 const ELFHeader *hdr, const ELFSectionHeader *rel_hdr, 2419 const ELFSectionHeader *plt_hdr, const ELFSectionHeader *sym_hdr, 2420 const lldb::SectionSP &plt_section_sp, DataExtractor &rel_data, 2421 DataExtractor &symtab_data, DataExtractor &strtab_data) { 2422 ELFRelocation rel(rel_type); 2423 ELFSymbol symbol; 2424 lldb::offset_t offset = 0; 2425 2426 uint64_t plt_offset, plt_entsize; 2427 std::tie(plt_entsize, plt_offset) = 2428 GetPltEntrySizeAndOffset(rel_hdr, plt_hdr); 2429 const elf_xword num_relocations = rel_hdr->sh_size / rel_hdr->sh_entsize; 2430 2431 typedef unsigned (*reloc_info_fn)(const ELFRelocation &rel); 2432 reloc_info_fn reloc_type; 2433 reloc_info_fn reloc_symbol; 2434 2435 if (hdr->Is32Bit()) { 2436 reloc_type = ELFRelocation::RelocType32; 2437 reloc_symbol = ELFRelocation::RelocSymbol32; 2438 } else { 2439 reloc_type = ELFRelocation::RelocType64; 2440 reloc_symbol = ELFRelocation::RelocSymbol64; 2441 } 2442 2443 unsigned slot_type = hdr->GetRelocationJumpSlotType(); 2444 unsigned i; 2445 for (i = 0; i < num_relocations; ++i) { 2446 if (!rel.Parse(rel_data, &offset)) 2447 break; 2448 2449 if (reloc_type(rel) != slot_type) 2450 continue; 2451 2452 lldb::offset_t symbol_offset = reloc_symbol(rel) * sym_hdr->sh_entsize; 2453 if (!symbol.Parse(symtab_data, &symbol_offset)) 2454 break; 2455 2456 const char *symbol_name = strtab_data.PeekCStr(symbol.st_name); 2457 uint64_t plt_index = plt_offset + i * plt_entsize; 2458 2459 Symbol jump_symbol( 2460 i + start_id, // Symbol table index 2461 symbol_name, // symbol name. 2462 eSymbolTypeTrampoline, // Type of this symbol 2463 false, // Is this globally visible? 2464 false, // Is this symbol debug info? 2465 true, // Is this symbol a trampoline? 2466 true, // Is this symbol artificial? 2467 plt_section_sp, // Section in which this symbol is defined or null. 2468 plt_index, // Offset in section or symbol value. 2469 plt_entsize, // Size in bytes of this symbol. 2470 true, // Size is valid 2471 false, // Contains linker annotations? 2472 0); // Symbol flags. 2473 2474 symbol_table->AddSymbol(jump_symbol); 2475 } 2476 2477 return i; 2478 } 2479 2480 unsigned 2481 ObjectFileELF::ParseTrampolineSymbols(Symtab *symbol_table, user_id_t start_id, 2482 const ELFSectionHeaderInfo *rel_hdr, 2483 user_id_t rel_id) { 2484 assert(rel_hdr->sh_type == SHT_RELA || rel_hdr->sh_type == SHT_REL); 2485 2486 // The link field points to the associated symbol table. 2487 user_id_t symtab_id = rel_hdr->sh_link; 2488 2489 // If the link field doesn't point to the appropriate symbol name table then 2490 // try to find it by name as some compiler don't fill in the link fields. 2491 if (!symtab_id) 2492 symtab_id = GetSectionIndexByName(".dynsym"); 2493 2494 // Get PLT section. We cannot use rel_hdr->sh_info, since current linkers 2495 // point that to the .got.plt or .got section instead of .plt. 2496 user_id_t plt_id = GetSectionIndexByName(".plt"); 2497 2498 if (!symtab_id || !plt_id) 2499 return 0; 2500 2501 const ELFSectionHeaderInfo *plt_hdr = GetSectionHeaderByIndex(plt_id); 2502 if (!plt_hdr) 2503 return 0; 2504 2505 const ELFSectionHeaderInfo *sym_hdr = GetSectionHeaderByIndex(symtab_id); 2506 if (!sym_hdr) 2507 return 0; 2508 2509 SectionList *section_list = m_sections_up.get(); 2510 if (!section_list) 2511 return 0; 2512 2513 Section *rel_section = section_list->FindSectionByID(rel_id).get(); 2514 if (!rel_section) 2515 return 0; 2516 2517 SectionSP plt_section_sp(section_list->FindSectionByID(plt_id)); 2518 if (!plt_section_sp) 2519 return 0; 2520 2521 Section *symtab = section_list->FindSectionByID(symtab_id).get(); 2522 if (!symtab) 2523 return 0; 2524 2525 // sh_link points to associated string table. 2526 Section *strtab = section_list->FindSectionByID(sym_hdr->sh_link).get(); 2527 if (!strtab) 2528 return 0; 2529 2530 DataExtractor rel_data; 2531 if (!ReadSectionData(rel_section, rel_data)) 2532 return 0; 2533 2534 DataExtractor symtab_data; 2535 if (!ReadSectionData(symtab, symtab_data)) 2536 return 0; 2537 2538 DataExtractor strtab_data; 2539 if (!ReadSectionData(strtab, strtab_data)) 2540 return 0; 2541 2542 unsigned rel_type = PLTRelocationType(); 2543 if (!rel_type) 2544 return 0; 2545 2546 return ParsePLTRelocations(symbol_table, start_id, rel_type, &m_header, 2547 rel_hdr, plt_hdr, sym_hdr, plt_section_sp, 2548 rel_data, symtab_data, strtab_data); 2549 } 2550 2551 unsigned ObjectFileELF::ApplyRelocations( 2552 Symtab *symtab, const ELFHeader *hdr, const ELFSectionHeader *rel_hdr, 2553 const ELFSectionHeader *symtab_hdr, const ELFSectionHeader *debug_hdr, 2554 DataExtractor &rel_data, DataExtractor &symtab_data, 2555 DataExtractor &debug_data, Section *rel_section) { 2556 ELFRelocation rel(rel_hdr->sh_type); 2557 lldb::addr_t offset = 0; 2558 const unsigned num_relocations = rel_hdr->sh_size / rel_hdr->sh_entsize; 2559 typedef unsigned (*reloc_info_fn)(const ELFRelocation &rel); 2560 reloc_info_fn reloc_type; 2561 reloc_info_fn reloc_symbol; 2562 2563 if (hdr->Is32Bit()) { 2564 reloc_type = ELFRelocation::RelocType32; 2565 reloc_symbol = ELFRelocation::RelocSymbol32; 2566 } else { 2567 reloc_type = ELFRelocation::RelocType64; 2568 reloc_symbol = ELFRelocation::RelocSymbol64; 2569 } 2570 2571 for (unsigned i = 0; i < num_relocations; ++i) { 2572 if (!rel.Parse(rel_data, &offset)) 2573 break; 2574 2575 Symbol *symbol = nullptr; 2576 2577 if (hdr->Is32Bit()) { 2578 switch (reloc_type(rel)) { 2579 case R_386_32: 2580 case R_386_PC32: 2581 default: 2582 // FIXME: This asserts with this input: 2583 // 2584 // foo.cpp 2585 // int main(int argc, char **argv) { return 0; } 2586 // 2587 // clang++.exe --target=i686-unknown-linux-gnu -g -c foo.cpp -o foo.o 2588 // 2589 // and running this on the foo.o module. 2590 assert(false && "unexpected relocation type"); 2591 } 2592 } else { 2593 switch (reloc_type(rel)) { 2594 case R_AARCH64_ABS64: 2595 case R_X86_64_64: { 2596 symbol = symtab->FindSymbolByID(reloc_symbol(rel)); 2597 if (symbol) { 2598 addr_t value = symbol->GetAddressRef().GetFileAddress(); 2599 DataBufferSP &data_buffer_sp = debug_data.GetSharedDataBuffer(); 2600 uint64_t *dst = reinterpret_cast<uint64_t *>( 2601 data_buffer_sp->GetBytes() + rel_section->GetFileOffset() + 2602 ELFRelocation::RelocOffset64(rel)); 2603 uint64_t val_offset = value + ELFRelocation::RelocAddend64(rel); 2604 memcpy(dst, &val_offset, sizeof(uint64_t)); 2605 } 2606 break; 2607 } 2608 case R_X86_64_32: 2609 case R_X86_64_32S: 2610 case R_AARCH64_ABS32: { 2611 symbol = symtab->FindSymbolByID(reloc_symbol(rel)); 2612 if (symbol) { 2613 addr_t value = symbol->GetAddressRef().GetFileAddress(); 2614 value += ELFRelocation::RelocAddend32(rel); 2615 if ((reloc_type(rel) == R_X86_64_32 && (value > UINT32_MAX)) || 2616 (reloc_type(rel) == R_X86_64_32S && 2617 ((int64_t)value > INT32_MAX && (int64_t)value < INT32_MIN)) || 2618 (reloc_type(rel) == R_AARCH64_ABS32 && 2619 ((int64_t)value > INT32_MAX && (int64_t)value < INT32_MIN))) { 2620 Log *log = GetLog(LLDBLog::Modules); 2621 LLDB_LOGF(log, "Failed to apply debug info relocations"); 2622 break; 2623 } 2624 uint32_t truncated_addr = (value & 0xFFFFFFFF); 2625 DataBufferSP &data_buffer_sp = debug_data.GetSharedDataBuffer(); 2626 uint32_t *dst = reinterpret_cast<uint32_t *>( 2627 data_buffer_sp->GetBytes() + rel_section->GetFileOffset() + 2628 ELFRelocation::RelocOffset32(rel)); 2629 memcpy(dst, &truncated_addr, sizeof(uint32_t)); 2630 } 2631 break; 2632 } 2633 case R_X86_64_PC32: 2634 default: 2635 assert(false && "unexpected relocation type"); 2636 } 2637 } 2638 } 2639 2640 return 0; 2641 } 2642 2643 unsigned ObjectFileELF::RelocateDebugSections(const ELFSectionHeader *rel_hdr, 2644 user_id_t rel_id, 2645 lldb_private::Symtab *thetab) { 2646 assert(rel_hdr->sh_type == SHT_RELA || rel_hdr->sh_type == SHT_REL); 2647 2648 // Parse in the section list if needed. 2649 SectionList *section_list = GetSectionList(); 2650 if (!section_list) 2651 return 0; 2652 2653 user_id_t symtab_id = rel_hdr->sh_link; 2654 user_id_t debug_id = rel_hdr->sh_info; 2655 2656 const ELFSectionHeader *symtab_hdr = GetSectionHeaderByIndex(symtab_id); 2657 if (!symtab_hdr) 2658 return 0; 2659 2660 const ELFSectionHeader *debug_hdr = GetSectionHeaderByIndex(debug_id); 2661 if (!debug_hdr) 2662 return 0; 2663 2664 Section *rel = section_list->FindSectionByID(rel_id).get(); 2665 if (!rel) 2666 return 0; 2667 2668 Section *symtab = section_list->FindSectionByID(symtab_id).get(); 2669 if (!symtab) 2670 return 0; 2671 2672 Section *debug = section_list->FindSectionByID(debug_id).get(); 2673 if (!debug) 2674 return 0; 2675 2676 DataExtractor rel_data; 2677 DataExtractor symtab_data; 2678 DataExtractor debug_data; 2679 2680 if (GetData(rel->GetFileOffset(), rel->GetFileSize(), rel_data) && 2681 GetData(symtab->GetFileOffset(), symtab->GetFileSize(), symtab_data) && 2682 GetData(debug->GetFileOffset(), debug->GetFileSize(), debug_data)) { 2683 ApplyRelocations(thetab, &m_header, rel_hdr, symtab_hdr, debug_hdr, 2684 rel_data, symtab_data, debug_data, debug); 2685 } 2686 2687 return 0; 2688 } 2689 2690 void ObjectFileELF::ParseSymtab(Symtab &lldb_symtab) { 2691 ModuleSP module_sp(GetModule()); 2692 if (!module_sp) 2693 return; 2694 2695 Progress progress( 2696 llvm::formatv("Parsing symbol table for {0}", 2697 m_file.GetFilename().AsCString("<Unknown>"))); 2698 ElapsedTime elapsed(module_sp->GetSymtabParseTime()); 2699 2700 // We always want to use the main object file so we (hopefully) only have one 2701 // cached copy of our symtab, dynamic sections, etc. 2702 ObjectFile *module_obj_file = module_sp->GetObjectFile(); 2703 if (module_obj_file && module_obj_file != this) 2704 return module_obj_file->ParseSymtab(lldb_symtab); 2705 2706 SectionList *section_list = module_sp->GetSectionList(); 2707 if (!section_list) 2708 return; 2709 2710 uint64_t symbol_id = 0; 2711 2712 // Sharable objects and dynamic executables usually have 2 distinct symbol 2713 // tables, one named ".symtab", and the other ".dynsym". The dynsym is a 2714 // smaller version of the symtab that only contains global symbols. The 2715 // information found in the dynsym is therefore also found in the symtab, 2716 // while the reverse is not necessarily true. 2717 Section *symtab = 2718 section_list->FindSectionByType(eSectionTypeELFSymbolTable, true).get(); 2719 if (symtab) 2720 symbol_id += ParseSymbolTable(&lldb_symtab, symbol_id, symtab); 2721 2722 // The symtab section is non-allocable and can be stripped, while the 2723 // .dynsym section which should always be always be there. To support the 2724 // minidebuginfo case we parse .dynsym when there's a .gnu_debuginfo 2725 // section, nomatter if .symtab was already parsed or not. This is because 2726 // minidebuginfo normally removes the .symtab symbols which have their 2727 // matching .dynsym counterparts. 2728 if (!symtab || 2729 GetSectionList()->FindSectionByName(ConstString(".gnu_debugdata"))) { 2730 Section *dynsym = 2731 section_list->FindSectionByType(eSectionTypeELFDynamicSymbols, true) 2732 .get(); 2733 if (dynsym) 2734 symbol_id += ParseSymbolTable(&lldb_symtab, symbol_id, dynsym); 2735 } 2736 2737 // DT_JMPREL 2738 // If present, this entry's d_ptr member holds the address of 2739 // relocation 2740 // entries associated solely with the procedure linkage table. 2741 // Separating 2742 // these relocation entries lets the dynamic linker ignore them during 2743 // process initialization, if lazy binding is enabled. If this entry is 2744 // present, the related entries of types DT_PLTRELSZ and DT_PLTREL must 2745 // also be present. 2746 const ELFDynamic *symbol = FindDynamicSymbol(DT_JMPREL); 2747 if (symbol) { 2748 // Synthesize trampoline symbols to help navigate the PLT. 2749 addr_t addr = symbol->d_ptr; 2750 Section *reloc_section = 2751 section_list->FindSectionContainingFileAddress(addr).get(); 2752 if (reloc_section) { 2753 user_id_t reloc_id = reloc_section->GetID(); 2754 const ELFSectionHeaderInfo *reloc_header = 2755 GetSectionHeaderByIndex(reloc_id); 2756 if (reloc_header) 2757 ParseTrampolineSymbols(&lldb_symtab, symbol_id, reloc_header, reloc_id); 2758 } 2759 } 2760 2761 if (DWARFCallFrameInfo *eh_frame = 2762 GetModule()->GetUnwindTable().GetEHFrameInfo()) { 2763 ParseUnwindSymbols(&lldb_symtab, eh_frame); 2764 } 2765 2766 // In the event that there's no symbol entry for the entry point we'll 2767 // artificially create one. We delegate to the symtab object the figuring 2768 // out of the proper size, this will usually make it span til the next 2769 // symbol it finds in the section. This means that if there are missing 2770 // symbols the entry point might span beyond its function definition. 2771 // We're fine with this as it doesn't make it worse than not having a 2772 // symbol entry at all. 2773 if (CalculateType() == eTypeExecutable) { 2774 ArchSpec arch = GetArchitecture(); 2775 auto entry_point_addr = GetEntryPointAddress(); 2776 bool is_valid_entry_point = 2777 entry_point_addr.IsValid() && entry_point_addr.IsSectionOffset(); 2778 addr_t entry_point_file_addr = entry_point_addr.GetFileAddress(); 2779 if (is_valid_entry_point && !lldb_symtab.FindSymbolContainingFileAddress( 2780 entry_point_file_addr)) { 2781 uint64_t symbol_id = lldb_symtab.GetNumSymbols(); 2782 // Don't set the name for any synthetic symbols, the Symbol 2783 // object will generate one if needed when the name is accessed 2784 // via accessors. 2785 SectionSP section_sp = entry_point_addr.GetSection(); 2786 Symbol symbol( 2787 /*symID=*/symbol_id, 2788 /*name=*/llvm::StringRef(), // Name will be auto generated. 2789 /*type=*/eSymbolTypeCode, 2790 /*external=*/true, 2791 /*is_debug=*/false, 2792 /*is_trampoline=*/false, 2793 /*is_artificial=*/true, 2794 /*section_sp=*/section_sp, 2795 /*offset=*/0, 2796 /*size=*/0, // FDE can span multiple symbols so don't use its size. 2797 /*size_is_valid=*/false, 2798 /*contains_linker_annotations=*/false, 2799 /*flags=*/0); 2800 // When the entry point is arm thumb we need to explicitly set its 2801 // class address to reflect that. This is important because expression 2802 // evaluation relies on correctly setting a breakpoint at this 2803 // address. 2804 if (arch.GetMachine() == llvm::Triple::arm && 2805 (entry_point_file_addr & 1)) { 2806 symbol.GetAddressRef().SetOffset(entry_point_addr.GetOffset() ^ 1); 2807 m_address_class_map[entry_point_file_addr ^ 1] = 2808 AddressClass::eCodeAlternateISA; 2809 } else { 2810 m_address_class_map[entry_point_file_addr] = AddressClass::eCode; 2811 } 2812 lldb_symtab.AddSymbol(symbol); 2813 } 2814 } 2815 } 2816 2817 void ObjectFileELF::RelocateSection(lldb_private::Section *section) 2818 { 2819 static const char *debug_prefix = ".debug"; 2820 2821 // Set relocated bit so we stop getting called, regardless of whether we 2822 // actually relocate. 2823 section->SetIsRelocated(true); 2824 2825 // We only relocate in ELF relocatable files 2826 if (CalculateType() != eTypeObjectFile) 2827 return; 2828 2829 const char *section_name = section->GetName().GetCString(); 2830 // Can't relocate that which can't be named 2831 if (section_name == nullptr) 2832 return; 2833 2834 // We don't relocate non-debug sections at the moment 2835 if (strncmp(section_name, debug_prefix, strlen(debug_prefix))) 2836 return; 2837 2838 // Relocation section names to look for 2839 std::string needle = std::string(".rel") + section_name; 2840 std::string needlea = std::string(".rela") + section_name; 2841 2842 for (SectionHeaderCollIter I = m_section_headers.begin(); 2843 I != m_section_headers.end(); ++I) { 2844 if (I->sh_type == SHT_RELA || I->sh_type == SHT_REL) { 2845 const char *hay_name = I->section_name.GetCString(); 2846 if (hay_name == nullptr) 2847 continue; 2848 if (needle == hay_name || needlea == hay_name) { 2849 const ELFSectionHeader &reloc_header = *I; 2850 user_id_t reloc_id = SectionIndex(I); 2851 RelocateDebugSections(&reloc_header, reloc_id, GetSymtab()); 2852 break; 2853 } 2854 } 2855 } 2856 } 2857 2858 void ObjectFileELF::ParseUnwindSymbols(Symtab *symbol_table, 2859 DWARFCallFrameInfo *eh_frame) { 2860 SectionList *section_list = GetSectionList(); 2861 if (!section_list) 2862 return; 2863 2864 // First we save the new symbols into a separate list and add them to the 2865 // symbol table after we collected all symbols we want to add. This is 2866 // neccessary because adding a new symbol invalidates the internal index of 2867 // the symtab what causing the next lookup to be slow because it have to 2868 // recalculate the index first. 2869 std::vector<Symbol> new_symbols; 2870 2871 size_t num_symbols = symbol_table->GetNumSymbols(); 2872 uint64_t last_symbol_id = 2873 num_symbols ? symbol_table->SymbolAtIndex(num_symbols - 1)->GetID() : 0; 2874 eh_frame->ForEachFDEEntries([&](lldb::addr_t file_addr, uint32_t size, 2875 dw_offset_t) { 2876 Symbol *symbol = symbol_table->FindSymbolAtFileAddress(file_addr); 2877 if (symbol) { 2878 if (!symbol->GetByteSizeIsValid()) { 2879 symbol->SetByteSize(size); 2880 symbol->SetSizeIsSynthesized(true); 2881 } 2882 } else { 2883 SectionSP section_sp = 2884 section_list->FindSectionContainingFileAddress(file_addr); 2885 if (section_sp) { 2886 addr_t offset = file_addr - section_sp->GetFileAddress(); 2887 uint64_t symbol_id = ++last_symbol_id; 2888 // Don't set the name for any synthetic symbols, the Symbol 2889 // object will generate one if needed when the name is accessed 2890 // via accessors. 2891 Symbol eh_symbol( 2892 /*symID=*/symbol_id, 2893 /*name=*/llvm::StringRef(), // Name will be auto generated. 2894 /*type=*/eSymbolTypeCode, 2895 /*external=*/true, 2896 /*is_debug=*/false, 2897 /*is_trampoline=*/false, 2898 /*is_artificial=*/true, 2899 /*section_sp=*/section_sp, 2900 /*offset=*/offset, 2901 /*size=*/0, // FDE can span multiple symbols so don't use its size. 2902 /*size_is_valid=*/false, 2903 /*contains_linker_annotations=*/false, 2904 /*flags=*/0); 2905 new_symbols.push_back(eh_symbol); 2906 } 2907 } 2908 return true; 2909 }); 2910 2911 for (const Symbol &s : new_symbols) 2912 symbol_table->AddSymbol(s); 2913 } 2914 2915 bool ObjectFileELF::IsStripped() { 2916 // TODO: determine this for ELF 2917 return false; 2918 } 2919 2920 //===----------------------------------------------------------------------===// 2921 // Dump 2922 // 2923 // Dump the specifics of the runtime file container (such as any headers 2924 // segments, sections, etc). 2925 void ObjectFileELF::Dump(Stream *s) { 2926 ModuleSP module_sp(GetModule()); 2927 if (!module_sp) { 2928 return; 2929 } 2930 2931 std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex()); 2932 s->Printf("%p: ", static_cast<void *>(this)); 2933 s->Indent(); 2934 s->PutCString("ObjectFileELF"); 2935 2936 ArchSpec header_arch = GetArchitecture(); 2937 2938 *s << ", file = '" << m_file 2939 << "', arch = " << header_arch.GetArchitectureName() << "\n"; 2940 2941 DumpELFHeader(s, m_header); 2942 s->EOL(); 2943 DumpELFProgramHeaders(s); 2944 s->EOL(); 2945 DumpELFSectionHeaders(s); 2946 s->EOL(); 2947 SectionList *section_list = GetSectionList(); 2948 if (section_list) 2949 section_list->Dump(s->AsRawOstream(), s->GetIndentLevel(), nullptr, true, 2950 UINT32_MAX); 2951 Symtab *symtab = GetSymtab(); 2952 if (symtab) 2953 symtab->Dump(s, nullptr, eSortOrderNone); 2954 s->EOL(); 2955 DumpDependentModules(s); 2956 s->EOL(); 2957 } 2958 2959 // DumpELFHeader 2960 // 2961 // Dump the ELF header to the specified output stream 2962 void ObjectFileELF::DumpELFHeader(Stream *s, const ELFHeader &header) { 2963 s->PutCString("ELF Header\n"); 2964 s->Printf("e_ident[EI_MAG0 ] = 0x%2.2x\n", header.e_ident[EI_MAG0]); 2965 s->Printf("e_ident[EI_MAG1 ] = 0x%2.2x '%c'\n", header.e_ident[EI_MAG1], 2966 header.e_ident[EI_MAG1]); 2967 s->Printf("e_ident[EI_MAG2 ] = 0x%2.2x '%c'\n", header.e_ident[EI_MAG2], 2968 header.e_ident[EI_MAG2]); 2969 s->Printf("e_ident[EI_MAG3 ] = 0x%2.2x '%c'\n", header.e_ident[EI_MAG3], 2970 header.e_ident[EI_MAG3]); 2971 2972 s->Printf("e_ident[EI_CLASS ] = 0x%2.2x\n", header.e_ident[EI_CLASS]); 2973 s->Printf("e_ident[EI_DATA ] = 0x%2.2x ", header.e_ident[EI_DATA]); 2974 DumpELFHeader_e_ident_EI_DATA(s, header.e_ident[EI_DATA]); 2975 s->Printf("\ne_ident[EI_VERSION] = 0x%2.2x\n", header.e_ident[EI_VERSION]); 2976 s->Printf("e_ident[EI_PAD ] = 0x%2.2x\n", header.e_ident[EI_PAD]); 2977 2978 s->Printf("e_type = 0x%4.4x ", header.e_type); 2979 DumpELFHeader_e_type(s, header.e_type); 2980 s->Printf("\ne_machine = 0x%4.4x\n", header.e_machine); 2981 s->Printf("e_version = 0x%8.8x\n", header.e_version); 2982 s->Printf("e_entry = 0x%8.8" PRIx64 "\n", header.e_entry); 2983 s->Printf("e_phoff = 0x%8.8" PRIx64 "\n", header.e_phoff); 2984 s->Printf("e_shoff = 0x%8.8" PRIx64 "\n", header.e_shoff); 2985 s->Printf("e_flags = 0x%8.8x\n", header.e_flags); 2986 s->Printf("e_ehsize = 0x%4.4x\n", header.e_ehsize); 2987 s->Printf("e_phentsize = 0x%4.4x\n", header.e_phentsize); 2988 s->Printf("e_phnum = 0x%8.8x\n", header.e_phnum); 2989 s->Printf("e_shentsize = 0x%4.4x\n", header.e_shentsize); 2990 s->Printf("e_shnum = 0x%8.8x\n", header.e_shnum); 2991 s->Printf("e_shstrndx = 0x%8.8x\n", header.e_shstrndx); 2992 } 2993 2994 // DumpELFHeader_e_type 2995 // 2996 // Dump an token value for the ELF header member e_type 2997 void ObjectFileELF::DumpELFHeader_e_type(Stream *s, elf_half e_type) { 2998 switch (e_type) { 2999 case ET_NONE: 3000 *s << "ET_NONE"; 3001 break; 3002 case ET_REL: 3003 *s << "ET_REL"; 3004 break; 3005 case ET_EXEC: 3006 *s << "ET_EXEC"; 3007 break; 3008 case ET_DYN: 3009 *s << "ET_DYN"; 3010 break; 3011 case ET_CORE: 3012 *s << "ET_CORE"; 3013 break; 3014 default: 3015 break; 3016 } 3017 } 3018 3019 // DumpELFHeader_e_ident_EI_DATA 3020 // 3021 // Dump an token value for the ELF header member e_ident[EI_DATA] 3022 void ObjectFileELF::DumpELFHeader_e_ident_EI_DATA(Stream *s, 3023 unsigned char ei_data) { 3024 switch (ei_data) { 3025 case ELFDATANONE: 3026 *s << "ELFDATANONE"; 3027 break; 3028 case ELFDATA2LSB: 3029 *s << "ELFDATA2LSB - Little Endian"; 3030 break; 3031 case ELFDATA2MSB: 3032 *s << "ELFDATA2MSB - Big Endian"; 3033 break; 3034 default: 3035 break; 3036 } 3037 } 3038 3039 // DumpELFProgramHeader 3040 // 3041 // Dump a single ELF program header to the specified output stream 3042 void ObjectFileELF::DumpELFProgramHeader(Stream *s, 3043 const ELFProgramHeader &ph) { 3044 DumpELFProgramHeader_p_type(s, ph.p_type); 3045 s->Printf(" %8.8" PRIx64 " %8.8" PRIx64 " %8.8" PRIx64, ph.p_offset, 3046 ph.p_vaddr, ph.p_paddr); 3047 s->Printf(" %8.8" PRIx64 " %8.8" PRIx64 " %8.8x (", ph.p_filesz, ph.p_memsz, 3048 ph.p_flags); 3049 3050 DumpELFProgramHeader_p_flags(s, ph.p_flags); 3051 s->Printf(") %8.8" PRIx64, ph.p_align); 3052 } 3053 3054 // DumpELFProgramHeader_p_type 3055 // 3056 // Dump an token value for the ELF program header member p_type which describes 3057 // the type of the program header 3058 void ObjectFileELF::DumpELFProgramHeader_p_type(Stream *s, elf_word p_type) { 3059 const int kStrWidth = 15; 3060 switch (p_type) { 3061 CASE_AND_STREAM(s, PT_NULL, kStrWidth); 3062 CASE_AND_STREAM(s, PT_LOAD, kStrWidth); 3063 CASE_AND_STREAM(s, PT_DYNAMIC, kStrWidth); 3064 CASE_AND_STREAM(s, PT_INTERP, kStrWidth); 3065 CASE_AND_STREAM(s, PT_NOTE, kStrWidth); 3066 CASE_AND_STREAM(s, PT_SHLIB, kStrWidth); 3067 CASE_AND_STREAM(s, PT_PHDR, kStrWidth); 3068 CASE_AND_STREAM(s, PT_TLS, kStrWidth); 3069 CASE_AND_STREAM(s, PT_GNU_EH_FRAME, kStrWidth); 3070 default: 3071 s->Printf("0x%8.8x%*s", p_type, kStrWidth - 10, ""); 3072 break; 3073 } 3074 } 3075 3076 // DumpELFProgramHeader_p_flags 3077 // 3078 // Dump an token value for the ELF program header member p_flags 3079 void ObjectFileELF::DumpELFProgramHeader_p_flags(Stream *s, elf_word p_flags) { 3080 *s << ((p_flags & PF_X) ? "PF_X" : " ") 3081 << (((p_flags & PF_X) && (p_flags & PF_W)) ? '+' : ' ') 3082 << ((p_flags & PF_W) ? "PF_W" : " ") 3083 << (((p_flags & PF_W) && (p_flags & PF_R)) ? '+' : ' ') 3084 << ((p_flags & PF_R) ? "PF_R" : " "); 3085 } 3086 3087 // DumpELFProgramHeaders 3088 // 3089 // Dump all of the ELF program header to the specified output stream 3090 void ObjectFileELF::DumpELFProgramHeaders(Stream *s) { 3091 if (!ParseProgramHeaders()) 3092 return; 3093 3094 s->PutCString("Program Headers\n"); 3095 s->PutCString("IDX p_type p_offset p_vaddr p_paddr " 3096 "p_filesz p_memsz p_flags p_align\n"); 3097 s->PutCString("==== --------------- -------- -------- -------- " 3098 "-------- -------- ------------------------- --------\n"); 3099 3100 for (const auto &H : llvm::enumerate(m_program_headers)) { 3101 s->Format("[{0,2}] ", H.index()); 3102 ObjectFileELF::DumpELFProgramHeader(s, H.value()); 3103 s->EOL(); 3104 } 3105 } 3106 3107 // DumpELFSectionHeader 3108 // 3109 // Dump a single ELF section header to the specified output stream 3110 void ObjectFileELF::DumpELFSectionHeader(Stream *s, 3111 const ELFSectionHeaderInfo &sh) { 3112 s->Printf("%8.8x ", sh.sh_name); 3113 DumpELFSectionHeader_sh_type(s, sh.sh_type); 3114 s->Printf(" %8.8" PRIx64 " (", sh.sh_flags); 3115 DumpELFSectionHeader_sh_flags(s, sh.sh_flags); 3116 s->Printf(") %8.8" PRIx64 " %8.8" PRIx64 " %8.8" PRIx64, sh.sh_addr, 3117 sh.sh_offset, sh.sh_size); 3118 s->Printf(" %8.8x %8.8x", sh.sh_link, sh.sh_info); 3119 s->Printf(" %8.8" PRIx64 " %8.8" PRIx64, sh.sh_addralign, sh.sh_entsize); 3120 } 3121 3122 // DumpELFSectionHeader_sh_type 3123 // 3124 // Dump an token value for the ELF section header member sh_type which 3125 // describes the type of the section 3126 void ObjectFileELF::DumpELFSectionHeader_sh_type(Stream *s, elf_word sh_type) { 3127 const int kStrWidth = 12; 3128 switch (sh_type) { 3129 CASE_AND_STREAM(s, SHT_NULL, kStrWidth); 3130 CASE_AND_STREAM(s, SHT_PROGBITS, kStrWidth); 3131 CASE_AND_STREAM(s, SHT_SYMTAB, kStrWidth); 3132 CASE_AND_STREAM(s, SHT_STRTAB, kStrWidth); 3133 CASE_AND_STREAM(s, SHT_RELA, kStrWidth); 3134 CASE_AND_STREAM(s, SHT_HASH, kStrWidth); 3135 CASE_AND_STREAM(s, SHT_DYNAMIC, kStrWidth); 3136 CASE_AND_STREAM(s, SHT_NOTE, kStrWidth); 3137 CASE_AND_STREAM(s, SHT_NOBITS, kStrWidth); 3138 CASE_AND_STREAM(s, SHT_REL, kStrWidth); 3139 CASE_AND_STREAM(s, SHT_SHLIB, kStrWidth); 3140 CASE_AND_STREAM(s, SHT_DYNSYM, kStrWidth); 3141 CASE_AND_STREAM(s, SHT_LOPROC, kStrWidth); 3142 CASE_AND_STREAM(s, SHT_HIPROC, kStrWidth); 3143 CASE_AND_STREAM(s, SHT_LOUSER, kStrWidth); 3144 CASE_AND_STREAM(s, SHT_HIUSER, kStrWidth); 3145 default: 3146 s->Printf("0x%8.8x%*s", sh_type, kStrWidth - 10, ""); 3147 break; 3148 } 3149 } 3150 3151 // DumpELFSectionHeader_sh_flags 3152 // 3153 // Dump an token value for the ELF section header member sh_flags 3154 void ObjectFileELF::DumpELFSectionHeader_sh_flags(Stream *s, 3155 elf_xword sh_flags) { 3156 *s << ((sh_flags & SHF_WRITE) ? "WRITE" : " ") 3157 << (((sh_flags & SHF_WRITE) && (sh_flags & SHF_ALLOC)) ? '+' : ' ') 3158 << ((sh_flags & SHF_ALLOC) ? "ALLOC" : " ") 3159 << (((sh_flags & SHF_ALLOC) && (sh_flags & SHF_EXECINSTR)) ? '+' : ' ') 3160 << ((sh_flags & SHF_EXECINSTR) ? "EXECINSTR" : " "); 3161 } 3162 3163 // DumpELFSectionHeaders 3164 // 3165 // Dump all of the ELF section header to the specified output stream 3166 void ObjectFileELF::DumpELFSectionHeaders(Stream *s) { 3167 if (!ParseSectionHeaders()) 3168 return; 3169 3170 s->PutCString("Section Headers\n"); 3171 s->PutCString("IDX name type flags " 3172 "addr offset size link info addralgn " 3173 "entsize Name\n"); 3174 s->PutCString("==== -------- ------------ -------------------------------- " 3175 "-------- -------- -------- -------- -------- -------- " 3176 "-------- ====================\n"); 3177 3178 uint32_t idx = 0; 3179 for (SectionHeaderCollConstIter I = m_section_headers.begin(); 3180 I != m_section_headers.end(); ++I, ++idx) { 3181 s->Printf("[%2u] ", idx); 3182 ObjectFileELF::DumpELFSectionHeader(s, *I); 3183 const char *section_name = I->section_name.AsCString(""); 3184 if (section_name) 3185 *s << ' ' << section_name << "\n"; 3186 } 3187 } 3188 3189 void ObjectFileELF::DumpDependentModules(lldb_private::Stream *s) { 3190 size_t num_modules = ParseDependentModules(); 3191 3192 if (num_modules > 0) { 3193 s->PutCString("Dependent Modules:\n"); 3194 for (unsigned i = 0; i < num_modules; ++i) { 3195 const FileSpec &spec = m_filespec_up->GetFileSpecAtIndex(i); 3196 s->Printf(" %s\n", spec.GetFilename().GetCString()); 3197 } 3198 } 3199 } 3200 3201 ArchSpec ObjectFileELF::GetArchitecture() { 3202 if (!ParseHeader()) 3203 return ArchSpec(); 3204 3205 if (m_section_headers.empty()) { 3206 // Allow elf notes to be parsed which may affect the detected architecture. 3207 ParseSectionHeaders(); 3208 } 3209 3210 if (CalculateType() == eTypeCoreFile && 3211 !m_arch_spec.TripleOSWasSpecified()) { 3212 // Core files don't have section headers yet they have PT_NOTE program 3213 // headers that might shed more light on the architecture 3214 for (const elf::ELFProgramHeader &H : ProgramHeaders()) { 3215 if (H.p_type != PT_NOTE || H.p_offset == 0 || H.p_filesz == 0) 3216 continue; 3217 DataExtractor data; 3218 if (data.SetData(m_data, H.p_offset, H.p_filesz) == H.p_filesz) { 3219 UUID uuid; 3220 RefineModuleDetailsFromNote(data, m_arch_spec, uuid); 3221 } 3222 } 3223 } 3224 return m_arch_spec; 3225 } 3226 3227 ObjectFile::Type ObjectFileELF::CalculateType() { 3228 switch (m_header.e_type) { 3229 case llvm::ELF::ET_NONE: 3230 // 0 - No file type 3231 return eTypeUnknown; 3232 3233 case llvm::ELF::ET_REL: 3234 // 1 - Relocatable file 3235 return eTypeObjectFile; 3236 3237 case llvm::ELF::ET_EXEC: 3238 // 2 - Executable file 3239 return eTypeExecutable; 3240 3241 case llvm::ELF::ET_DYN: 3242 // 3 - Shared object file 3243 return eTypeSharedLibrary; 3244 3245 case ET_CORE: 3246 // 4 - Core file 3247 return eTypeCoreFile; 3248 3249 default: 3250 break; 3251 } 3252 return eTypeUnknown; 3253 } 3254 3255 ObjectFile::Strata ObjectFileELF::CalculateStrata() { 3256 switch (m_header.e_type) { 3257 case llvm::ELF::ET_NONE: 3258 // 0 - No file type 3259 return eStrataUnknown; 3260 3261 case llvm::ELF::ET_REL: 3262 // 1 - Relocatable file 3263 return eStrataUnknown; 3264 3265 case llvm::ELF::ET_EXEC: 3266 // 2 - Executable file 3267 // TODO: is there any way to detect that an executable is a kernel 3268 // related executable by inspecting the program headers, section headers, 3269 // symbols, or any other flag bits??? 3270 return eStrataUser; 3271 3272 case llvm::ELF::ET_DYN: 3273 // 3 - Shared object file 3274 // TODO: is there any way to detect that an shared library is a kernel 3275 // related executable by inspecting the program headers, section headers, 3276 // symbols, or any other flag bits??? 3277 return eStrataUnknown; 3278 3279 case ET_CORE: 3280 // 4 - Core file 3281 // TODO: is there any way to detect that an core file is a kernel 3282 // related executable by inspecting the program headers, section headers, 3283 // symbols, or any other flag bits??? 3284 return eStrataUnknown; 3285 3286 default: 3287 break; 3288 } 3289 return eStrataUnknown; 3290 } 3291 3292 size_t ObjectFileELF::ReadSectionData(Section *section, 3293 lldb::offset_t section_offset, void *dst, 3294 size_t dst_len) { 3295 // If some other objectfile owns this data, pass this to them. 3296 if (section->GetObjectFile() != this) 3297 return section->GetObjectFile()->ReadSectionData(section, section_offset, 3298 dst, dst_len); 3299 3300 if (!section->Test(SHF_COMPRESSED)) 3301 return ObjectFile::ReadSectionData(section, section_offset, dst, dst_len); 3302 3303 // For compressed sections we need to read to full data to be able to 3304 // decompress. 3305 DataExtractor data; 3306 ReadSectionData(section, data); 3307 return data.CopyData(section_offset, dst_len, dst); 3308 } 3309 3310 size_t ObjectFileELF::ReadSectionData(Section *section, 3311 DataExtractor §ion_data) { 3312 // If some other objectfile owns this data, pass this to them. 3313 if (section->GetObjectFile() != this) 3314 return section->GetObjectFile()->ReadSectionData(section, section_data); 3315 3316 size_t result = ObjectFile::ReadSectionData(section, section_data); 3317 if (result == 0 || !llvm::object::Decompressor::isCompressedELFSection( 3318 section->Get(), section->GetName().GetStringRef())) 3319 return result; 3320 3321 auto Decompressor = llvm::object::Decompressor::create( 3322 section->GetName().GetStringRef(), 3323 {reinterpret_cast<const char *>(section_data.GetDataStart()), 3324 size_t(section_data.GetByteSize())}, 3325 GetByteOrder() == eByteOrderLittle, GetAddressByteSize() == 8); 3326 if (!Decompressor) { 3327 GetModule()->ReportWarning( 3328 "Unable to initialize decompressor for section '%s': %s", 3329 section->GetName().GetCString(), 3330 llvm::toString(Decompressor.takeError()).c_str()); 3331 section_data.Clear(); 3332 return 0; 3333 } 3334 3335 auto buffer_sp = 3336 std::make_shared<DataBufferHeap>(Decompressor->getDecompressedSize(), 0); 3337 if (auto error = Decompressor->decompress( 3338 {reinterpret_cast<char *>(buffer_sp->GetBytes()), 3339 size_t(buffer_sp->GetByteSize())})) { 3340 GetModule()->ReportWarning( 3341 "Decompression of section '%s' failed: %s", 3342 section->GetName().GetCString(), 3343 llvm::toString(std::move(error)).c_str()); 3344 section_data.Clear(); 3345 return 0; 3346 } 3347 3348 section_data.SetData(buffer_sp); 3349 return buffer_sp->GetByteSize(); 3350 } 3351 3352 llvm::ArrayRef<ELFProgramHeader> ObjectFileELF::ProgramHeaders() { 3353 ParseProgramHeaders(); 3354 return m_program_headers; 3355 } 3356 3357 DataExtractor ObjectFileELF::GetSegmentData(const ELFProgramHeader &H) { 3358 return DataExtractor(m_data, H.p_offset, H.p_filesz); 3359 } 3360 3361 bool ObjectFileELF::AnySegmentHasPhysicalAddress() { 3362 for (const ELFProgramHeader &H : ProgramHeaders()) { 3363 if (H.p_paddr != 0) 3364 return true; 3365 } 3366 return false; 3367 } 3368 3369 std::vector<ObjectFile::LoadableData> 3370 ObjectFileELF::GetLoadableData(Target &target) { 3371 // Create a list of loadable data from loadable segments, using physical 3372 // addresses if they aren't all null 3373 std::vector<LoadableData> loadables; 3374 bool should_use_paddr = AnySegmentHasPhysicalAddress(); 3375 for (const ELFProgramHeader &H : ProgramHeaders()) { 3376 LoadableData loadable; 3377 if (H.p_type != llvm::ELF::PT_LOAD) 3378 continue; 3379 loadable.Dest = should_use_paddr ? H.p_paddr : H.p_vaddr; 3380 if (loadable.Dest == LLDB_INVALID_ADDRESS) 3381 continue; 3382 if (H.p_filesz == 0) 3383 continue; 3384 auto segment_data = GetSegmentData(H); 3385 loadable.Contents = llvm::ArrayRef<uint8_t>(segment_data.GetDataStart(), 3386 segment_data.GetByteSize()); 3387 loadables.push_back(loadable); 3388 } 3389 return loadables; 3390 } 3391