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