14#include <unordered_map>
36#include "llvm/ADT/IntervalMap.h"
37#include "llvm/ADT/PointerUnion.h"
38#include "llvm/ADT/StringRef.h"
39#include "llvm/BinaryFormat/ELF.h"
40#include "llvm/Object/Decompressor.h"
41#include "llvm/Support/ARMBuildAttributes.h"
42#include "llvm/Support/CRC.h"
43#include "llvm/Support/FormatVariadic.h"
44#include "llvm/Support/MathExtras.h"
45#include "llvm/Support/MemoryBuffer.h"
46#include "llvm/Support/MipsABIFlags.h"
48#define CASE_AND_STREAM(s, def, width) \
50 s->Printf("%-*s", width, #def); \
56using namespace llvm::ELF;
103 ELFRelocation(
unsigned type);
109 static unsigned RelocType32(
const ELFRelocation &rel);
111 static unsigned RelocType64(
const ELFRelocation &rel);
113 static unsigned RelocSymbol32(
const ELFRelocation &rel);
115 static unsigned RelocSymbol64(
const ELFRelocation &rel);
117 static elf_addr RelocOffset32(
const ELFRelocation &rel);
119 static elf_addr RelocOffset64(
const ELFRelocation &rel);
121 static elf_sxword RelocAddend32(
const ELFRelocation &rel);
123 static elf_sxword RelocAddend64(
const ELFRelocation &rel);
125 bool IsRela() {
return (reloc.is<
ELFRela *>()); }
128 typedef llvm::PointerUnion<ELFRel *, ELFRela *> RelocUnion;
134ELFRelocation::ELFRelocation(
unsigned type) {
135 if (type == DT_REL || type == SHT_REL)
137 else if (type == DT_RELA || type == SHT_RELA)
140 assert(
false &&
"unexpected relocation type");
141 reloc =
static_cast<ELFRel *
>(
nullptr);
145ELFRelocation::~ELFRelocation() {
147 delete reloc.get<
ELFRel *>();
160unsigned ELFRelocation::RelocType32(
const ELFRelocation &rel) {
161 if (rel.reloc.is<
ELFRel *>())
167unsigned ELFRelocation::RelocType64(
const ELFRelocation &rel) {
168 if (rel.reloc.is<
ELFRel *>())
174unsigned ELFRelocation::RelocSymbol32(
const ELFRelocation &rel) {
175 if (rel.reloc.is<
ELFRel *>())
181unsigned ELFRelocation::RelocSymbol64(
const ELFRelocation &rel) {
182 if (rel.reloc.is<
ELFRel *>())
188elf_addr ELFRelocation::RelocOffset32(
const ELFRelocation &rel) {
189 if (rel.reloc.is<
ELFRel *>())
190 return rel.reloc.get<
ELFRel *>()->r_offset;
192 return rel.reloc.get<
ELFRela *>()->r_offset;
195elf_addr ELFRelocation::RelocOffset64(
const ELFRelocation &rel) {
196 if (rel.reloc.is<
ELFRel *>())
197 return rel.reloc.get<
ELFRel *>()->r_offset;
199 return rel.reloc.get<
ELFRela *>()->r_offset;
202elf_sxword ELFRelocation::RelocAddend32(
const ELFRelocation &rel) {
203 if (rel.reloc.is<
ELFRel *>())
206 return rel.reloc.get<
ELFRela *>()->r_addend;
209elf_sxword ELFRelocation::RelocAddend64(
const ELFRelocation &rel) {
210 if (rel.reloc.is<
ELFRel *>())
213 return rel.reloc.get<
ELFRela *>()->r_addend;
233 if (strncmp(buf,
"CORE", 4) == 0) {
241 if (cstr ==
nullptr) {
243 LLDB_LOGF(log,
"Failed to parse note name lacking nul terminator");
252 const uint32_t mips_arch = header.
e_flags & llvm::ELF::EF_MIPS_ARCH;
253 uint32_t endian = header.
e_ident[EI_DATA];
255 uint32_t fileclass = header.
e_ident[EI_CLASS];
260 if (header.
e_type == ET_CORE) {
262 case llvm::ELF::ELFCLASS32:
265 case llvm::ELF::ELFCLASS64:
274 case llvm::ELF::EF_MIPS_ARCH_1:
275 case llvm::ELF::EF_MIPS_ARCH_2:
276 case llvm::ELF::EF_MIPS_ARCH_32:
279 case llvm::ELF::EF_MIPS_ARCH_32R2:
282 case llvm::ELF::EF_MIPS_ARCH_32R6:
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:
291 case llvm::ELF::EF_MIPS_ARCH_64R2:
294 case llvm::ELF::EF_MIPS_ARCH_64R6:
305 uint32_t fileclass = header.
e_ident[EI_CLASS];
307 case llvm::ELF::ELFCLASS32:
309 case llvm::ELF::ELFCLASS64:
317 uint32_t endian = header.
e_ident[EI_DATA];
318 if (endian == ELFDATA2LSB)
325 uint32_t fileclass = header.
e_ident[EI_CLASS];
327 case llvm::ELF::ELFCLASS32:
329 case llvm::ELF::ELFCLASS64:
337 if (header.
e_machine == llvm::ELF::EM_MIPS)
339 else if (header.
e_machine == llvm::ELF::EM_PPC64)
341 else if (header.
e_machine == llvm::ELF::EM_RISCV)
343 else if (header.
e_machine == llvm::ELF::EM_LOONGARCH)
371 bool mapped_writable =
false;
377 mapped_writable =
true;
382 if (data_sp->GetByteSize() <= (llvm::ELF::EI_NIDENT + data_offset))
385 const uint8_t *magic = data_sp->GetBytes() + data_offset;
390 if (data_sp->GetByteSize() < length) {
395 mapped_writable =
true;
396 magic = data_sp->GetBytes();
400 if (!mapped_writable) {
401 data_sp = std::make_shared<DataBufferHeap>(data_sp->GetBytes(),
402 data_sp->GetByteSize());
404 magic = data_sp->GetBytes();
408 if (address_size == 4 || address_size == 8) {
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();
422 if (data_sp && data_sp->GetByteSize() > (llvm::ELF::EI_NIDENT)) {
423 const uint8_t *magic = data_sp->GetBytes();
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();
442 data_sp->GetByteSize() > (llvm::ELF::EI_NIDENT + data_offset)) {
443 const uint8_t *magic = data_sp->GetBytes() + data_offset;
450 return llvm::crc32(init,
457 uint32_t core_notes_crc = 0;
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;
465 if (segment_data.
SetData(object_data, ph_offset, ph_size) != ph_size) {
471 core_notes_crc =
calc_crc32(core_notes_crc, segment_data);
475 return core_notes_crc;
479#define _MAKE_OSABI_CASE(x) \
482 switch (osabi_byte) {
504 return "<unknown-osabi>";
506#undef _MAKE_OSABI_CASE
516 llvm::Triple::OSType &ostype) {
517 switch (osabi_byte) {
519 ostype = llvm::Triple::OSType::AIX;
521 case ELFOSABI_FREEBSD:
522 ostype = llvm::Triple::OSType::FreeBSD;
525 ostype = llvm::Triple::OSType::Linux;
527 case ELFOSABI_NETBSD:
528 ostype = llvm::Triple::OSType::NetBSD;
530 case ELFOSABI_OPENBSD:
531 ostype = llvm::Triple::OSType::OpenBSD;
533 case ELFOSABI_SOLARIS:
534 ostype = llvm::Triple::OSType::Solaris;
537 ostype = llvm::Triple::OSType::UnknownOS;
539 return ostype != llvm::Triple::OSType::UnknownOS;
548 const size_t initial_count = specs.
GetSize();
555 if (header.
Parse(data, &header_offset)) {
572 llvm::Triple::OSType ostype;
573 llvm::Triple::VendorType vendor;
574 llvm::Triple::OSType spec_ostype =
577 LLDB_LOGF(log,
"ObjectFileELF::%s file '%s' module OSABI: %s",
578 __FUNCTION__, file.
GetPath().c_str(),
583 assert(vendor == llvm::Triple::UnknownVendor);
589 assert(spec_ostype == ostype);
590 if (spec_ostype != llvm::Triple::OSType::UnknownOS) {
592 "ObjectFileELF::%s file '%s' set ELF module OS type "
593 "from ELF header OSABI.",
594 __FUNCTION__, file.
GetPath().c_str());
601 if (data_sp->GetByteSize() < length)
611 header.
Parse(data, &header_offset);
614 uint32_t gnu_debuglink_crc = 0;
615 std::string gnu_debuglink_file;
620 gnu_debuglink_file, gnu_debuglink_crc,
626 "ObjectFileELF::%s file '%s' module set to triple: %s "
628 __FUNCTION__, file.
GetPath().c_str(),
629 spec_triple.getTriple().c_str(),
633 uint32_t core_notes_crc = 0;
635 if (!gnu_debuglink_crc) {
637 "Calculating module crc32 %s with size %" PRIu64
" KiB",
639 (length - file_offset) / 1024);
645 if (header.
e_type == llvm::ELF::ET_CORE) {
655 using u32le = llvm::support::ulittle32_t;
656 if (gnu_debuglink_crc) {
658 u32le data(gnu_debuglink_crc);
659 uuid =
UUID(&data,
sizeof(data));
660 }
else if (core_notes_crc) {
665 uuid =
UUID(data,
sizeof(data));
675 return specs.
GetSize() - initial_count;
684 :
ObjectFile(module_sp, file, file_offset, length, data_sp, data_offset) {
693 :
ObjectFile(module_sp, process_sp, header_addr, header_data_sp) {}
700 bool value_is_offset) {
703 size_t num_loaded_sections = 0;
706 if (!value_is_offset) {
713 const size_t num_sections = section_list->
GetSize();
716 for (sect_idx = 0; sect_idx < num_sections; ++sect_idx) {
732 if (section_sp->IsThreadSpecific())
734 if (section_sp->Test(SHF_ALLOC) ||
746 load_addr &= 0xFFFFFFFF;
750 ++num_loaded_sections;
753 return num_loaded_sections > 0;
774 return AddressClass::eUnknown;
779 if (symtab_objfile !=
nullptr && symtab_objfile !=
this)
783 if (res != AddressClass::eCode)
790 return AddressClass::eCode;
819 using u32le = llvm::support::ulittle32_t;
821 uint32_t core_notes_crc = 0;
829 if (core_notes_crc) {
858 uint32_t num_specs = 0;
860 for (
unsigned i = 0; i < num_modules; ++i) {
879 if (!dynsym_section_sp)
881 assert(dynsym_section_sp->GetObjectFile() ==
this);
883 user_id_t dynsym_id = dynsym_section_sp->GetID();
891 if (symbol.
d_tag == DT_DEBUG) {
895 return Address(dynsym_section_sp, offset);
899 else if ((symbol.
d_tag == DT_MIPS_RLD_MAP ||
900 symbol.
d_tag == DT_MIPS_RLD_MAP_REL) &&
903 addr_t dyn_base = dynsym_section_sp->GetLoadBaseAddress(target);
908 if (symbol.
d_tag == DT_MIPS_RLD_MAP) {
914 if (symbol.
d_tag == DT_MIPS_RLD_MAP_REL) {
922 addr_t debug_ptr_address =
1014 while (offset < section_size) {
1015 if (!symbol.
Parse(dynsym_data, &offset))
1018 if (symbol.
d_tag != DT_NEEDED)
1021 uint32_t str_index =
static_cast<uint32_t
>(symbol.
d_val);
1022 const char *lib_name = dynstr_data.
PeekCStr(str_index);
1037 if (!program_headers.empty())
1038 return program_headers.size();
1044 program_headers.resize(header.
e_phnum);
1045 if (program_headers.size() != header.
e_phnum)
1051 if (data.
SetData(object_data, ph_offset, ph_size) != ph_size)
1056 for (idx = 0, offset = 0; idx < header.
e_phnum; ++idx) {
1057 if (!program_headers[idx].Parse(data, &offset))
1061 if (idx < program_headers.size())
1062 program_headers.resize(idx);
1064 return program_headers.size();
1085 if (!note.
Parse(data, &offset)) {
1090 LLDB_LOGF(log,
"ObjectFileELF::%s parsing note name='%s', type=%" PRIu32,
1098 uint32_t version_info;
1099 if (data.
GetU32(&offset, &version_info, 1) ==
nullptr) {
1100 error.SetErrorString(
"failed to read FreeBSD ABI note payload");
1105 const uint32_t version_major = version_info / 100000;
1106 const uint32_t version_minor = (version_info / 1000) % 100;
1109 snprintf(os_name,
sizeof(os_name),
"freebsd%" PRIu32
".%" PRIu32,
1110 version_major, version_minor);
1113 arch_spec.
GetTriple().setOSName(os_name);
1114 arch_spec.
GetTriple().setVendor(llvm::Triple::VendorType::UnknownVendor);
1117 "ObjectFileELF::%s detected FreeBSD %" PRIu32
".%" PRIu32
1119 __FUNCTION__, version_major, version_minor,
1120 static_cast<uint32_t
>(version_info % 1000));
1128 uint32_t version_info[4];
1131 error.SetErrorString(
"failed to read GNU ABI note payload");
1136 switch (version_info[0]) {
1138 arch_spec.
GetTriple().setOS(llvm::Triple::OSType::Linux);
1140 llvm::Triple::VendorType::UnknownVendor);
1142 "ObjectFileELF::%s detected Linux, min version %" PRIu32
1143 ".%" PRIu32
".%" PRIu32,
1144 __FUNCTION__, version_info[1], version_info[2],
1151 arch_spec.
GetTriple().setOS(llvm::Triple::OSType::UnknownOS);
1153 llvm::Triple::VendorType::UnknownVendor);
1155 "ObjectFileELF::%s detected Hurd (unsupported), min "
1156 "version %" PRIu32
".%" PRIu32
".%" PRIu32,
1157 __FUNCTION__, version_info[1], version_info[2],
1161 arch_spec.
GetTriple().setOS(llvm::Triple::OSType::Solaris);
1163 llvm::Triple::VendorType::UnknownVendor);
1165 "ObjectFileELF::%s detected Solaris, min version %" PRIu32
1166 ".%" PRIu32
".%" PRIu32,
1167 __FUNCTION__, version_info[1], version_info[2],
1172 "ObjectFileELF::%s unrecognized OS in note, id %" PRIu32
1173 ", min version %" PRIu32
".%" PRIu32
".%" PRIu32,
1174 __FUNCTION__, version_info[0], version_info[1],
1175 version_info[2], version_info[3]);
1192 error.SetErrorString(
"failed to read GNU_BUILD_ID note payload");
1199 if (arch_spec.
IsMIPS() &&
1200 arch_spec.
GetTriple().getOS() == llvm::Triple::OSType::UnknownOS)
1202 arch_spec.
GetTriple().setOS(llvm::Triple::OSType::Linux);
1210 uint32_t version_info;
1211 if (data.
GetU32(&offset, &version_info, 1) ==
nullptr) {
1212 error.SetErrorString(
"failed to read NetBSD ABI note payload");
1222 const uint32_t version_major = version_info / 100000000;
1223 const uint32_t version_minor = (version_info % 100000000) / 1000000;
1224 const uint32_t version_patch = (version_info % 10000) / 100;
1227 llvm::formatv(
"netbsd{0}.{1}.{2}", version_major, version_minor,
1228 version_patch).str());
1229 arch_spec.
GetTriple().setVendor(llvm::Triple::VendorType::UnknownVendor);
1235 arch_spec.
GetTriple().setOS(llvm::Triple::OSType::NetBSD);
1236 arch_spec.
GetTriple().setVendor(llvm::Triple::VendorType::UnknownVendor);
1241 arch_spec.
GetTriple().setOS(llvm::Triple::OSType::OpenBSD);
1242 arch_spec.
GetTriple().setVendor(llvm::Triple::VendorType::UnknownVendor);
1244 arch_spec.
GetTriple().setOS(llvm::Triple::OSType::Linux);
1246 llvm::Triple::EnvironmentType::Android);
1250 arch_spec.
GetTriple().setOS(llvm::Triple::OSType::Linux);
1274 if (note.
n_type == NT_FILE) {
1278 offset += count * 3 *
1280 for (
size_t i = 0; i < count; ++i) {
1282 if (cstr ==
nullptr) {
1283 error.SetErrorStringWithFormat(
"ObjectFileELF::%s trying to read "
1284 "at an offset after the end "
1285 "(GetCStr returned nullptr)",
1289 llvm::StringRef path(cstr);
1290 if (path.contains(
"/lib/x86_64-linux-gnu") || path.contains(
"/lib/i386-linux-gnu")) {
1291 arch_spec.
GetTriple().setOS(llvm::Triple::OSType::Linux);
1295 if (arch_spec.
IsMIPS() &&
1296 arch_spec.
GetTriple().getOS() == llvm::Triple::OSType::UnknownOS)
1299 arch_spec.
GetTriple().setOS(llvm::Triple::OSType::Linux);
1315 uint8_t FormatVersion = data.
GetU8(&Offset);
1316 if (FormatVersion != llvm::ELFAttrs::Format_Version)
1319 Offset = Offset +
sizeof(uint32_t);
1320 llvm::StringRef VendorName = data.
GetCStr(&Offset);
1322 if (VendorName !=
"aeabi")
1325 if (arch_spec.
GetTriple().getEnvironment() ==
1326 llvm::Triple::UnknownEnvironment)
1327 arch_spec.
GetTriple().setEnvironment(llvm::Triple::EABI);
1329 while (Offset < length) {
1330 uint8_t Tag = data.
GetU8(&Offset);
1331 uint32_t Size = data.
GetU32(&Offset);
1333 if (Tag != llvm::ARMBuildAttrs::File || Size == 0)
1336 while (Offset < length) {
1342 else if (Tag % 2 == 0)
1349 case llvm::ARMBuildAttrs::CPU_raw_name:
1350 case llvm::ARMBuildAttrs::CPU_name:
1355 case llvm::ARMBuildAttrs::ABI_VFP_args: {
1358 if (VFPArgs == llvm::ARMBuildAttrs::BaseAAPCS) {
1359 if (arch_spec.
GetTriple().getEnvironment() ==
1360 llvm::Triple::UnknownEnvironment ||
1361 arch_spec.
GetTriple().getEnvironment() == llvm::Triple::EABIHF)
1362 arch_spec.
GetTriple().setEnvironment(llvm::Triple::EABI);
1365 }
else if (VFPArgs == llvm::ARMBuildAttrs::HardFPAAPCS) {
1366 if (arch_spec.
GetTriple().getEnvironment() ==
1367 llvm::Triple::UnknownEnvironment ||
1368 arch_spec.
GetTriple().getEnvironment() == llvm::Triple::EABI)
1369 arch_spec.
GetTriple().setEnvironment(llvm::Triple::EABIHF);
1386 std::string &gnu_debuglink_file,
1387 uint32_t &gnu_debuglink_crc,
1390 if (!section_headers.empty())
1391 return section_headers.size();
1395 if (arch_spec.
GetTriple().getOS() == llvm::Triple::OSType::UnknownOS) {
1396 llvm::Triple::OSType ostype;
1397 llvm::Triple::OSType spec_ostype;
1409 spec_ostype = arch_spec.
GetTriple().getOS();
1410 assert(spec_ostype == ostype);
1414 if (arch_spec.
GetMachine() == llvm::Triple::mips ||
1415 arch_spec.
GetMachine() == llvm::Triple::mipsel ||
1416 arch_spec.
GetMachine() == llvm::Triple::mips64 ||
1417 arch_spec.
GetMachine() == llvm::Triple::mips64el) {
1418 switch (header.
e_flags & llvm::ELF::EF_MIPS_ARCH_ASE) {
1419 case llvm::ELF::EF_MIPS_MICROMIPS:
1422 case llvm::ELF::EF_MIPS_ARCH_ASE_M16:
1425 case llvm::ELF::EF_MIPS_ARCH_ASE_MDMX:
1433 if (arch_spec.
GetMachine() == llvm::Triple::arm ||
1434 arch_spec.
GetMachine() == llvm::Triple::thumb) {
1435 if (header.
e_flags & llvm::ELF::EF_ARM_SOFT_FLOAT)
1437 else if (header.
e_flags & llvm::ELF::EF_ARM_VFP_FLOAT)
1441 if (arch_spec.
GetMachine() == llvm::Triple::riscv32 ||
1442 arch_spec.
GetMachine() == llvm::Triple::riscv64) {
1443 uint32_t flags = arch_spec.
GetFlags();
1445 if (header.
e_flags & llvm::ELF::EF_RISCV_RVC)
1447 if (header.
e_flags & llvm::ELF::EF_RISCV_RVE)
1450 if ((header.
e_flags & llvm::ELF::EF_RISCV_FLOAT_ABI_SINGLE) ==
1451 llvm::ELF::EF_RISCV_FLOAT_ABI_SINGLE)
1453 else if ((header.
e_flags & llvm::ELF::EF_RISCV_FLOAT_ABI_DOUBLE) ==
1454 llvm::ELF::EF_RISCV_FLOAT_ABI_DOUBLE)
1456 else if ((header.
e_flags & llvm::ELF::EF_RISCV_FLOAT_ABI_QUAD) ==
1457 llvm::ELF::EF_RISCV_FLOAT_ABI_QUAD)
1469 section_headers.resize(header.
e_shnum);
1470 if (section_headers.size() != header.
e_shnum)
1476 if (sh_data.
SetData(object_data, sh_offset, sh_size) != sh_size)
1481 for (idx = 0, offset = 0; idx < header.
e_shnum; ++idx) {
1482 if (!section_headers[idx].Parse(sh_data, &offset))
1485 if (idx < section_headers.size())
1486 section_headers.resize(idx);
1488 const unsigned strtab_idx = header.
e_shstrndx;
1489 if (strtab_idx && strtab_idx < section_headers.size()) {
1491 const size_t byte_size = sheader.
sh_size;
1492 const Elf64_Off offset = sheader.
sh_offset;
1495 if (shstr_data.
SetData(object_data, offset, byte_size) == byte_size) {
1497 I != section_headers.end(); ++I) {
1498 static ConstString g_sect_name_gnu_debuglink(
".gnu_debuglink");
1500 const uint64_t section_size =
1504 I->section_name = name;
1506 if (arch_spec.
IsMIPS()) {
1507 uint32_t arch_flags = arch_spec.
GetFlags();
1509 if (sheader.
sh_type == SHT_MIPS_ABIFLAGS) {
1512 section_size) == section_size)) {
1515 arch_flags |= data.
GetU32(&offset);
1519 switch (data.
GetU8(&offset)) {
1520 case llvm::Mips::Val_GNU_MIPS_ABI_FP_ANY:
1523 case llvm::Mips::Val_GNU_MIPS_ABI_FP_DOUBLE:
1526 case llvm::Mips::Val_GNU_MIPS_ABI_FP_SINGLE:
1529 case llvm::Mips::Val_GNU_MIPS_ABI_FP_SOFT:
1532 case llvm::Mips::Val_GNU_MIPS_ABI_FP_OLD_64:
1535 case llvm::Mips::Val_GNU_MIPS_ABI_FP_XX:
1538 case llvm::Mips::Val_GNU_MIPS_ABI_FP_64:
1541 case llvm::Mips::Val_GNU_MIPS_ABI_FP_64A:
1548 switch (header.
e_flags & llvm::ELF::EF_MIPS_ABI) {
1549 case llvm::ELF::EF_MIPS_ABI_O32:
1552 case EF_MIPS_ABI_O64:
1555 case EF_MIPS_ABI_EABI32:
1558 case EF_MIPS_ABI_EABI64:
1563 if (header.
e_ident[EI_CLASS] == llvm::ELF::ELFCLASS64)
1565 else if (header.
e_flags & llvm::ELF::EF_MIPS_ABI2)
1572 if (arch_spec.
GetMachine() == llvm::Triple::arm ||
1573 arch_spec.
GetMachine() == llvm::Triple::thumb) {
1576 if (sheader.
sh_type == SHT_ARM_ATTRIBUTES && section_size != 0 &&
1577 data.
SetData(object_data, sheader.
sh_offset, section_size) == section_size)
1581 if (name == g_sect_name_gnu_debuglink) {
1584 section_size) == section_size)) {
1586 gnu_debuglink_file = data.
GetCStr(&gnu_debuglink_offset);
1587 gnu_debuglink_offset = llvm::alignTo(gnu_debuglink_offset, 4);
1588 data.
GetU32(&gnu_debuglink_offset, &gnu_debuglink_crc, 1);
1593 bool is_note_header = (sheader.
sh_type == SHT_NOTE);
1597 static ConstString g_sect_name_android_ident(
".note.android.ident");
1598 if (!is_note_header && name == g_sect_name_android_ident)
1599 is_note_header =
true;
1601 if (is_note_header) {
1605 section_size) == section_size)) {
1608 LLDB_LOGF(log,
"ObjectFileELF::%s ELF note processing failed: %s",
1609 __FUNCTION__,
error.AsCString());
1616 if (arch_spec.
GetTriple().getVendor() == llvm::Triple::UnknownVendor)
1617 arch_spec.
GetTriple().setVendorName(llvm::StringRef());
1618 if (arch_spec.
GetTriple().getOS() == llvm::Triple::UnknownOS)
1619 arch_spec.
GetTriple().setOSName(llvm::StringRef());
1621 return section_headers.size();
1625 section_headers.clear();
1631 size_t pos = symbol_name.find(
'@');
1632 return symbol_name.substr(0, pos);
1663 if (Name.consume_front(
".debug_")) {
1664 return llvm::StringSwitch<SectionType>(Name)
1696 return llvm::StringSwitch<SectionType>(Name)
1745 Permissions Perm = Permissions(0);
1747 Perm |= ePermissionsReadable;
1749 Perm |= ePermissionsWritable;
1751 Perm |= ePermissionsExecutable;
1756 Permissions Perm = Permissions(0);
1758 Perm |= ePermissionsReadable;
1760 Perm |= ePermissionsWritable;
1762 Perm |= ePermissionsExecutable;
1770struct SectionAddressInfo {
1778class VMAddressProvider {
1780 llvm::IntervalMapHalfOpenInfo<addr_t>>;
1783 addr_t NextVMAddress = 0;
1784 VMMap::Allocator Alloc;
1786 VMMap Sections{Alloc};
1788 size_t SegmentCount = 0;
1789 std::string SegmentName;
1797 if ((ObjectType == ObjectFile::Type::eTypeObjectFile ||
1798 (ObjectType == ObjectFile::Type::eTypeDebugInfo && H.
sh_addr == 0)) &&
1801 llvm::alignTo(NextVMAddress, std::max<addr_t>(H.
sh_addralign, 1));
1803 NextVMAddress += Size;
1810 : ObjectType(
Type), SegmentName(std::string(SegmentName)) {}
1812 std::string GetNextSegmentName()
const {
1813 return llvm::formatv(
"{0}[{1}]", SegmentName, SegmentCount).str();
1818 LLDB_LOG(
Log,
"Ignoring zero-sized {0} segment. Corrupt object file?",
1820 return std::nullopt;
1824 LLDB_LOG(
Log,
"Ignoring overlapping {0} segment. Corrupt object file?",
1826 return std::nullopt;
1831 std::optional<SectionAddressInfo> GetAddressInfo(
const ELFSectionHeader &H) {
1835 if ((H.
sh_flags & SHF_ALLOC) && It.valid()) {
1843 LLDB_LOG(
Log,
"Shortening section crossing segment boundaries. "
1844 "Corrupt object file?");
1850 LLDB_LOG(
Log,
"Ignoring overlapping section. Corrupt object file?");
1851 return std::nullopt;
1855 return SectionAddressInfo{Segment,
Range};
1863 void AddSection(SectionAddressInfo Info,
SectionSP Sect) {
1864 if (Info.Range.GetByteSize() == 0)
1867 Info.Range.Slide(Info.Segment->GetFileAddress());
1868 Sections.insert(Info.Range.GetRangeBase(), Info.Range.GetRangeEnd(),
1882 addr_t vm_addr = section->GetFileAddress();
1884 offset_t byte_size = section->GetByteSize();
1885 bool thread_specific = section->IsThreadSpecific();
1886 uint32_t permissions = section->GetPermissions();
1887 uint32_t alignment = section->GetLog2Align();
1889 for (
auto sect : section_list) {
1890 if (sect->GetName() == name &&
1891 sect->IsThreadSpecific() == thread_specific &&
1892 sect->GetPermissions() == permissions &&
1893 sect->GetByteSize() == byte_size && sect->GetFileAddress() == vm_addr &&
1894 sect->GetLog2Align() == alignment) {
1912 VMAddressProvider regular_provider(
GetType(),
"PT_LOAD");
1913 VMAddressProvider tls_provider(
GetType(),
"PT_TLS");
1920 VMAddressProvider &provider =
1921 PHdr.
p_type == PT_TLS ? tls_provider : regular_provider;
1922 auto InfoOr = provider.GetAddressInfo(PHdr);
1926 uint32_t Log2Align = llvm::Log2_64(std::max<elf_xword>(PHdr.
p_align, 1));
1927 SectionSP Segment = std::make_shared<Section>(
1930 InfoOr->GetRangeBase(), InfoOr->GetByteSize(), PHdr.
p_offset,
1933 Segment->SetIsThreadSpecific(PHdr.
p_type == PT_TLS);
1936 provider.AddSegment(*InfoOr, std::move(Segment));
1948 const uint64_t file_size =
1951 VMAddressProvider &provider =
1952 header.
sh_flags & SHF_TLS ? tls_provider : regular_provider;
1953 auto InfoOr = provider.GetAddressInfo(header);
1959 const uint32_t target_bytes_size =
1972 InfoOr->Range.GetRangeBase(),
1973 InfoOr->Range.GetByteSize(),
1978 target_bytes_size));
1981 section_sp->SetIsThreadSpecific(header.
sh_flags & SHF_TLS);
1982 (InfoOr->Segment ? InfoOr->Segment->GetChildren() : *
m_sections_up)
1983 .AddSection(section_sp);
1984 provider.AddSection(std::move(*InfoOr), std::move(section_sp));
1996 if (
auto gdd_objfile_section_list = gdd_obj_file->GetSectionList()) {
1998 gdd_objfile_section_list->FindSectionByType(
2002 if (module_section_sp)
2006 unified_section_list.
AddSection(symtab_section_sp);
2023 "No LZMA support found for reading .gnu_debugdata section");
2029 section->GetSectionData(data);
2030 llvm::SmallVector<uint8_t, 0> uncompressedData;
2034 "An error occurred while decompression the section {0}: {1}",
2035 section->GetName().AsCString(), llvm::toString(std::move(err)).c_str());
2041 new DataBufferHeap(uncompressedData.data(), uncompressedData.size()));
2043 llvm::StringRef(
"gnu_debugdata"));
2045 GetModule(), gdd_data_buf, 0, &fspec, 0, gdd_data_buf->GetByteSize()));
2066 const char *dollar_pos = ::strchr(symbol_name,
'$');
2067 if (!dollar_pos || dollar_pos[1] ==
'\0')
2070 if (dollar_pos[2] ==
'\0' || dollar_pos[2] ==
'.')
2071 return dollar_pos[1];
2075#define STO_MIPS_ISA (3 << 6)
2076#define STO_MICROMIPS (2 << 6)
2077#define IS_MICROMIPS(ST_OTHER) (((ST_OTHER)&STO_MIPS_ISA) == STO_MICROMIPS)
2080std::pair<unsigned, ObjectFileELF::FileAddressToAddressClassMap>
2082 SectionList *section_list,
const size_t num_symbols,
2099 static ConstString rodata_section_name(
".rodata");
2100 static ConstString rodata1_section_name(
".rodata1");
2116 bool skip_oatdata_oatexec =
2117 file_extension ==
".oat" || file_extension ==
".odex";
2122 module_sp ? module_sp->GetSectionList() :
nullptr;
2129 std::unordered_map<lldb::SectionSP, lldb::SectionSP> section_map;
2132 for (i = 0; i < num_symbols; ++i) {
2133 if (!symbol.
Parse(symtab_data, &offset))
2141 if (symbol.
getType() != STT_SECTION &&
2142 (symbol_name ==
nullptr || symbol_name[0] ==
'\0'))
2147 if (skip_oatdata_oatexec && (::strcmp(symbol_name,
"oatdata") == 0 ||
2148 ::strcmp(symbol_name,
"oatexec") == 0))
2153 Elf64_Half shndx = symbol.
st_shndx;
2210 if (symbol_section_sp) {
2211 ConstString sect_name = symbol_section_sp->GetName();
2212 if (sect_name == text_section_name || sect_name == init_section_name ||
2213 sect_name == fini_section_name || sect_name == ctors_section_name ||
2214 sect_name == dtors_section_name) {
2216 }
else if (sect_name == data_section_name ||
2217 sect_name == data2_section_name ||
2218 sect_name == rodata_section_name ||
2219 sect_name == rodata1_section_name ||
2220 sect_name == bss_section_name) {
2226 int64_t symbol_value_offset = 0;
2227 uint32_t additional_flags = 0;
2230 if (arch.
GetMachine() == llvm::Triple::arm) {
2234 switch (mapping_symbol) {
2237 address_class_map[symbol.
st_value] = AddressClass::eCode;
2243 address_class_map[symbol.
st_value] =
2244 AddressClass::eCodeAlternateISA;
2248 address_class_map[symbol.
st_value] = AddressClass::eData;
2255 }
else if (arch.
GetMachine() == llvm::Triple::aarch64) {
2259 switch (mapping_symbol) {
2262 address_class_map[symbol.
st_value] = AddressClass::eCode;
2266 address_class_map[symbol.
st_value] = AddressClass::eData;
2275 if (arch.
GetMachine() == llvm::Triple::arm) {
2283 symbol_value_offset = -1;
2284 address_class_map[symbol.
st_value ^ 1] =
2285 AddressClass::eCodeAlternateISA;
2288 address_class_map[symbol.
st_value] = AddressClass::eCode;
2309 address_class_map[symbol.
st_value] = AddressClass::eCodeAlternateISA;
2312 address_class_map[symbol.
st_value] = AddressClass::eCodeAlternateISA;
2315 address_class_map[symbol.
st_value] = AddressClass::eCode;
2317 address_class_map[symbol.
st_value] = AddressClass::eData;
2319 address_class_map[symbol.
st_value] = AddressClass::eUnknown;
2326 uint64_t symbol_value = symbol.
st_value + symbol_value_offset;
2328 if (symbol_section_sp &&
2330 symbol_value -= symbol_section_sp->GetFileAddress();
2332 if (symbol_section_sp && module_section_list &&
2333 module_section_list != section_list) {
2334 auto section_it = section_map.find(symbol_section_sp);
2335 if (section_it == section_map.end()) {
2336 section_it = section_map
2337 .emplace(symbol_section_sp,
2342 if (section_it->second)
2343 symbol_section_sp = section_it->second;
2346 bool is_global = symbol.
getBinding() == STB_GLOBAL;
2347 uint32_t flags = symbol.
st_other << 8 | symbol.
st_info | additional_flags;
2348 llvm::StringRef symbol_ref(symbol_name);
2352 size_t version_pos = symbol_ref.find(
'@');
2353 bool has_suffix = version_pos != llvm::StringRef::npos;
2354 llvm::StringRef symbol_bare = symbol_ref.substr(0, version_pos);
2360 llvm::StringRef suffix = symbol_ref.substr(version_pos);
2363 if (!mangled_name.empty())
2367 llvm::StringRef demangled_name = demangled.
GetStringRef();
2368 if (!demangled_name.empty())
2377 bool symbol_size_valid =
2380 bool is_trampoline =
false;
2389 if (trampoline_name.starts_with(
"__AArch64ADRPThunk_") ||
2390 trampoline_name.starts_with(
"__AArch64AbsLongThunk_")) {
2392 is_trampoline =
true;
2418 return {i, address_class_map};
2421std::pair<unsigned, ObjectFileELF::FileAddressToAddressClassMap>
2429 auto [num_symbols, address_class_map] =
2436 return {num_symbols, address_class_map};
2446 assert(symtab_hdr->
sh_type == SHT_SYMTAB ||
2447 symtab_hdr->
sh_type == SHT_DYNSYM);
2453 if (symtab && strtab) {
2463 return ParseSymbols(symbol_table, start_id, section_list, num_symbols,
2464 symtab_data, strtab_data);
2493 while (cursor < section_size) {
2494 if (!symbol.
Parse(dynsym_data, &cursor))
2510 for (; I != E; ++I) {
2513 if (symbol->
d_tag == tag)
2529 return symbol->
d_val;
2538static std::pair<uint64_t, uint64_t>
2554 if (plt_entsize <= 4) {
2564 plt_entsize = plt_hdr->
sh_size / (num_relocations + 1);
2569 return std::make_pair(plt_entsize, plt_offset);
2578 ELFRelocation rel(rel_type);
2582 uint64_t plt_offset, plt_entsize;
2583 std::tie(plt_entsize, plt_offset) =
2587 typedef unsigned (*reloc_info_fn)(
const ELFRelocation &rel);
2588 reloc_info_fn reloc_type;
2589 reloc_info_fn reloc_symbol;
2592 reloc_type = ELFRelocation::RelocType32;
2593 reloc_symbol = ELFRelocation::RelocSymbol32;
2595 reloc_type = ELFRelocation::RelocType64;
2596 reloc_symbol = ELFRelocation::RelocSymbol64;
2601 for (i = 0; i < num_relocations; ++i) {
2602 if (!rel.Parse(rel_data, &offset))
2605 if (reloc_type(rel) != slot_type)
2609 if (!symbol.
Parse(symtab_data, &symbol_offset))
2613 uint64_t plt_index = plt_offset + i * plt_entsize;
2640 assert(rel_hdr->
sh_type == SHT_RELA || rel_hdr->
sh_type == SHT_REL);
2654 if (!symtab_id || !plt_id)
2674 if (!plt_section_sp)
2703 rel_hdr, plt_hdr, sym_hdr, plt_section_sp,
2704 rel_data, symtab_data, strtab_data);
2716 llvm::cast<WritableDataBuffer>(data_buffer_sp.get());
2717 uint64_t *dst =
reinterpret_cast<uint64_t *
>(
2719 ELFRelocation::RelocOffset64(rel));
2720 uint64_t val_offset = value + ELFRelocation::RelocAddend64(rel);
2721 memcpy(dst, &val_offset,
sizeof(uint64_t));
2727 Section *rel_section,
bool is_signed) {
2731 value += ELFRelocation::RelocAddend32(rel);
2734 ((int64_t)value >
INT32_MAX || (int64_t)value < INT32_MIN))) {
2736 LLDB_LOGF(log,
"Failed to apply debug info relocations");
2739 uint32_t truncated_addr = (value & 0xFFFFFFFF);
2743 llvm::cast<WritableDataBuffer>(data_buffer_sp.get());
2744 uint32_t *dst =
reinterpret_cast<uint32_t *
>(
2746 ELFRelocation::RelocOffset32(rel));
2747 memcpy(dst, &truncated_addr,
sizeof(uint32_t));
2760 LLDB_LOGF(log,
"Debug info symbol invalid: %s", name);
2763 assert(llvm::isUInt<32>(value) &&
"Valid addresses are 32-bit");
2767 llvm::cast<WritableDataBuffer>(data_buffer_sp.get());
2769 ELFRelocation::RelocOffset32(rel);
2772 memcpy(&addend, dst,
sizeof(int32_t));
2775 if (addend < 0 &&
static_cast<uint32_t
>(-addend) > value) {
2776 LLDB_LOGF(log,
"Debug info relocation overflow: 0x%" PRIx64,
2777 static_cast<int64_t
>(value) + addend);
2780 if (!llvm::isUInt<32>(value + addend)) {
2781 LLDB_LOGF(log,
"Debug info relocation out of range: 0x%" PRIx64, value);
2784 uint32_t addr = value + addend;
2785 memcpy(dst, &addr,
sizeof(uint32_t));
2794 ELFRelocation rel(rel_hdr->
sh_type);
2797 typedef unsigned (*reloc_info_fn)(
const ELFRelocation &rel);
2798 reloc_info_fn reloc_type;
2799 reloc_info_fn reloc_symbol;
2802 reloc_type = ELFRelocation::RelocType32;
2803 reloc_symbol = ELFRelocation::RelocSymbol32;
2805 reloc_type = ELFRelocation::RelocType64;
2806 reloc_symbol = ELFRelocation::RelocSymbol64;
2809 for (
unsigned i = 0; i < num_relocations; ++i) {
2810 if (!rel.Parse(rel_data, &offset)) {
2811 GetModule()->ReportError(
".rel{0}[{1:d}] failed to parse relocation",
2815 Symbol *symbol =
nullptr;
2819 case llvm::ELF::EM_ARM:
2820 switch (reloc_type(rel)) {
2825 GetModule()->ReportError(
"unsupported AArch32 relocation:"
2826 " .rel{0}[{1}], type {2}",
2831 assert(
false &&
"unexpected relocation type");
2834 case llvm::ELF::EM_386:
2835 switch (reloc_type(rel)) {
2840 rel_section->
GetFileOffset() + ELFRelocation::RelocOffset32(rel);
2844 llvm::cast<WritableDataBuffer>(data_buffer_sp.get());
2845 uint32_t *dst =
reinterpret_cast<uint32_t *
>(
2846 data_buffer->
GetBytes() + f_offset);
2850 value += ELFRelocation::RelocAddend32(rel);
2856 GetModule()->ReportError(
".rel{0}[{1}] unknown symbol id: {2:d}",
2863 GetModule()->ReportError(
"unsupported i386 relocation:"
2864 " .rel{0}[{1}], type {2}",
2869 assert(
false &&
"unexpected relocation type");
2874 GetModule()->ReportError(
"unsupported 32-bit ELF machine arch: {0}", hdr->
e_machine);
2879 case llvm::ELF::EM_AARCH64:
2880 switch (reloc_type(rel)) {
2881 case R_AARCH64_ABS64:
2884 case R_AARCH64_ABS32:
2888 assert(
false &&
"unexpected relocation type");
2891 case llvm::ELF::EM_LOONGARCH:
2892 switch (reloc_type(rel)) {
2900 assert(
false &&
"unexpected relocation type");
2903 case llvm::ELF::EM_X86_64:
2904 switch (reloc_type(rel)) {
2917 assert(
false &&
"unexpected relocation type");
2921 GetModule()->ReportError(
"unsupported 64-bit ELF machine arch: {0}", hdr->
e_machine);
2933 assert(rel_hdr->
sh_type == SHT_RELA || rel_hdr->
sh_type == SHT_REL);
2971 rel_data, symtab_data, debug_data, debug);
2982 Progress progress(
"Parsing symbol table",
2988 ObjectFile *module_obj_file = module_sp->GetObjectFile();
2989 if (module_obj_file && module_obj_file !=
this)
2992 SectionList *section_list = module_sp->GetSectionList();
2996 uint64_t symbol_id = 0;
3006 auto [num_symbols, address_class_map] =
3009 symbol_id += num_symbols;
3024 auto [num_symbols, address_class_map] =
3026 symbol_id += num_symbols;
3046 if (reloc_section) {
3056 GetModule()->GetUnwindTable().GetEHFrameInfo()) {
3070 bool is_valid_entry_point =
3071 entry_point_addr.IsValid() && entry_point_addr.IsSectionOffset();
3072 addr_t entry_point_file_addr = entry_point_addr.GetFileAddress();
3074 entry_point_file_addr)) {
3079 SectionSP section_sp = entry_point_addr.GetSection();
3098 if (arch.
GetMachine() == llvm::Triple::arm &&
3099 (entry_point_file_addr & 1)) {
3102 AddressClass::eCodeAlternateISA;
3113 static const char *debug_prefix =
".debug";
3125 if (section_name ==
nullptr)
3129 if (strncmp(section_name, debug_prefix, strlen(debug_prefix)))
3133 std::string needle = std::string(
".rel") + section_name;
3134 std::string needlea = std::string(
".rela") + section_name;
3138 if (I->sh_type == SHT_RELA || I->sh_type == SHT_REL) {
3139 const char *hay_name = I->section_name.GetCString();
3140 if (hay_name ==
nullptr)
3142 if (needle == hay_name || needlea == hay_name) {
3163 std::vector<Symbol> new_symbols;
3166 uint64_t last_symbol_id =
3173 symbol->SetByteSize(size);
3174 symbol->SetSizeIsSynthesized(true);
3180 addr_t offset = file_addr - section_sp->GetFileAddress();
3181 uint64_t symbol_id = ++last_symbol_id;
3199 new_symbols.push_back(eh_symbol);
3205 for (
const Symbol &s : new_symbols)
3225 std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
3226 s->
Printf(
"%p: ",
static_cast<void *
>(
this));
3232 *s <<
", file = '" <<
m_file
3258 s->
Printf(
"e_ident[EI_MAG0 ] = 0x%2.2x\n", header.
e_ident[EI_MAG0]);
3259 s->
Printf(
"e_ident[EI_MAG1 ] = 0x%2.2x '%c'\n", header.
e_ident[EI_MAG1],
3261 s->
Printf(
"e_ident[EI_MAG2 ] = 0x%2.2x '%c'\n", header.
e_ident[EI_MAG2],
3263 s->
Printf(
"e_ident[EI_MAG3 ] = 0x%2.2x '%c'\n", header.
e_ident[EI_MAG3],
3266 s->
Printf(
"e_ident[EI_CLASS ] = 0x%2.2x\n", header.
e_ident[EI_CLASS]);
3267 s->
Printf(
"e_ident[EI_DATA ] = 0x%2.2x ", header.
e_ident[EI_DATA]);
3269 s->
Printf(
"\ne_ident[EI_VERSION] = 0x%2.2x\n", header.
e_ident[EI_VERSION]);
3270 s->
Printf(
"e_ident[EI_PAD ] = 0x%2.2x\n", header.
e_ident[EI_PAD]);
3317 unsigned char ei_data) {
3320 *s <<
"ELFDATANONE";
3323 *s <<
"ELFDATA2LSB - Little Endian";
3326 *s <<
"ELFDATA2MSB - Big Endian";
3339 s->
Printf(
" %8.8" PRIx64
" %8.8" PRIx64
" %8.8" PRIx64, ph.
p_offset,
3353 const int kStrWidth = 15;
3365 s->
Printf(
"0x%8.8x%*s", p_type, kStrWidth - 10,
"");
3374 *s << ((p_flags & PF_X) ?
"PF_X" :
" ")
3375 << (((p_flags & PF_X) && (p_flags & PF_W)) ?
'+' :
' ')
3376 << ((p_flags & PF_W) ?
"PF_W" :
" ")
3377 << (((p_flags & PF_W) && (p_flags & PF_R)) ?
'+' :
' ')
3378 << ((p_flags & PF_R) ?
"PF_R" :
" ");
3389 s->
PutCString(
"IDX p_type p_offset p_vaddr p_paddr "
3390 "p_filesz p_memsz p_flags p_align\n");
3391 s->
PutCString(
"==== --------------- -------- -------- -------- "
3392 "-------- -------- ------------------------- --------\n");
3395 s->
Format(
"[{0,2}] ", H.index());
3410 s->
Printf(
") %8.8" PRIx64
" %8.8" PRIx64
" %8.8" PRIx64, sh.
sh_addr,
3421 const int kStrWidth = 12;
3440 s->
Printf(
"0x%8.8x%*s", sh_type, kStrWidth - 10,
"");
3450 *s << ((sh_flags & SHF_WRITE) ?
"WRITE" :
" ")
3451 << (((sh_flags & SHF_WRITE) && (sh_flags & SHF_ALLOC)) ?
'+' :
' ')
3452 << ((sh_flags & SHF_ALLOC) ?
"ALLOC" :
" ")
3453 << (((sh_flags & SHF_ALLOC) && (sh_flags & SHF_EXECINSTR)) ?
'+' :
' ')
3454 << ((sh_flags & SHF_EXECINSTR) ?
"EXECINSTR" :
" ");
3466 "addr offset size link info addralgn "
3468 s->
PutCString(
"==== -------- ------------ -------------------------------- "
3469 "-------- -------- -------- -------- -------- -------- "
3470 "-------- ====================\n");
3475 s->
Printf(
"[%2u] ", idx);
3477 const char *section_name = I->section_name.AsCString(
"");
3479 *s <<
' ' << section_name <<
"\n";
3486 if (num_modules > 0) {
3488 for (
unsigned i = 0; i < num_modules; ++i) {
3509 if (H.p_type != PT_NOTE || H.p_offset == 0 || H.p_filesz == 0)
3512 if (data.
SetData(
m_data, H.p_offset, H.p_filesz) == H.p_filesz) {
3523 case llvm::ELF::ET_NONE:
3527 case llvm::ELF::ET_REL:
3531 case llvm::ELF::ET_EXEC:
3535 case llvm::ELF::ET_DYN:
3551 case llvm::ELF::ET_NONE:
3555 case llvm::ELF::ET_REL:
3559 case llvm::ELF::ET_EXEC:
3564 static ConstString loader_section_name(
".interp");
3567 if (loader_section) {
3575 llvm::StringRef loader_name(buffer, read_size - 1);
3576 llvm::StringRef freebsd_kernel_loader_name(
"/red/herring");
3577 if (loader_name == freebsd_kernel_loader_name)
3584 case llvm::ELF::ET_DYN:
3612 if (!section->
Test(SHF_COMPRESSED))
3619 return data.
CopyData(section_offset, dst_len, dst);
3629 if (result == 0 || !(section->
Get() & llvm::ELF::SHF_COMPRESSED))
3632 auto Decompressor = llvm::object::Decompressor::create(
3634 {reinterpret_cast<const char *>(section_data.GetDataStart()),
3635 size_t(section_data.GetByteSize())},
3637 if (!Decompressor) {
3639 "Unable to initialize decompressor for section '{0}': {1}",
3641 llvm::toString(Decompressor.takeError()).c_str());
3642 section_data.
Clear();
3647 std::make_shared<DataBufferHeap>(Decompressor->getDecompressedSize(), 0);
3648 if (
auto error = Decompressor->decompress(
3649 {buffer_sp->GetBytes(), size_t(buffer_sp->GetByteSize())})) {
3650 GetModule()->ReportWarning(
"Decompression of section '{0}' failed: {1}",
3652 llvm::toString(std::move(
error)).c_str());
3653 section_data.
Clear();
3657 section_data.
SetData(buffer_sp);
3658 return buffer_sp->GetByteSize();
3678std::vector<ObjectFile::LoadableData>
3682 std::vector<LoadableData> loadables;
3686 if (H.p_type != llvm::ELF::PT_LOAD)
3688 loadable.
Dest = should_use_paddr ? H.p_paddr : H.p_vaddr;
3691 if (H.p_filesz == 0)
3694 loadable.
Contents = llvm::ArrayRef<uint8_t>(segment_data.GetDataStart(),
3695 segment_data.GetByteSize());
3696 loadables.push_back(loadable);
static llvm::raw_ostream & error(Stream &strm)
#define LLDB_LOG(log,...)
The LLDB_LOG* macros defined below are the way to emit log messages.
#define LLDB_LOGF(log,...)
static void ApplyELF64ABS32Relocation(Symtab *symtab, ELFRelocation &rel, DataExtractor &debug_data, Section *rel_section, bool is_signed)
static const elf_word LLDB_NT_NETBSD_IDENT_DESCSZ
static const char *const LLDB_NT_OWNER_NETBSDCORE
static const elf_word LLDB_NT_FREEBSD_ABI_TAG
static uint32_t riscvVariantFromElfFlags(const elf::ELFHeader &header)
static const elf_word LLDB_NT_GNU_ABI_OS_LINUX
static uint32_t ppc64VariantFromElfFlags(const elf::ELFHeader &header)
static bool GetOsFromOSABI(unsigned char osabi_byte, llvm::Triple::OSType &ostype)
#define _MAKE_OSABI_CASE(x)
static uint32_t subTypeFromElfHeader(const elf::ELFHeader &header)
static uint32_t calc_crc32(uint32_t init, const DataExtractor &data)
static char FindArmAarch64MappingSymbol(const char *symbol_name)
static const char *const LLDB_NT_OWNER_CORE
static const elf_word LLDB_NT_NETBSD_IDENT_TAG
static const elf_word LLDB_NT_GNU_ABI_OS_SOLARIS
static std::pair< uint64_t, uint64_t > GetPltEntrySizeAndOffset(const ELFSectionHeader *rel_hdr, const ELFSectionHeader *plt_hdr)
static SectionType GetSectionTypeFromName(llvm::StringRef Name)
static const elf_word LLDB_NT_FREEBSD_ABI_SIZE
static const elf_word LLDB_NT_GNU_ABI_TAG
static SectionSP FindMatchingSection(const SectionList §ion_list, SectionSP section)
static const char *const LLDB_NT_OWNER_GNU
static const elf_word LLDB_NT_NETBSD_PROCINFO
#define CASE_AND_STREAM(s, def, width)
static user_id_t SegmentID(size_t PHdrIndex)
static void ApplyELF32ABS32RelRelocation(Symtab *symtab, ELFRelocation &rel, DataExtractor &debug_data, Section *rel_section)
static const elf_word LLDB_NT_GNU_ABI_SIZE
static uint32_t GetTargetByteSize(SectionType Type, const ArchSpec &arch)
static const char *const LLDB_NT_OWNER_OPENBSD
static const char *const LLDB_NT_OWNER_FREEBSD
static const char *const LLDB_NT_OWNER_LINUX
static const char * OSABIAsCString(unsigned char osabi_byte)
static Permissions GetPermissions(const ELFSectionHeader &H)
static const char *const LLDB_NT_OWNER_ANDROID
#define IS_MICROMIPS(ST_OTHER)
static const elf_word LLDB_NT_NETBSD_IDENT_NAMESZ
static uint32_t loongarchVariantFromElfFlags(const elf::ELFHeader &header)
static const elf_word LLDB_NT_GNU_ABI_OS_HURD
static uint32_t mipsVariantFromElfFlags(const elf::ELFHeader &header)
static const char *const LLDB_NT_OWNER_NETBSD
static unsigned ParsePLTRelocations(Symtab *symbol_table, user_id_t start_id, unsigned rel_type, const ELFHeader *hdr, const ELFSectionHeader *rel_hdr, const ELFSectionHeader *plt_hdr, const ELFSectionHeader *sym_hdr, const lldb::SectionSP &plt_section_sp, DataExtractor &rel_data, DataExtractor &symtab_data, DataExtractor &strtab_data)
static void ApplyELF64ABS64Relocation(Symtab *symtab, ELFRelocation &rel, DataExtractor &debug_data, Section *rel_section)
static const elf_word LLDB_NT_GNU_BUILD_ID_TAG
#define LLDB_PLUGIN_DEFINE(PluginName)
static double elapsed(const StatsTimepoint &start, const StatsTimepoint &end)
#define LLDB_SCOPED_TIMERF(...)
Generic COFF object file reader.
static size_t GetSectionHeaderInfo(SectionHeaderColl §ion_headers, lldb_private::DataExtractor &object_data, const elf::ELFHeader &header, lldb_private::UUID &uuid, std::string &gnu_debuglink_file, uint32_t &gnu_debuglink_crc, lldb_private::ArchSpec &arch_spec)
Parses the elf section headers and returns the uuid, debug link name, crc, archspec.
std::vector< elf::ELFProgramHeader > ProgramHeaderColl
static void DumpELFHeader(lldb_private::Stream *s, const elf::ELFHeader &header)
unsigned ParseTrampolineSymbols(lldb_private::Symtab *symbol_table, lldb::user_id_t start_id, const ELFSectionHeaderInfo *rela_hdr, lldb::user_id_t section_id)
Scans the relocation entries and adds a set of artificial symbols to the given symbol table for each ...
lldb_private::ArchSpec m_arch_spec
The architecture detected from parsing elf file contents.
static void DumpELFSectionHeader_sh_type(lldb_private::Stream *s, elf::elf_word sh_type)
std::shared_ptr< ObjectFileELF > m_gnu_debug_data_object_file
Object file parsed from .gnu_debugdata section (.
SectionHeaderColl::iterator SectionHeaderCollIter
uint32_t m_gnu_debuglink_crc
unsigned RelocateDebugSections(const elf::ELFSectionHeader *rel_hdr, lldb::user_id_t rel_id, lldb_private::Symtab *thetab)
Relocates debug sections.
bool AnySegmentHasPhysicalAddress()
static void DumpELFProgramHeader(lldb_private::Stream *s, const elf::ELFProgramHeader &ph)
lldb_private::Address m_entry_point_address
Cached value of the entry point for this module.
size_t ReadSectionData(lldb_private::Section *section, lldb::offset_t section_offset, void *dst, size_t dst_len) override
llvm::StringRef StripLinkerSymbolAnnotations(llvm::StringRef symbol_name) const override
static void ParseARMAttributes(lldb_private::DataExtractor &data, uint64_t length, lldb_private::ArchSpec &arch_spec)
lldb_private::DataExtractor GetSegmentData(const elf::ELFProgramHeader &H)
void RelocateSection(lldb_private::Section *section) override
Perform relocations on the section if necessary.
FileAddressToAddressClassMap m_address_class_map
The address class for each symbol in the elf file.
static llvm::StringRef GetPluginDescriptionStatic()
static const uint32_t g_core_uuid_magic
static size_t GetModuleSpecifications(const lldb_private::FileSpec &file, lldb::DataBufferSP &data_sp, lldb::offset_t data_offset, lldb::offset_t file_offset, lldb::offset_t length, lldb_private::ModuleSpecList &specs)
bool IsExecutable() const override
Tells whether this object file is capable of being the main executable for a process.
void DumpDependentModules(lldb_private::Stream *s)
ELF dependent module dump routine.
static void DumpELFHeader_e_type(lldb_private::Stream *s, elf::elf_half e_type)
static size_t GetProgramHeaderInfo(ProgramHeaderColl &program_headers, lldb_private::DataExtractor &object_data, const elf::ELFHeader &header)
static bool MagicBytesMatch(lldb::DataBufferSP &data_sp, lldb::addr_t offset, lldb::addr_t length)
DynamicSymbolColl m_dynamic_symbols
Collection of symbols from the dynamic table.
static void DumpELFSectionHeader(lldb_private::Stream *s, const ELFSectionHeaderInfo &sh)
std::vector< ELFSectionHeaderInfo > SectionHeaderColl
static void DumpELFHeader_e_ident_EI_DATA(lldb_private::Stream *s, unsigned char ei_data)
lldb_private::ArchSpec GetArchitecture() override
Get the ArchSpec for this object file.
std::optional< lldb_private::FileSpec > GetDebugLink()
Return the contents of the .gnu_debuglink section, if the object file contains it.
lldb_private::AddressClass GetAddressClass(lldb::addr_t file_addr) override
Get the address type given a file address in an object file.
static void DumpELFSectionHeader_sh_flags(lldb_private::Stream *s, elf::elf_xword sh_flags)
lldb_private::UUID GetUUID() override
Gets the UUID for this object file.
ObjectFileELF(const lldb::ModuleSP &module_sp, lldb::DataBufferSP data_sp, lldb::offset_t data_offset, const lldb_private::FileSpec *file, lldb::offset_t offset, lldb::offset_t length)
static void DumpELFProgramHeader_p_type(lldb_private::Stream *s, elf::elf_word p_type)
static lldb_private::Status RefineModuleDetailsFromNote(lldb_private::DataExtractor &data, lldb_private::ArchSpec &arch_spec, lldb_private::UUID &uuid)
size_t SectionIndex(const SectionHeaderCollIter &I)
Returns the index of the given section header.
static void DumpELFProgramHeader_p_flags(lldb_private::Stream *s, elf::elf_word p_flags)
static llvm::StringRef GetPluginNameStatic()
size_t ParseDependentModules()
Scans the dynamic section and locates all dependent modules (shared libraries) populating m_filespec_...
void DumpELFSectionHeaders(lldb_private::Stream *s)
std::shared_ptr< ObjectFileELF > GetGnuDebugDataObjectFile()
Takes the .gnu_debugdata and returns the decompressed object file that is stored within that section.
static lldb::WritableDataBufferSP MapFileDataWritable(const lldb_private::FileSpec &file, uint64_t Size, uint64_t Offset)
void Dump(lldb_private::Stream *s) override
Dump a description of this object to a Stream.
static uint32_t CalculateELFNotesSegmentsCRC32(const ProgramHeaderColl &program_headers, lldb_private::DataExtractor &data)
lldb_private::UUID m_uuid
ELF build ID.
void DumpELFProgramHeaders(lldb_private::Stream *s)
std::pair< unsigned, FileAddressToAddressClassMap > ParseSymbolTable(lldb_private::Symtab *symbol_table, lldb::user_id_t start_id, lldb_private::Section *symtab)
Populates the symbol table with all non-dynamic linker symbols.
size_t ParseDynamicSymbols()
Parses the dynamic symbol table and populates m_dynamic_symbols.
static lldb_private::ObjectFile * CreateInstance(const lldb::ModuleSP &module_sp, lldb::DataBufferSP data_sp, lldb::offset_t data_offset, const lldb_private::FileSpec *file, lldb::offset_t file_offset, lldb::offset_t length)
ObjectFile::Type CalculateType() override
The object file should be able to calculate its type by looking at its file header and possibly the s...
lldb::SectionType GetSectionType(const ELFSectionHeaderInfo &H) const
bool SetLoadAddress(lldb_private::Target &target, lldb::addr_t value, bool value_is_offset) override
Sets the load address for an entire module, assuming a rigid slide of sections, if possible in the im...
std::unique_ptr< lldb_private::FileSpecList > m_filespec_up
List of file specifications corresponding to the modules (shared libraries) on which this object file...
bool ParseProgramHeaders()
Parses all section headers present in this object file and populates m_program_headers.
DynamicSymbolColl::iterator DynamicSymbolCollIter
std::vector< LoadableData > GetLoadableData(lldb_private::Target &target) override
Loads this objfile to memory.
const ELFSectionHeaderInfo * GetSectionHeaderByIndex(lldb::user_id_t id)
Returns the section header with the given id or NULL.
void CreateSections(lldb_private::SectionList &unified_section_list) override
lldb::user_id_t GetSectionIndexByName(const char *name)
Utility method for looking up a section given its name.
uint32_t GetAddressByteSize() const override
Gets the address size in bytes for the current object file.
SectionHeaderColl::const_iterator SectionHeaderCollConstIter
ProgramHeaderColl m_program_headers
Collection of program headers.
unsigned ApplyRelocations(lldb_private::Symtab *symtab, const elf::ELFHeader *hdr, const elf::ELFSectionHeader *rel_hdr, const elf::ELFSectionHeader *symtab_hdr, const elf::ELFSectionHeader *debug_hdr, lldb_private::DataExtractor &rel_data, lldb_private::DataExtractor &symtab_data, lldb_private::DataExtractor &debug_data, lldb_private::Section *rel_section)
lldb::ByteOrder GetByteOrder() const override
Gets whether endian swapping should occur when extracting data from this object file.
bool ParseHeader() override
Attempts to parse the object header.
elf::ELFHeader m_header
ELF file header.
std::string m_gnu_debuglink_file
ELF .gnu_debuglink file and crc data if available.
void ParseUnwindSymbols(lldb_private::Symtab *symbol_table, lldb_private::DWARFCallFrameInfo *eh_frame)
std::pair< unsigned, FileAddressToAddressClassMap > ParseSymbols(lldb_private::Symtab *symbol_table, lldb::user_id_t start_id, lldb_private::SectionList *section_list, const size_t num_symbols, const lldb_private::DataExtractor &symtab_data, const lldb_private::DataExtractor &strtab_data)
Helper routine for ParseSymbolTable().
SectionHeaderColl m_section_headers
Collection of section headers.
lldb_private::Address GetEntryPointAddress() override
Returns the address of the Entry Point in this object file - if the object file doesn't have an entry...
ObjectFile::Strata CalculateStrata() override
The object file should be able to calculate the strata of the object file.
void ParseSymtab(lldb_private::Symtab &symtab) override
Parse the symbol table into the provides symbol table object.
unsigned PLTRelocationType()
static lldb_private::ObjectFile * CreateMemoryInstance(const lldb::ModuleSP &module_sp, lldb::WritableDataBufferSP data_sp, const lldb::ProcessSP &process_sp, lldb::addr_t header_addr)
uint32_t GetDependentModules(lldb_private::FileSpecList &files) override
Extract the dependent modules from an object file.
size_t ParseSectionHeaders()
Parses all section headers present in this object file and populates m_section_headers.
lldb_private::Address GetBaseAddress() override
Returns base address of this object file.
bool IsStripped() override
Detect if this object file has been stripped of local symbols.
const elf::ELFDynamic * FindDynamicSymbol(unsigned tag)
std::map< lldb::addr_t, lldb_private::AddressClass > FileAddressToAddressClassMap
An ordered map of file address to address class.
llvm::ArrayRef< elf::ELFProgramHeader > ProgramHeaders()
lldb_private::Address GetImageInfoAddress(lldb_private::Target *target) override
Similar to Process::GetImageInfoAddress().
A section + offset based address range class.
A section + offset based address class.
bool ResolveAddressUsingFileSections(lldb::addr_t addr, const SectionList *sections)
Resolve a file virtual address using a section list.
lldb::addr_t GetFileAddress() const
Get the file address.
bool IsValid() const
Check if the object state is valid.
bool SetOffset(lldb::addr_t offset)
Set accessor for the offset.
An architecture specification class.
@ eLoongArchSubType_loongarch64
@ eLoongArchSubType_unknown
@ eLoongArchSubType_loongarch32
uint32_t GetCodeByteSize() const
Architecture code byte width accessor.
bool IsValid() const
Tests if this ArchSpec is valid.
llvm::Triple & GetTriple()
Architecture triple accessor.
void SetFlags(uint32_t flags)
bool SetArchitecture(ArchitectureType arch_type, uint32_t cpu, uint32_t sub, uint32_t os=0)
Change the architecture object type, CPU type and OS type.
bool IsMIPS() const
if MIPS architecture return true.
uint32_t GetDataByteSize() const
Architecture data byte width accessor.
uint32_t GetFlags() const
@ eMIPSSubType_mips32r6el
@ eMIPSSubType_mips64r6el
@ eMIPSSubType_mips64r2el
@ eMIPSSubType_mips32r2el
llvm::Triple::ArchType GetMachine() const
Returns a machine family for the current architecture.
@ eRISCV_float_abi_double
single precision floating point, +f
@ eRISCV_float_abi_quad
double precision floating point, +d
@ eRISCV_float_abi_single
soft float
bool TripleOSWasSpecified() const
const char * GetArchitectureName() const
Returns a static string representing the current architecture.
A uniqued constant string class.
const char * AsCString(const char *value_if_empty=nullptr) const
Get the string value as a C string.
llvm::StringRef GetStringRef() const
Get the string value as a llvm::StringRef.
const char * GetCString() const
Get the string value as a C string.
void ForEachFDEEntries(const std::function< bool(lldb::addr_t, uint32_t, dw_offset_t)> &callback)
A subclass of DataBuffer that stores a data buffer on the heap.
A class that measures elapsed time in an exception safe way.
bool AppendIfUnique(const FileSpec &file)
Append a FileSpec object if unique.
FileSpec CopyByAppendingPathComponent(llvm::StringRef component) const
const ConstString & GetFilename() const
Filename string const get accessor.
size_t GetPath(char *path, size_t max_path_length, bool denormalize=true) const
Extract the full path to the file.
llvm::StringRef GetFileNameExtension() const
Extract the extension of the file.
void Resolve(llvm::SmallVectorImpl< char > &path)
Resolve path to make it canonical.
std::shared_ptr< WritableDataBuffer > CreateWritableDataBuffer(const llvm::Twine &path, uint64_t size=0, uint64_t offset=0)
static FileSystem & Instance()
ValueType Get() const
Get accessor for all flags.
bool Test(ValueType bit) const
Test a single flag bit.
A class that handles mangled names.
void SetDemangledName(ConstString name)
ConstString GetDemangledName() const
Demangled name get accessor.
void SetMangledName(ConstString name)
ConstString & GetMangledName()
Mangled name get accessor.
ConstString GetName(NamePreference preference=ePreferDemangled) const
Best name get accessor.
lldb::ModuleSP GetModule() const
Get const accessor for the module pointer.
void Append(const ModuleSpec &spec)
void SetObjectSize(uint64_t object_size)
ArchSpec & GetArchitecture()
void SetObjectOffset(uint64_t object_offset)
A plug-in interface definition class for object file parsers.
DataExtractor m_data
The data for this object file so things can be parsed lazily.
Symtab * GetSymtab()
Gets the symbol table for the currently selected architecture (and object for archives).
std::unique_ptr< lldb_private::SectionList > m_sections_up
static lldb::DataBufferSP MapFileData(const FileSpec &file, uint64_t Size, uint64_t Offset)
virtual void ParseSymtab(Symtab &symtab)=0
Parse the symbol table into the provides symbol table object.
virtual AddressClass GetAddressClass(lldb::addr_t file_addr)
Get the address type given a file address in an object file.
size_t GetData(lldb::offset_t offset, size_t length, DataExtractor &data) const
@ eTypeExecutable
A normal executable.
@ eTypeDebugInfo
An object file that contains only debug information.
@ eTypeObjectFile
An intermediate object file.
@ eTypeCoreFile
A core file that has a checkpoint of a program's execution state.
@ eTypeSharedLibrary
A shared library that can be used during execution.
virtual FileSpec & GetFileSpec()
Get accessor to the object file specification.
virtual SectionList * GetSectionList(bool update_module_section_list=true)
Gets the section list for the currently selected architecture (and object for archives).
virtual size_t ReadSectionData(Section *section, lldb::offset_t section_offset, void *dst, size_t dst_len)
static bool RegisterPlugin(llvm::StringRef name, llvm::StringRef description, ABICreateInstance create_callback)
static bool UnregisterPlugin(ABICreateInstance create_callback)
A Progress indicator helper class.
lldb::SectionSP FindSectionByName(ConstString section_dstr) const
lldb::SectionSP FindSectionByID(lldb::user_id_t sect_id) const
lldb::SectionSP FindSectionContainingFileAddress(lldb::addr_t addr, uint32_t depth=UINT32_MAX) const
size_t AddSection(const lldb::SectionSP §ion_sp)
bool ReplaceSection(lldb::user_id_t sect_id, const lldb::SectionSP §ion_sp, uint32_t depth=UINT32_MAX)
lldb::SectionSP FindSectionByType(lldb::SectionType sect_type, bool check_children, size_t start_idx=0) const
void Dump(llvm::raw_ostream &s, unsigned indent, Target *target, bool show_header, uint32_t depth) const
lldb::SectionSP GetSectionAtIndex(size_t idx) const
bool SetSectionLoadAddress(const lldb::SectionSP §ion_sp, lldb::addr_t load_addr, bool warn_multiple=false)
ConstString GetName() const
void SetIsRelocated(bool b)
lldb::offset_t GetFileOffset() const
ObjectFile * GetObjectFile()
lldb::offset_t GetFileSize() const
A stream class that can stream formatted output to a file.
void Format(const char *format, Args &&... args)
llvm::raw_ostream & AsRawOstream()
Returns a raw_ostream that forwards the data to this Stream object.
size_t Indent(llvm::StringRef s="")
Indent the current line in the stream.
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
size_t PutCString(llvm::StringRef cstr)
Output a C string to the stream.
size_t EOL()
Output and End of Line character to the stream.
unsigned GetIndentLevel() const
Get the current indentation level.
bool GetByteSizeIsValid() const
Address & GetAddressRef()
ConstString GetName() const
Symbol * FindSymbolByID(lldb::user_id_t uid) const
Symbol * SymbolAtIndex(size_t idx)
Symbol * FindSymbolAtFileAddress(lldb::addr_t file_addr)
Symbol * FindSymbolContainingFileAddress(lldb::addr_t file_addr)
uint32_t AddSymbol(const Symbol &symbol)
void Dump(Stream *s, Target *target, SortOrder sort_type, Mangled::NamePreference name_preference=Mangled::ePreferDemangled)
ObjectFile * GetObjectFile() const
size_t GetNumSymbols() const
SectionLoadList & GetSectionLoadList()
bool ReadPointerFromMemory(const Address &addr, Status &error, Address &pointer_addr, bool force_live_memory=false)
uint64_t ReadUnsignedIntegerFromMemory(const Address &addr, size_t integer_byte_size, uint64_t fail_value, Status &error, bool force_live_memory=false)
uint8_t * GetBytes()
Get a pointer to the data.
#define LLDB_INVALID_CPUTYPE
#define UNUSED_IF_ASSERT_DISABLED(x)
#define LLDB_INVALID_ADDRESS
llvm::Error uncompress(llvm::ArrayRef< uint8_t > InputBuffer, llvm::SmallVectorImpl< uint8_t > &Uncompressed)
A class that represents a running process on the host machine.
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
std::shared_ptr< lldb_private::Process > ProcessSP
ByteOrder
Byte ordering definitions.
std::shared_ptr< lldb_private::DataBuffer > DataBufferSP
std::shared_ptr< lldb_private::Section > SectionSP
std::shared_ptr< lldb_private::WritableDataBuffer > WritableDataBufferSP
@ eSectionTypeDWARFDebugStrOffsets
@ eSectionTypeELFDynamicSymbols
Elf SHT_DYNSYM section.
@ eSectionTypeDWARFDebugPubNames
@ eSectionTypeDWARFDebugLocDwo
@ eSectionTypeDWARFDebugFrame
@ eSectionTypeContainer
The section contains child sections.
@ eSectionTypeDWARFDebugLocLists
DWARF v5 .debug_loclists.
@ eSectionTypeDWARFDebugTypes
DWARF .debug_types section.
@ eSectionTypeELFDynamicLinkInfo
Elf SHT_DYNAMIC section.
@ eSectionTypeDWARFDebugMacInfo
@ eSectionTypeAbsoluteAddress
Dummy section for symbols with absolute address.
@ eSectionTypeELFRelocationEntries
Elf SHT_REL or SHT_REL section.
@ eSectionTypeDWARFDebugNames
DWARF v5 .debug_names.
@ eSectionTypeDWARFDebugRngLists
DWARF v5 .debug_rnglists.
@ eSectionTypeDWARFDebugStrOffsetsDwo
@ eSectionTypeDWARFDebugMacro
@ eSectionTypeDWARFDebugInfo
@ eSectionTypeDWARFDebugTypesDwo
@ eSectionTypeDWARFDebugRanges
@ eSectionTypeDWARFDebugRngListsDwo
@ eSectionTypeDWARFDebugLine
@ eSectionTypeDWARFDebugPubTypes
@ eSectionTypeDWARFDebugTuIndex
@ eSectionTypeDWARFDebugStr
@ eSectionTypeDWARFDebugLineStr
DWARF v5 .debug_line_str.
@ eSectionTypeDWARFDebugLoc
@ eSectionTypeSwiftModules
@ eSectionTypeDWARFDebugCuIndex
@ eSectionTypeDWARFDebugAranges
@ eSectionTypeDWARFDebugAbbrevDwo
@ eSectionTypeDWARFGNUDebugAltLink
@ eSectionTypeDWARFDebugStrDwo
@ eSectionTypeDWARFDebugAbbrev
@ eSectionTypeDWARFDebugLocListsDwo
@ eSectionTypeDWARFDebugInfoDwo
@ eSectionTypeDWARFDebugAddr
@ eSectionTypeELFSymbolTable
Elf SHT_SYMTAB section.
std::shared_ptr< lldb_private::Module > ModuleSP
bool Parse(const lldb_private::DataExtractor &data, lldb::offset_t *offset)
Parse an ELFNote entry from the given DataExtractor starting at position offset.
size_t GetByteSize() const
Represents an entry in an ELF dynamic table.
elf_addr d_ptr
Pointer value of the table entry.
elf_xword d_val
Integer value of the table entry.
bool Parse(const lldb_private::DataExtractor &data, lldb::offset_t *offset)
Parse an ELFDynamic entry from the given DataExtractor starting at position offset.
elf_sxword d_tag
Type of dynamic table entry.
Represents a relocation entry with an implicit addend.
static unsigned RelocSymbol64(const ELFRel &rel)
Returns the symbol index when the given entry represents a 64-bit relocation.
static unsigned RelocType64(const ELFRel &rel)
Returns the type when the given entry represents a 64-bit relocation.
static unsigned RelocType32(const ELFRel &rel)
Returns the type when the given entry represents a 32-bit relocation.
static unsigned RelocSymbol32(const ELFRel &rel)
Returns the symbol index when the given entry represents a 32-bit relocation.
Represents a relocation entry with an explicit addend.
static unsigned RelocSymbol64(const ELFRela &rela)
Returns the symbol index when the given entry represents a 64-bit relocation.
static unsigned RelocType64(const ELFRela &rela)
Returns the type when the given entry represents a 64-bit relocation.
static unsigned RelocType32(const ELFRela &rela)
Returns the type when the given entry represents a 32-bit relocation.
static unsigned RelocSymbol32(const ELFRela &rela)
Returns the symbol index when the given entry represents a 32-bit relocation.
Represents a symbol within an ELF symbol table.
unsigned char getType() const
Returns the type attribute of the st_info member.
elf_half st_shndx
Section to which this symbol applies.
unsigned char st_info
Symbol type and binding attributes.
unsigned char getBinding() const
Returns the binding attribute of the st_info member.
bool Parse(const lldb_private::DataExtractor &data, lldb::offset_t *offset)
Parse an ELFSymbol entry from the given DataExtractor starting at position offset.
elf_addr st_value
Absolute or relocatable address.
elf_word st_name
Symbol name string index.
elf_xword st_size
Size of the symbol or zero.
unsigned char st_other
Reserved for future use.
llvm::ArrayRef< uint8_t > Contents
BaseType GetRangeBase() const
SizeType GetByteSize() const
BaseType GetRangeEnd() const
void Slide(BaseType slide)
void SetByteSize(SizeType s)
lldb::user_id_t GetID() const
Get accessor for the user ID.