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