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